easybill-ui 1.4.1 → 1.4.2

package/dist/components/CurdTable/src/STableColumnControl.vue.js

@@ -0,0 +1,132 @@
+import { defineComponent as N, inject as U, ref as j, computed as h, watch as D, shallowRef as F, resolveComponent as a, createBlock as b, openBlock as d, unref as p, withCtx as i, createVNode as u, createElementBlock as $, Fragment as E, renderList as H, resolveDynamicComponent as M, triggerRef as w } from "vue";
+import { CaretLeft as P, VideoPause as T, CaretRight as q } from "@element-plus/icons-vue";
+import { useLocale as A } from "../../../utils/hooks/useLocal.js";
+const O = /* @__PURE__ */ N({
+  __name: "STableColumnControl",
+  props: {
+    visible: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["update:visible", "change"],
+  setup(g, { emit: x }) {
+    const v = g, m = x, { t: c } = A(), r = U("columns") || j([]), f = h({
+      get() {
+        return v.visible;
+      },
+      set(e) {
+        m("update:visible", e);
+      }
+    });
+    D(
+      () => v.visible,
+      (e) => {
+        f.value = e;
+      }
+    );
+    const C = h(() => {
+      const e = [];
+      for (const l in r.value) {
+        const t = r.value[l];
+        if (t.children) {
+          for (const _ in t.children) {
+            const s = t.children[_];
+            s.neverShow || e.push(s);
+          }
+          continue;
+        } else t.neverShow || e.push(t);
+      }
+      return e;
+    }), y = F([
+      { value: "left", label: c("el.table.fixLeft"), icon: P },
+      { value: "", label: c("el.table.fixNone"), icon: T },
+      { value: "right", label: c("el.table.fixRight"), icon: q }
+    ]), V = (e, l) => {
+      l ? e.fixed = l : delete e.fixed, w(r), m("change");
+    }, k = () => {
+      w(r), m("change");
+    };
+    return (e, l) => {
+      const t = a("el-table-column"), _ = a("el-switch"), s = a("el-icon"), S = a("el-button"), B = a("el-tooltip"), L = a("el-button-group"), R = a("el-table"), z = a("el-drawer");
+      return d(), b(z, {
+        modelValue: f.value,
+        "onUpdate:modelValue": l[1] || (l[1] = (n) => f.value = n),
+        title: p(c)("el.table.columnSet"),
+        size: "40%",
+        "append-to-body": ""
+      }, {
+        default: i(() => [
+          u(R, { data: C.value }, {
+            default: i(() => [
+              u(t, {
+                property: "label",
+                label: p(c)("el.table.columnName")
+              }, null, 8, ["label"]),
+              u(t, {
+                property: "hidden",
+                label: p(c)("el.table.show"),
+                width: "60"
+              }, {
+                default: i((n) => [
+                  u(_, {
+                    modelValue: n.row.hidden,
+                    "onUpdate:modelValue": (o) => n.row.hidden = o,
+                    "active-value": !1,
+                    "inactive-value": !0,
+                    size: "small",
+                    onChange: l[0] || (l[0] = (o) => k())
+                  }, null, 8, ["modelValue", "onUpdate:modelValue"])
+                ]),
+                _: 1
+              }, 8, ["label"]),
+              u(t, {
+                property: "fixed",
+                label: p(c)("el.table.fixShow"),
+                width: "160",
+                align: "center"
+              }, {
+                default: i((n) => [
+                  u(L, null, {
+                    default: i(() => [
+                      (d(!0), $(E, null, H(y.value, (o) => (d(), b(B, {
+                        key: o.value,
+                        content: o.label
+                      }, {
+                        default: i(() => [
+                          u(S, {
+                            type: !n.row.fixed && o.value == "" || n.row.fixed == o.value ? "primary" : "",
+                            size: "small",
+                            onClick: (G) => V(n.row, o.value)
+                          }, {
+                            default: i(() => [
+                              u(s, null, {
+                                default: i(() => [
+                                  (d(), b(M(o.icon)))
+                                ]),
+                                _: 2
+                              }, 1024)
+                            ]),
+                            _: 2
+                          }, 1032, ["type", "onClick"])
+                        ]),
+                        _: 2
+                      }, 1032, ["content"]))), 128))
+                    ]),
+                    _: 2
+                  }, 1024)
+                ]),
+                _: 1
+              }, 8, ["label"])
+            ]),
+            _: 1
+          }, 8, ["data"])
+        ]),
+        _: 1
+      }, 8, ["modelValue", "title"]);
+    };
+  }
+});
+export {
+  O as default
+};

package/dist/components/CurdTable/src/STableColumnControl.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableColumnControl.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableDetail.vue.d.ts

@@ -0,0 +1,9 @@
+import { ColumnItem } from './types';
+interface OpenOption {
+    columns: Array<ColumnItem>;
+    data: Record<string, unknown>;
+}
+declare const _default: import('vue').DefineComponent<{}, {
+    open: (option: OpenOption) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableDetail.vue.js

@@ -0,0 +1,53 @@
+import { defineComponent as f, ref as d, resolveComponent as c, createBlock as h, openBlock as v, unref as p, withCtx as b, createVNode as _ } from "vue";
+import { DetailInfo as w } from "../../DetailInfo/index.js";
+import { useLocale as x } from "../../../utils/hooks/useLocal.js";
+const y = /* @__PURE__ */ f({
+  __name: "STableDetail",
+  setup(V, { expose: u }) {
+    const { t: s } = x(), r = d(!1), n = d([]), i = (l, e, o) => e.formatter ? e.formatter(l, e, l[e.prop], o) : typeof l[e.prop] > "u" || l[e.prop] === "" ? "--" : l[e.prop];
+    return u({ open: (l) => {
+      n.value = [], l.columns.forEach((e, o) => {
+        if (e.children && e.children.length)
+          for (let t = 0; t < e.children.length; t++) {
+            const a = e.children[t];
+            a.hidden || n.value.push({
+              label: a.label,
+              value: i(l.data, a, t),
+              span: a.detail && a.detail.span || 24,
+              options: a.options
+            });
+          }
+        else {
+          if (e.hidden) return;
+          n.value.push({
+            label: e.label,
+            value: i(l.data, e, o),
+            span: e.detail && e.detail.span || 24,
+            options: e.options
+          });
+        }
+      }), r.value = !0;
+    } }), (l, e) => {
+      const o = c("el-drawer");
+      return v(), h(o, {
+        modelValue: r.value,
+        "onUpdate:modelValue": e[0] || (e[0] = (t) => r.value = t),
+        title: p(s)("el.table.detail"),
+        size: "40%"
+      }, {
+        default: b(() => [
+          _(p(w), {
+            data: n.value,
+            title: p(s)("el.table.detail"),
+            "label-width": "110px",
+            "show-type": "table"
+          }, null, 8, ["data", "title"])
+        ]),
+        _: 1
+      }, 8, ["modelValue", "title"]);
+    };
+  }
+});
+export {
+  y as default
+};

package/dist/components/CurdTable/src/STableDetail.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableDetail.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableFilter.vue.d.ts

@@ -0,0 +1,28 @@
+import { PropType, Ref } from 'vue';
+import { FilterItem, ListQuery } from '../../TableFilter';
+declare const _default: import('vue').DefineComponent<{
+    listQuery: {
+        type: PropType<ListQuery>;
+        default(): {};
+    };
+}, {
+    filterRef: Ref<any>;
+    setItem: (prop: string, filterItem?: FilterItem) => void;
+    getSelectList: () => any;
+    loadOptions: (prop: string, config?: unknown) => any;
+    clear: (prop: string) => any;
+    refreshSelectParams: () => void;
+    getCurrentTableFilterProp: () => string | undefined;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    listQuery: {
+        type: PropType<ListQuery>;
+        default(): {};
+    };
+}>> & {
+    onSearch?: ((...args: any[]) => any) | undefined;
+}, {
+    listQuery: ListQuery;
+}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableFilter.vue.js

@@ -0,0 +1,40 @@
+import { defineComponent as v, inject as o, ref as c, createElementBlock as _, openBlock as b, createVNode as h, unref as s, mergeProps as P } from "vue";
+import { TableFilter as g } from "../../TableFilter/index.js";
+const x = { class: "s-table-filter" }, L = /* @__PURE__ */ v({
+  __name: "STableFilter",
+  props: {
+    listQuery: {
+      type: Object,
+      default() {
+        return {};
+      }
+    }
+  },
+  emits: ["search"],
+  setup(i, { expose: u, emit: p }) {
+    const m = p, f = o("option"), l = o("selectParams") || c([]), n = i, d = () => {
+      m("search", n.listQuery);
+    }, e = c();
+    return u({ filterRef: e, setItem: (t, r) => {
+      e.value.setItem(t, r);
+    }, getSelectList: () => e.value.selectList, loadOptions: (t, r) => e.value.loadOptions(t, r), clear: (t) => e.value.clear(t), refreshSelectParams: () => {
+      e.value.refreshSelectParams();
+    }, getCurrentTableFilterProp: () => {
+      if (e.value.getCurrentIndex() !== void 0)
+        return l.value[e.value.getCurrentIndex()].prop;
+    } }), (t, r) => {
+      var a;
+      return b(), _("div", x, [
+        h(s(g), P({
+          ref_key: "tableFilterRef",
+          ref: e,
+          "select-params": s(l),
+          "list-query": n.listQuery
+        }, (a = s(f)) == null ? void 0 : a.filterAttrs, { onSearch: d }), null, 16, ["select-params", "list-query"])
+      ]);
+    };
+  }
+});
+export {
+  L as default
+};

package/dist/components/CurdTable/src/STableFilter.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableFilter.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableItem.vue.d.ts

@@ -0,0 +1,127 @@
+import { PropType } from 'vue';
+import { Fields } from '../../CurdForm';
+import { ColumnItem } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<Record<string, (scope: Record<string, unknown>) => unknown>> & Record<string, (scope: Record<string, unknown>) => unknown>;
+    refs: {
+        tableItemFilterRef: import('vue').CreateComponentPublicInstance<Readonly<import('vue').ExtractPropTypes<{
+            filter: {
+                type: PropType<import('../../../index.ts').ColumnItemFilter>;
+                default(): {};
+            };
+            modelValue: {
+                type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+        }>> & {
+            onChange?: ((...args: any[]) => any) | undefined;
+        }, {
+            search: (event: {
+                listQuery: Fields;
+            }) => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            change: (...args: any[]) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
+            filter: {
+                type: PropType<import('../../../index.ts').ColumnItemFilter>;
+                default(): {};
+            };
+            modelValue: {
+                type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+        }>> & {
+            onChange?: ((...args: any[]) => any) | undefined;
+        }, {
+            filter: import('../../../index.ts').ColumnItemFilter;
+            modelValue: string | number | boolean;
+        }, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            filter: {
+                type: PropType<import('../../../index.ts').ColumnItemFilter>;
+                default(): {};
+            };
+            modelValue: {
+                type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+                default: string;
+            };
+        }>> & {
+            onChange?: ((...args: any[]) => any) | undefined;
+        }, {
+            search: (event: {
+                listQuery: Fields;
+            }) => void;
+        }, {}, {}, {}, {
+            filter: import('../../../index.ts').ColumnItemFilter;
+            modelValue: string | number | boolean;
+        }> | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    schema: {
+        type: PropType<ColumnItem<Record<string, unknown>>>;
+        default(): {
+            options: never[];
+        };
+    };
+    isSlot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isSlotHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    option: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}, {
+    search: (opt: {
+        listQuery: Record<string, unknown>;
+    }) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    schema: {
+        type: PropType<ColumnItem<Record<string, unknown>>>;
+        default(): {
+            options: never[];
+        };
+    };
+    isSlot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isSlotHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    option: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & {
+    onSearch?: ((...args: any[]) => any) | undefined;
+}, {
+    option: Record<string, any>;
+    schema: ColumnItem<Record<string, unknown>>;
+    isSlot: boolean;
+    isSlotHeader: boolean;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/CurdTable/src/STableItem.vue.js

@@ -0,0 +1,147 @@
+import { defineComponent as W, inject as T, computed as y, ref as I, resolveComponent as _, createBlock as s, createCommentVNode as m, openBlock as o, mergeProps as k, withCtx as h, renderSlot as v, createElementBlock as a, normalizeProps as C, guardReactiveProps as L, Fragment as p, renderList as M, createSlots as X, unref as S, createVNode as V, withModifiers as Y, createTextVNode as B, toDisplayString as j, createElementVNode as Z, normalizeClass as ee, resolveDynamicComponent as te } from "vue";
+import { CopyDocument as oe } from "@element-plus/icons-vue";
+import { ConstantStatus as ne } from "../../ConstantStatus/index.js";
+import { useLocale as re } from "../../../utils/hooks/useLocal.js";
+import { ElMessage as se } from "element-plus";
+import { copy as ae } from "../utils/common.js";
+import le from "./STableItemFilter.vue.js";
+import F from "./STableItemFormatter.vue.js";
+import ce from "./STableItemHeader.vue.js";
+const me = { key: 1 }, ie = ["innerHTML"], he = { key: 2 }, pe = ["innerHTML"], be = /* @__PURE__ */ W({
+  __name: "STableItem",
+  props: {
+    schema: {
+      type: Object,
+      default() {
+        return { options: [] };
+      }
+    },
+    isSlot: {
+      type: Boolean,
+      default: !1
+    },
+    isSlotHeader: {
+      type: Boolean,
+      default: !1
+    },
+    option: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["search"],
+  setup(b, { expose: N, emit: R }) {
+    const { t: g } = re(), e = b, u = T("selectParams"), d = y(() => {
+      let t = u == null ? void 0 : u.value.filter((r) => {
+        var i;
+        return r.prop == ((i = e.schema.filter) == null ? void 0 : i.prop) || r.prop == e.schema.prop;
+      });
+      return t && t.length > 1 && (t = t == null ? void 0 : t.filter((r) => r.label == e.schema.label)), t && t[0] || {};
+    }), z = y(() => {
+      const { children: t, ...r } = e.schema;
+      return r || t;
+    }), c = (t) => typeof t[e.schema.prop] > "u" || t[e.schema.prop] === "" ? "--" : t[e.schema.prop], D = async (t) => {
+      ae(String(t)), se.success(g("el.table.clickCopySuccess"));
+    }, w = R, E = T("search", {}), P = y(() => e.schema.hidden && e.schema.hidden instanceof Function ? e.schema.hidden(e.schema, E) : e.schema.hidden), O = (t, r) => {
+      w("search", t, r, d.value);
+    }, f = I(), A = (t) => {
+      f.value && f.value.search(t);
+    }, q = I({}), G = (t) => t && typeof t == "object" ? t : {}, J = (t, r) => {
+      w("search", t, r, d.value);
+    };
+    return N({ search: A }), (t, r) => {
+      const i = _("STableItem", !0), K = _("el-icon"), Q = _("el-table-column");
+      return P.value ? m("", !0) : (o(), s(Q, k({
+        key: 0,
+        fixed: e.schema.fixed
+      }, z.value), {
+        header: h((n) => [
+          Z("div", {
+            class: ee(["header-td", [e.schema.align]])
+          }, [
+            v(t.$slots, e.schema.prop + "Header", C(L(n))),
+            e.schema.headerComponent ? (o(), s(te(e.schema.headerComponent), C(k({ key: 0 }, n)), null, 16)) : e.isSlotHeader ? m("", !0) : (o(), s(ce, {
+              key: 1,
+              "schema-item": e.schema
+            }, null, 8, ["schema-item"])),
+            e.schema.filter && e.schema.filter.inner ? (o(), s(le, {
+              key: 2,
+              ref_key: "tableItemFilterRef",
+              ref: f,
+              filter: d.value,
+              onChange: O
+            }, null, 8, ["filter"])) : m("", !0)
+          ], 2)
+        ]),
+        default: h((n) => {
+          var H;
+          return [
+            v(t.$slots, e.schema.prop, C(L(n))),
+            (H = e.schema.children) != null && H.length ? (o(!0), a(p, { key: 0 }, M(e.schema.children, (l) => (o(), s(i, {
+              key: l.label,
+              ref_for: !0,
+              ref: ($) => q.value[l.prop] = $,
+              schema: l,
+              "is-slot": !!t.$slots[l.prop],
+              "is-slot-header": !!t.$slots[l.prop + "Header"],
+              option: b.option,
+              onSearch: J
+            }, X({ _: 2 }, [
+              M(t.$slots, ($, x) => ({
+                name: x,
+                fn: h((U) => [
+                  v(t.$slots, x, k({ ref_for: !0 }, G(U)))
+                ])
+              }))
+            ]), 1032, ["schema", "is-slot", "is-slot-header", "option"]))), 128)) : m("", !0),
+            e.isSlot ? m("", !0) : (o(), a(p, { key: 1 }, [
+              e.schema.options ? (o(), s(S(ne), {
+                key: 0,
+                value: n.row[e.schema.prop],
+                options: e.schema.options
+              }, null, 8, ["value", "options"])) : e.schema.copy ? (o(), a("span", me, [
+                V(K, {
+                  class: "copy",
+                  title: S(g)("el.table.clickCopy"),
+                  onClick: Y((l) => D(c(n.row)), ["stop"])
+                }, {
+                  default: h(() => [
+                    V(S(oe))
+                  ]),
+                  _: 2
+                }, 1032, ["title", "onClick"]),
+                e.schema.vHtml ? (o(), a("span", {
+                  key: 0,
+                  innerHTML: c(n.row)
+                }, null, 8, ie)) : e.schema.formatter ? (o(), s(F, {
+                  key: 1,
+                  row: n.row,
+                  index: n.index,
+                  schema: e.schema
+                }, null, 8, ["row", "index", "schema"])) : (o(), a(p, { key: 2 }, [
+                  B(j(c(n.row)), 1)
+                ], 64))
+              ])) : (o(), a("span", he, [
+                e.schema.vHtml ? (o(), a("span", {
+                  key: 0,
+                  innerHTML: c(n.row)
+                }, null, 8, pe)) : e.schema.formatter ? (o(), s(F, {
+                  key: 1,
+                  row: n.row,
+                  index: n.index,
+                  schema: e.schema
+                }, null, 8, ["row", "index", "schema"])) : (o(), a(p, { key: 2 }, [
+                  B(j(c(n.row)), 1)
+                ], 64))
+              ]))
+            ], 64))
+          ];
+        }),
+        _: 3
+      }, 16, ["fixed"]));
+    };
+  }
+});
+export {
+  be as default
+};

package/dist/components/CurdTable/src/STableItem.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableItem.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableItemFilter.vue.d.ts

@@ -0,0 +1,34 @@
+import { PropType } from 'vue';
+import { Fields } from '../../CurdForm';
+import { ColumnItemFilter } from './types';
+declare const _default: import('vue').DefineComponent<{
+    filter: {
+        type: PropType<ColumnItemFilter>;
+        default(): {};
+    };
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+}, {
+    search: (event: {
+        listQuery: Fields;
+    }) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    filter: {
+        type: PropType<ColumnItemFilter>;
+        default(): {};
+    };
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+}, {
+    filter: ColumnItemFilter;
+    modelValue: string | number | boolean;
+}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableItemFilter.vue.js

@@ -0,0 +1,71 @@
+import { defineComponent as C, ref as l, computed as b, resolveComponent as h, createBlock as k, openBlock as V, unref as r, withCtx as i, createVNode as s, createElementVNode as x, withModifiers as R, normalizeClass as w } from "vue";
+import { Filter as B } from "@element-plus/icons-vue";
+import { ElPopover as F } from "element-plus";
+import N from "../../TableFilter/src/components/FilterType.vue.js";
+const z = /* @__PURE__ */ C({
+  __name: "STableItemFilter",
+  props: {
+    filter: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    modelValue: {
+      type: [String, Number, Boolean],
+      default: ""
+    }
+  },
+  emits: ["change"],
+  setup(u, { expose: f, emit: m }) {
+    const o = u, v = m;
+    let t = l("");
+    const n = l(!1), d = b(() => {
+      const e = {};
+      return e[o.filter.prop || ""] = o.modelValue || t.value, e;
+    }), a = l(), p = l(), _ = () => {
+      n.value = !0, a.value.open(p.value, o.filter);
+    }, g = (e) => {
+      t.value = e.value, v("change", e.prop, e.value);
+    };
+    return f({ search: (e) => {
+      t.value = e.listQuery[o.filter.prop || ""];
+    } }), (e, c) => {
+      const y = h("el-icon");
+      return V(), k(r(F), {
+        visible: n.value,
+        trigger: "click",
+        "popper-class": "filter-type-popper"
+      }, {
+        reference: i(() => [
+          x("span", {
+            ref_key: "toggleRef",
+            ref: p,
+            class: w(["filter-dropdown-toggle", { active: typeof r(t) < "u" && r(t) !== "" }]),
+            onClick: R(_, ["stop"])
+          }, [
+            s(y, null, {
+              default: i(() => [
+                s(r(B))
+              ]),
+              _: 1
+            })
+          ], 2)
+        ]),
+        default: i(() => [
+          s(N, {
+            ref_key: "typeRef",
+            ref: a,
+            "list-query": d.value,
+            onChange: g,
+            onClose: c[0] || (c[0] = (E) => n.value = !1)
+          }, null, 8, ["list-query"])
+        ]),
+        _: 1
+      }, 8, ["visible"]);
+    };
+  }
+});
+export {
+  z as default
+};

package/dist/components/CurdTable/src/STableItemFilter.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableItemFilter.vue.js";
+export {
+  f as default
+};