@ued_fpi/data-visual 1.2.15 → 1.2.19

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

@@ -0,0 +1,32 @@
+export declare namespace DAY_KLINE_API_REQUEST {
+    interface getKLine {
+        accessCode: string;
+        factor: number | string;
+        factorFlag: boolean;
+        beginTime: number;
+        endTime: number;
+        queryTimeType: string;
+    }
+    interface requestParamsTs {
+        accessCode: string;
+        factor: number | string;
+        factorFlag: boolean;
+        alarmTime: number;
+        timeDiff: number;
+        queryTimeType: string;
+        factorName: string;
+        factorCode: string;
+        factorUnit: string;
+    }
+}
+export declare namespace DAY_KLINE_API_RESPONSE {
+    interface getKLineTs {
+        'time': string;
+        'value': string;
+        'quality': number;
+        'maxValue': number | string;
+        'minValue': number | string;
+        'firstValue': number | string;
+        'lastValue': number | string;
+    }
+}

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

@@ -0,0 +1,161 @@
+import _DayKLine from './index.vue';
+export declare const DvWgmsDayKLine: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            params?: import("./api/types").DAY_KLINE_API_REQUEST.requestParamsTs | 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").DAY_KLINE_API_REQUEST.requestParamsTs>;
+                default: () => {
+                    accessCode: string;
+                    factor: number;
+                    factorFlag: boolean;
+                    alarmTime: number;
+                    timeDiff: number;
+                    queryTimeType: string;
+                    factorName: string;
+                    factorCode: string;
+                    factorUnit: string;
+                };
+            };
+            isLazy: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>, {
+            reload: () => Promise<void>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            params: import("./api/types").DAY_KLINE_API_REQUEST.requestParamsTs;
+            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").DAY_KLINE_API_REQUEST.requestParamsTs>;
+            default: () => {
+                accessCode: string;
+                factor: number;
+                factorFlag: boolean;
+                alarmTime: number;
+                timeDiff: number;
+                queryTimeType: string;
+                factorName: string;
+                factorCode: string;
+                factorUnit: string;
+            };
+        };
+        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").DAY_KLINE_API_REQUEST.requestParamsTs>;
+        default: () => {
+            accessCode: string;
+            factor: number;
+            factorFlag: boolean;
+            alarmTime: number;
+            timeDiff: number;
+            queryTimeType: string;
+            factorName: string;
+            factorCode: string;
+            factorUnit: string;
+        };
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    params: import("./api/types").DAY_KLINE_API_REQUEST.requestParamsTs;
+    isLazy: boolean;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
+export default _DayKLine;

package/dist/lib/wgms/src/DayKLine/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 DvWgmsDayKLine = tools.install(index_vue_vue_type_script_setup_true_lang.default);
+
+exports.default = index_vue_vue_type_script_setup_true_lang.default;
+exports.DvWgmsDayKLine = DvWgmsDayKLine;

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

@@ -0,0 +1,47 @@
+import type { PropType } from 'vue';
+import type { DAY_KLINE_API_REQUEST } from './api/types';
+declare const _default: import("vue").DefineComponent<{
+    params: {
+        type: PropType<DAY_KLINE_API_REQUEST.requestParamsTs>;
+        default: () => {
+            accessCode: string;
+            factor: number;
+            factorFlag: boolean;
+            alarmTime: number;
+            timeDiff: number;
+            queryTimeType: string;
+            factorName: string;
+            factorCode: string;
+            factorUnit: string;
+        };
+    };
+    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: PropType<DAY_KLINE_API_REQUEST.requestParamsTs>;
+        default: () => {
+            accessCode: string;
+            factor: number;
+            factorFlag: boolean;
+            alarmTime: number;
+            timeDiff: number;
+            queryTimeType: string;
+            factorName: string;
+            factorCode: string;
+            factorUnit: string;
+        };
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    params: DAY_KLINE_API_REQUEST.requestParamsTs;
+    isLazy: boolean;
+}, {}>;
+export default _default;

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

@@ -0,0 +1,301 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const dayjs = require('dayjs');
+const lodashEs = require('lodash-es');
+const BaseECharts_vue_vue_type_script_setup_true_lang = require('../../utils/echarts/BaseECharts.vue.js');
+const index = require('./api/index.js');
+
+const _hoisted_1 = { class: "dv-wgms-day-kline" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    params: {
+      type: Object,
+      default: () => {
+        return {
+          accessCode: "3116008",
+          factor: 2,
+          factorFlag: false,
+          alarmTime: 1700028e6,
+          timeDiff: 7,
+          queryTimeType: "hour",
+          // 下面是因子
+          factorName: "总磷(以 P 计）",
+          factorCode: "w21003",
+          // 监测因子
+          factorUnit: "mg/L"
+        };
+      }
+    },
+    isLazy: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const chartDayLine = vue.ref();
+    const option = vue.ref(void 0);
+    const timeStrList = {
+      hour: "小时",
+      day: "日",
+      week: "周",
+      month: "月",
+      year: "年"
+    };
+    const getKlineDateParams = (alarmTime, timeDiff) => {
+      let startTime, endTime;
+      if (props.params?.queryTimeType === "hour" || props.params?.queryTimeType === "day") {
+        startTime = dayjs(alarmTime).add(-(timeDiff - 1), "days").startOf("day").format("x");
+        endTime = dayjs(alarmTime).add(1, "days").startOf("day").format("x");
+      } else if (props.params?.queryTimeType === "week") {
+        startTime = dayjs(alarmTime).add(-(timeDiff - 1), "week").startOf("week").format("x");
+        endTime = dayjs(alarmTime).add(1, "week").startOf("week").format("x");
+      } else if (props.params?.queryTimeType === "month") {
+        startTime = dayjs(alarmTime).add(-(timeDiff - 1), "month").startOf("month").format("x");
+        endTime = dayjs(alarmTime).add(1, "month").startOf("month").format("x");
+      } else if (props.params?.queryTimeType === "year") {
+        startTime = dayjs(alarmTime).add(-(timeDiff - 1), "year").startOf("year").format("x");
+        endTime = dayjs(alarmTime).add(1, "year").startOf("year").format("x");
+      }
+      return {
+        startTime,
+        endTime
+      };
+    };
+    const getData = async () => {
+      const { startTime, endTime } = getKlineDateParams(props.params?.alarmTime, props.params?.timeDiff);
+      const params = {
+        accessCode: props.params?.accessCode,
+        factor: props.params?.factor,
+        factorFlag: props.params?.factorFlag,
+        beginTime: startTime,
+        endTime,
+        queryTimeType: props.params?.queryTimeType === "hour" ? "day" : props.params.queryTimeType
+      };
+      const res = await index.getKLine(params);
+      const resData = res?.data || [];
+      const klineData = {
+        xAxis: [],
+        kData: [],
+        values: [],
+        quality: []
+      };
+      resData.forEach((item) => {
+        item.maxValue = Number(item.max);
+        item.minValue = Number(item.min);
+        if (props.params?.queryTimeType === "hour" || props.params?.queryTimeType === "day") {
+          klineData.xAxis.push(item.time);
+        } else {
+          klineData.xAxis.push(item.time);
+        }
+        klineData.kData.push([
+          item.min,
+          item.first,
+          item.avg,
+          item.last,
+          item.max
+        ]);
+        klineData.values.push(item.avg);
+        klineData.quality.push(item.grade);
+      });
+      const maxObj = lodashEs.maxBy(resData, "maxValue");
+      const minObj = lodashEs.minBy(resData, "minValue");
+      vue.nextTick();
+      option.value = await dayKLine(klineData, maxObj?.maxValue, minObj?.minValue, props.params?.factorName, props?.params?.factorUnit, timeStrList[props.params?.queryTimeType === "hour" ? "day" : props.params?.queryTimeType]);
+    };
+    const dayKLine = async (data, min, max, factorName, unit, timeStr) => {
+      const { xAxis, kData, values, quality } = data;
+      const res = await index.waterSurfaceListAll({});
+      const gradeList = res?.entries ?? [];
+      const option2 = {
+        grid: {
+          top: 24,
+          right: 46,
+          bottom: 30,
+          left: 32
+        },
+        tooltip: {
+          link: { xAxisIndex: "all" },
+          trigger: "axis",
+          axisPointer: {
+            type: "shadow"
+          },
+          formatter(param) {
+            param = param[0];
+            const level = quality[param.dataIndex];
+            const currData = gradeList.find((item) => {
+              return level ? Number(item.level) === Number(level.toString()) : false;
+            });
+            const levelColor = currData?.color || "#6D7278";
+            const value_ = !param.value ? "--" : param.value;
+            const marker = param.marker ? param.marker.replace("background-color:#A162F7", `background-color:${levelColor}`) : "";
+            return [`${marker + timeStr}变化 ${param.name}`, `${factorName}：${value_}${unit}`, `水质等级：${currData?.name || "--"}`].join("<br/>");
+          }
+        },
+        xAxis: [
+          {
+            boundaryGap: true,
+            axisTick: {
+              show: false
+            },
+            axisLine: {
+              show: false
+            },
+            axisLabel: {
+              show: true,
+              textStyle: {
+                color: "var(--dv-color-text-primary)",
+                fontFamily: "var(--dv-font-family-number)",
+                fontSize: "var(--dv-text-number2)"
+              },
+              formatter: (time) => {
+                return props.params?.queryTimeType === "hour" || props.params?.queryTimeType === "day" ? dayjs(time).format("MM-DD") : time;
+              }
+            },
+            data: xAxis
+          }
+        ],
+        yAxis: [
+          {
+            type: "value",
+            name: props?.params?.factorUnit || "",
+            nameTextStyle: {
+              align: "right",
+              color: "var(--dv-color-text-secondary)",
+              fontFamily: "var(--dv-font-family-number)",
+              fontSize: "var(--dv-text-number2)",
+              padding: [0, -10, -6, 0]
+            },
+            splitNumber: 5,
+            axisLabel: {
+              show: true,
+              textStyle: {
+                color: "var(--dv-color-text-secondary)",
+                fontFamily: "var(--dv-font-family-number)",
+                fontSize: "var(--dv-text-number2)"
+              }
+            },
+            axisLine: {
+              show: false
+            },
+            axisPointer: {
+              snap: true
+            },
+            splitLine: { show: false },
+            axisTick: { show: false }
+          },
+          {
+            type: "value",
+            name: "",
+            minInterval: 1,
+            axisLabel: {
+              show: true,
+              formatter: (value2) => {
+                if (value2 === 0) {
+                  return "";
+                } else {
+                  const level = gradeList.find((item) => {
+                    return item.level === value2;
+                  })?.name ?? "";
+                  return `${level}类`;
+                }
+              },
+              textStyle: {
+                color: "var(--dv-color-text-secondary)",
+                fontFamily: "var(--dv-font-family-number)",
+                fontSize: "var(--dv-text-number2)"
+              }
+            },
+            axisLine: {
+              show: false
+            },
+            axisPointer: {
+              snap: true
+            },
+            splitLine: {
+              show: true,
+              lineStyle: {
+                color: "var(--dv-color-border-light)",
+                width: 1
+              }
+            },
+            axisTick: { show: false }
+          }
+        ],
+        series: [
+          {
+            name: props?.params?.factorUnit || "",
+            type: "line",
+            // smooth: true,
+            showSymbol: true,
+            symbolSize: 6,
+            lineStyle: {
+              color: "#A162F7",
+              width: 2
+            },
+            color: "var(--dv-color-text-primary)",
+            itemStyle: {
+              color: (params) => {
+                const level = quality[params.dataIndex];
+                const currData = gradeList.filter((item) => {
+                  return level ? Number(item.level) === Number(level.toString()) : false;
+                });
+                if (level != null)
+                  return currData.length ? currData[0].color : "#6D7278";
+              },
+              normal: {
+                color: "#A162F7",
+                borderWidth: 1
+              }
+            },
+            data: values
+          },
+          {
+            name: `${timeStr}变化`,
+            type: "bar",
+            barWidth: 12,
+            yAxisIndex: 1,
+            itemStyle: {
+              color: (params) => {
+                const level = quality[params.dataIndex];
+                const currData = gradeList.filter((item) => {
+                  return level ? Number(item.level) === Number(level.toString()) : false;
+                });
+                if (level != null)
+                  return currData.length ? currData[0].color : "#6D7278";
+              }
+            },
+            data: quality
+          }
+        ]
+      };
+      return option2;
+    };
+    vue.onMounted(() => {
+      !props.isLazy && getData();
+    });
+    vue.watch([() => props.params, () => props.isLazy], () => {
+      !props.isLazy && getData();
+    }, { deep: true });
+    __expose({
+      reload: getData
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createElementVNode("div", {
+          ref_key: "chartDayLine",
+          ref: chartDayLine,
+          class: "chart"
+        }, [
+          vue.createVNode(BaseECharts_vue_vue_type_script_setup_true_lang.default, { options: option.value }, null, 8, ["options"])
+        ], 512)
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/wgms/src/DayKLine/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/DayKLine/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/EnvironmentalAnalysis/images/percent-bg-dark.png.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const _imports_0 = "data:image/png;base64,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";
+
+exports.default = _imports_0;