@dfsj/components 3.0.0

package/dist/components/Table/src/useTable.js

@@ -0,0 +1,284 @@
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { ElMessageBox, ElMessage } from 'element-plus';
+import { ref, watch, unref, onMounted, nextTick } from 'vue';
+
+var t = function t(v) {
+  return v;
+};
+var useTable = function useTable(config) {
+  var _config$immediate = config.immediate,
+    immediate = _config$immediate === void 0 ? true : _config$immediate;
+  var loading = ref(false);
+  var currentPage = ref(1);
+  var pageSize = ref(10);
+  var total = ref(0);
+  var dataList = ref([]);
+  watch(function () {
+    return currentPage.value;
+  }, function () {
+    methods.getList();
+  });
+  watch(function () {
+    return pageSize.value;
+  }, function () {
+    if (unref(currentPage) === 1) {
+      methods.getList();
+    } else {
+      currentPage.value = 1;
+      methods.getList();
+    }
+  });
+  onMounted(function () {
+    if (immediate) {
+      methods.getList();
+    }
+  });
+  var tableRef = ref();
+  var elTableRef = ref();
+  var register = function register(ref, elRef) {
+    tableRef.value = ref;
+    elTableRef.value = unref(elRef);
+  };
+  var getTable = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var table;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return nextTick();
+          case 2:
+            table = unref(tableRef);
+            if (!table) {
+              console.error('The table is not registered. Please use the register method to register');
+            }
+            return _context.abrupt("return", table);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function getTable() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var methods = {
+    getList: function () {
+      var _getList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var res;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              loading.value = true;
+              _context2.prev = 1;
+              _context2.next = 4;
+              return config === null || config === void 0 ? void 0 : config.fetchDataApi();
+            case 4:
+              res = _context2.sent;
+              console.log('fetchDataApi res', res);
+              if (res) {
+                dataList.value = res.list;
+                total.value = res.total || 0;
+              }
+              _context2.next = 12;
+              break;
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](1);
+              console.log('fetchDataApi error');
+            case 12:
+              _context2.prev = 12;
+              loading.value = false;
+              return _context2.finish(12);
+            case 15:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[1, 9, 12, 15]]);
+      }));
+      function getList() {
+        return _getList.apply(this, arguments);
+      }
+      return getList;
+    }(),
+    setProps: function () {
+      var _setProps = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var props,
+          table,
+          _args3 = arguments;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              props = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {};
+              _context3.next = 3;
+              return getTable();
+            case 3:
+              table = _context3.sent;
+              table === null || table === void 0 || table.setProps(props);
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function setProps() {
+        return _setProps.apply(this, arguments);
+      }
+      return setProps;
+    }(),
+    setColumn: function () {
+      var _setColumn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(columnProps) {
+        var table;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return getTable();
+            case 2:
+              table = _context4.sent;
+              table === null || table === void 0 || table.setColumn(columnProps);
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function setColumn(_x) {
+        return _setColumn.apply(this, arguments);
+      }
+      return setColumn;
+    }(),
+    addColumn: function () {
+      var _addColumn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(tableColumn, index) {
+        var table;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return getTable();
+            case 2:
+              table = _context5.sent;
+              table === null || table === void 0 || table.addColumn(tableColumn, index);
+            case 4:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function addColumn(_x2, _x3) {
+        return _addColumn.apply(this, arguments);
+      }
+      return addColumn;
+    }(),
+    delColumn: function () {
+      var _delColumn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(field) {
+        var table;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return getTable();
+            case 2:
+              table = _context6.sent;
+              table === null || table === void 0 || table.delColumn(field);
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function delColumn(_x4) {
+        return _delColumn.apply(this, arguments);
+      }
+      return delColumn;
+    }(),
+    getElTableExpose: function () {
+      var _getElTableExpose = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 2;
+              return getTable();
+            case 2:
+              return _context7.abrupt("return", unref(elTableRef));
+            case 3:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function getElTableExpose() {
+        return _getElTableExpose.apply(this, arguments);
+      }
+      return getElTableExpose;
+    }(),
+    refresh: function refresh() {
+      methods.getList();
+    },
+    delList: function () {
+      var _delList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(idsLength) {
+        var fetchDelApi;
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              fetchDelApi = config.fetchDelApi;
+              if (fetchDelApi) {
+                _context9.next = 4;
+                break;
+              }
+              console.warn('fetchDelApi is undefined');
+              return _context9.abrupt("return");
+            case 4:
+              ElMessageBox.confirm(t('common.delMessage'), t('common.delWarning'), {
+                confirmButtonText: t('common.delOk'),
+                cancelButtonText: t('common.delCancel'),
+                type: 'warning'
+              }).then( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+                var res, current;
+                return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+                  while (1) switch (_context8.prev = _context8.next) {
+                    case 0:
+                      _context8.next = 2;
+                      return fetchDelApi();
+                    case 2:
+                      res = _context8.sent;
+                      if (res) {
+                        ElMessage.success(t('common.delSuccess'));
+                        current = unref(total) % unref(pageSize) === idsLength || unref(pageSize) === 1 ? unref(currentPage) > 1 ? unref(currentPage) - 1 : unref(currentPage) : unref(currentPage);
+                        currentPage.value = current;
+                        methods.getList();
+                      }
+                    case 4:
+                    case "end":
+                      return _context8.stop();
+                  }
+                }, _callee8);
+              })));
+            case 5:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function delList(_x5) {
+        return _delList.apply(this, arguments);
+      }
+      return delList;
+    }()
+  };
+  return {
+    tableRegister: register,
+    tableMethods: methods,
+    tableState: {
+      currentPage: currentPage,
+      pageSize: pageSize,
+      total: total,
+      dataList: dataList,
+      loading: loading
+    }
+  };
+};
+
+export { useTable };

package/dist/components/UnifyChart/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./src/props";
+import UnifyChart from "./src/UnifyChart.vue";
+import ChartToolbox from "./src/ChartToolbox.vue";
+export { UnifyChart, ChartToolbox };

package/dist/components/UnifyChart/src/ChartToolbox.vue.d.ts

@@ -0,0 +1,63 @@
+declare const _default: import("vue").DefineComponent<{
+    instance: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    iconSize: import("vue-types").VueTypeValidableDef<number, import("vue-types/dist/types").ValidatorFunction<number>> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    toggleTable: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    toggleStatistic: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    toolbox: () => any[];
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    instance: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    iconSize: import("vue-types").VueTypeValidableDef<number, import("vue-types/dist/types").ValidatorFunction<number>> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    toggleTable: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    toggleStatistic: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    toolbox: () => any[];
+}>>, {
+    instance: {
+        [key: string]: any;
+    };
+    iconSize: number;
+    toggleTable: (...args: any[]) => any;
+    toggleStatistic: (...args: any[]) => any;
+}, {}>;
+export default _default;

package/dist/components/UnifyChart/src/ChartToolbox.vue.js

@@ -0,0 +1,5 @@
+import script from './ChartToolbox.vue2.js';
+
+script.__file = "src/components/UnifyChart/src/ChartToolbox.vue";
+
+export { script as default };

package/dist/components/UnifyChart/src/ChartToolbox.vue2.js

@@ -0,0 +1,83 @@
+import { normalizeClass, defineComponent, ref, toRefs, openBlock, createElementBlock, unref, createVNode, createCommentVNode, createBlock, renderSlot } from 'vue';
+import { toolboxProps, EToolbox } from './props.js';
+import '../../Icon/src/Icon.vue.js';
+import '../../Icon/src/SvgIcon.vue.js';
+import { isEmpty } from '../../../utils/is.js';
+import { useDownLoad } from '@dfsj/echarts';
+import script$1 from '../../Icon/src/Icon.vue2.js';
+
+var _hoisted_1 = {
+  key: 0,
+  "class": normalizeClass("tools-container absolute top-0 right-0")
+};
+var _hoisted_2 = {
+  key: 0
+};
+var _hoisted_3 = {
+  key: 1
+};
+var _hoisted_4 = {
+  key: 2
+};
+var prefixCls = 'ec-chart-toolbox-wrap';
+var script = defineComponent({
+  __name: 'ChartToolbox',
+  props: toolboxProps,
+  setup: function setup(__props) {
+    var props = __props;
+    var isOpenTable = ref(false);
+    var _toRefs = toRefs(props),
+      iconSize = _toRefs.iconSize,
+      toolbox = _toRefs.toolbox;
+    var toggleStatistic = props.toggleStatistic,
+      toggleTable = props.toggleTable,
+      getInstance = props.instance;
+    function handleTable(ev) {
+      isOpenTable.value = !isOpenTable.value;
+      toggleTable();
+    }
+    function handleStatistic(ev) {
+      toggleStatistic();
+    }
+    function handleDownload(ev) {
+      var _useDownLoad = useDownLoad(getInstance),
+        downloadImg = _useDownLoad.downloadImg;
+      downloadImg({
+        backgroundColor: '#000'
+      });
+    }
+    var hasTool = function hasTool(tool) {
+      var _toolbox$value;
+      return toolbox === null || toolbox === void 0 || (_toolbox$value = toolbox.value) === null || _toolbox$value === void 0 ? void 0 : _toolbox$value.includes(tool);
+    };
+    return function (_ctx, _cache) {
+      return openBlock(), createElementBlock("div", {
+        "class": normalizeClass("".concat(prefixCls, " h-full w-full relative"))
+      }, [!unref(isEmpty)(unref(toolbox)) ? (openBlock(), createElementBlock("div", _hoisted_1, [hasTool(unref(EToolbox).Download) ? (openBlock(), createElementBlock("div", _hoisted_2, [createVNode(unref(script$1), {
+        color: '#f2973d',
+        onClick: handleDownload,
+        size: unref(iconSize),
+        icon: 'mdi:cloud-arrow-down'
+      }, null, 8, ["size"])])) : createCommentVNode("v-if", true), hasTool(unref(EToolbox).Statistic) ? (openBlock(), createElementBlock("div", _hoisted_3, [createVNode(unref(script$1), {
+        color: '#0885ec',
+        onClick: handleStatistic,
+        size: unref(iconSize),
+        icon: 'mdi:chart-arc'
+      }, null, 8, ["size"])])) : createCommentVNode("v-if", true), hasTool(unref(EToolbox).Table) ? (openBlock(), createElementBlock("div", _hoisted_4, [isOpenTable.value ? (openBlock(), createBlock(unref(script$1), {
+        key: 0,
+        color: '#4caf50',
+        onClick: handleTable,
+        size: unref(iconSize),
+        icon: 'mdi:chart-line'
+      }, null, 8, ["size"])) : (openBlock(), createBlock(unref(script$1), {
+        key: 1,
+        color: '#4caf50',
+        onClick: handleTable,
+        size: unref(iconSize),
+        icon: 'mdi:table'
+      }, null, 8, ["size"]))])) : createCommentVNode("v-if", true)])) : createCommentVNode("v-if", true), renderSlot(_ctx.$slots, "default")], 2);
+    };
+  }
+});
+
+export { script as default };

package/dist/components/UnifyChart/src/UnifyChart.vue.d.ts

@@ -0,0 +1,185 @@
+declare const _default: import("vue").DefineComponent<{
+    data: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    options: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    width: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    height: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    target: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    convert: () => import("./props").Convert;
+    datasource: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    toolbox: () => any[];
+    chartHooks: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    stateful: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    options: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    width: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    height: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    target: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    convert: () => import("./props").Convert;
+    datasource: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    toolbox: () => any[];
+    chartHooks: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    stateful: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+}>>, {
+    data: {
+        [key: string]: any;
+    };
+    options: {
+        [key: string]: any;
+    };
+    width: string;
+    height: string;
+    target: {
+        [key: string]: any;
+    };
+    datasource: {
+        [key: string]: any;
+    };
+    chartHooks: (...args: any[]) => any;
+    stateful: {
+        [key: string]: any;
+    };
+}, {}>;
+export default _default;

package/dist/components/UnifyChart/src/UnifyChart.vue.js

@@ -0,0 +1,5 @@
+import script from './UnifyChart.vue2.js';
+
+script.__file = "src/components/UnifyChart/src/UnifyChart.vue";
+
+export { script as default };

package/dist/components/UnifyChart/src/UnifyChart.vue2.js

@@ -0,0 +1,54 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { defineComponent, ref, toRefs, computed, openBlock, createBlock, withCtx, createVNode, normalizeProps, guardReactiveProps, unref, createElementVNode, normalizeStyle } from 'vue';
+import './ChartToolbox.vue.js';
+import { useRender } from './hooks/useRender.js';
+import { unifyChartProps } from './props.js';
+import '../../Stateful/src/Stateful.vue.js';
+import script$1 from '../../Stateful/src/Stateful.vue2.js';
+import script$2 from './ChartToolbox.vue2.js';
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var script = defineComponent({
+  __name: 'UnifyChart',
+  props: unifyChartProps,
+  setup: function setup(__props) {
+    var chartRef = ref(null);
+    var props = __props;
+    var _toRefs = toRefs(props),
+      data = _toRefs.data;
+      _toRefs.stateful;
+    var compState = computed(function () {
+      var _props$stateful;
+      return (_props$stateful = props.stateful) === null || _props$stateful === void 0 ? void 0 : _props$stateful.stringify;
+    });
+    var chartHooks = props.chartHooks,
+      convert = props.convert;
+    var _useRender = useRender(_objectSpread(_objectSpread({}, chartHooks(chartRef)), convert), data, props.toolbox),
+      getBindValue = _useRender.getBindValue;
+    return function (_ctx, _cache) {
+      return openBlock(), createBlock(script$1, {
+        value: compState.value
+      }, {
+        "default": withCtx(function () {
+          return [createVNode(script$2, normalizeProps(guardReactiveProps(unref(getBindValue))), {
+            "default": withCtx(function () {
+              return [createElementVNode("div", {
+                ref_key: "chartRef",
+                ref: chartRef,
+                style: normalizeStyle({
+                  height: props.height,
+                  width: props.width
+                })
+              }, null, 4)];
+            }),
+            _: 1
+          }, 16)];
+        }),
+        _: 1
+      }, 8, ["value"]);
+    };
+  }
+});
+
+export { script as default };