super-page-runtime 2.0.8 → 2.0.10

package/dist/lib/components/runtime/views/assemblys/button/dropdown/dropdown-runtime.vue2.js

@@ -0,0 +1,110 @@
+"use strict";
+const Vue = require("vue");
+const index = require("../../../../../../node_modules/.pnpm/@element-plus_icons-vue@2.3.1_vue@3.4.21/node_modules/@element-plus/icons-vue/dist/index.js");
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const _hoisted_1 = { key: 1 };
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "dropdown-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const designProperty = runtimeInfo.props ? runtimeInfo.props : {};
+    let listOptions = null;
+    const dataOrigin = props.configure.props && props.configure.props.dataOrigin ? props.configure.props.dataOrigin : {};
+    const valueType = dataOrigin.optionValueSetType;
+    if (valueType == "variable") {
+      listOptions = Vue.computed(() => {
+        let options;
+        const menuValues = pageHelperUtil.formatVariableValue(props.pageContext, designProperty.menuField);
+        if (menuValues && Array.isArray(menuValues)) {
+          options = menuValues;
+          for (let i = 0; i < options.length; i++) {
+            const option = options[i];
+            if (!option.label) {
+              option.label = i + 1;
+            }
+          }
+        } else {
+          const strs = (menuValues ? menuValues + "" : "").trim().split(",");
+          options = [];
+          for (let str of strs) {
+            options.push({
+              value: str,
+              label: str
+            });
+          }
+        }
+        return options;
+      });
+    } else {
+      listOptions = Vue.ref(designProperty.options ? designProperty.options : []);
+    }
+    return (_ctx, _cache) => {
+      const _component_el_button = Vue.resolveComponent("el-button");
+      const _component_el_icon = Vue.resolveComponent("el-icon");
+      const _component_el_text = Vue.resolveComponent("el-text");
+      const _component_el_dropdown_item = Vue.resolveComponent("el-dropdown-item");
+      const _component_el_dropdown_menu = Vue.resolveComponent("el-dropdown-menu");
+      const _component_el_dropdown = Vue.resolveComponent("el-dropdown");
+      return Vue.openBlock(), Vue.createBlock(_component_el_dropdown, {
+        class: Vue.normalizeClass(Vue.unref(runtimeClass)),
+        style: Vue.normalizeStyle(Vue.unref(runtimeStyle)),
+        placement: Vue.unref(designProperty).placement,
+        "split-button": Vue.unref(designProperty).splitButton,
+        disabled: Vue.unref(designProperty).state === "disabled",
+        type: Vue.unref(designProperty).buttonType,
+        size: Vue.unref(designProperty).size,
+        trigger: Vue.unref(designProperty).trigger
+      }, {
+        dropdown: Vue.withCtx(() => [
+          Vue.createVNode(_component_el_dropdown_menu, null, {
+            default: Vue.withCtx(() => [
+              (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(Vue.unref(listOptions), (item, index2) => {
+                return Vue.openBlock(), Vue.createBlock(_component_el_dropdown_item, { key: item }, {
+                  default: Vue.withCtx(() => [
+                    Vue.createTextVNode(Vue.toDisplayString(item.label), 1)
+                  ]),
+                  _: 2
+                }, 1024);
+              }), 128))
+            ]),
+            _: 1
+          })
+        ]),
+        default: Vue.withCtx(() => [
+          Vue.unref(designProperty).triggerElement === "button" ? (Vue.openBlock(), Vue.createElementBlock(Vue.Fragment, { key: 0 }, [
+            !Vue.unref(designProperty).splitButton ? (Vue.openBlock(), Vue.createBlock(_component_el_button, {
+              key: 0,
+              size: Vue.unref(designProperty).size,
+              type: Vue.unref(designProperty).buttonType
+            }, {
+              default: Vue.withCtx(() => [
+                Vue.createTextVNode(Vue.toDisplayString(Vue.unref(designProperty).title), 1)
+              ]),
+              _: 1
+            }, 8, ["size", "type"])) : (Vue.openBlock(), Vue.createElementBlock("span", _hoisted_1, Vue.toDisplayString(Vue.unref(designProperty).title), 1))
+          ], 64)) : (Vue.openBlock(), Vue.createBlock(_component_el_text, { key: 1 }, {
+            default: Vue.withCtx(() => [
+              Vue.createTextVNode(Vue.toDisplayString(Vue.unref(designProperty).title) + " ", 1),
+              Vue.createVNode(_component_el_icon, null, {
+                default: Vue.withCtx(() => [
+                  Vue.createVNode(Vue.unref(index.ArrowDown))
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }))
+        ]),
+        _: 1
+      }, 8, ["class", "style", "placement", "split-button", "disabled", "type", "size", "trigger"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/chart/column-line/column-line-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const columnLineRuntime_vue_vue_type_script_setup_true_lang = require("./column-line-runtime.vue2.js");
+module.exports = columnLineRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/chart/column-line/column-line-runtime.vue2.js

@@ -0,0 +1,432 @@
+"use strict";
+const Vue = require("vue");
+const chartUtil = require("../../../../utils/charts/chart-util.js");
+const commonUtil = require("../../../../utils/common-util.js");
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const commonChartHeader_vue_vue_type_script_setup_true_lang = require("../common/common-chart-header.vue.js");
+const index_esm_min = require("../../../../../../node_modules/.pnpm/vue-echarts@6.6.9_echarts@5.5.0_vue@3.4.21/node_modules/vue-echarts/dist/index.esm.min.js");
+const extension = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/extension.js");
+const installCanvasRenderer = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/renderer/installCanvasRenderer.js");
+const install = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/chart/line/install.js");
+const install$1 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/component/grid/install.js");
+const install$2 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/component/legend/install.js");
+const install$3 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/component/title/install.js");
+const install$4 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/component/tooltip/install.js");
+const install$5 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/chart/bar/install.js");
+const install$6 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/component/toolbox/install.js");
+const install$7 = require("../../../../../../node_modules/.pnpm/echarts@5.5.0/node_modules/echarts/lib/component/dataZoom/install.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "column-line-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    extension.use([
+      installCanvasRenderer.install,
+      install.install,
+      install$1.install,
+      install$2.install,
+      install$3.install,
+      install$4.install,
+      install$5.install,
+      install$6.install,
+      install$7.install
+    ]);
+    const props = __props;
+    const thisRef = Vue.ref(null);
+    const chartRef = Vue.ref(null);
+    const headerRef = Vue.ref(null);
+    const enableDrill = props.configure.props ? props.configure.props.enableDrill : null;
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const dataConfig = runtimeInfo.dataConfig;
+    const headerInfo = runtimeInfo.headerInfo ? runtimeInfo.headerInfo : {};
+    let cacheDatas = null;
+    const chartOption = runtimeInfo.chartOption;
+    const defaultSeries = chartOption.series;
+    if (defaultSeries && defaultSeries.length > 0) {
+      for (let s of defaultSeries) {
+        s.data = [];
+      }
+    }
+    const defaultXaxis = chartOption.xAxis;
+    if (defaultXaxis && defaultXaxis.length > 0 && defaultXaxis[0].data) {
+      defaultXaxis[0].data = [];
+    }
+    const defaultYaxis = chartOption.yAxis;
+    if (defaultYaxis) {
+      for (let yAxis of defaultYaxis) {
+        if (yAxis.data) {
+          yAxis.data = [];
+        }
+      }
+    }
+    console.log("chartOption", chartOption);
+    const configureProps = props.configure.props ? props.configure.props : {};
+    const customTheme = chartUtil.getCustomTheme(configureProps.customTheme);
+    function updateChartDatas(resultData) {
+      if (!resultData) {
+        resultData = [];
+      }
+      resultData = resultData.length > 0 ? resultData[0] : {};
+      if (!resultData) {
+        resultData = {};
+      }
+      if (resultData.hasRender) {
+        resultData.hasRender = true;
+        console.log("重复更新!", resultData);
+        return;
+      }
+      resultData.hasRender = true;
+      updateChartOption(resultData);
+    }
+    Vue.onMounted(() => {
+      const resultData = pageHelperUtil.getChartDatasFromPage(props.pageContext, props.configure);
+      if (resultData) {
+        updateChartDatas(resultData);
+      }
+      if (enableDrill && chartRef.value) {
+        chartRef.value.chart.on("click", function(params) {
+          if (headerRef.value && headerRef.value.drill) {
+            headerRef.value.drill(params, cacheDatas);
+          }
+        });
+      }
+    });
+    function onDrillEnd(params) {
+    }
+    let hisGroupValue = headerInfo.groupValue;
+    Vue.watch(headerInfo, () => {
+      if (hisGroupValue == headerInfo.groupValue) {
+        return;
+      }
+      hisGroupValue = headerInfo.groupValue;
+      refresh();
+    });
+    function refresh() {
+      if (!dataConfig) {
+        console.log("无数据源配置，不需要查询!");
+        return;
+      }
+      dataConfig.services[0].groupValue = headerInfo.groupValue;
+      pageHelperUtil.updateChartDatasources(props.pageContext, [dataConfig], headerInfo.drillParams);
+    }
+    function updateChartOption(resultData) {
+      if (!resultData || !resultData.result) {
+        return;
+      }
+      const result = resultData && resultData.result ? resultData.result : {};
+      const groupValue = resultData && resultData.groupValue ? resultData.groupValue : [];
+      const dataSetField = props.configure.serviceDataField;
+      let datas = null;
+      if (dataSetField) {
+        datas = result[dataSetField];
+      } else {
+        if (result) {
+          if (Array.isArray(result)) {
+            datas = result;
+          } else {
+            datas = [result];
+          }
+        }
+      }
+      if (!datas) {
+        datas = [];
+      }
+      let confGroups = props.configure.props ? props.configure.props.groups : null;
+      if (!confGroups) {
+        confGroups = [];
+      }
+      const groupMap = {};
+      const groupFields = [];
+      for (let g of confGroups) {
+        groupMap[g.group] = g.target;
+        if (g.target && !groupFields.includes(g.target)) {
+          groupFields.push(g.target);
+        }
+      }
+      let mulGroupShow = props.configure.props ? props.configure.props.mulGroupShow : "";
+      mulGroupShow = mulGroupShow == "break" ? "<br/>" : " ";
+      const xFieldName = "__x";
+      for (let d of datas) {
+        if (!d) {
+          continue;
+        }
+        const xValues2 = [];
+        for (let g of groupValue) {
+          const fieldName = groupMap[g];
+          const value = pageHelperUtil.getValueFromSource(d, fieldName, void 0);
+          if (value) {
+            xValues2.push(value);
+          }
+        }
+        const xValue = xValues2.join(mulGroupShow);
+        d[xFieldName] = xValue;
+      }
+      const itemConfs = props.configure.items ? props.configure.items : [];
+      const serieValues = [];
+      const serieValueMap = {};
+      const dynamicFileds = [];
+      const dynamicValueField = {};
+      const allValueFields = [];
+      for (let item of itemConfs) {
+        const itemProps = item.props ? item.props : {};
+        const sourceType = itemProps.yaxisSource;
+        const yaxisField = itemProps.yaxisField;
+        let serieValue = null;
+        if (yaxisField && (!sourceType || sourceType == "variable")) {
+          serieValue = {
+            uuid: item.uuid,
+            type: "variable",
+            field: yaxisField,
+            data: [],
+            dynamicDatas: []
+            //动态系列数据
+          };
+          if (yaxisField && !allValueFields.includes(yaxisField)) {
+            allValueFields.push(yaxisField);
+          }
+        } else {
+          serieValue = {
+            uuid: item.uuid,
+            type: "fixed",
+            field: itemProps.yaxisFix,
+            data: [],
+            dynamicDatas: []
+            //动态系列数据
+          };
+        }
+        if (serieValue != null) {
+          serieValues.push(serieValue);
+          serieValueMap[item.uuid] = serieValue;
+        }
+        if (itemProps.dynamicSeriesField && // !groupFields.includes(itemProps.dynamicSeriesField) &&
+        !dynamicFileds.includes(itemProps.dynamicSeriesField) && serieValue && yaxisField) {
+          serieValue.dynamicField = itemProps.dynamicSeriesField;
+          serieValue.dynamicSeriesTitle = itemProps.dynamicSeriesTitle;
+          serieValue.dynamicShowStack = itemProps.dynamicShowStack;
+          dynamicFileds.push(itemProps.dynamicSeriesField);
+          dynamicValueField[itemProps.dynamicSeriesField] = yaxisField;
+        }
+      }
+      const dynamicLabelMap = {};
+      if (dynamicFileds.length > 0) {
+        const newDatas = [];
+        const dataMap = {};
+        for (let d of datas) {
+          if (!d) {
+            continue;
+          }
+          for (let valueField of allValueFields) {
+            const groupValue2 = d[xFieldName];
+            let newData = dataMap[groupValue2];
+            if (!newData) {
+              newData = {};
+              for (let gField of groupFields) {
+                newData[gField] = d[gField];
+              }
+              newData[xFieldName] = d[xFieldName];
+              dataMap[groupValue2] = newData;
+              newDatas.push(newData);
+            }
+            let newValue = pageHelperUtil.getValueFromSource(d, valueField, void 0);
+            if (!isNaN(newValue)) {
+              const hisValue = newData[valueField];
+              if (!isNaN) {
+                newValue += hisValue;
+              }
+              newData[valueField] = newValue;
+            }
+          }
+        }
+        for (let dynamicField of dynamicFileds) {
+          const dynamicLabels = [];
+          for (let d of datas) {
+            if (!d) {
+              continue;
+            }
+            const groupValue2 = d[xFieldName];
+            let newData = dataMap[groupValue2];
+            if (!newData) {
+              continue;
+            }
+            let dynamicLabel = pageHelperUtil.getValueFromSource(d, dynamicField, void 0);
+            dynamicLabel = dynamicLabel == null || dynamicLabel == void 0 ? "" : dynamicLabel;
+            if (!dynamicLabels.includes(dynamicLabel)) {
+              dynamicLabels.push(dynamicLabel);
+            }
+            const valueField = dynamicValueField[dynamicField];
+            let newValue = pageHelperUtil.getValueFromSource(d, valueField, void 0);
+            if (!isNaN(newValue)) {
+              const hisValue = newData[dynamicLabel];
+              if (!isNaN) {
+                newValue += hisValue;
+              }
+              newData[dynamicLabel] = newValue;
+            }
+          }
+          dynamicLabelMap[dynamicField] = dynamicLabels;
+        }
+        datas = newDatas;
+      }
+      sortDatas(datas);
+      const xValues = [];
+      for (let data of datas) {
+        if (!data) {
+          continue;
+        }
+        xValues.push(data[xFieldName]);
+        for (let item of serieValues) {
+          let serieData = item.data;
+          const dynamicDatas = item.dynamicDatas;
+          if (item.dynamicField) {
+            let dynamicLabels = dynamicLabelMap[item.dynamicField];
+            dynamicLabels = dynamicLabels ? dynamicLabels : [];
+            for (let i = 0; i < dynamicLabels.length; i++) {
+              if (i >= dynamicDatas.length) {
+                dynamicDatas.push([]);
+              }
+              serieData = dynamicDatas[i];
+              const fieldName = dynamicLabels[i];
+              const value = pageHelperUtil.getValueFromSource(data, fieldName, void 0);
+              serieData.push(value);
+            }
+          } else if (item.type == "fixed") {
+            serieData.push(item.field);
+          } else if (item.type == "variable") {
+            const value = pageHelperUtil.getValueFromSource(data, item.field, void 0);
+            serieData.push(value);
+          } else {
+            serieData.push(void 0);
+          }
+        }
+      }
+      const tempSeries = commonUtil.deepCopy(defaultSeries == null ? [] : defaultSeries);
+      const newSeries = [];
+      for (let serie of tempSeries) {
+        const serieValue = serieValueMap[serie.uuid];
+        if (serieValue.dynamicField) {
+          let dynamicLabels = dynamicLabelMap[serieValue.dynamicField];
+          dynamicLabels = dynamicLabels ? dynamicLabels : [];
+          const dynamicDatas = serieValue.dynamicDatas ? serieValue.dynamicDatas : [];
+          for (let i = 0; i < dynamicLabels.length; i++) {
+            let label = dynamicLabels[i];
+            const newSerie = commonUtil.deepCopy(serie);
+            if (serieValue.dynamicSeriesTitle) {
+              const dynamicSeriesTitle = serieValue.dynamicSeriesTitle.replace("${name}", label);
+              newSerie.name = pageHelperUtil.formatVariableValue(props.pageContext, dynamicSeriesTitle);
+            } else {
+              newSerie.name = label;
+            }
+            newSerie.data = i < dynamicDatas.length ? dynamicDatas[i] : [];
+            if (serie.type == "bar" && serieValue.dynamicShowStack) {
+              newSerie.stack = serie.uuid;
+            }
+            newSeries.push(newSerie);
+          }
+        } else {
+          serie.data = serieValue ? serieValue.data : [];
+          newSeries.push(serie);
+        }
+      }
+      chartOption.series = newSeries;
+      if (chartOption.isBar) {
+        if (defaultYaxis) {
+          for (let tempYaxis of defaultYaxis) {
+            tempYaxis.data = xValues;
+          }
+        }
+        chartOption.xAxis = defaultXaxis;
+        chartOption.yAxis = defaultYaxis;
+      } else {
+        if (defaultXaxis && defaultXaxis.length > 0) {
+          defaultXaxis[0].data = xValues;
+        }
+        chartOption.xAxis = defaultXaxis;
+        chartOption.yAxis = defaultYaxis;
+      }
+      cacheDatas = datas;
+      console.log("chartOption", chartOption);
+    }
+    function sortDatas(datas) {
+      const itemConfs = props.configure.items ? props.configure.items : [];
+      let orderByTarget = props.configure.props ? props.configure.props.orderByTarget : "";
+      let orderField = null;
+      if (orderByTarget == "x" || orderByTarget == "X") {
+        orderField = "__x";
+      } else if (orderByTarget) {
+        for (let item of itemConfs) {
+          if (item.uuid == orderByTarget) {
+            const itemProps = item.props ? item.props : {};
+            const sourceType = itemProps.yaxisSource;
+            const yaxisField = itemProps.yaxisField;
+            if (yaxisField && (!sourceType || sourceType == "variable")) {
+              orderField = yaxisField;
+              break;
+            }
+          }
+        }
+      }
+      if (!orderField) {
+        return;
+      }
+      let orderSource = props.configure.props ? props.configure.props.orderSource : "";
+      let orderValue = props.configure.props ? props.configure.props.orderFix : "";
+      if (orderSource == "variable") {
+        let orderVariable = props.configure.props ? props.configure.props.orderVariable : "";
+        orderValue = pageHelperUtil.formatVariableValue(props.pageContext, orderVariable);
+      }
+      orderValue = orderValue == "desc" || orderValue == "DESC" ? "desc" : "asc";
+      let maxLen = datas.length;
+      for (let i = 0; i < maxLen - 1; i++) {
+        let vali = pageHelperUtil.getValueFromSource(datas[i], orderField, void 0);
+        for (let j = i + 1; j < maxLen; j++) {
+          let valj = pageHelperUtil.getValueFromSource(datas[j], orderField, void 0);
+          let isSwap = false;
+          if ("desc" == orderValue) {
+            if (vali < valj) {
+              isSwap = true;
+            }
+          } else {
+            if (vali > valj) {
+              isSwap = true;
+            }
+          }
+          if (isSwap) {
+            [datas[i], datas[j]] = [datas[j], datas[i]];
+          }
+        }
+      }
+    }
+    __expose({
+      updateChartDatas
+    });
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("div", {
+        style: Vue.normalizeStyle(Vue.unref(runtimeStyle)),
+        class: Vue.normalizeClass([Vue.unref(runtimeClass), "amb-widget-chart"]),
+        ref_key: "thisRef",
+        ref: thisRef
+      }, [
+        Vue.withDirectives(Vue.createVNode(commonChartHeader_vue_vue_type_script_setup_true_lang, {
+          ref_key: "headerRef",
+          ref: headerRef,
+          headerInfo: Vue.unref(headerInfo),
+          onDrillEnd
+        }, null, 8, ["headerInfo"]), [
+          [Vue.vShow, Vue.unref(headerInfo).showHeader]
+        ]),
+        Vue.createVNode(Vue.unref(index_esm_min.default), {
+          ref_key: "chartRef",
+          ref: chartRef,
+          theme: Vue.unref(customTheme),
+          option: Vue.unref(chartOption),
+          autoresize: ""
+        }, null, 8, ["theme", "option"])
+      ], 6);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/chart/common/common-chart-header-breadcrumb.vue.js

@@ -0,0 +1,43 @@
+"use strict";
+const Vue = require("vue");
+const index = require("../../../../../../node_modules/.pnpm/@element-plus_icons-vue@2.3.1_vue@3.4.21/node_modules/@element-plus/icons-vue/dist/index.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "common-chart-header-breadcrumb",
+  props: {
+    headerInfo: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: ["close-drill"],
+  setup(__props, { emit: __emit }) {
+    const $emits = __emit;
+    function closeDrill(drillIndex) {
+      $emits("close-drill", drillIndex);
+    }
+    return (_ctx, _cache) => {
+      const _component_el_tag = Vue.resolveComponent("el-tag");
+      const _component_el_breadcrumb = Vue.resolveComponent("el-breadcrumb");
+      return Vue.openBlock(), Vue.createBlock(_component_el_breadcrumb, { "separator-icon": Vue.unref(index.ArrowRight) }, {
+        default: Vue.withCtx(() => [
+          (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(__props.headerInfo.drillOptions, (tag, index2) => {
+            return Vue.openBlock(), Vue.createBlock(_component_el_tag, {
+              key: tag.name,
+              closable: "",
+              type: "success",
+              style: { "margin-left": "4px" },
+              onClose: ($event) => closeDrill(index2)
+            }, {
+              default: Vue.withCtx(() => [
+                Vue.createTextVNode(Vue.toDisplayString(tag.label), 1)
+              ]),
+              _: 2
+            }, 1032, ["onClose"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["separator-icon"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/chart/common/common-chart-header-breadcrumb.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const commonChartHeaderBreadcrumb_vue_vue_type_script_setup_true_lang = require("./common-chart-header-breadcrumb.vue.js");
+module.exports = commonChartHeaderBreadcrumb_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/chart/common/common-chart-header-group.vue.js

@@ -0,0 +1,61 @@
+"use strict";
+const Vue = require("vue");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "common-chart-header-group",
+  props: {
+    headerInfo: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    Vue.watch(props.headerInfo, () => {
+      console.log("props.headerInfo", props.headerInfo);
+    });
+    return (_ctx, _cache) => {
+      const _component_el_checkbox = Vue.resolveComponent("el-checkbox");
+      const _component_el_checkbox_group = Vue.resolveComponent("el-checkbox-group");
+      const _component_el_radio = Vue.resolveComponent("el-radio");
+      const _component_el_radio_button = Vue.resolveComponent("el-radio-button");
+      const _component_el_radio_group = Vue.resolveComponent("el-radio-group");
+      return __props.headerInfo.groupComponent == "checkbox" ? (Vue.openBlock(), Vue.createBlock(_component_el_checkbox_group, {
+        key: 0,
+        modelValue: __props.headerInfo.groupValue,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => __props.headerInfo.groupValue = $event)
+      }, {
+        default: Vue.withCtx(() => [
+          (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(__props.headerInfo.options, (o) => {
+            return Vue.openBlock(), Vue.createBlock(_component_el_checkbox, {
+              label: o.label,
+              value: o.value
+            }, null, 8, ["label", "value"]);
+          }), 256))
+        ]),
+        _: 1
+      }, 8, ["modelValue"])) : __props.headerInfo.groupComponent == "radio" ? (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, { key: 1 }, Vue.renderList(__props.headerInfo.options, (o) => {
+        return Vue.openBlock(), Vue.createBlock(_component_el_radio, {
+          modelValue: __props.headerInfo.groupValue,
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => __props.headerInfo.groupValue = $event),
+          value: o.value,
+          label: o.label
+        }, null, 8, ["modelValue", "value", "label"]);
+      }), 256)) : (Vue.openBlock(), Vue.createBlock(_component_el_radio_group, {
+        key: 2,
+        modelValue: __props.headerInfo.groupValue,
+        "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => __props.headerInfo.groupValue = $event)
+      }, {
+        default: Vue.withCtx(() => [
+          (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(__props.headerInfo.options, (o) => {
+            return Vue.openBlock(), Vue.createBlock(_component_el_radio_button, {
+              label: o.label,
+              value: o.value
+            }, null, 8, ["label", "value"]);
+          }), 256))
+        ]),
+        _: 1
+      }, 8, ["modelValue"]));
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/chart/common/common-chart-header-group.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const commonChartHeaderGroup_vue_vue_type_script_setup_true_lang = require("./common-chart-header-group.vue.js");
+module.exports = commonChartHeaderGroup_vue_vue_type_script_setup_true_lang;