@minilo/ui 0.0.2 → 0.0.3

package/minilo/lib/components/tree-select-dialog/index.vue2.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index$1 = require('../tree-select/index.js');
+var type = require('./type.js');
+var index = require('../../utils/index.js');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "MlTreeSelectDialog"
+  },
+  __name: "index",
+  props: /* @__PURE__ */ vue.mergeModels({
+    treeData: { type: Array, required: true },
+    treeProps: { type: Object, required: false, default: () => ({ label: "label", children: "children" }) },
+    multiple: { type: Boolean, required: false, default: false },
+    defaultExpandAll: { type: Boolean, required: false, default: true },
+    defaultSelectedKeys: { type: Array, required: false, default: () => [] },
+    nodeKey: { type: String, required: false, default: "id" },
+    showSearch: { type: Boolean, required: false, default: true },
+    expandOnClickNode: { type: Boolean, required: false },
+    placeholder: { type: String, required: false },
+    title: { type: String, required: false, default: "\u6811\u5F62\u9009\u62E9" },
+    width: { type: String, required: false, default: "500px" },
+    appendToBody: { type: Boolean, required: false },
+    appendTo: { type: null, required: false },
+    beforeClose: { type: Function, required: false },
+    destroyOnClose: { type: Boolean, required: false },
+    closeOnClickModal: { type: Boolean, required: false },
+    closeOnPressEscape: { type: Boolean, required: false },
+    lockScroll: { type: Boolean, required: false },
+    modal: { type: Boolean, required: false },
+    openDelay: { type: Number, required: false },
+    closeDelay: { type: Number, required: false },
+    top: { type: String, required: false },
+    modelValue: { type: Boolean, required: false },
+    modalClass: { type: String, required: false },
+    headerClass: { type: String, required: false },
+    bodyClass: { type: String, required: false },
+    footerClass: { type: String, required: false },
+    zIndex: { type: Number, required: false },
+    trapFocus: { type: Boolean, required: false },
+    headerAriaLevel: { type: String, required: false },
+    center: { type: Boolean, required: false },
+    alignCenter: { type: Boolean, required: false },
+    closeIcon: { type: null, required: false },
+    draggable: { type: Boolean, required: false },
+    overflow: { type: Boolean, required: false },
+    fullscreen: { type: Boolean, required: false },
+    showClose: { type: Boolean, required: false },
+    ariaLevel: { type: String, required: false }
+  }, {
+    "modelValue": { type: Boolean, ...{ default: false } },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ vue.mergeModels(["confirm", "close", "input"], ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const visible = vue.useModel(__props, "modelValue");
+    const props = __props;
+    const emit = __emit;
+    const attrs = vue.useAttrs();
+    const dialogAttrs = vue.computed(() => {
+      const result = {
+        title: props.title,
+        width: props.width
+      };
+      Object.keys(attrs).forEach((key) => {
+        if (type.dialogPropKeys.includes(key)) {
+          result[key] = attrs[key];
+        }
+      });
+      return result;
+    });
+    const treeSelectAttrs = vue.computed(() => {
+      const result = {
+        treeData: props.treeData,
+        treeProps: props.treeProps,
+        multiple: props.multiple,
+        defaultExpandAll: props.defaultExpandAll,
+        defaultSelectedKeys: props.defaultSelectedKeys,
+        nodeKey: props.nodeKey,
+        showSearch: props.showSearch
+      };
+      Object.keys(attrs).forEach((key) => {
+        if (!type.dialogPropKeys.includes(key) && !key.startsWith("on")) {
+          result[key] = attrs[key];
+        }
+      });
+      return result;
+    });
+    const treeSelectRef = vue.ref();
+    vue.watch(visible, (val) => {
+      if (!val && treeSelectRef.value) {
+        treeSelectRef.value.reset();
+      }
+    });
+    const handleBeforeClose = () => {
+      visible.value = false;
+    };
+    const handleConfirm = (selectedData) => {
+      emit("confirm", selectedData);
+      visible.value = false;
+    };
+    const handleCancel = () => {
+      visible.value = false;
+    };
+    __expose({
+      input: (value) => emit("input", value)
+    });
+    return (_ctx, _cache) => {
+      const _component_el_dialog = vue.resolveComponent("el-dialog");
+      return vue.openBlock(), vue.createBlock(_component_el_dialog, vue.mergeProps({
+        modelValue: visible.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => visible.value = $event)
+      }, dialogAttrs.value, {
+        class: vue.unref(index.bem)("tree-select-dialog"),
+        "before-close": handleBeforeClose,
+        onClose: _cache[1] || (_cache[1] = ($event) => emit("close"))
+      }), {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(index$1.MlTreeSelect), vue.mergeProps({
+            ref_key: "treeSelectRef",
+            ref: treeSelectRef,
+            "tree-data": props.treeData
+          }, treeSelectAttrs.value, vue.toHandlers(_ctx.$attrs), {
+            onConfirm: handleConfirm,
+            onCancel: handleCancel
+          }), null, 16, ["tree-data"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 16, ["modelValue", "class"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/minilo/lib/components/tree-select-dialog/type.d.ts

@@ -0,0 +1,9 @@
+import { TreeSelectProps } from '../tree-select/type';
+import { DialogProps } from 'element-plus';
+export interface DialogContainerProps extends Partial<DialogProps> {
+    title?: string;
+    width?: string;
+}
+export interface TreeSelectDialogProps<T = any> extends TreeSelectProps<T>, DialogContainerProps {
+}
+export declare const dialogPropKeys: string[];

package/minilo/lib/components/tree-select-dialog/type.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const dialogPropKeys = [
+  "title",
+  "width",
+  "fullscreen",
+  "top",
+  "modal",
+  "modalClass",
+  "appendToBody",
+  "appendTo",
+  "lockScroll",
+  "closeOnClickModal",
+  "closeOnPressEscape",
+  "showClose",
+  "draggable",
+  "overflow",
+  "center",
+  "alignCenter",
+  "destroyOnClose",
+  "closeIcon",
+  "zIndex",
+  "headerAriaLevel"
+];
+
+exports.dialogPropKeys = dialogPropKeys;

package/minilo/lib/components/tree-select-drawer/index.d.ts

@@ -0,0 +1,64 @@
+export declare const MlTreeSelectDrawer: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {};
+    attrs: any;
+    emit: (((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "close") => void)) & ((evt: "update:modelValue", value: boolean) => void);
+}, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+        readonly onInput?: (value: string) => any;
+        readonly "onUpdate:modelValue"?: (value: boolean) => any;
+        readonly onClose?: () => any;
+        readonly onConfirm?: (selectedData: T | T[]) => any;
+        modelValue?: boolean;
+        treeData: T[];
+        treeProps?: Record<string, any>;
+        multiple?: boolean;
+        defaultExpandAll?: boolean;
+        defaultSelectedKeys?: any[];
+        nodeKey?: string;
+        showSearch?: boolean;
+        expandOnClickNode?: boolean;
+        placeholder?: string;
+        title?: string;
+        size?: string | number;
+        direction?: "rtl" | "ltr" | "ttb" | "btt";
+        readonly overflow?: boolean;
+        readonly center?: boolean;
+        readonly appendTo?: string | HTMLElement;
+        readonly showClose?: boolean;
+        readonly draggable?: boolean;
+        readonly appendToBody?: boolean;
+        readonly destroyOnClose?: boolean;
+        readonly closeOnClickModal?: boolean;
+        readonly closeOnPressEscape?: boolean;
+        readonly lockScroll?: boolean;
+        readonly modal?: boolean;
+        readonly openDelay?: number;
+        readonly closeDelay?: number;
+        readonly trapFocus?: boolean;
+        readonly headerAriaLevel?: string;
+        readonly alignCenter?: boolean;
+        readonly fullscreen?: boolean;
+        readonly ariaLevel?: string;
+        readonly withHeader?: boolean;
+        readonly modalFade?: boolean;
+        readonly top?: string;
+        readonly width?: string | number;
+        readonly zIndex?: number;
+        readonly beforeClose?: import('element-plus').DialogBeforeCloseFn;
+        readonly modalClass?: string;
+        readonly headerClass?: string;
+        readonly bodyClass?: string;
+        readonly footerClass?: string;
+        readonly closeIcon?: unknown;
+    } & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        input: (value: string) => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "close") => void)) & ((evt: "update:modelValue", value: boolean) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default MlTreeSelectDrawer;
+export * from './type';

package/minilo/lib/components/tree-select-drawer/index.js

@@ -0,0 +1,13 @@
+'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');
+var type = require('./type.js');
+
+const MlTreeSelectDrawer = index.withInstall(index_vue_vue_type_script_setup_true_lang.default);
+
+exports.drawerPropKeys = type.drawerPropKeys;
+exports.MlTreeSelectDrawer = MlTreeSelectDrawer;
+exports.default = MlTreeSelectDrawer;

package/minilo/lib/components/tree-select-drawer/index.vue.d.ts

@@ -0,0 +1,23 @@
+import { TreeSelectDrawerProps } from './type';
+declare const _default: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onInput?: (value: string) => any;
+        readonly "onUpdate:modelValue"?: (value: boolean) => any;
+        readonly onConfirm?: (selectedData: T | T[]) => any;
+        readonly onClose?: () => any;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onInput" | "onUpdate:modelValue" | "onClose" | "onConfirm"> & ({
+        modelValue?: boolean;
+    } & TreeSelectDrawerProps<T>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        input: (value: string) => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "close") => void)) & ((evt: "update:modelValue", value: boolean) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/minilo/lib/components/tree-select-drawer/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/tree-select-drawer/index.vue2.js

@@ -0,0 +1,144 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var type = require('./type.js');
+var index_vue_vue_type_script_setup_true_lang = require('../tree-select/index.vue2.js');
+var index = require('../../utils/index.js');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "MlTreeSelectDrawer"
+  },
+  __name: "index",
+  props: /* @__PURE__ */ vue.mergeModels({
+    treeData: { type: Array, required: true },
+    treeProps: { type: Object, required: false, default: () => ({ label: "label", children: "children" }) },
+    multiple: { type: Boolean, required: false, default: false },
+    defaultExpandAll: { type: Boolean, required: false, default: true },
+    defaultSelectedKeys: { type: Array, required: false, default: () => [] },
+    nodeKey: { type: String, required: false, default: "id" },
+    showSearch: { type: Boolean, required: false, default: true },
+    expandOnClickNode: { type: Boolean, required: false },
+    placeholder: { type: String, required: false },
+    title: { type: String, required: false, default: "\u6811\u5F62\u9009\u62E9" },
+    size: { type: [String, Number], required: false, default: "400px" },
+    direction: { type: String, required: false, default: "rtl" },
+    withHeader: { type: Boolean, required: false },
+    modalFade: { type: Boolean, required: false },
+    headerAriaLevel: { type: String, required: false },
+    appendToBody: { type: Boolean, required: false },
+    appendTo: { type: null, required: false },
+    beforeClose: { type: Function, required: false },
+    destroyOnClose: { type: Boolean, required: false },
+    closeOnClickModal: { type: Boolean, required: false },
+    closeOnPressEscape: { type: Boolean, required: false },
+    lockScroll: { type: Boolean, required: false },
+    modal: { type: Boolean, required: false },
+    openDelay: { type: Number, required: false },
+    closeDelay: { type: Number, required: false },
+    top: { type: String, required: false },
+    modelValue: { type: Boolean, required: false },
+    modalClass: { type: String, required: false },
+    headerClass: { type: String, required: false },
+    bodyClass: { type: String, required: false },
+    footerClass: { type: String, required: false },
+    width: { type: null, required: false },
+    zIndex: { type: Number, required: false },
+    trapFocus: { type: Boolean, required: false },
+    center: { type: Boolean, required: false },
+    alignCenter: { type: Boolean, required: false },
+    closeIcon: { type: null, required: false },
+    draggable: { type: Boolean, required: false },
+    overflow: { type: Boolean, required: false },
+    fullscreen: { type: Boolean, required: false },
+    showClose: { type: Boolean, required: false },
+    ariaLevel: { type: String, required: false }
+  }, {
+    "modelValue": { type: Boolean, ...{ default: false } },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ vue.mergeModels(["confirm", "close", "input"], ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const visible = vue.useModel(__props, "modelValue");
+    const props = __props;
+    const emit = __emit;
+    const attrs = vue.useAttrs();
+    const drawerAttrs = vue.computed(() => {
+      const result = {
+        title: props.title,
+        size: props.size,
+        direction: props.direction
+      };
+      Object.keys(attrs).forEach((key) => {
+        if (type.drawerPropKeys.includes(key)) {
+          result[key] = attrs[key];
+        }
+      });
+      return result;
+    });
+    const treeSelectAttrs = vue.computed(() => {
+      const result = {
+        treeProps: props.treeProps,
+        multiple: props.multiple,
+        defaultExpandAll: props.defaultExpandAll,
+        defaultSelectedKeys: props.defaultSelectedKeys,
+        nodeKey: props.nodeKey,
+        showSearch: props.showSearch
+      };
+      Object.keys(attrs).forEach((key) => {
+        if (!type.drawerPropKeys.includes(key) && !key.startsWith("on")) {
+          result[key] = attrs[key];
+        }
+      });
+      return result;
+    });
+    const treeSelectRef = vue.ref();
+    vue.watch(visible, (val) => {
+      if (!val && treeSelectRef.value) {
+        treeSelectRef.value.reset();
+      }
+    });
+    const handleBeforeClose = (done) => {
+      visible.value = false;
+      done();
+    };
+    const handleConfirm = (selectedData) => {
+      emit("confirm", selectedData);
+      visible.value = false;
+    };
+    const handleCancel = () => {
+      visible.value = false;
+    };
+    __expose({
+      input: (value) => emit("input", value)
+    });
+    return (_ctx, _cache) => {
+      const _component_el_drawer = vue.resolveComponent("el-drawer");
+      return vue.openBlock(), vue.createBlock(_component_el_drawer, vue.mergeProps({
+        modelValue: visible.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => visible.value = $event)
+      }, drawerAttrs.value, {
+        class: vue.unref(index.bem)("tree-select-drawer"),
+        "before-close": handleBeforeClose,
+        onClose: _cache[1] || (_cache[1] = ($event) => emit("close"))
+      }), {
+        default: vue.withCtx(() => [
+          vue.createVNode(index_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({
+            ref_key: "treeSelectRef",
+            ref: treeSelectRef,
+            "tree-data": __props.treeData
+          }, treeSelectAttrs.value, vue.toHandlers(_ctx.$attrs), {
+            onConfirm: handleConfirm,
+            onCancel: handleCancel
+          }), null, 16, ["tree-data"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 16, ["modelValue", "class"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/minilo/lib/components/tree-select-drawer/type.d.ts

@@ -0,0 +1,10 @@
+import { TreeSelectProps } from '../tree-select/type';
+import { DrawerProps } from 'element-plus';
+export interface DrawerContainerProps extends Partial<DrawerProps> {
+    title?: string;
+    size?: string | number;
+    direction?: 'rtl' | 'ltr' | 'ttb' | 'btt';
+}
+export interface TreeSelectDrawerProps<T = any> extends TreeSelectProps<T>, DrawerContainerProps {
+}
+export declare const drawerPropKeys: string[];

package/minilo/lib/components/tree-select-drawer/type.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const drawerPropKeys = [
+  "title",
+  "size",
+  "direction",
+  "appendToBody",
+  "appendTo",
+  "modal",
+  "modalClass",
+  "lockScroll",
+  "closeOnClickModal",
+  "closeOnPressEscape",
+  "showClose",
+  "withHeader",
+  "openDelay",
+  "closeDelay",
+  "destroyOnClose",
+  "zIndex"
+];
+
+exports.drawerPropKeys = drawerPropKeys;

package/minilo/lib/components/virtual-list/index.d.ts

@@ -1,6 +1,6 @@
 export declare const MlVirtualList: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').MlVirtualListProps> & Readonly<{
-        "onLoad-more"?: (() => any) | undefined;
+        "onLoad-more"?: () => any;
     }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
         "load-more": () => any;
     }, import('vue').PublicProps, {
@@ -11,7 +11,7 @@ export declare const MlVirtualList: {
         preLoadCount: number;
         threshold: number;
         dataSource: any[];
-    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         containerRef: HTMLDivElement;
     }, HTMLDivElement, import('vue').ComponentProvideOptions, {
         P: {};
@@ -21,7 +21,7 @@ export declare const MlVirtualList: {
         M: {};
         Defaults: {};
     }, Readonly<import('./type').MlVirtualListProps> & Readonly<{
-        "onLoad-more"?: (() => any) | undefined;
+        "onLoad-more"?: () => any;
     }>, {}, {}, {}, {}, {
         height: number;
         itemHeight: number;
@@ -35,7 +35,7 @@ export declare const MlVirtualList: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import('vue').ComponentOptionsBase<Readonly<import('./type').MlVirtualListProps> & Readonly<{
-    "onLoad-more"?: (() => any) | undefined;
+    "onLoad-more"?: () => any;
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "load-more": () => any;
 }, string, {

package/minilo/lib/components/virtual-list/index.vue.d.ts

@@ -18,7 +18,7 @@ type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<MlVirtualListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "load-more": () => any;
 }, string, import('vue').PublicProps, Readonly<MlVirtualListProps> & Readonly<{
-    "onLoad-more"?: (() => any) | undefined;
+    "onLoad-more"?: () => any;
 }>, {
     height: number;
     itemHeight: number;
@@ -27,7 +27,7 @@ declare const __VLS_component: import('vue').DefineComponent<MlVirtualListProps,
     preLoadCount: number;
     threshold: number;
     dataSource: any[];
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     containerRef: HTMLDivElement;
 }, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;