@ued_fpi/data-visual 1.2.13 → 1.2.15

package/dist/lib/wgms/index.js

@@ -2,16 +2,16 @@
 
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
 
-const index$n = require('./src/index.js');
+const index$u = require('./src/index.js');
 
 const wgms = {
   install: (app) => {
-    for (const c in index$n) {
-      const currCom = index$n[c];
+    for (const c in index$u) {
+      const currCom = index$u[c];
       if (currCom.__name === "index")
         app.component(c, currCom);
       else
-        app.use(index$n[c]);
+        app.use(index$u[c]);
     }
   }
 };

package/dist/lib/wgms/src/CrossSectionCorrelation/index.vue.js

@@ -85,7 +85,6 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     });
     const getData = async () => {
       const res = await index.correlationAnalysis(data.params);
-      console.log(res);
       const resData = res.data || [];
       data.relativeData = resData.map((item) => {
         return {

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/api/index.d.ts

@@ -0,0 +1,6 @@
+import type { WATER_QUALITY_LEVEL_RES } from './types';
+export declare const waterQualityLevel: (params: WATER_QUALITY_LEVEL_RES.ParamsRequest) => Promise<{
+    code: number;
+    data: WATER_QUALITY_LEVEL_RES.DataResponse[] | null;
+    message: string;
+}>;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/api/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const request = require('../../../service/request.js');
+
+const waterQualityLevel = (params) => {
+  return request.default({
+    url: "/api/v1/screen/water-quality-level-distribution",
+    server: "wgmsScreenServer",
+    params
+  });
+};
+
+exports.waterQualityLevel = waterQualityLevel;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/api/types.d.ts

@@ -0,0 +1,15 @@
+export declare namespace WATER_QUALITY_LEVEL_RES {
+    interface ParamsRequest {
+        treeId: number | string;
+        treeType: number;
+        year: string;
+    }
+    interface DataResponse {
+        count: number | null;
+        level: number | null;
+        levelName: string | null;
+        percent: number | null;
+        qoqPercent: number | null;
+        totalCount: number | null;
+    }
+}

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/index.d.ts

@@ -0,0 +1,158 @@
+import _DistributionOfWaterQualityLevels from './index.vue';
+export declare const DvWgmsDistributionOfWaterQualityLevels: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            data?: import("./api/types").WATER_QUALITY_LEVEL_RES.DataResponse[] | undefined;
+            params?: import("./api/types").WATER_QUALITY_LEVEL_RES.ParamsRequest | undefined;
+            isLazy?: boolean | undefined;
+            key?: string | number | symbol | undefined;
+            style?: unknown;
+            ref?: import("vue").VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: globalThis.VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            class?: unknown;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: globalThis.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: globalThis.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            params: {
+                type: globalThis.PropType<import("./api/types").WATER_QUALITY_LEVEL_RES.ParamsRequest>;
+                default: () => {
+                    treeId: number;
+                    treeType: number;
+                    year: string;
+                };
+            };
+            data: {
+                type: globalThis.PropType<import("./api/types").WATER_QUALITY_LEVEL_RES.DataResponse[]>;
+                default: () => never[];
+            };
+            isLazy: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>, {
+            reload: () => Promise<void>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            data: import("./api/types").WATER_QUALITY_LEVEL_RES.DataResponse[];
+            params: import("./api/types").WATER_QUALITY_LEVEL_RES.ParamsRequest;
+            isLazy: boolean;
+        }, {}, string, {}> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: globalThis.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: globalThis.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        params: {
+            type: globalThis.PropType<import("./api/types").WATER_QUALITY_LEVEL_RES.ParamsRequest>;
+            default: () => {
+                treeId: number;
+                treeType: number;
+                year: string;
+            };
+        };
+        data: {
+            type: globalThis.PropType<import("./api/types").WATER_QUALITY_LEVEL_RES.DataResponse[]>;
+            default: () => never[];
+        };
+        isLazy: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{
+        reload: () => Promise<void>;
+    }> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    params: {
+        type: globalThis.PropType<import("./api/types").WATER_QUALITY_LEVEL_RES.ParamsRequest>;
+        default: () => {
+            treeId: number;
+            treeType: number;
+            year: string;
+        };
+    };
+    data: {
+        type: globalThis.PropType<import("./api/types").WATER_QUALITY_LEVEL_RES.DataResponse[]>;
+        default: () => never[];
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    data: import("./api/types").WATER_QUALITY_LEVEL_RES.DataResponse[];
+    params: import("./api/types").WATER_QUALITY_LEVEL_RES.ParamsRequest;
+    isLazy: boolean;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
+export default _DistributionOfWaterQualityLevels;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const tools = require('../../utils/tools.js');
+const index_vue_vue_type_script_setup_true_lang = require('./index.vue.js');
+require('./index.vue2.js');
+
+const DvWgmsDistributionOfWaterQualityLevels = tools.install(index_vue_vue_type_script_setup_true_lang.default);
+
+exports.default = index_vue_vue_type_script_setup_true_lang.default;
+exports.DvWgmsDistributionOfWaterQualityLevels = DvWgmsDistributionOfWaterQualityLevels;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/index.vue.d.ts

@@ -0,0 +1,43 @@
+import type { WATER_QUALITY_LEVEL_RES } from './api/types';
+declare const _default: import("vue").DefineComponent<{
+    params: {
+        type: globalThis.PropType<WATER_QUALITY_LEVEL_RES.ParamsRequest>;
+        default: () => {
+            treeId: number;
+            treeType: number;
+            year: string;
+        };
+    };
+    data: {
+        type: globalThis.PropType<WATER_QUALITY_LEVEL_RES.DataResponse[]>;
+        default: () => never[];
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    params: {
+        type: globalThis.PropType<WATER_QUALITY_LEVEL_RES.ParamsRequest>;
+        default: () => {
+            treeId: number;
+            treeType: number;
+            year: string;
+        };
+    };
+    data: {
+        type: globalThis.PropType<WATER_QUALITY_LEVEL_RES.DataResponse[]>;
+        default: () => never[];
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    data: WATER_QUALITY_LEVEL_RES.DataResponse[];
+    params: WATER_QUALITY_LEVEL_RES.ParamsRequest;
+    isLazy: boolean;
+}, {}>;
+export default _default;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/index.vue.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const dayjs = require('dayjs');
+const commonArrow_vue_vue_type_script_setup_true_lang = require('../common/common-arrow.vue.js');
+require('../common/common-arrow.vue2.js');
+const utils = require('../../../utils.js');
+const index = require('./api/index.js');
+
+const _hoisted_1 = { class: "dv-wgms-water-quality-level-list" };
+const _hoisted_2 = { class: "line-value" };
+const _hoisted_3 = { class: "text" };
+const _hoisted_4 = { class: "value" };
+const _hoisted_5 = { class: "val" };
+const _hoisted_6 = /* @__PURE__ */ vue.createElementVNode("span", { class: "split" }, "/", -1);
+const _hoisted_7 = { class: "line-compare" };
+const _hoisted_8 = /* @__PURE__ */ vue.createElementVNode("div", { class: "text" }, " 环比 ", -1);
+const _hoisted_9 = { class: "value dv-wgms-flex-left-center" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    params: {
+      type: Object,
+      default: () => {
+        return {
+          treeId: 3301,
+          treeType: 1,
+          year: dayjs().format("YYYY")
+        };
+      }
+    },
+    data: {
+      type: Array,
+      default: () => []
+    },
+    isLazy: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const { isDark } = utils.useThemeHook();
+    const levelList = vue.ref();
+    const getResData = async () => {
+      if (props.data && props.data.length) {
+        levelList.value = props.data;
+        return;
+      }
+      const { data: res } = await index.waterQualityLevel(props.params);
+      res && (levelList.value = res);
+    };
+    vue.onMounted(() => {
+      !props.isLazy && getResData();
+    });
+    vue.watch([() => props.params, () => props.data, () => props.isLazy], () => {
+      !props.isLazy && getResData();
+    }, { deep: true });
+    __expose({
+      reload: getResData
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(levelList), (item, index) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: index,
+            class: "dv-wgms-water-quality-level-list-item"
+          }, [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(["data-base", vue.unref(isDark) ? "" : "light"])
+            }, vue.toDisplayString(item.percent === null ? "--" : `${item.percent}%`), 3),
+            vue.createElementVNode("div", _hoisted_2, [
+              vue.createElementVNode("div", _hoisted_3, vue.toDisplayString(item.levelName), 1),
+              vue.createElementVNode("div", _hoisted_4, [
+                vue.createElementVNode("span", _hoisted_5, vue.toDisplayString(item.count === null ? "--" : item.count), 1),
+                _hoisted_6,
+                vue.createElementVNode("span", null, vue.toDisplayString(item.totalCount === null ? "--" : item.totalCount), 1)
+              ])
+            ]),
+            vue.createElementVNode("div", _hoisted_7, [
+              _hoisted_8,
+              vue.createElementVNode("div", _hoisted_9, [
+                vue.createElementVNode("span", {
+                  class: "mgr4",
+                  style: vue.normalizeStyle({ color: item.qoqPercent === null ? "var(--dv-color-text-placeholder)" : item.qoqPercent > 0 ? "var(--dv-color-success)" : item.qoqPercent < 0 ? "var(--dv-color-danger)" : "var(--dv-color-index)" })
+                }, vue.toDisplayString(item.qoqPercent === null ? "--" : item.qoqPercent === 0 ? "持平" : `${item.qoqPercent}%`), 5),
+                item.qoqPercent !== null ? (vue.openBlock(), vue.createBlock(commonArrow_vue_vue_type_script_setup_true_lang.default, {
+                  key: 0,
+                  direction: item.qoqPercent > 0 ? "up" : item.qoqPercent < 0 ? "down" : "flat"
+                }, null, 8, ["direction"])) : vue.createCommentVNode("", true)
+              ])
+            ])
+          ]);
+        }), 128))
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/index.vue2.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+/* unplugin-vue-components disabled */const index_vue_vue_type_style_index_0_lang = '';
+
+exports.default = index_vue_vue_type_style_index_0_lang;

package/dist/lib/wgms/src/DistributionOfWaterQualityLevels/index.vue3.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const index_vue_vue_type_script_setup_true_lang = require('./index.vue.js');
+require('./index.vue2.js');
+
+
+
+exports.default = index_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/wgms/src/DrinkingWaterComplianceRate/index.d.ts

@@ -5,6 +5,7 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
         $data: {};
         $props: {
             params?: import("./api/types").DRINK_WATER_RES.ParamsRequest | undefined;
+            isLazy?: boolean | undefined;
             titleStyle?: Record<string, any> | undefined;
             key?: string | number | symbol | undefined;
             style?: unknown;
@@ -80,6 +81,12 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
                     waterSourceScaleCode: string;
                 };
             };
+            isLazy: {
+                type: globalThis.PropType<boolean>;
+                required: true;
+            } & {
+                default: boolean;
+            };
             titleStyle: {
                 type: globalThis.PropType<Record<string, any>>;
                 required: true;
@@ -88,8 +95,11 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
                     color: string;
                 };
             };
-        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        }>>, {
+            reload: () => Promise<void>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
             params: import("./api/types").DRINK_WATER_RES.ParamsRequest;
+            isLazy: boolean;
             titleStyle: Record<string, any>;
         }, {}, string, {}> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
@@ -127,6 +137,12 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
                 waterSourceScaleCode: string;
             };
         };
+        isLazy: {
+            type: globalThis.PropType<boolean>;
+            required: true;
+        } & {
+            default: boolean;
+        };
         titleStyle: {
             type: globalThis.PropType<Record<string, any>>;
             required: true;
@@ -135,7 +151,9 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
                 color: string;
             };
         };
-    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    }>> & import("vue").ShallowUnwrapRef<{
+        reload: () => Promise<void>;
+    }> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
@@ -155,6 +173,12 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
             waterSourceScaleCode: string;
         };
     };
+    isLazy: {
+        type: globalThis.PropType<boolean>;
+        required: true;
+    } & {
+        default: boolean;
+    };
     titleStyle: {
         type: globalThis.PropType<Record<string, any>>;
         required: true;
@@ -163,8 +187,11 @@ export declare const DvWgmsDrinkingWaterComplianceRate: {
             color: string;
         };
     };
-}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+}>>, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
     params: import("./api/types").DRINK_WATER_RES.ParamsRequest;
+    isLazy: boolean;
     titleStyle: Record<string, any>;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
 export default _DrinkingWaterComplianceRate;

package/dist/lib/wgms/src/DrinkingWaterComplianceRate/index.vue.d.ts

@@ -2,6 +2,7 @@ import type { DRINK_WATER_RES } from './api/types';
 declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     params: DRINK_WATER_RES.ParamsRequest;
     titleStyle: Record<string, any>;
+    isLazy: boolean;
 }>, {
     params: () => {
         startTime: number;
@@ -16,9 +17,13 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     titleStyle: () => {
         color: string;
     };
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    isLazy: boolean;
+}>, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     params: DRINK_WATER_RES.ParamsRequest;
     titleStyle: Record<string, any>;
+    isLazy: boolean;
 }>, {
     params: () => {
         startTime: number;
@@ -33,8 +38,10 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     titleStyle: () => {
         color: string;
     };
+    isLazy: boolean;
 }>>>, {
     params: DRINK_WATER_RES.ParamsRequest;
+    isLazy: boolean;
     titleStyle: Record<string, any>;
 }, {}>;
 export default _default;

package/dist/lib/wgms/src/DrinkingWaterComplianceRate/index.vue.js

@@ -38,16 +38,17 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       return {
         color: "#909399"
       };
-    } }
+    } },
+    isLazy: { type: Boolean, default: false }
   },
-  setup(__props) {
+  setup(__props, { expose: __expose }) {
     const props = __props;
     const { isDark } = utils.useThemeHook();
     vue.onMounted(() => {
-      getResData();
+      !props.isLazy && getResData();
     });
     vue.watch(() => props.params, () => {
-      getResData();
+      !props.isLazy && getResData();
     }, { deep: true });
     const imgList = /* #__PURE__ */ Object.assign({"./images/icon-1.svg": icon1,"./images/icon-2.svg": icon2,"./images/icon-3.svg": icon3,"./images/icon-light-1.svg": iconLight1,"./images/icon-light-2.svg": iconLight2,"./images/icon-light-3.svg": iconLight3});
     const listData = vue.ref();
@@ -63,6 +64,9 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     const getImg = (url) => {
       return imgList[url]?.default;
     };
+    __expose({
+      reload: getResData
+    });
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
         (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(listData.value, (item, index) => {

package/dist/lib/wgms/src/FactorTopThreeRanking/index.vue.js

@@ -62,7 +62,6 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       () => props.endTime,
       () => props.data
     ], () => {
-      console.log(props.data, "props.data");
       if (!props.data) {
         getData();
       } else {

package/dist/lib/wgms/src/KeyRiverWaterQualityEvaluation/index.d.ts

@@ -6,6 +6,7 @@ export declare const DvWgmsKeyRiverWaterQualityEvaluation: {
         $props: {
             data?: import("./api/types").KEY_RIVER_RES.DataResponse[] | undefined;
             params?: import("./api/types").KEY_RIVER_RES.ParamsRequest | undefined;
+            isLazy?: boolean | undefined;
             key?: string | number | symbol | undefined;
             style?: unknown;
             ref?: import("vue").VNodeRef | undefined;
@@ -82,9 +83,18 @@ export declare const DvWgmsKeyRiverWaterQualityEvaluation: {
                     treeId: string;
                 };
             };
-        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            isLazy: {
+                type: globalThis.PropType<boolean>;
+                required: true;
+            } & {
+                default: boolean;
+            };
+        }>>, {
+            reload: () => Promise<void>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
             data: import("./api/types").KEY_RIVER_RES.DataResponse[];
             params: import("./api/types").KEY_RIVER_RES.ParamsRequest;
+            isLazy: boolean;
         }, {}, string, {}> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
@@ -123,7 +133,15 @@ export declare const DvWgmsKeyRiverWaterQualityEvaluation: {
                 treeId: string;
             };
         };
-    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+        isLazy: {
+            type: globalThis.PropType<boolean>;
+            required: true;
+        } & {
+            default: boolean;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{
+        reload: () => Promise<void>;
+    }> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
@@ -145,8 +163,17 @@ export declare const DvWgmsKeyRiverWaterQualityEvaluation: {
             treeId: string;
         };
     };
-}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    isLazy: {
+        type: globalThis.PropType<boolean>;
+        required: true;
+    } & {
+        default: boolean;
+    };
+}>>, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
     data: import("./api/types").KEY_RIVER_RES.DataResponse[];
     params: import("./api/types").KEY_RIVER_RES.ParamsRequest;
+    isLazy: boolean;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
 export default _KeyRiverWaterQualityEvaluation;