@minilo/ui 0.0.1

package/minilo/lib/components/search-table/index.d.ts

@@ -0,0 +1,274 @@
+export declare const MlSearchTable: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        methodType: {
+            type: () => import('./props').RequestMethodType;
+            default: string;
+        };
+        url: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseDataField: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseTotalField: {
+            type: StringConstructor;
+            default: string;
+        };
+        headers: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        showPagination: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        paramsHandler: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        render: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        searchProps: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        tableProps: {
+            type: ObjectConstructor;
+            default: () => {
+                border: boolean;
+            };
+        };
+        columns: {
+            type: {
+                (arrayLength: number): any[];
+                (...items: any[]): any[];
+                new (arrayLength: number): any[];
+                new (...items: any[]): any[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: () => never[];
+        };
+        search: {
+            type: import('vue').PropType<import('../search/props').SearchModel>;
+        };
+    }>> & Readonly<{
+        onReset?: ((...args: any[]) => any) | undefined;
+        "onUpdate:search"?: ((value: import('../search/props').SearchModel) => any) | undefined;
+    }>, {
+        handleSearch: (reset?: boolean) => Promise<void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        reset: (...args: any[]) => void;
+        "update:search": (value: import('../search/props').SearchModel) => void;
+    }, import('vue').PublicProps, {
+        url: string;
+        render: Function;
+        methodType: import('./props').RequestMethodType;
+        responseDataField: string;
+        responseTotalField: string;
+        headers: Record<string, any>;
+        showPagination: boolean;
+        paramsHandler: Function;
+        searchProps: Record<string, any>;
+        tableProps: Record<string, any>;
+        columns: any[];
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        methodType: {
+            type: () => import('./props').RequestMethodType;
+            default: string;
+        };
+        url: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseDataField: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseTotalField: {
+            type: StringConstructor;
+            default: string;
+        };
+        headers: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        showPagination: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        paramsHandler: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        render: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        searchProps: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        tableProps: {
+            type: ObjectConstructor;
+            default: () => {
+                border: boolean;
+            };
+        };
+        columns: {
+            type: {
+                (arrayLength: number): any[];
+                (...items: any[]): any[];
+                new (arrayLength: number): any[];
+                new (...items: any[]): any[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: () => never[];
+        };
+        search: {
+            type: import('vue').PropType<import('../search/props').SearchModel>;
+        };
+    }>> & Readonly<{
+        onReset?: ((...args: any[]) => any) | undefined;
+        "onUpdate:search"?: ((value: import('../search/props').SearchModel) => any) | undefined;
+    }>, {
+        handleSearch: (reset?: boolean) => Promise<void>;
+    }, {}, {}, {}, {
+        url: string;
+        render: Function;
+        methodType: import('./props').RequestMethodType;
+        responseDataField: string;
+        responseTotalField: string;
+        headers: Record<string, any>;
+        showPagination: boolean;
+        paramsHandler: Function;
+        searchProps: Record<string, any>;
+        tableProps: Record<string, any>;
+        columns: any[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    methodType: {
+        type: () => import('./props').RequestMethodType;
+        default: string;
+    };
+    url: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseDataField: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseTotalField: {
+        type: StringConstructor;
+        default: string;
+    };
+    headers: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    showPagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    paramsHandler: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    render: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    searchProps: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    tableProps: {
+        type: ObjectConstructor;
+        default: () => {
+            border: boolean;
+        };
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    search: {
+        type: import('vue').PropType<import('../search/props').SearchModel>;
+    };
+}>> & Readonly<{
+    onReset?: ((...args: any[]) => any) | undefined;
+    "onUpdate:search"?: ((value: import('../search/props').SearchModel) => any) | undefined;
+}>, {
+    handleSearch: (reset?: boolean) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reset: (...args: any[]) => void;
+    "update:search": (value: import('../search/props').SearchModel) => void;
+}, string, {
+    url: string;
+    render: Function;
+    methodType: import('./props').RequestMethodType;
+    responseDataField: string;
+    responseTotalField: string;
+    headers: Record<string, any>;
+    showPagination: boolean;
+    paramsHandler: Function;
+    searchProps: Record<string, any>;
+    tableProps: Record<string, any>;
+    columns: any[];
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<any, (_: {}) => any>> & Partial<Record<any, (_: {
+        index: any;
+        row: any;
+    }) => any>> & {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+    };
+});
+export default MlSearchTable;

package/minilo/lib/components/search-table/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 MlSearchTable = index.withInstall(index_vue_vue_type_script_setup_true_lang.default);
+
+exports.MlSearchTable = MlSearchTable;
+exports.default = MlSearchTable;

package/minilo/lib/components/search-table/index.vue.d.ts

@@ -0,0 +1,173 @@
+import { RequestMethodType } from './props';
+import { SearchModel } from '../search/props';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<any, (_: {}) => any>> & Partial<Record<any, (_: {
+        index: any;
+        row: any;
+    }) => any>> & {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    methodType: {
+        type: () => RequestMethodType;
+        default: string;
+    };
+    url: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseDataField: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseTotalField: {
+        type: StringConstructor;
+        default: string;
+    };
+    headers: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    showPagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    paramsHandler: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    render: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    searchProps: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    tableProps: {
+        type: ObjectConstructor;
+        default: () => {
+            border: boolean;
+        };
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    search: {
+        type: import('vue').PropType<SearchModel>;
+    };
+}>, {
+    handleSearch: (reset?: boolean) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reset: (...args: any[]) => void;
+    "update:search": (value: SearchModel) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    methodType: {
+        type: () => RequestMethodType;
+        default: string;
+    };
+    url: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseDataField: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseTotalField: {
+        type: StringConstructor;
+        default: string;
+    };
+    headers: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    showPagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    paramsHandler: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    render: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    searchProps: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    tableProps: {
+        type: ObjectConstructor;
+        default: () => {
+            border: boolean;
+        };
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    search: {
+        type: import('vue').PropType<SearchModel>;
+    };
+}>> & Readonly<{
+    onReset?: ((...args: any[]) => any) | undefined;
+    "onUpdate:search"?: ((value: SearchModel) => any) | undefined;
+}>, {
+    url: string;
+    render: Function;
+    methodType: RequestMethodType;
+    responseDataField: string;
+    responseTotalField: string;
+    headers: Record<string, any>;
+    showPagination: boolean;
+    paramsHandler: Function;
+    searchProps: Record<string, any>;
+    tableProps: Record<string, any>;
+    columns: any[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/search-table/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/search-table/index.vue2.js

@@ -0,0 +1,199 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index_vue_vue_type_script_setup_true_lang = require('../search/index.vue2.js');
+var props = require('./props.js');
+var elementPlus = require('element-plus');
+var render = require('./render.js');
+var index$1 = require('../../utils/index.js');
+var index = require('../../packages/utils/dist/request/index.js');
+var common = require('../../packages/utils/dist/func/common.js');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "MlSearchTable",
+    inheritAttrs: false
+  },
+  __name: "index",
+  props: /* @__PURE__ */ vue.mergeModels(props.searchTableProps, {
+    "search": { type: Object },
+    "searchModifiers": {}
+  }),
+  emits: /* @__PURE__ */ vue.mergeModels(["reset"], ["update:search"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const searchModel = vue.useModel(__props, "search");
+    const props$1 = __props;
+    const attrs = vue.useAttrs();
+    const emit = __emit;
+    const axios = index.initRequestInstance({
+      baseURL: "",
+      headers: props$1.headers
+    });
+    const data = vue.ref([]);
+    const loading = vue.ref(false);
+    const pagination = vue.ref({
+      currentPage: 1,
+      pageSize: 20,
+      total: 100
+    });
+    const handleSearch = async (reset2 = true) => {
+      try {
+        if (reset2) {
+          pagination.value.currentPage = 1;
+        }
+        const defaultParams = {
+          ...searchModel.value
+        };
+        if (props$1.showPagination) {
+          Object.assign(defaultParams, {
+            pageSize: pagination.value.pageSize,
+            currentPage: pagination.value.currentPage
+          });
+        }
+        const params = props$1.paramsHandler ? props$1.paramsHandler(defaultParams) : defaultParams;
+        const requestParams = [props.RequestMethodType.GET, props.RequestMethodType.DELETE].includes(
+          props$1.methodType
+        ) ? { params } : params;
+        loading.value = true;
+        const res = await axios[props$1.methodType](
+          props$1.url,
+          requestParams
+        );
+        data.value = common.getNestedValue(res, props$1.responseDataField);
+        if (props$1.showPagination) {
+          pagination.value.total = common.getNestedValue(res, props$1.responseTotalField);
+        }
+      } catch (error) {
+        console.log(error);
+      } finally {
+        loading.value = false;
+      }
+    };
+    const submit = () => {
+      handleSearch();
+    };
+    const reset = () => {
+      emit("reset");
+      handleSearch();
+    };
+    vue.onMounted(() => {
+      handleSearch();
+    });
+    __expose({
+      handleSearch
+    });
+    const tableListeners = Object.keys(attrs).reduce((listeners, key) => {
+      if (key.startsWith("on")) {
+        listeners[key] = attrs[key];
+      }
+      return listeners;
+    }, {});
+    return (_ctx, _cache) => {
+      const _directive_loading = vue.resolveDirective("loading");
+      return vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          class: vue.normalizeClass(vue.unref(index$1.bem)("search-table"))
+        },
+        [
+          vue.createVNode(index_vue_vue_type_script_setup_true_lang.default, vue.mergeProps({
+            onSubmit: submit,
+            onReset: reset,
+            modelValue: searchModel.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => searchModel.value = $event)
+          }, _ctx.searchProps), vue.createSlots({
+            _: 2
+            /* DYNAMIC */
+          }, [
+            vue.renderList(_ctx.searchProps.slots, (item) => {
+              return {
+                name: item.prop,
+                fn: vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, item.prop)
+                ])
+              };
+            })
+          ]), 1040, ["modelValue"]),
+          vue.renderSlot(_ctx.$slots, "prefix"),
+          vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTable), vue.mergeProps(vue.toHandlers(vue.unref(tableListeners)), {
+            class: vue.unref(index$1.bem)("search-table", "content")
+          }, _ctx.tableProps, {
+            border: true,
+            data: data.value
+          }), {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(
+                vue.Fragment,
+                null,
+                vue.renderList(_ctx.columns, (item, index) => {
+                  return vue.openBlock(), vue.createBlock(
+                    vue.unref(elementPlus.ElTableColumn),
+                    vue.mergeProps({ key: index }, { ref_for: true }, item),
+                    {
+                      default: vue.withCtx((scope) => [
+                        item.slotName ? vue.renderSlot(_ctx.$slots, item.slotName, {
+                          key: 0,
+                          index: scope.$index,
+                          row: scope.row
+                        }) : vue.createCommentVNode("v-if", true),
+                        item.render ? (vue.openBlock(), vue.createBlock(vue.unref(render.default), {
+                          key: 1,
+                          scope,
+                          render: item.render
+                        }, null, 8, ["scope", "render"])) : vue.createCommentVNode("v-if", true)
+                      ]),
+                      _: 2
+                      /* DYNAMIC */
+                    },
+                    1040
+                    /* FULL_PROPS, DYNAMIC_SLOTS */
+                  );
+                }),
+                128
+                /* KEYED_FRAGMENT */
+              ))
+            ]),
+            _: 3
+            /* FORWARDED */
+          }, 16, ["class", "data"])), [
+            [
+              _directive_loading,
+              loading.value,
+              void 0,
+              { lock: true }
+            ]
+          ]),
+          vue.createElementVNode(
+            "div",
+            {
+              class: vue.normalizeClass(vue.unref(index$1.bem)("search-table", "pagination"))
+            },
+            [
+              _ctx.showPagination ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElPagination), {
+                key: 0,
+                onChange: _cache[1] || (_cache[1] = ($event) => handleSearch(false)),
+                style: { "margin-top": "10px" },
+                background: "",
+                layout: "total, sizes, prev, pager, next, jumper",
+                "page-size": pagination.value.pageSize,
+                "onUpdate:pageSize": _cache[2] || (_cache[2] = ($event) => pagination.value.pageSize = $event),
+                "current-page": pagination.value.currentPage,
+                "onUpdate:currentPage": _cache[3] || (_cache[3] = ($event) => pagination.value.currentPage = $event),
+                total: pagination.value.total
+              }, null, 8, ["page-size", "current-page", "total"])) : vue.createCommentVNode("v-if", true)
+            ],
+            2
+            /* CLASS */
+          ),
+          vue.renderSlot(_ctx.$slots, "suffix")
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+exports.default = _sfc_main;