easybill-ui 1.4.1 → 1.4.3

package/dist/components/CurdForm/src/CurdFormItem.vue2.js

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

package/dist/components/CurdForm/src/FormItem.vue.d.ts

@@ -0,0 +1,44 @@
+import { PropType } from 'vue';
+import { Fields, FormItem } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    formItem: {
+        required: true;
+        type: PropType<FormItem>;
+    };
+    formModel: {
+        type: PropType<Fields>;
+        default: () => {};
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    formItem: {
+        required: true;
+        type: PropType<FormItem>;
+    };
+    formModel: {
+        type: PropType<Fields>;
+        default: () => {};
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+}, {
+    formModel: Fields;
+}, {}>;
+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/CurdForm/src/FormItem.vue.js

@@ -0,0 +1,128 @@
+import { defineComponent as A, ref as g, computed as v, createElementBlock as d, openBlock as t, createCommentVNode as V, renderSlot as M, createBlock as i, Fragment as k, renderList as c, resolveDynamicComponent as a, createSlots as O, withCtx as L, mergeProps as b, toHandlers as T } from "vue";
+import { getComponent as h } from "./components/index.js";
+import B from "./FormTooltip.vue.js";
+import { useForm as S } from "./hooks/index.js";
+const $ = { class: "form-item" }, P = ["innerHTML"], _ = ["innerHTML"], N = /* @__PURE__ */ A({
+  __name: "FormItem",
+  props: {
+    // 动态验证表单
+    formItem: {
+      required: !0,
+      type: Object
+    },
+    formModel: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["change"],
+  setup(C, { emit: U }) {
+    const e = C, x = U, { formContext: p } = S(), m = g(e.formModel || {}), u = v(() => e.formItem.props ? e.formItem.props instanceof Function ? e.formItem.props(e.formModel, e.formItem) : e.formItem.props : {}), j = v(() => p.components && p.components[e.formItem.type || "input"] || h(e.formItem.type)), s = g(
+      (() => {
+        const l = { ...e.formItem.eventObject };
+        if (!e.formItem.eventObject || Object.keys(e.formItem.eventObject).length <= 0)
+          return {
+            change: () => {
+              x("change", e.formModel, e.formItem, p);
+            }
+          };
+        const r = e.formItem.eventObject.change;
+        l.change = (...o) => {
+          r ? r && r.apply(null, [e.formModel, e.formItem, p, ...o]) && x("change", e.formModel, e.formItem, p, ...o) : x("change", e.formModel, e.formItem, p, ...o);
+        };
+        for (let o in l)
+          if (o !== "change") {
+            const f = l[o];
+            l[o] = (...n) => {
+              f && f(e.formModel, e.formItem, p, ...n);
+            };
+          }
+        return l;
+      })()
+    ), I = (l) => typeof l == "string", F = v(() => !e.formItem.prefix || I(e.formItem.prefix) ? [] : Array.isArray(e.formItem.prefix) ? e.formItem.prefix : [e.formItem.prefix]), H = v(() => !e.formItem.suffix || I(e.formItem.suffix) ? [] : Array.isArray(e.formItem.suffix) ? e.formItem.suffix : [e.formItem.suffix]);
+    return (l, r) => (t(), d("div", $, [
+      e.formItem.prefix && I(e.formItem.prefix) ? (t(), d("div", {
+        key: 0,
+        class: "form-item-prefix",
+        innerHTML: e.formItem.prefix
+      }, null, 8, P)) : V("", !0),
+      (t(!0), d(k, null, c(F.value, (o, f) => (t(), i(a(o), {
+        key: f,
+        modelValue: m.value[e.formItem.prop || ""],
+        "onUpdate:modelValue": r[0] || (r[0] = (n) => m.value[e.formItem.prop || ""] = n),
+        "form-item": e.formItem,
+        "form-model": m.value,
+        props: u.value,
+        "event-object": s.value
+      }, null, 8, ["modelValue", "form-item", "form-model", "props", "event-object"]))), 128)),
+      M(l.$slots, "prefix"),
+      j.value ? (t(), i(a(j.value), {
+        key: 1,
+        modelValue: m.value[e.formItem.prop || ""],
+        "onUpdate:modelValue": r[2] || (r[2] = (o) => m.value[e.formItem.prop || ""] = o),
+        "form-item": e.formItem,
+        "form-model": m.value,
+        props: u.value,
+        "event-object": s.value
+      }, O({ _: 2 }, [
+        c(u.value.slots, (o, f) => ({
+          name: f,
+          fn: L((n) => [
+            (t(), i(a(o), b({
+              modelValue: m.value[e.formItem.prop || ""],
+              "onUpdate:modelValue": r[1] || (r[1] = (y) => m.value[e.formItem.prop || ""] = y)
+            }, n, {
+              "form-item": e.formItem,
+              "form-model": m.value,
+              props: u.value,
+              "event-object": s.value
+            }), null, 16, ["modelValue", "form-item", "form-model", "props", "event-object"]))
+          ])
+        }))
+      ]), 1032, ["modelValue", "form-item", "form-model", "props", "event-object"])) : (t(), i(a(e.formItem.type), b({
+        key: 2,
+        modelValue: m.value[e.formItem.prop || ""],
+        "onUpdate:modelValue": r[4] || (r[4] = (o) => m.value[e.formItem.prop || ""] = o)
+      }, u.value, T(s.value)), O({ _: 2 }, [
+        c(u.value.slots, (o, f) => ({
+          name: f,
+          fn: L((n) => [
+            (t(), i(a(o), b({
+              modelValue: m.value[e.formItem.prop || ""],
+              "onUpdate:modelValue": r[3] || (r[3] = (y) => m.value[e.formItem.prop || ""] = y)
+            }, n, {
+              "form-item": e.formItem,
+              "form-model": m.value,
+              props: u.value,
+              "event-object": s.value
+            }), null, 16, ["modelValue", "form-item", "form-model", "props", "event-object"]))
+          ])
+        }))
+      ]), 1040, ["modelValue"])),
+      e.formItem.tooltip ? (t(), i(B, {
+        key: 3,
+        tooltip: e.formItem.tooltip,
+        "form-item": e.formItem,
+        "form-model": e.formModel
+      }, null, 8, ["tooltip", "form-item", "form-model"])) : V("", !0),
+      M(l.$slots, "suffix"),
+      e.formItem.suffix && I(e.formItem.suffix) ? (t(), d("div", {
+        key: 4,
+        class: "form-item-suffix",
+        innerHTML: e.formItem.suffix
+      }, null, 8, _)) : V("", !0),
+      (t(!0), d(k, null, c(H.value, (o, f) => (t(), i(a(o), {
+        key: f,
+        modelValue: m.value[e.formItem.prop || ""],
+        "onUpdate:modelValue": r[5] || (r[5] = (n) => m.value[e.formItem.prop || ""] = n),
+        "form-item": e.formItem,
+        "form-model": m.value,
+        props: u.value,
+        "event-object": s.value
+      }, null, 8, ["modelValue", "form-item", "form-model", "props", "event-object"]))), 128))
+    ]));
+  }
+});
+export {
+  N as default
+};

package/dist/components/CurdForm/src/FormItem.vue2.js

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

package/dist/components/CurdForm/src/FormTooltip.vue.d.ts

@@ -0,0 +1,33 @@
+import { PropType } from 'vue';
+import { Fields, FormItem, TooltipProps } from './types';
+declare const _default: import('vue').DefineComponent<{
+    tooltip: {
+        type: PropType<string | ((formModel: Fields, formItem: FormItem) => Partial<TooltipProps> | string) | Partial<TooltipProps>>;
+        default: null;
+    };
+    formItem: {
+        required: true;
+        type: PropType<FormItem>;
+    };
+    formModel: {
+        type: PropType<Fields>;
+        default: () => {};
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    tooltip: {
+        type: PropType<string | ((formModel: Fields, formItem: FormItem) => Partial<TooltipProps> | string) | Partial<TooltipProps>>;
+        default: null;
+    };
+    formItem: {
+        required: true;
+        type: PropType<FormItem>;
+    };
+    formModel: {
+        type: PropType<Fields>;
+        default: () => {};
+    };
+}>>, {
+    tooltip: string | Partial<TooltipProps> | ((formModel: Fields, formItem: FormItem) => Partial<TooltipProps> | string);
+    formModel: Fields;
+}, {}>;
+export default _default;

package/dist/components/CurdForm/src/FormTooltip.vue.js

@@ -0,0 +1,63 @@
+import { defineComponent as s, computed as _, resolveComponent as l, createBlock as a, openBlock as d, mergeProps as y, withCtx as o, createVNode as c, unref as b, createElementVNode as g } from "vue";
+import { Warning as v } from "@element-plus/icons-vue";
+const M = ["innerHTML"], j = /* @__PURE__ */ s({
+  __name: "FormTooltip",
+  props: {
+    tooltip: {
+      type: [String, Function, Object],
+      default: null
+    },
+    formItem: {
+      required: !0,
+      type: Object
+    },
+    formModel: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(p) {
+    const n = p, r = _(() => {
+      let t = n.tooltip;
+      return t ? (typeof t == "function" && (t = t(n.formModel, n.formItem)), i(t)) : { content: "" };
+    }), i = (t) => {
+      if (!t)
+        return { content: "" };
+      let e = {};
+      return typeof t == "string" ? e = { content: t } : e = t, e;
+    };
+    return (t, e) => {
+      const u = l("el-icon"), f = l("el-button"), m = l("el-tooltip");
+      return d(), a(m, y({
+        content: r.value.content
+      }, r.value || {}), {
+        content: o(() => [
+          g("div", {
+            innerHTML: r.value.content
+          }, null, 8, M)
+        ]),
+        default: o(() => [
+          c(f, {
+            class: "tooltip",
+            type: "primary",
+            link: ""
+          }, {
+            default: o(() => [
+              c(u, null, {
+                default: o(() => [
+                  c(b(v))
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16, ["content"]);
+    };
+  }
+});
+export {
+  j as default
+};

package/dist/components/CurdForm/src/FormTooltip.vue2.js

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

package/dist/components/CurdForm/src/components/index.d.ts

@@ -0,0 +1,10 @@
+import { Component, VNode } from 'vue';
+interface PresetMap {
+    [key: string]: Component;
+}
+declare const presetMap: PresetMap;
+export default presetMap;
+export declare const preset: string[];
+export declare const getComponent: (type?: string | VNode) => string | Component | VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null;

package/dist/components/CurdForm/src/components/index.js

@@ -0,0 +1,38 @@
+import { isReactive as r, isRef as o, isVNode as c } from "vue";
+import i from "./schema-form-autocomplete.vue.js";
+import s from "./schema-form-cascader.vue.js";
+import a from "./schema-form-checkbox.vue.js";
+import t from "./schema-form-choose.vue.js";
+import h from "./schema-form-color-picker.vue.js";
+import f from "./schema-form-date-picker.vue.js";
+import n from "./schema-form-input-number.vue.js";
+import p from "./schema-form-input.vue.js";
+import l from "./schema-form-radio.vue.js";
+import u from "./schema-form-select-v2.vue.js";
+import _ from "./schema-form-select.vue.js";
+import S from "./schema-form-switch.vue.js";
+import k from "./schema-form-time-picker.vue.js";
+import F from "./schema-form-tree-select.vue.js";
+import d from "./schema-form-value.vue.js";
+const e = {
+  "schema-input": p,
+  "schema-select": _,
+  "schema-select-v2": u,
+  "schema-radio": l,
+  "schema-checkbox": a,
+  "schema-input-number": n,
+  "schema-switch": S,
+  "schema-date-picker": f,
+  "schema-time-picker": k,
+  "schema-color-picker": h,
+  "schema-value": d,
+  "schema-cascader": s,
+  "schema-autocomplete": i,
+  "schema-tree-select": F,
+  "schema-choose": t
+}, $ = Object.keys(e), z = (m = "input") => typeof m == "string" && $.includes("schema-" + m) ? e["schema-" + m] : r(m) || o(m) || c(m) || typeof m == "object" && "setup" in m ? m : null;
+export {
+  e as default,
+  z as getComponent,
+  $ as preset
+};

package/dist/components/CurdForm/src/components/schema-form-autocomplete.vue.d.ts

@@ -0,0 +1,56 @@
+import { CascaderValue } from 'element-plus';
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: PropType<CascaderValue>;
+        default: undefined;
+    };
+    formItem: {
+        type: PropType<import('../types').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<import('../types').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<import('../types').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<import('../types').EventObject>;
+        default: () => {};
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<CascaderValue>;
+        default: undefined;
+    };
+    formItem: {
+        type: PropType<import('../types').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<import('../types').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<import('../types').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<import('../types').EventObject>;
+        default: () => {};
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    props: import('../types').FormItemPropObject;
+    modelValue: CascaderValue;
+    formItem: import('../types').FormItem;
+    formModel: import('../types').Fields;
+    eventObject: import('../types').EventObject;
+}, {}>;
+export default _default;

package/dist/components/CurdForm/src/components/schema-form-autocomplete.vue.js

@@ -0,0 +1,39 @@
+import { defineComponent as d, computed as c, resolveComponent as i, createBlock as _, openBlock as t, mergeProps as f, toHandlers as v, withCtx as V, createElementBlock as a, toDisplayString as h } from "vue";
+import { FormItemProps as k } from "../types.js";
+import "element-plus";
+const g = ["innerHTML"], y = { key: 1 }, C = /* @__PURE__ */ d({
+  __name: "schema-form-autocomplete",
+  props: {
+    ...k,
+    modelValue: {
+      type: [String, Number],
+      default: void 0
+    }
+    // 表单项值
+  },
+  emits: ["update:modelValue"],
+  setup(r, { emit: p }) {
+    const o = r, s = p, l = c({
+      get: () => o.modelValue,
+      set: (m) => s("update:modelValue", m)
+    });
+    return (m, n) => {
+      const u = i("el-autocomplete");
+      return t(), _(u, f({
+        modelValue: l.value,
+        "onUpdate:modelValue": n[0] || (n[0] = (e) => l.value = e)
+      }, o.props, v(o.eventObject)), {
+        default: V(({ item: e }) => [
+          e.html ? (t(), a("div", {
+            key: 0,
+            innerHTML: e.html
+          }, null, 8, g)) : (t(), a("div", y, h(e.label || e.value), 1))
+        ]),
+        _: 1
+      }, 16, ["modelValue"]);
+    };
+  }
+});
+export {
+  C as default
+};

package/dist/components/CurdForm/src/components/schema-form-autocomplete.vue2.js

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

package/dist/components/CurdForm/src/components/schema-form-cascader.vue.d.ts

@@ -0,0 +1,56 @@
+import { CascaderValue } from 'element-plus';
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: PropType<CascaderValue>;
+        default: undefined;
+    };
+    formItem: {
+        type: PropType<import('../types').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<import('../types').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<import('../types').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<import('../types').EventObject>;
+        default: () => {};
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<CascaderValue>;
+        default: undefined;
+    };
+    formItem: {
+        type: PropType<import('../types').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<import('../types').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<import('../types').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<import('../types').EventObject>;
+        default: () => {};
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    props: import('../types').FormItemPropObject;
+    modelValue: CascaderValue;
+    formItem: import('../types').FormItem;
+    formModel: import('../types').Fields;
+    eventObject: import('../types').EventObject;
+}, {}>;
+export default _default;

package/dist/components/CurdForm/src/components/schema-form-cascader.vue.js

@@ -0,0 +1,32 @@
+import { defineComponent as c, computed as s, resolveComponent as d, createBlock as i, openBlock as f, mergeProps as V, toHandlers as _ } from "vue";
+import "element-plus";
+import { FormItemProps as v } from "../types.js";
+const x = /* @__PURE__ */ c({
+  __name: "schema-form-cascader",
+  props: {
+    ...v,
+    modelValue: {
+      type: [String, Number],
+      default: void 0
+    }
+    // 表单项值
+  },
+  emits: ["update:modelValue"],
+  setup(n, { emit: r }) {
+    const e = n, l = r, t = s({
+      get: () => e.modelValue,
+      set: (o) => l("update:modelValue", o)
+    }), p = s(() => e.formItem.options);
+    return (o, m) => {
+      const a = d("el-cascader");
+      return f(), i(a, V({
+        modelValue: t.value,
+        "onUpdate:modelValue": m[0] || (m[0] = (u) => t.value = u),
+        options: p.value
+      }, e.props, _(e.eventObject)), null, 16, ["modelValue", "options"]);
+    };
+  }
+});
+export {
+  x as default
+};

package/dist/components/CurdForm/src/components/schema-form-cascader.vue2.js

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

package/dist/components/CurdForm/src/components/schema-form-checkbox.vue.d.ts

@@ -0,0 +1,59 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: PropType<(string | number)[]>;
+        default: () => never[];
+    };
+    formItem: {
+        type: PropType<import('../../../../index.ts').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<import('../../../../index.ts').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<import('../../../../index.ts').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<import('../../../../index.ts').EventObject>;
+        default: () => {};
+    };
+}, {
+    model: import('vue').WritableComputedRef<(string | number)[]>;
+    empty: string | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    t: import('../../../../index.ts').Translator;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<(string | number)[]>;
+        default: () => never[];
+    };
+    formItem: {
+        type: PropType<import('../../../../index.ts').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<import('../../../../index.ts').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<import('../../../../index.ts').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<import('../../../../index.ts').EventObject>;
+        default: () => {};
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    props: import('../../../../index.ts').FormItemPropObject;
+    modelValue: (string | number)[];
+    formItem: import('../../../../index.ts').FormItem;
+    formModel: import('../../../../index.ts').Fields;
+    eventObject: import('../../../../index.ts').EventObject;
+}, {}>;
+export default _default;