@minilo/ui 0.0.6 → 0.0.8

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

@@ -1,302 +0,0 @@
-'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

@@ -1,107 +0,0 @@
-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: () => any[];
-    };
-    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: () => any[];
-    };
-};

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

@@ -1,58 +0,0 @@
-'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;