ep-craft 0.1.34 → 0.1.36

package/dist/components/tree-select/src/tree.js

@@ -0,0 +1,179 @@
+import { watch as D, nextTick as K, computed as C, toRefs as H } from "vue";
+import { isEqual as L, pick as P, isNil as R } from "lodash-unified";
+import { UPDATE_MODEL_EVENT as _, CHANGE_EVENT as z } from "../../../constants/event.js";
+import { isEmpty as F } from "../../../utils/types.js";
+import "@vueuse/core";
+import { isFunction as I } from "@vue/shared";
+import { escapeStringRegexp as j } from "../../../utils/strings.js";
+import "@element-plus/icons-vue";
+import { EpTree as q } from "../../tree/index.js";
+import B from "./tree-select-option.js";
+import { toValidArray as r, treeFind as N, isValidValue as M, treeEach as x, isValidArray as G } from "./utils.js";
+const ce = (e, { attrs: u, slots: b, emit: E }, {
+  select: v,
+  tree: o,
+  key: V
+}) => {
+  D(
+    [() => e.modelValue, o],
+    () => {
+      e.showCheckbox && K(() => {
+        const l = o.value;
+        l && !L(
+          l.getCheckedKeys(),
+          r(e.modelValue)
+        ) && l.setCheckedKeys(r(e.modelValue));
+      });
+    },
+    {
+      immediate: !0,
+      deep: !0
+    }
+  );
+  const w = C(() => ({
+    value: V.value,
+    label: "label",
+    children: "children",
+    disabled: "disabled",
+    isLeaf: "isLeaf",
+    ...e.props
+  })), n = (l, c) => {
+    var t;
+    const d = w.value[l];
+    return I(d) ? d(
+      c,
+      (t = o.value) == null ? void 0 : t.getNode(n("value", c))
+    ) : c[d];
+  }, g = r(e.modelValue).map((l) => N(
+    e.data || [],
+    (c) => n("value", c) === l,
+    (c) => n("children", c),
+    (c, d, t, a) => a && n("value", a)
+  )).filter((l) => M(l)), S = C(() => {
+    if (!e.renderAfterExpand && !e.lazy) return [];
+    const l = [];
+    return x(
+      e.data.concat(e.cacheData),
+      (c) => {
+        const d = n("value", c);
+        l.push({
+          value: d,
+          currentLabel: n("label", c),
+          isDisabled: n("disabled", c)
+        });
+      },
+      (c) => n("children", c)
+    ), l;
+  }), O = () => {
+    var l;
+    return (l = o.value) == null ? void 0 : l.getCheckedKeys().filter((c) => {
+      var t;
+      const d = (t = o.value) == null ? void 0 : t.getNode(c);
+      return !R(d) && F(d.childNodes);
+    });
+  }, T = (l) => {
+    L(e.modelValue, l) || E(z, l);
+  };
+  function m(l) {
+    E(_, l), T(l);
+  }
+  return {
+    ...P(H(e), Object.keys(q.props)),
+    ...u,
+    nodeKey: V,
+    // only expand on click node when the `check-strictly` is false
+    expandOnClickNode: C(() => !e.checkStrictly && e.expandOnClickNode),
+    // show current selected node only first time,
+    // fix the problem of expanding multiple nodes when checking multiple nodes
+    defaultExpandedKeys: C(() => e.defaultExpandedKeys ? e.defaultExpandedKeys.concat(g) : g),
+    renderContent: (l, { node: c, data: d, store: t }) => l(
+      B,
+      {
+        value: n("value", d),
+        label: n("label", d),
+        disabled: n("disabled", d),
+        visible: c.visible
+      },
+      e.renderContent ? () => e.renderContent(l, { node: c, data: d, store: t }) : b.default ? () => b.default({ node: c, data: d, store: t }) : void 0
+    ),
+    filterNodeMethod: (l, c, d) => e.filterNodeMethod ? e.filterNodeMethod(l, c, d) : l ? new RegExp(j(l), "i").test(n("label", c) || "") : !0,
+    onNodeClick: (l, c, d) => {
+      var t, a, s;
+      if ((t = u.onNodeClick) == null || t.call(u, l, c, d), !(e.showCheckbox && e.checkOnClickNode))
+        if (!e.showCheckbox && (e.checkStrictly || c.isLeaf)) {
+          if (!n("disabled", l)) {
+            const f = (a = v.value) == null ? void 0 : a.states.options.get(
+              n("value", l)
+            );
+            (s = v.value) == null || s.handleOptionSelect(f);
+          }
+        } else e.expandOnClickNode && d.proxy.handleExpandIconClick();
+    },
+    onCheck: (l, c) => {
+      var y;
+      if (!e.showCheckbox) return;
+      const d = n("value", l), t = {};
+      x(
+        [o.value.store.root],
+        (i) => t[i.key] = i,
+        (i) => i.childNodes
+      );
+      const a = c.checkedKeys, s = e.multiple ? r(e.modelValue).filter(
+        (i) => !(i in t) && !a.includes(i)
+      ) : [], f = s.concat(a);
+      if (e.checkStrictly)
+        m(
+          e.multiple ? f : f.includes(d) ? d : void 0
+        );
+      else if (e.multiple) {
+        const i = O();
+        m(s.concat(i));
+      } else {
+        const i = N(
+          [l],
+          (h) => !G(n("children", h)) && !n("disabled", h),
+          (h) => n("children", h)
+        ), k = i ? n("value", i) : void 0, A = M(e.modelValue) && !!N(
+          [l],
+          (h) => n("value", h) === e.modelValue,
+          (h) => n("children", h)
+        );
+        m(
+          k === e.modelValue || A ? void 0 : k
+        );
+      }
+      K(() => {
+        var k;
+        const i = r(e.modelValue);
+        o.value.setCheckedKeys(i), (k = u.onCheck) == null || k.call(u, l, {
+          checkedKeys: o.value.getCheckedKeys(),
+          checkedNodes: o.value.getCheckedNodes(),
+          halfCheckedKeys: o.value.getHalfCheckedKeys(),
+          halfCheckedNodes: o.value.getHalfCheckedNodes()
+        });
+      }), (y = v.value) == null || y.focus();
+    },
+    onNodeExpand: (l, c, d) => {
+      var t;
+      (t = u.onNodeExpand) == null || t.call(u, l, c, d), K(() => {
+        if (!e.checkStrictly && e.lazy && e.multiple && c.checked) {
+          const a = {}, s = o.value.getCheckedKeys();
+          x(
+            [o.value.store.root],
+            (i) => a[i.key] = i,
+            (i) => i.childNodes
+          );
+          const f = r(e.modelValue).filter(
+            (i) => !(i in a) && !s.includes(i)
+          ), y = O();
+          m(f.concat(y));
+        }
+      });
+    },
+    // else
+    cacheOptions: S
+  };
+};
+export {
+  ce as useTree
+};

package/dist/components/tree-select/src/utils.d.ts

@@ -0,0 +1,10 @@
+import type { TreeNodeData } from '@element-plus/components/tree/src/tree.type';
+export declare function isValidValue(val: any): any;
+export declare function isValidArray(val: any): number | false;
+export declare function toValidArray(val: any): any[];
+type TreeCallback<T extends TreeNodeData, R> = (data: T, index: number, array: T[], parent?: T) => R;
+type TreeFindCallback<T extends TreeNodeData> = TreeCallback<T, boolean>;
+export declare function treeFind<T extends TreeNodeData>(treeData: T[], findCallback: TreeFindCallback<T>, getChildren: (data: T) => T[]): T | undefined;
+export declare function treeFind<T extends TreeNodeData, R>(treeData: T[], findCallback: TreeFindCallback<T>, getChildren: (data: T) => T[], resultCallback?: TreeCallback<T, R>, parent?: T): R | undefined;
+export declare function treeEach<T extends TreeNodeData>(treeData: T[], callback: TreeCallback<T, void>, getChildren: (data: T) => T[], parent?: T): void;
+export {};

package/dist/components/tree-select/src/utils.js

@@ -0,0 +1,49 @@
+import { isArray as d } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "vue";
+function p(i) {
+  return i || i === 0;
+}
+function m(i) {
+  return d(i) && i.length;
+}
+function E(i) {
+  return d(i) ? i : p(i) ? [i] : [];
+}
+function h(i, t, f, u, r) {
+  for (let n = 0; n < i.length; n++) {
+    const o = i[n];
+    if (t(o, n, i, r))
+      return u ? u(o, n, i, r) : o;
+    {
+      const c = f(o);
+      if (m(c)) {
+        const s = h(
+          c,
+          t,
+          f,
+          u,
+          o
+        );
+        if (s) return s;
+      }
+    }
+  }
+}
+function V(i, t, f, u) {
+  for (let r = 0; r < i.length; r++) {
+    const n = i[r];
+    t(n, r, i, u);
+    const o = f(n);
+    m(o) && V(o, t, f, n);
+  }
+}
+export {
+  m as isValidArray,
+  p as isValidValue,
+  E as toValidArray,
+  V as treeEach,
+  h as treeFind
+};

package/dist/components/upload/src/upload-content.vue.d.ts

@@ -16,13 +16,13 @@ declare const __VLS_component: import("vue").DefineComponent<UploadContentProps,
     onProgress: (evt: import("./upload").UploadProgressEvent, rawFile: UploadRawFile) => void;
     onError: (err: import("./ajax.js").UploadAjaxError, rawFile: UploadRawFile) => void;
     method: string;
+    action: string;
+    accept: string;
     beforeUpload: UploadHooks["beforeUpload"];
     onRemove: (file: UploadFile | UploadRawFile) => void;
     onSuccess: (response: any, rawFile: UploadRawFile) => unknown;
     onExceed: UploadHooks["onExceed"];
-    action: string;
     showFileList: boolean;
-    accept: string;
     fileList: import("./upload").UploadUserFile[];
     autoUpload: boolean;
     listType: import("./upload").ListType;

package/dist/components/upload/src/upload.vue.d.ts

@@ -42,14 +42,14 @@ declare const __VLS_component: import("vue").DefineComponent<UploadProps, {
     onProgress: import("./upload").UploadHooks["onProgress"];
     onError: import("./upload").UploadHooks["onError"];
     method: string;
+    action: string;
+    accept: string;
     beforeUpload: import("./upload").UploadHooks["beforeUpload"];
     onRemove: import("./upload").UploadHooks["onRemove"];
     onPreview: import("./upload").UploadHooks["onPreview"];
     onSuccess: import("./upload").UploadHooks["onSuccess"];
     onExceed: import("./upload").UploadHooks["onExceed"];
-    action: string;
     showFileList: boolean;
-    accept: string;
     fileList: import("./upload").UploadUserFile[];
     autoUpload: boolean;
     listType: import("./upload").ListType;

package/dist/constants/column-alignment.js

@@ -0,0 +1,4 @@
+const t = ["left", "center", "right"];
+export {
+  t as columnAlignment
+};