@minilo/ui 0.0.1

package/minilo/es/node_modules/.pnpm/@element-plus_icons-vue@2.3.1_vue@3.5.17_typescript@5.8.3_/node_modules/@element-plus/icons-vue/dist/index.mjs

@@ -0,0 +1,25 @@
+import { defineComponent, createElementBlock, openBlock, createElementVNode } from 'vue';
+
+var warning_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  name: "Warning",
+  __name: "warning",
+  setup(__props) {
+    return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 1024 1024"
+    }, [
+      createElementVNode("path", {
+        fill: "currentColor",
+        d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896m0 832a384 384 0 0 0 0-768 384 384 0 0 0 0 768m48-176a48 48 0 1 1-96 0 48 48 0 0 1 96 0m-48-464a32 32 0 0 1 32 32v288a32 32 0 0 1-64 0V288a32 32 0 0 1 32-32"
+      })
+    ]));
+  }
+});
+var warning_default = warning_vue_vue_type_script_setup_true_lang_default;
+/*! Bundled license information:
+
+@element-plus/icons-vue/dist/index.js:
+  (*! Element Plus Icons Vue v2.3.1 *)
+*/
+
+export { warning_default as Warning };

package/minilo/es/node_modules/.pnpm/@vueuse_core@13.6.0_vue@3.5.17_typescript@5.9.3_/node_modules/@vueuse/core/index.mjs

@@ -0,0 +1,73 @@
+import { tryOnScopeDispose, isClient } from '../../../../@vueuse_shared@13.6.0_vue@3.5.17_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+export { createFilterWrapper, debounceFilter, noop, useDebounceFn } from '../../../../@vueuse_shared@13.6.0_vue@3.5.17_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+import { computed, toValue, watch, shallowRef, getCurrentInstance, onMounted } from 'vue';
+
+const defaultWindow = isClient ? window : void 0;
+
+function unrefElement(elRef) {
+  var _a;
+  const plain = toValue(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+
+// @__NO_SIDE_EFFECTS__
+function useMounted() {
+  const isMounted = shallowRef(false);
+  const instance = getCurrentInstance();
+  if (instance) {
+    onMounted(() => {
+      isMounted.value = true;
+    }, instance);
+  }
+  return isMounted;
+}
+
+// @__NO_SIDE_EFFECTS__
+function useSupported(callback) {
+  const isMounted = useMounted();
+  return computed(() => {
+    isMounted.value;
+    return Boolean(callback());
+  });
+}
+
+function useResizeObserver(target, callback, options = {}) {
+  const { window = defaultWindow, ...observerOptions } = options;
+  let observer;
+  const isSupported = useSupported(() => window && "ResizeObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const targets = computed(() => {
+    const _targets = toValue(target);
+    return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
+  });
+  const stopWatch = watch(
+    targets,
+    (els) => {
+      cleanup();
+      if (isSupported.value && window) {
+        observer = new ResizeObserver(callback);
+        for (const _el of els) {
+          if (_el)
+            observer.observe(_el, observerOptions);
+        }
+      }
+    },
+    { immediate: true, flush: "post" }
+  );
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+
+export { defaultWindow, isClient, tryOnScopeDispose, unrefElement, useMounted, useResizeObserver, useSupported };

package/minilo/es/node_modules/.pnpm/@vueuse_shared@13.6.0_vue@3.5.17_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs

@@ -0,0 +1,76 @@
+import { getCurrentScope, onScopeDispose, toValue } from 'vue';
+
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const noop = () => {
+};
+
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = noop;
+  const _clearTimeout = (timer2) => {
+    clearTimeout(timer2);
+    lastRejector();
+    lastRejector = noop;
+  };
+  let lastInvoker;
+  const filter = (invoke) => {
+    const duration = toValue(ms);
+    const maxDuration = toValue(options.maxWait);
+    if (timer)
+      _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = void 0;
+      }
+      return Promise.resolve(invoke());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      lastInvoker = invoke;
+      if (maxDuration && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          if (timer)
+            _clearTimeout(timer);
+          maxTimer = void 0;
+          resolve(lastInvoker());
+        }, maxDuration);
+      }
+      timer = setTimeout(() => {
+        if (maxTimer)
+          _clearTimeout(maxTimer);
+        maxTimer = void 0;
+        resolve(invoke());
+      }, duration);
+    });
+  };
+  return filter;
+}
+
+// @__NO_SIDE_EFFECTS__
+function useDebounceFn(fn, ms = 200, options = {}) {
+  return createFilterWrapper(
+    debounceFilter(ms, options),
+    fn
+  );
+}
+
+export { createFilterWrapper, debounceFilter, isClient, noop, tryOnScopeDispose, useDebounceFn };

package/minilo/es/packages/utils/dist/func/common.mjs

@@ -0,0 +1,14 @@
+function getNestedValue(obj, path, defaultValue) {
+  if (typeof obj !== "object" || obj === null || !path) {
+    return defaultValue;
+  }
+  const keys = path.split(".").filter((key) => key !== "");
+  return keys.reduce((current, key) => {
+    if (typeof current !== "object" || current === null) {
+      return defaultValue;
+    }
+    return current[key] !== void 0 ? current[key] : defaultValue;
+  }, obj);
+}
+
+export { getNestedValue };

package/minilo/es/packages/utils/dist/request/index.mjs

@@ -0,0 +1,110 @@
+import axios$1 from 'axios';
+export * from 'axios';
+import { ElMessage } from 'element-plus';
+import { defu } from 'defu';
+
+const initRequestInstance = (extendConfig = {}, interceptorsRequestFn = () => {
+}, interceptorsResponseFn = () => {
+}) => {
+  const axiosConfig = defu({}, extendConfig, {
+    baseURL: "/",
+    // 从环境变量获取基础URL
+    timeout: 1e4,
+    // 超时时间
+    headers: {
+      "Content-Type": "application/json;charset=utf-8"
+    }
+  });
+  const instance = axios$1.create(axiosConfig);
+  instance.interceptors.request.use(
+    (config) => {
+      interceptorsRequestFn(config);
+      addPendingRequest(config);
+      return config;
+    },
+    (error) => {
+      return Promise.reject(error);
+    }
+  );
+  instance.interceptors.response.use(
+    (response) => {
+      interceptorsResponseFn(response);
+      removePendingRequest(response.config);
+      const data = response.data;
+      console.log(data);
+      if (data.code === 200) {
+        return Promise.resolve({
+          ...response,
+          ...data,
+          data: data.data
+        });
+      } else {
+        ElMessage.error(data.msg || "\u8BF7\u6C42\u5931\u8D25");
+        return Promise.reject(new Error(data.msg || "\u8BF7\u6C42\u5931\u8D25"));
+      }
+    },
+    (error) => {
+      console.log("\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF>>>>>>>>>>>>>>>>>>\uFF1A", error);
+      if (error.config) {
+        removePendingRequest(error.config);
+      }
+      if (axios$1.isCancel(error)) {
+        console.warn("\u8BF7\u6C42\u5DF2\u88AB\u53D6\u6D88:", error.message);
+        return Promise.reject(new Error("\u8BF7\u6C42\u5DF2\u88AB\u53D6\u6D88"));
+      }
+      if (!window.navigator.onLine) {
+        ElMessage.error("\u7F51\u7EDC\u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC");
+        return Promise.reject(new Error("\u7F51\u7EDC\u8FDE\u63A5\u5DF2\u65AD\u5F00"));
+      }
+      const { response } = error;
+      if (response) {
+        switch (response.status) {
+          case 401:
+            ElMessage.error("\u8EAB\u4EFD\u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+            break;
+          case 403:
+            ElMessage.error("\u6CA1\u6709\u6743\u9650\u6267\u884C\u6B64\u64CD\u4F5C");
+            break;
+          case 404:
+            ElMessage.error("\u8BF7\u6C42\u7684\u8D44\u6E90\u4E0D\u5B58\u5728");
+            break;
+          case 500:
+            ElMessage.error("\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+            break;
+          default:
+            ElMessage.error(`\u8BF7\u6C42\u9519\u8BEF: ${response.status}`);
+        }
+      } else {
+        ElMessage.error("\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+      }
+      return Promise.reject(error);
+    }
+  );
+  return instance;
+};
+const pendingRequests = /* @__PURE__ */ new Map();
+const generateRequestKey = (config) => {
+  const { method, url, params, data } = config;
+  const paramsStr = params ? JSON.stringify(params) : "";
+  const dataStr = data ? JSON.stringify(data) : "";
+  return `${method}-${url}-${paramsStr}-${dataStr}`;
+};
+const addPendingRequest = (config) => {
+  const requestKey = generateRequestKey(config);
+  if (pendingRequests.has(requestKey)) {
+    const cancelToken = pendingRequests.get(requestKey);
+    cancelToken.cancel(`\u91CD\u590D\u8BF7\u6C42\u88AB\u53D6\u6D88: ${config.url}`);
+    pendingRequests.delete(requestKey);
+  }
+  const source = axios$1.CancelToken.source();
+  config.cancelToken = source.token;
+  pendingRequests.set(requestKey, source);
+};
+const removePendingRequest = (config) => {
+  const requestKey = generateRequestKey(config);
+  if (pendingRequests.has(requestKey)) {
+    pendingRequests.delete(requestKey);
+  }
+};
+
+export { addPendingRequest, generateRequestKey, initRequestInstance, removePendingRequest };

package/minilo/es/resolver/index.d.ts

@@ -0,0 +1,8 @@
+export declare const MiniloUiResolver: () => {
+    type: "component";
+    resolve: (name: string) => {
+        name: string;
+        from: string;
+        sideEffects: string;
+    } | null;
+};

package/minilo/es/resolver/index.mjs

@@ -0,0 +1,26 @@
+const libraryNamePrefixUpperCase = "Ml";
+const libraryName = "minilo";
+function kebabCase(key) {
+  const result = key.replace(/([A-Z])/g, " $1").trim();
+  return result.split(" ").join("-").toLowerCase();
+}
+
+const MiniloUiResolver = () => {
+  console.log("MiniloUiResolver\u521D\u59CB\u5316");
+  return {
+    type: "component",
+    resolve: (name) => {
+      if (name.startsWith(libraryNamePrefixUpperCase)) {
+        const componentName = kebabCase(name.slice(2));
+        return {
+          name,
+          from: `@${libraryName}/ui/es/${componentName}`,
+          sideEffects: `@${libraryName}/ui/theme-chalk/ml-${componentName}`
+        };
+      }
+      return null;
+    }
+  };
+};
+
+export { MiniloUiResolver };

package/minilo/es/utils/index.d.ts

@@ -0,0 +1,28 @@
+import { Component } from 'vue';
+export declare const libraryNamePrefix = "ml";
+export declare const libraryNamePrefixUpperCase = "Ml";
+export declare const libraryName = "minilo";
+/**
+ * @description 组件注册函数
+ * @author xieshuhong
+ * @template T
+ * @param {T} comp
+ * @return {*}
+ */
+export declare const withInstall: <T extends Component>(comp: T) => T;
+/**
+ * BEM命名规范工具函数
+ * @param {string} block - 必选，块名（如'button'）
+ * @param {string|undefined} element - 可选，元素名（如'icon'）
+ * @param {string|string[]|undefined} modifier - 可选，修饰符（如'primary'或['large', 'disabled']）
+ * @returns {string} 生成的class字符串
+ */
+export declare function bem(block?: string, element?: string, modifier?: string): string;
+/**
+ * @description 驼峰转 kabab
+ * @author xieshuhong
+ * @export
+ * @param {string} key
+ * @return {*}
+ */
+export declare function kebabCase(key: string): string;

package/minilo/es/utils/index.mjs

@@ -0,0 +1,30 @@
+const libraryNamePrefix = "ml";
+const withInstall = (comp) => {
+  comp.install = (app) => {
+    const compName = comp.name;
+    if (!compName) return;
+    app.component(compName, comp);
+  };
+  return comp;
+};
+function bem(block = "", element = "", modifier = "") {
+  if (!block || typeof block !== "string") {
+    console.error("BEM: block\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u4E14\u4E0D\u80FD\u4E3A\u7A7A");
+    return "";
+  }
+  let base = `${libraryNamePrefix}-${block}`;
+  if (element && typeof element === "string") {
+    base += `__${element}`;
+  }
+  if (!modifier) {
+    return base;
+  }
+  const modifiers = Array.isArray(modifier) ? modifier : [modifier];
+  const validModifiers = modifiers.filter((m) => typeof m === "string" && m.trim() !== "");
+  if (validModifiers.length === 0) {
+    return base;
+  }
+  return validModifiers.map((mod) => `${base}--${mod}`).join(" ");
+}
+
+export { bem, libraryNamePrefix, withInstall };

package/minilo/lib/components/button/index.d.ts

@@ -0,0 +1,47 @@
+export declare const MlButton: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').MlButtonSelfProps> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (...args: any[]) => void;
+    }, import('vue').PublicProps, {
+        time: number;
+        placement: string;
+        tip: string;
+        tipProps: Record<string, any>;
+        isDebounce: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').MlButtonSelfProps> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        time: number;
+        placement: string;
+        tip: string;
+        tipProps: Record<string, any>;
+        isDebounce: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').MlButtonSelfProps> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, {
+    time: number;
+    placement: string;
+    tip: string;
+    tipProps: Record<string, any>;
+    isDebounce: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+});
+export default MlButton;

package/minilo/lib/components/button/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../utils/index.js');
+var index_vue_vue_type_script_setup_true_lang = require('./index.vue2.js');
+
+const MlButton = index.withInstall(index_vue_vue_type_script_setup_true_lang.default);
+
+exports.MlButton = MlButton;
+exports.default = MlButton;

package/minilo/lib/components/button/index.vue.d.ts

@@ -0,0 +1,29 @@
+import { MlButtonSelfProps as MlButtonProps } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MlButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<MlButtonProps> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    time: number;
+    placement: string;
+    tip: string;
+    tipProps: Record<string, any>;
+    isDebounce: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/minilo/lib/components/button/index.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_vue_vue_type_script_setup_true_lang = require('./index.vue2.js');
+
+
+
+exports.default = index_vue_vue_type_script_setup_true_lang.default;

package/minilo/lib/components/button/index.vue2.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../utils/index.js');
+var elementPlus = require('element-plus');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "MlButton"
+  },
+  __name: "index",
+  props: {
+    time: { type: Number, required: false, default: 1e3 },
+    tip: { type: String, required: false, default: "" },
+    placement: { type: String, required: false, default: "top" },
+    tipProps: { type: Object, required: false, default: () => ({}) },
+    isDebounce: { type: Boolean, required: false, default: true }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const record = vue.ref(0);
+    const handleClick = () => {
+      if (!props.isDebounce) return emits("click");
+      const newTime = /* @__PURE__ */ new Date();
+      if (newTime.getTime() - record.value > props.time) {
+        emits("click");
+      }
+      record.value = newTime.getTime();
+    };
+    return (_ctx, _cache) => {
+      return __props.tip ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTooltip), vue.mergeProps({
+        key: 0,
+        content: __props.tip,
+        placement: __props.placement
+      }, __props.tipProps), {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(elementPlus.ElButton), vue.mergeProps(_ctx.$attrs, {
+            class: vue.unref(index.bem)("button", "tip"),
+            onClick: handleClick
+          }), {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+            /* FORWARDED */
+          }, 16, ["class"])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["content", "placement"])) : (vue.openBlock(), vue.createBlock(
+        vue.unref(elementPlus.ElButton),
+        vue.mergeProps({ key: 1 }, _ctx.$attrs, { onClick: handleClick }),
+        {
+          default: vue.withCtx(() => [
+            vue.renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+          /* FORWARDED */
+        },
+        16
+        /* FULL_PROPS */
+      ));
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/minilo/lib/components/button/type.d.ts

@@ -0,0 +1,10 @@
+import { ButtonProps } from 'element-plus';
+import { Mutable } from 'element-plus/es/utils';
+export interface MlButtonSelfProps {
+    time?: number;
+    tip?: string;
+    placement?: string;
+    tipProps?: Record<string, any>;
+    isDebounce?: boolean;
+}
+export type MlButtonProps = MlButtonSelfProps & Partial<Mutable<ButtonProps>>;

package/minilo/lib/components/button/type.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/minilo/lib/components/chart/index.d.ts

@@ -0,0 +1,49 @@
+export declare const MlChart: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').MlChartProps> & Readonly<{
+        [x: `on${Capitalize<string>}`]: ((...args: unknown[] & []) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        [x: string]: ((...args: unknown[]) => any) | (() => any);
+    }, import('vue').PublicProps, {
+        options: Record<string, any>;
+        id: string;
+        theme: string;
+        isEmpty: boolean | ((options: Record<string, any>) => boolean);
+        description: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        echartRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').MlChartProps> & Readonly<{
+        [x: `on${Capitalize<string>}`]: ((...args: unknown[] & []) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        options: Record<string, any>;
+        id: string;
+        theme: string;
+        isEmpty: boolean | ((options: Record<string, any>) => boolean);
+        description: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').MlChartProps> & Readonly<{
+    [x: `on${Capitalize<string>}`]: ((...args: unknown[] & []) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    [x: string]: ((...args: unknown[]) => any) | (() => any);
+}, string, {
+    options: Record<string, any>;
+    id: string;
+    theme: string;
+    isEmpty: boolean | ((options: Record<string, any>) => boolean);
+    description: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        empty?(_: {}): any;
+        default?(_: {}): any;
+    };
+});
+export default MlChart;

package/minilo/lib/components/chart/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../utils/index.js');
+var index_vue_vue_type_script_setup_true_lang = require('./index.vue2.js');
+
+const MlChart = index.withInstall(index_vue_vue_type_script_setup_true_lang.default);
+
+exports.MlChart = MlChart;
+exports.default = MlChart;