leiting-bim 2.1.35 → 2.1.37

package/plugins/plugins/cesium-core/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "declaration": true,           // ✅ 生成 .d.ts 文件
+    "emitDeclarationOnly": true,   // 只生成声明文件
+    "outDir": "dist",
+    "strict": true,
+    "module": "NodeNext",
+    "target": "ESNext",
+    "moduleResolution": "nodenext",
+    "skipLibCheck": true,
+    "types": ["node", "undici-types"]
+  },
+  "include": ["src"]
+}

package/plugins/plugins/cesium-core/vite.config.ts

@@ -0,0 +1,35 @@
+import { defineConfig } from 'vite';
+import path from 'path';
+import dts from 'vite-plugin-dts';
+import { visualizer } from 'rollup-plugin-visualizer';
+
+export default defineConfig({
+  plugins: [
+    dts({
+      insertTypesEntry: true, // 生成 index.d.ts
+    }),
+    process.env.REPORT === 'true' && visualizer({
+      filename: 'stats.html',
+      open: false,
+      gzipSize: true,
+      brotliSize: true,
+    }),
+  ],
+  build: {
+    sourcemap: process.env.BUILD_MODE !== 'production',
+    lib: {
+      entry: path.resolve(__dirname, 'src/index.ts'),
+      name: 'CesiumCore',
+      formats: ['es', 'umd'],
+      fileName: 'cesium-core',
+    },
+    rollupOptions: {
+      external: ['cesium'],
+      output: {
+        globals: {
+          cesium: 'Cesium',
+        },
+      },
+    },
+  },
+});

package/plugins/plugins/cesium-vue/dist/components/basic-audio/index.d.ts

@@ -0,0 +1,18 @@
+declare const CxBasicAudio: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly src: {
+        readonly type: StringConstructor;
+        readonly required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly src: {
+        readonly type: StringConstructor;
+        readonly required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>>;
+export default CxBasicAudio;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxBasicAudio: typeof CxBasicAudio;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/basic-audio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/basic-audio/index.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,YAAY;;;;;;;;;;6GAA2B,CAAC;AAC9C,eAAe,YAAY,CAAC;AAE5B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,YAAY,EAAE,OAAO,YAAY,CAAC;KACnC;CACF"}

package/plugins/plugins/cesium-vue/dist/components/basic-video/index.d.ts

@@ -0,0 +1,92 @@
+export * from './src/basicVideo';
+declare const CxBasicVideo: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly default: "";
+        readonly required: true;
+    };
+    readonly url: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly poster: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly autoPlay: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loop: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly control: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly width: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    ready: (...args: any[]) => void;
+    unload: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly default: "";
+        readonly required: true;
+    };
+    readonly url: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly poster: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly autoPlay: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loop: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly control: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly width: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+}>> & Readonly<{
+    onReady?: ((...args: any[]) => any) | undefined;
+    onUnload?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly id: string;
+    readonly width: string;
+    readonly height: string;
+    readonly url: string;
+    readonly poster: string;
+    readonly autoPlay: boolean;
+    readonly loop: boolean;
+    readonly control: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>>;
+export default CxBasicVideo;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxBasicVideo: typeof CxBasicVideo;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/basic-video/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/basic-video/index.ts"],"names":[],"mappings":"AAEA,cAAc,kBAAkB,CAAC;AAEjC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wFAA2B,CAAC;AAC9C,eAAe,YAAY,CAAC;AAE5B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,YAAY,EAAE,OAAO,YAAY,CAAC;KACnC;CACF"}

package/plugins/plugins/cesium-vue/dist/components/camera-roam/index.d.ts

@@ -0,0 +1,82 @@
+export declare const CxCameraRoam: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly Cesium: {
+        readonly type: import('vue').PropType<any>;
+        readonly required: false;
+    };
+    readonly viewer: {
+        readonly type: import('vue').PropType<any>;
+        readonly required: false;
+    };
+    readonly visible: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultSpeed: {
+        readonly type: NumberConstructor;
+        readonly default: 500;
+    };
+    readonly defaultModelUrl: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly defaultModelScale: {
+        readonly type: NumberConstructor;
+        readonly default: 1;
+    };
+}>, {
+    init: (Cesium: any, viewer: any, options?: any) => void;
+    open: (visible?: boolean) => void;
+    getConfig: () => {
+        activeRouteId: string;
+        routes: {
+            waypoints: any[];
+            id: string;
+            name: string;
+            speed: number;
+            modelUrl: string;
+            modelScale: number;
+            showPath: boolean;
+            showStops: boolean;
+        }[];
+    };
+    setConfig: (config: any) => void;
+    tool: import('vue').ShallowRef<import('@report-components/cesium-core').CameraRoamTool | null, import('@report-components/cesium-core').CameraRoamTool | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:visible": (...args: any[]) => void;
+    save: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly Cesium: {
+        readonly type: import('vue').PropType<any>;
+        readonly required: false;
+    };
+    readonly viewer: {
+        readonly type: import('vue').PropType<any>;
+        readonly required: false;
+    };
+    readonly visible: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultSpeed: {
+        readonly type: NumberConstructor;
+        readonly default: 500;
+    };
+    readonly defaultModelUrl: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly defaultModelScale: {
+        readonly type: NumberConstructor;
+        readonly default: 1;
+    };
+}>> & Readonly<{
+    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+    onSave?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly visible: boolean;
+    readonly defaultSpeed: number;
+    readonly defaultModelUrl: string;
+    readonly defaultModelScale: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default CxCameraRoam;
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/camera-roam/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/camera-roam/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFAAa,CAAC;AACvC,eAAe,YAAY,CAAC"}

package/plugins/plugins/cesium-vue/dist/components/card-carousel/index.d.ts

@@ -0,0 +1,152 @@
+export * from './src/cardCarousel';
+declare const CxCardCarousel: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<Array<import('../card-content').ContentModel>>;
+        readonly default: () => never[];
+    };
+    readonly bgClass: {
+        readonly type: {
+            (arrayLength: number): String[];
+            (...items: String[]): String[];
+            new (arrayLength: number): String[];
+            new (...items: String[]): String[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        readonly default: () => never[];
+    };
+    readonly imgSrc: {
+        readonly type: StringConstructor;
+        readonly default: () => string;
+    };
+    readonly styleConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties>;
+        readonly default: () => import('vue').CSSProperties;
+    };
+    readonly arrowConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            show?: boolean;
+            size: string;
+        }>;
+        readonly default: () => {
+            show: boolean;
+            color: string;
+            size: string;
+            background: string;
+        };
+    };
+    readonly titleConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            show?: boolean;
+        }>;
+        readonly default: () => {
+            show: boolean;
+            color: string;
+            size: string;
+            background: string;
+        };
+    };
+    readonly pageInfoConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            show?: boolean;
+        }>;
+        readonly default: () => {
+            color: string;
+            backgroundColor: string;
+        };
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<Array<import('../card-content').ContentModel>>;
+        readonly default: () => never[];
+    };
+    readonly bgClass: {
+        readonly type: {
+            (arrayLength: number): String[];
+            (...items: String[]): String[];
+            new (arrayLength: number): String[];
+            new (...items: String[]): String[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        readonly default: () => never[];
+    };
+    readonly imgSrc: {
+        readonly type: StringConstructor;
+        readonly default: () => string;
+    };
+    readonly styleConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties>;
+        readonly default: () => import('vue').CSSProperties;
+    };
+    readonly arrowConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            show?: boolean;
+            size: string;
+        }>;
+        readonly default: () => {
+            show: boolean;
+            color: string;
+            size: string;
+            background: string;
+        };
+    };
+    readonly titleConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            show?: boolean;
+        }>;
+        readonly default: () => {
+            show: boolean;
+            color: string;
+            size: string;
+            background: string;
+        };
+    };
+    readonly pageInfoConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            show?: boolean;
+        }>;
+        readonly default: () => {
+            color: string;
+            backgroundColor: string;
+        };
+    };
+}>> & Readonly<{}>, {
+    readonly data: import('../card-content').ContentModel[];
+    readonly bgClass: String[];
+    readonly imgSrc: string;
+    readonly styleConfig: import('vue').CSSProperties;
+    readonly arrowConfig: import('vue').CSSProperties & {
+        show?: boolean;
+        size: string;
+    };
+    readonly titleConfig: import('vue').CSSProperties & {
+        show?: boolean;
+    };
+    readonly pageInfoConfig: import('vue').CSSProperties & {
+        show?: boolean;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>>;
+export default CxCardCarousel;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxCardCarousel: typeof CxCardCarousel;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/card-carousel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/card-carousel/index.ts"],"names":[],"mappings":"AAEA,cAAc,oBAAoB,CAAC;AAEnC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wFAA6B,CAAC;AAClD,eAAe,cAAc,CAAC;AAE9B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,cAAc,EAAE,OAAO,cAAc,CAAC;KACvC;CACF"}

package/plugins/plugins/cesium-vue/dist/components/card-content/index.d.ts

@@ -0,0 +1,21 @@
+export * from './src/cardContent';
+declare const CxCardContent: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<import('./src/cardContent').ContentModel>;
+        readonly default: () => import('./src/cardContent').ContentModel;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<import('./src/cardContent').ContentModel>;
+        readonly default: () => import('./src/cardContent').ContentModel;
+    };
+}>> & Readonly<{}>, {
+    readonly data: import('./src/cardContent').ContentModel;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>>;
+export default CxCardContent;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxCardContent: typeof CxCardContent;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/card-content/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/card-content/index.ts"],"names":[],"mappings":"AAEA,cAAc,mBAAmB,CAAC;AAElC,QAAA,MAAM,aAAa;;;;;;;;;;;;wFAA4B,CAAC;AAChD,eAAe,aAAa,CAAC;AAE7B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,aAAa,EAAE,OAAO,aAAa,CAAC;KACrC;CACF"}

package/plugins/plugins/cesium-vue/dist/components/card-page/index.d.ts

@@ -0,0 +1,69 @@
+export * from './src/cardPage';
+declare const CxCardPage: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<Array<import('../card-content').ContentModel>>;
+        readonly default: () => never[];
+    };
+    readonly imgSrc: {
+        readonly type: StringConstructor;
+        readonly default: () => string;
+    };
+    readonly styleConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties>;
+        readonly default: () => import('vue').CSSProperties;
+    };
+    readonly paginationStyle: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            buttonHoverColor?: string;
+            textColor?: string;
+            buttonColor?: string;
+            pageInfoColor?: string;
+        }>;
+        readonly default: () => {
+            color: string;
+            backgroundColor: string;
+        };
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<Array<import('../card-content').ContentModel>>;
+        readonly default: () => never[];
+    };
+    readonly imgSrc: {
+        readonly type: StringConstructor;
+        readonly default: () => string;
+    };
+    readonly styleConfig: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties>;
+        readonly default: () => import('vue').CSSProperties;
+    };
+    readonly paginationStyle: {
+        readonly type: import('vue').PropType<import('vue').CSSProperties & {
+            buttonHoverColor?: string;
+            textColor?: string;
+            buttonColor?: string;
+            pageInfoColor?: string;
+        }>;
+        readonly default: () => {
+            color: string;
+            backgroundColor: string;
+        };
+    };
+}>> & Readonly<{}>, {
+    readonly data: import('../card-content').ContentModel[];
+    readonly imgSrc: string;
+    readonly styleConfig: import('vue').CSSProperties;
+    readonly paginationStyle: import('vue').CSSProperties & {
+        buttonHoverColor?: string;
+        textColor?: string;
+        buttonColor?: string;
+        pageInfoColor?: string;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>>;
+export default CxCardPage;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxCardPage: typeof CxCardPage;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/card-page/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/card-page/index.ts"],"names":[],"mappings":"AAEA,cAAc,gBAAgB,CAAC;AAE/B,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wFAAyB,CAAC;AAC1C,eAAe,UAAU,CAAC;AAE1B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,UAAU,EAAE,OAAO,UAAU,CAAC;KAC/B;CACF"}

package/plugins/plugins/cesium-vue/dist/components/carousel-img/index.d.ts

@@ -0,0 +1,21 @@
+export * from './src/carouselImg';
+declare const CxCarouselImg: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<string[]>;
+        readonly default: () => never[];
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly data: {
+        readonly type: import('vue').PropType<string[]>;
+        readonly default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    readonly data: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+export default CxCarouselImg;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxCarouselImg: typeof CxCarouselImg;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/carousel-img/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/carousel-img/index.ts"],"names":[],"mappings":"AAEA,cAAc,mBAAmB,CAAC;AAElC,QAAA,MAAM,aAAa;;;;;;;;;;;;6EAA4B,CAAC;AAChD,eAAe,aAAa,CAAC;AAE7B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,aAAa,EAAE,OAAO,aAAa,CAAC;KACrC;CACF"}

package/plugins/plugins/cesium-vue/dist/components/echarts-pro/index.d.ts

@@ -0,0 +1,68 @@
+export * from './src/echartsPro';
+declare const CxEchartsPro: import('@report-components/utils/with-install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly width: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+    readonly option: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly dataset: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly dataSourceSetting: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly theme: {
+        readonly type: StringConstructor;
+        readonly default: "light";
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly width: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "100%";
+    };
+    readonly option: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly dataset: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly dataSourceSetting: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly theme: {
+        readonly type: StringConstructor;
+        readonly default: "light";
+    };
+}>> & Readonly<{}>, {
+    readonly option: Record<string, any>;
+    readonly width: string;
+    readonly height: string;
+    readonly theme: string;
+    readonly dataset: Record<string, any>;
+    readonly dataSourceSetting: Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    chartRef: HTMLDivElement;
+}, HTMLDivElement>>;
+export default CxEchartsPro;
+declare module 'vue' {
+    interface GlobalComponents {
+        CxEchartsPro: typeof CxEchartsPro;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/plugins/plugins/cesium-vue/dist/components/echarts-pro/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/echarts-pro/index.ts"],"names":[],"mappings":"AAEA,cAAc,kBAAkB,CAAC;AAEjC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA2B,CAAC;AAC9C,eAAe,YAAY,CAAC;AAE5B,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAiB,gBAAgB;QAC/B,YAAY,EAAE,OAAO,YAAY,CAAC;KACnC;CACF"}