@ued_fpi/data-visual 1.2.15 → 1.2.19

package/dist/es/wgms/src/CrossSectionCorrelation/index.vue.d.ts

@@ -1,104 +1,50 @@
+import type { CROSS_SECTION_CORRELATION_API_REQUEST } from './api/types';
 declare const _default: import("vue").DefineComponent<{
-    time: {
-        type: NumberConstructor;
-        default: number;
-    };
-    analysisTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    beginTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    accessCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    targetFactorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    queryTimeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    sourceFactors: {
-        type: StringConstructor;
-        default: string;
-    };
-    delayedFlag: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    filterEmpty: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    limit: {
-        type: NumberConstructor;
-        default: number;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    time: {
-        type: NumberConstructor;
-        default: number;
-    };
-    analysisTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    beginTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    accessCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    targetFactorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    queryTimeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    sourceFactors: {
-        type: StringConstructor;
-        default: string;
-    };
-    delayedFlag: {
+    params: {
+        type: globalThis.PropType<CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+        default: () => {
+            alartTime: number;
+            analysisTime: number;
+            accessCode: string;
+            targetFactorId: number;
+            queryTimeType: string;
+            beginTime: number;
+            endTime: number;
+            delayedFlag: boolean;
+            filterEmptyData: boolean;
+            limit: number;
+            factorCode: string;
+        };
+    };
+    isLazy: {
         type: BooleanConstructor;
         default: boolean;
     };
-    filterEmpty: {
+}, {
+    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<CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+        default: () => {
+            alartTime: number;
+            analysisTime: number;
+            accessCode: string;
+            targetFactorId: number;
+            queryTimeType: string;
+            beginTime: number;
+            endTime: number;
+            delayedFlag: boolean;
+            filterEmptyData: boolean;
+            limit: number;
+            factorCode: string;
+        };
+    };
+    isLazy: {
         type: BooleanConstructor;
         default: boolean;
     };
-    limit: {
-        type: NumberConstructor;
-        default: number;
-    };
 }>>, {
-    time: number;
-    beginTime: number;
-    endTime: number;
-    queryTimeType: string;
-    accessCode: string;
-    limit: number;
-    analysisTime: number;
-    targetFactorId: number;
-    sourceFactors: string;
-    delayedFlag: boolean;
-    filterEmpty: boolean;
+    params: CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis;
+    isLazy: boolean;
 }, {}>;
 export default _default;

package/dist/es/wgms/src/CrossSectionCorrelation/index.vue.mjs

@@ -1,140 +1,137 @@
-import { defineComponent, reactive, watch, onMounted, nextTick, toRefs, openBlock, createElementBlock, createElementVNode, Fragment, renderList, unref, toDisplayString, createVNode, createStaticVNode } from 'vue';
+import { defineComponent, reactive, onMounted, watch, toRefs, openBlock, createElementBlock, createElementVNode, createCommentVNode, Fragment, renderList, unref, toDisplayString, createVNode } from 'vue';
 import dayjs from 'dayjs';
+import { getDateEndTime } from '../../utils/tools.mjs';
 import _sfc_main$1 from '../common/ProgressBar.vue.mjs';
 import '../common/ProgressBar.vue2.mjs';
 import { correlationAnalysis } from './api/index.mjs';
 
 const _hoisted_1 = { class: "dv-wgms-cross-section-correlation" };
 const _hoisted_2 = { class: "section-correlation-table" };
-const _hoisted_3 = /* @__PURE__ */ createStaticVNode('<div class="section-correlation-list header"><span class="sort"></span><span class="name"></span><span class="progress"></span><span class="correlation-coefficient">相关系数</span><span class="alarm">报警数</span></div>', 1);
-const _hoisted_4 = { class: "sort" };
-const _hoisted_5 = ["title"];
-const _hoisted_6 = { class: "progress" };
-const _hoisted_7 = { class: "correlation-coefficient green" };
-const _hoisted_8 = { class: "alarm red" };
+const _hoisted_3 = { class: "section-correlation-list header" };
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("span", { class: "sort" }, null, -1);
+const _hoisted_5 = /* @__PURE__ */ createElementVNode("span", { class: "name" }, null, -1);
+const _hoisted_6 = {
+  key: 0,
+  class: "progress"
+};
+const _hoisted_7 = {
+  key: 1,
+  class: "correlation-coefficient"
+};
+const _hoisted_8 = /* @__PURE__ */ createElementVNode("span", { class: "alarm" }, "报警数", -1);
+const _hoisted_9 = { class: "sort" };
+const _hoisted_10 = ["title"];
+const _hoisted_11 = {
+  key: 0,
+  class: "progress"
+};
+const _hoisted_12 = {
+  key: 1,
+  class: "correlation-coefficient green"
+};
+const _hoisted_13 = { class: "alarm red" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "index",
   props: {
-    time: {
-      type: Number,
-      default: dayjs().startOf("year").valueOf()
-    },
-    analysisTime: {
-      type: Number,
-      default: 27
-    },
-    beginTime: {
-      type: Number,
-      default: dayjs().startOf("year").valueOf()
-    },
-    endTime: {
-      type: Number,
-      default: dayjs().endOf("year").valueOf()
-    },
-    accessCode: {
-      type: String,
-      default: ""
-    },
-    targetFactorId: {
-      type: Number,
-      default: 27
-    },
-    queryTimeType: {
-      type: String,
-      default: "hour"
-    },
-    sourceFactors: {
-      type: String,
-      default: ""
-    },
-    delayedFlag: {
-      type: Boolean,
-      default: true
+    params: {
+      type: Object,
+      default: () => {
+        return {
+          alartTime: 1701964799999,
+          // 报警时间
+          analysisTime: 24,
+          accessCode: "31100614",
+          targetFactorId: 1,
+          queryTimeType: "day",
+          beginTime: 170136e7,
+          // 分析时间开始
+          endTime: 1701964799999,
+          // 分析时间结束
+          delayedFlag: true,
+          filterEmptyData: true,
+          limit: 3,
+          factorCode: "w01009"
+        };
+      }
     },
-    filterEmpty: {
+    isLazy: {
       type: Boolean,
       default: false
-    },
-    limit: {
-      type: Number,
-      default: 3
     }
   },
-  setup(__props) {
+  setup(__props, { expose: __expose }) {
     const props = __props;
     const data = reactive({
-      relativeData: [],
-      firstAlarmNum: "",
-      params: {
-        time: 16539264e5,
-        analysisTime: 24,
-        accessCode: "GKA330100_2009",
-        targetFactorId: 27,
-        queryTimeType: "hour",
-        beginTime: 16539264e5,
-        endTime: 16566912e5,
-        sourceFactors: "",
-        delayedFlag: true,
-        filterEmpty: false,
-        limit: 3
-      }
+      relativeData: []
     });
     const getData = async () => {
-      const res = await correlationAnalysis(data.params);
+      const params = {
+        time: dayjs(props?.params?.alartTime).valueOf(),
+        // 报警时间
+        analysisTime: props?.params?.analysisTime,
+        accessCode: props?.params?.accessCode,
+        targetFactorId: props?.params?.targetFactorId,
+        queryTimeType: props?.params?.queryTimeType,
+        beginTime: props?.params?.beginTime,
+        // 分析时间开始
+        endTime: getDateEndTime(props?.params?.queryTimeType, props.params?.endTime),
+        sourceFactors: props?.params?.factorCode,
+        delayedFlag: props?.params?.delayedFlag,
+        filterEmptyData: props?.params?.filterEmptyData,
+        limit: props?.params?.limit
+      };
+      const res = await correlationAnalysis(params);
       const resData = res.data || [];
       data.relativeData = resData.map((item) => {
         return {
+          rank: item.rank,
           label: item.name,
           alarmNum: item.alarmCount,
-          coefficientDoubleValue: item.corr
+          coefficientDoubleValue: item.corr !== null ? item.corr : "--"
         };
       });
+      if (props?.params?.queryTimeType === "hour")
+        data.relativeData = data.relativeData.filter((item) => !(item.alarmNum === 0 && item.coefficientDoubleValue === "--"));
+      else
+        data.relativeData = data.relativeData.filter((item) => item.alarmNum !== 0);
     };
-    const initData = () => {
-      data.params = {
-        time: props.time,
-        analysisTime: props.analysisTime,
-        accessCode: props.accessCode,
-        targetFactorId: props.targetFactorId,
-        queryTimeType: props.queryTimeType,
-        beginTime: props.beginTime,
-        endTime: props.endTime,
-        sourceFactors: props.sourceFactors,
-        delayedFlag: props.delayedFlag,
-        filterEmpty: props.filterEmpty,
-        limit: props.limit
-      };
-      getData();
-    };
-    watch(() => [props.time, props.analysisTime, props.accessCode, props.targetFactorId, props.queryTimeType, props.beginTime, props.endTime, props.sourceFactors, props.delayedFlag, props.filterEmpty, props.limit], () => {
-      initData();
+    onMounted(() => {
+      !props.isLazy && getData();
     });
-    onMounted(async () => {
-      await nextTick();
-      initData();
+    watch([() => props.params, () => props.isLazy], () => {
+      !props.isLazy && getData();
+    }, { deep: true });
+    __expose({
+      reload: getData
     });
-    const { relativeData, params } = toRefs(data);
+    const { relativeData } = toRefs(data);
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", _hoisted_1, [
         createElementVNode("div", _hoisted_2, [
-          _hoisted_3,
+          createElementVNode("div", _hoisted_3, [
+            _hoisted_4,
+            _hoisted_5,
+            props?.params?.queryTimeType === "hour" ? (openBlock(), createElementBlock("span", _hoisted_6)) : createCommentVNode("", true),
+            props?.params?.queryTimeType === "hour" ? (openBlock(), createElementBlock("span", _hoisted_7, "相关系数")) : createCommentVNode("", true),
+            _hoisted_8
+          ]),
           (openBlock(true), createElementBlock(Fragment, null, renderList(unref(relativeData), (item, index) => {
             return openBlock(), createElementBlock("div", {
               key: index,
               class: "section-correlation-list"
             }, [
-              createElementVNode("span", _hoisted_4, toDisplayString(index + 1), 1),
+              createElementVNode("span", _hoisted_9, toDisplayString(item.rank), 1),
               createElementVNode("span", {
                 class: "name",
                 title: item.label
-              }, toDisplayString(item.label), 9, _hoisted_5),
-              createElementVNode("div", _hoisted_6, [
+              }, toDisplayString(item.label), 9, _hoisted_10),
+              props?.params?.queryTimeType === "hour" ? (openBlock(), createElementBlock("div", _hoisted_11, [
                 createVNode(_sfc_main$1, {
                   percentage: item.coefficientDoubleValue * 100
                 }, null, 8, ["percentage"])
-              ]),
-              createElementVNode("span", _hoisted_7, toDisplayString(item.coefficientDoubleValue || "--"), 1),
-              createElementVNode("span", _hoisted_8, toDisplayString(item.alarmNum || "--"), 1)
+              ])) : createCommentVNode("", true),
+              props?.params?.queryTimeType === "hour" ? (openBlock(), createElementBlock("span", _hoisted_12, toDisplayString(item.coefficientDoubleValue ?? "--"), 1)) : createCommentVNode("", true),
+              createElementVNode("span", _hoisted_13, toDisplayString(item.alarmNum || item.alarmNum === 0 ? item.alarmNum : "--"), 1)
             ]);
           }), 128))
         ])

package/dist/es/wgms/src/DayKLine/api/index.d.ts

@@ -0,0 +1,21 @@
+import type { DAY_KLINE_API_REQUEST, DAY_KLINE_API_RESPONSE } from './types';
+/**
+ * @name: getKLine
+ * @test: test font
+ * @msg: K线
+ * @param {DAY_KLINE_API_REQUEST} params
+ * @return {*}
+ */
+export declare const getKLine: (params: DAY_KLINE_API_REQUEST.getKLine) => Promise<{
+    code: number;
+    data: DAY_KLINE_API_RESPONSE.getKLineTs[] | null;
+    message: string;
+}>;
+/**
+ * @name: waterSurfaceListAll
+ * @test: test font
+ * @msg: 地表水断面水质等级
+ * @param {UPSTREAM_IMPACT_API_REQUEST} params
+ * @return {*}
+ */
+export declare const waterSurfaceListAll: (params: {}) => Promise<any>;

package/dist/es/wgms/src/DayKLine/api/index.mjs

@@ -0,0 +1,19 @@
+import requestControl from '../../../service/request.mjs';
+
+const getKLine = (params) => {
+  return requestControl({
+    url: "/api/v1.0/analyse/kLineAnalyse",
+    server: "wgmsMonitorDataServer",
+    method: "get",
+    params
+  });
+};
+const waterSurfaceListAll = (params) => {
+  return requestControl({
+    url: "/api/v1.0/water/qualityGrade/listAll",
+    server: "envStandardManagerServer",
+    params
+  });
+};
+
+export { getKLine, waterSurfaceListAll };

package/dist/es/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/es/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/es/wgms/src/DayKLine/index.mjs

@@ -0,0 +1,7 @@
+import { install } from '../../utils/tools.mjs';
+import _sfc_main from './index.vue.mjs';
+import './index.vue2.mjs';
+
+const DvWgmsDayKLine = install(_sfc_main);
+
+export { DvWgmsDayKLine, _sfc_main as default };

package/dist/es/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;