@minilo/ui 0.0.1

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

@@ -0,0 +1,302 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var props = require('./props.js');
+var vue$1 = require('@iconify/vue');
+var elementPlus = require('element-plus');
+var index = require('../../utils/index.js');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "MlSearch" },
+  __name: "index",
+  props: /* @__PURE__ */ vue.mergeModels(props.searchProps, {
+    "modelValue": { type: Object },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ vue.mergeModels(["submit", "reset"], ["update:modelValue"]),
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props$1 = __props;
+    const options = vue.ref([]);
+    const searchFormRef = vue.ref();
+    const isCollapse = vue.ref(false);
+    const searchModel = vue.useModel(__props, "modelValue");
+    const emit = __emit;
+    const handleSubmit = () => {
+      emit("submit");
+    };
+    const handleReset = () => {
+      searchFormRef.value?.resetFields();
+      emit("reset");
+    };
+    vue.onMounted(() => {
+      console.log(props$1);
+      const itemProps = props$1.item.map((item) => ({
+        type: props.SearchTypeEnum.ITEM,
+        ...item
+      }));
+      const slotProps = props$1.slots.map((item) => ({
+        type: props.SearchTypeEnum.SLOT,
+        ...item
+      }));
+      slotProps.forEach((item) => {
+        itemProps.splice(item.position || 0, 0, item);
+      });
+      options.value = itemProps;
+      console.log("\u914D\u7F6E\u9879\u7684\u503C:", options.value);
+    });
+    __expose({});
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          class: vue.normalizeClass(vue.unref(index.bem)("search"))
+        },
+        [
+          vue.createVNode(vue.unref(elementPlus.ElForm), {
+            size: _ctx.size,
+            "label-position": _ctx.labelPosition,
+            inline: _ctx.inline,
+            model: searchModel.value,
+            "label-width": _ctx.labelWidth,
+            ref_key: "searchFormRef",
+            ref: searchFormRef
+          }, {
+            default: vue.withCtx(() => [
+              vue.createElementVNode(
+                "div",
+                {
+                  class: vue.normalizeClass(vue.unref(index.bem)("search", "content"))
+                },
+                [
+                  vue.createElementVNode(
+                    "div",
+                    {
+                      class: vue.normalizeClass(vue.unref(index.bem)("search", "content__left"))
+                    },
+                    [
+                      vue.createVNode(vue.unref(elementPlus.ElRow), { gutter: _ctx.gutter }, {
+                        default: vue.withCtx(() => [
+                          (vue.openBlock(true), vue.createElementBlock(
+                            vue.Fragment,
+                            null,
+                            vue.renderList(options.value, (item, index) => {
+                              return vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCol), vue.mergeProps({
+                                key: item.prop,
+                                span: _ctx.span
+                              }, { ref_for: true }, item.colProps), {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(elementPlus.ElFormItem), vue.mergeProps({ ref_for: true }, item.formItemProps, {
+                                    prop: item.prop
+                                  }), {
+                                    default: vue.withCtx(() => [
+                                      item.type === vue.unref(props.SearchTypeEnum).SLOT ? vue.renderSlot(_ctx.$slots, item.prop, {
+                                        key: 0,
+                                        searchModel: searchModel.value
+                                      }) : (vue.openBlock(), vue.createElementBlock(
+                                        vue.Fragment,
+                                        { key: 1 },
+                                        [
+                                          vue.createCommentVNode(" \u8F93\u5165\u6846 "),
+                                          item.input.type === "input" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElInput), vue.mergeProps({
+                                            key: 0,
+                                            modelValue: searchModel.value[item.prop],
+                                            "onUpdate:modelValue": ($event) => searchModel.value[item.prop] = $event
+                                          }, { ref_for: true }, item.input.props, { clearable: "" }), null, 16, ["modelValue", "onUpdate:modelValue"])) : vue.createCommentVNode("v-if", true),
+                                          vue.createCommentVNode(" \u7B5B\u9009\u6846 "),
+                                          item.input.type === "select" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElSelect), vue.mergeProps({
+                                            key: 1,
+                                            modelValue: searchModel.value[item.prop],
+                                            "onUpdate:modelValue": ($event) => searchModel.value[item.prop] = $event
+                                          }, { ref_for: true }, item.input.props, {
+                                            style: { "width": "100%" },
+                                            clearable: ""
+                                          }), {
+                                            default: vue.withCtx(() => [
+                                              (vue.openBlock(true), vue.createElementBlock(
+                                                vue.Fragment,
+                                                null,
+                                                vue.renderList(item.input.props.options, (subItem) => {
+                                                  return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElOption), {
+                                                    key: subItem.value,
+                                                    label: subItem[item.input.props.labelKey],
+                                                    value: subItem[item.input.props.valueKey],
+                                                    disabled: subItem.disabled
+                                                  }, null, 8, ["label", "value", "disabled"]);
+                                                }),
+                                                128
+                                                /* KEYED_FRAGMENT */
+                                              ))
+                                            ]),
+                                            _: 2
+                                            /* DYNAMIC */
+                                          }, 1040, ["modelValue", "onUpdate:modelValue"])) : vue.createCommentVNode("v-if", true),
+                                          vue.createCommentVNode(" \u65F6\u95F4\u9009\u62E9\u6846 "),
+                                          item.input.type === "date-picker" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDatePicker), vue.mergeProps({
+                                            key: 2,
+                                            modelValue: searchModel.value[item.prop],
+                                            "onUpdate:modelValue": ($event) => searchModel.value[item.prop] = $event
+                                          }, { ref_for: true }, item.input.props), null, 16, ["modelValue", "onUpdate:modelValue"])) : vue.createCommentVNode("v-if", true)
+                                        ],
+                                        64
+                                        /* STABLE_FRAGMENT */
+                                      ))
+                                    ]),
+                                    _: 2
+                                    /* DYNAMIC */
+                                  }, 1040, ["prop"])
+                                ]),
+                                _: 2
+                                /* DYNAMIC */
+                              }, 1040, ["span"])), [
+                                [vue.vShow, !isCollapse.value ? true : index <= 24 / _ctx.span - 1]
+                              ]);
+                            }),
+                            128
+                            /* KEYED_FRAGMENT */
+                          )),
+                          options.value.length <= 24 / _ctx.span - 1 ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCol), {
+                            key: 0,
+                            span: _ctx.span
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(elementPlus.ElFormItem), { label: "\u64CD\u4F5C" }, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(vue.unref(elementPlus.ElButton), {
+                                    type: "primary",
+                                    size: _ctx.size,
+                                    loading: false,
+                                    onClick: vue.withModifiers(handleSubmit, ["stop"])
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createTextVNode(
+                                        vue.toDisplayString(_ctx.submitBtnText),
+                                        1
+                                        /* TEXT */
+                                      )
+                                    ]),
+                                    _: 1
+                                    /* STABLE */
+                                  }, 8, ["size"]),
+                                  vue.createVNode(vue.unref(elementPlus.ElButton), {
+                                    loading: false,
+                                    onClick: vue.withModifiers(handleReset, ["stop"])
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createTextVNode(
+                                        vue.toDisplayString(_ctx.resetBtnText),
+                                        1
+                                        /* TEXT */
+                                      )
+                                    ]),
+                                    _: 1
+                                    /* STABLE */
+                                  })
+                                ]),
+                                _: 1
+                                /* STABLE */
+                              })
+                            ]),
+                            _: 1
+                            /* STABLE */
+                          }, 8, ["span"])) : vue.createCommentVNode("v-if", true)
+                        ]),
+                        _: 3
+                        /* FORWARDED */
+                      }, 8, ["gutter"])
+                    ],
+                    2
+                    /* CLASS */
+                  ),
+                  options.value.length > 24 / _ctx.span - 1 ? (vue.openBlock(), vue.createElementBlock(
+                    "div",
+                    {
+                      key: 0,
+                      class: vue.normalizeClass(vue.unref(index.bem)("search", "content__right"))
+                    },
+                    [
+                      vue.createVNode(vue.unref(elementPlus.ElFormItem), { label: "\u64CD\u4F5C" }, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(vue.unref(elementPlus.ElButton), {
+                            type: "primary",
+                            size: _ctx.size,
+                            loading: false,
+                            onClick: vue.withModifiers(handleSubmit, ["stop"])
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createTextVNode(
+                                vue.toDisplayString(_ctx.submitBtnText),
+                                1
+                                /* TEXT */
+                              )
+                            ]),
+                            _: 1
+                            /* STABLE */
+                          }, 8, ["size"]),
+                          vue.createVNode(vue.unref(elementPlus.ElButton), {
+                            loading: false,
+                            onClick: vue.withModifiers(handleReset, ["stop"])
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createTextVNode(
+                                vue.toDisplayString(_ctx.resetBtnText),
+                                1
+                                /* TEXT */
+                              )
+                            ]),
+                            _: 1
+                            /* STABLE */
+                          })
+                        ]),
+                        _: 1
+                        /* STABLE */
+                      })
+                    ],
+                    2
+                    /* CLASS */
+                  )) : vue.createCommentVNode("v-if", true)
+                ],
+                2
+                /* CLASS */
+              ),
+              options.value.length > 24 / _ctx.span ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElRow), {
+                key: 0,
+                class: vue.normalizeClass(vue.unref(index.bem)("search", "collapse"))
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(elementPlus.ElLink), {
+                    type: "primary",
+                    underline: "never",
+                    onClick: _cache[0] || (_cache[0] = ($event) => isCollapse.value = !isCollapse.value)
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createTextVNode(
+                        vue.toDisplayString(isCollapse.value ? "\u5C55\u5F00" : "\u6536\u8D77") + "\u66F4\u591A\u7B5B\u9009\u6761\u4EF6 ",
+                        1
+                        /* TEXT */
+                      ),
+                      vue.createVNode(vue.unref(vue$1.Icon), {
+                        icon: isCollapse.value ? "ep:arrow-down" : "ep:arrow-up"
+                      }, null, 8, ["icon"])
+                    ]),
+                    _: 1
+                    /* STABLE */
+                  })
+                ]),
+                _: 1
+                /* STABLE */
+              }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
+            ]),
+            _: 3
+            /* FORWARDED */
+          }, 8, ["size", "label-position", "inline", "model", "label-width"])
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/minilo/lib/components/search/props.d.ts

@@ -0,0 +1,107 @@
+import { PropType } from 'vue';
+export declare enum SearchTypeEnum {
+    ITEM = 1,
+    SLOT = 2
+}
+export interface SearchItem {
+    prop: string;
+    span?: number;
+    placeholder?: string;
+    multiple?: boolean;
+    options?: any[];
+    labelWidth?: string;
+    input?: any;
+    colProps?: any;
+    formItemProps?: any;
+    [keyname: string]: any;
+}
+export interface CustomSlot {
+    prop: string;
+    span?: number;
+    colProps?: any;
+    formItemProps?: any;
+    position?: number;
+    [keyname: string]: any;
+}
+export interface SearchProps extends SearchItem, CustomSlot {
+    type: SearchTypeEnum;
+}
+export interface SearchModel {
+    [key: string]: any;
+}
+export declare const searchProps: {
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    labelPosition: {
+        type: PropType<"left" | "right" | "top">;
+        default: string;
+    };
+    size: {
+        type: PropType<"" | "large" | "default" | "small">;
+        default: string;
+    };
+    gutter: {
+        type: NumberConstructor[];
+        default: number;
+    };
+    span: {
+        type: NumberConstructor;
+        default: number;
+    };
+    submitBtnText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetBtnText: {
+        type: StringConstructor;
+        default: string;
+    };
+    slots: {
+        type: {
+            (arrayLength: number): CustomSlot[];
+            (...items: CustomSlot[]): CustomSlot[];
+            new (arrayLength: number): CustomSlot[];
+            new (...items: CustomSlot[]): CustomSlot[];
+            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[];
+    };
+    item: {
+        type: {
+            (arrayLength: number): SearchItem[];
+            (...items: SearchItem[]): SearchItem[];
+            new (arrayLength: number): SearchItem[];
+            new (...items: SearchItem[]): SearchItem[];
+            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[];
+    };
+};

package/minilo/lib/components/search/props.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var SearchTypeEnum = /* @__PURE__ */ ((SearchTypeEnum2) => {
+  SearchTypeEnum2[SearchTypeEnum2["ITEM"] = 1] = "ITEM";
+  SearchTypeEnum2[SearchTypeEnum2["SLOT"] = 2] = "SLOT";
+  return SearchTypeEnum2;
+})(SearchTypeEnum || {});
+const searchProps = {
+  inline: {
+    type: Boolean,
+    default: false
+  },
+  disabled: {
+    type: Boolean,
+    default: false
+  },
+  labelWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  // 'left' | 'right' | 'top'
+  labelPosition: {
+    type: String,
+    default: "top"
+  },
+  // '' | 'large' | 'default' | 'small'
+  size: {
+    type: String,
+    default: "default"
+  },
+  gutter: {
+    type: [Number],
+    default: 10
+  },
+  span: {
+    type: Number,
+    default: 6
+  },
+  submitBtnText: {
+    type: String,
+    default: "\u67E5\u8BE2"
+  },
+  resetBtnText: {
+    type: String,
+    default: "\u91CD\u7F6E"
+  },
+  slots: {
+    type: Array,
+    default: () => []
+  },
+  item: {
+    type: Array,
+    default: () => []
+  }
+};
+
+exports.SearchTypeEnum = SearchTypeEnum;
+exports.searchProps = searchProps;