@king-one/form-antdv 0.0.6 → 0.0.9

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @king-one/form-antdv
 
+## 0.0.9
+
+### Patch Changes
+
+- 优化组件销毁逻辑
+- Updated dependencies
+  - @king-one/form-render@0.0.8
+
+## 0.0.8
+
+### Patch Changes
+
+- feat：发布新版本
+
+## 0.0.7
+
+### Patch Changes
+
+- Updated dependencies
+  - @king-one/form-render@0.0.7
+
 ## 0.0.6
 
 ### Patch Changes

package/dist/es/node_modules/.pnpm/@king-one_path@1.0.4/node_modules/@king-one/path/dist/es/index.mjs

@@ -0,0 +1,4 @@
+import { Path as r } from "./src/index.mjs";
+export {
+  r as FormPath
+};

package/dist/es/node_modules/.pnpm/@king-one_path@1.0.4/node_modules/@king-one/path/dist/es/src/contexts.mjs

@@ -0,0 +1,15 @@
+function t(n, e) {
+  return {
+    flag: n,
+    ...e
+  };
+}
+const o = t("[]"), c = t("[\\d]"), r = t("[[]]"), x = t("()"), s = t("{}"), C = t("{x}");
+export {
+  s as braceContext,
+  c as bracketArrayContext,
+  o as bracketContext,
+  r as bracketDContext,
+  C as destructorContext,
+  x as parenContext
+};

package/dist/es/node_modules/.pnpm/@king-one_path@1.0.4/node_modules/@king-one/path/dist/es/src/destructor.mjs

@@ -0,0 +1,72 @@
+import { isObjectPattern as h, isIdentifier as u, isArrayPattern as y, isDestructorExpression as l } from "./types.mjs";
+import { isNum as k } from "./shared.mjs";
+const p = /* @__PURE__ */ new Map(), I = (n) => n != null;
+function E(n) {
+  return p.get(n);
+}
+function x(n, t) {
+  p.set(n, t);
+}
+function f(n) {
+  const t = [];
+  if (h(n)) {
+    let e = 0;
+    return n.properties.forEach((r) => {
+      t[e] = {
+        path: []
+      }, t[e].key = r.key.value, t[e].path.push(r.key.value), u(r.value) && (t[e].key = r.value.value);
+      const s = t[e].path, c = f(r.value);
+      let o = e;
+      c.forEach((a) => {
+        t[o] ? (t[o].key = a.key, t[o].path = s.concat(a.path)) : t[o] = {
+          key: a.key,
+          path: s.concat(a.path)
+        }, o++;
+      }), o > e ? e = o : e++;
+    }), t;
+  } else if (y(n)) {
+    let e = 0;
+    return n.elements.forEach((r, s) => {
+      t[e] = {
+        path: []
+      }, t[e].key = s, t[e].path.push(s), u(r) && (t[e].key = r.value);
+      const c = t[e].path, o = f(r);
+      let a = e;
+      o.forEach((i) => {
+        t[a] ? (t[a].key = i.key, t[a].path = c.concat(i.path)) : t[a] = {
+          key: i.key,
+          path: c.concat(i.path)
+        }, a++;
+      }), a > e ? e = a : e++;
+    }), t;
+  }
+  return l(n) ? f(n.value) : t;
+}
+function g(n, t, e, r) {
+  t.forEach(({ key: s, path: c }) => {
+    r.setIn([s], n, r.getIn(c, e));
+  });
+}
+function m(n, t, e) {
+  let r = {};
+  return t.length && k(t[0].path[0]) && (r = []), n = I(n) ? n : {}, t.forEach(({ key: s, path: c }) => {
+    e.setIn(c, r, n[s]);
+  }), r;
+}
+function B(n, t, e) {
+  t.forEach(({ key: r }) => {
+    e.deleteIn([r], n);
+  });
+}
+function P(n, t, e, r) {
+  return t.every(({ key: s }) => r.existIn([s], n, e));
+}
+export {
+  B as deleteInByDestructor,
+  P as existInByDestructor,
+  E as getDestructor,
+  m as getInByDestructor,
+  f as parseDestructorRules,
+  x as setDestructor,
+  g as setInByDestructor
+};

package/dist/es/node_modules/.pnpm/@king-one_path@1.0.4/node_modules/@king-one/path/dist/es/src/index.mjs

@@ -0,0 +1,317 @@
+import { Parser as G } from "./parser.mjs";
+import { isStr as R, isNum as A, isArr as $, isObj as D, isFn as b, isRegExp as O, isEqual as V } from "./shared.mjs";
+import { getDestructor as I, getInByDestructor as _, setInByDestructor as k, deleteInByDestructor as z, existInByDestructor as J } from "./destructor.mjs";
+import { Matcher as j } from "./matcher.mjs";
+var K = Object.defineProperty, L = (e, t, s) => t in e ? K(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s, r = (e, t, s) => L(e, typeof t != "symbol" ? t + "" : t, s);
+const x = /* @__PURE__ */ new Map(), v = Symbol("PATH_MATCHER"), P = (e) => e != null;
+function Q(e) {
+  return !e.includes("*") && !e.includes("~") && !e.includes("[") && !e.includes("]") && !e.includes(",") && !e.includes(":") && !e.includes(" ") && e[0] !== ".";
+}
+const W = (e) => typeof e == "object" || typeof e == "function", U = (e) => R(e) ? /^\d+$/.test(e) : A(e);
+function E(e, t) {
+  for (let s = 0; s < e.length; s++) {
+    const n = e[s], h = I(n);
+    if (h) {
+      t = _(t, h, { setIn: M, getIn: E });
+      break;
+    } else {
+      if (!P(t))
+        return;
+      t = t[n];
+    }
+  }
+  return t;
+}
+function M(e, t, s) {
+  for (let n = 0; n < e.length; n++) {
+    const h = e[n], m = I(h);
+    if (m) {
+      k(t, m, s, { setIn: M, getIn: E });
+      break;
+    } else {
+      if (!P(t) || !W(t) || $(t) && !U(h))
+        return;
+      if (!P(t[h])) {
+        if (s === void 0) {
+          t[h] === null && (t[h] = s);
+          return;
+        }
+        n < e.length - 1 && (t[h] = A(e[n + 1]) ? [] : {});
+      }
+      n === e.length - 1 && (t[h] = s), t = t[h];
+    }
+  }
+}
+function y(e, t) {
+  for (let s = 0; s < e.length; s++) {
+    const n = e[s], h = I(n);
+    if (h) {
+      z(t, h, {
+        setIn: M,
+        getIn: E,
+        deleteIn: y
+      });
+      break;
+    } else {
+      if (s === e.length - 1 && P(t)) {
+        delete t[n];
+        return;
+      }
+      if (!P(t) || !W(t) || (t = t[n], !D(t)))
+        return;
+    }
+  }
+}
+const X = Object.prototype.hasOwnProperty;
+function B(e, t, s) {
+  s instanceof w && (s = s.length);
+  for (let n = s; n < e.length; n++) {
+    const h = e[n], m = I(h);
+    if (m)
+      return J(t, m, s, {
+        setIn: M,
+        getIn: E,
+        deleteIn: y,
+        existIn: B
+      });
+    if (n === e.length - 1)
+      return X.call(t, h);
+    if (!P(t) || !W(t) || (t = t[h], !D(t)))
+      return !1;
+  }
+}
+function C(e, t) {
+  if (e instanceof w)
+    return {
+      entire: e.entire,
+      segments: e.segments.slice(),
+      isRegExp: !1,
+      haveRelativePattern: e.haveRelativePattern,
+      isWildMatchPattern: e.isWildMatchPattern,
+      isMatchPattern: e.isMatchPattern,
+      haveExcludePattern: e.haveExcludePattern,
+      tree: e.tree
+    };
+  if (R(e)) {
+    if (!e)
+      return {
+        entire: "",
+        segments: [],
+        isRegExp: !1,
+        isWildMatchPattern: !1,
+        haveExcludePattern: !1,
+        isMatchPattern: !1
+      };
+    if (Q(e))
+      return {
+        entire: e,
+        segments: e.split("."),
+        isRegExp: !1,
+        isWildMatchPattern: !1,
+        haveExcludePattern: !1,
+        isMatchPattern: !1
+      };
+    const s = new G(e, w.parse(t)), n = s.parse();
+    if (s.isMatchPattern)
+      return {
+        entire: e,
+        segments: [],
+        isRegExp: !1,
+        haveRelativePattern: !1,
+        isWildMatchPattern: s.isWildMatchPattern,
+        haveExcludePattern: s.haveExcludePattern,
+        isMatchPattern: !0,
+        tree: n
+      };
+    {
+      const h = s.data.segments;
+      return {
+        entire: h.join("."),
+        segments: h,
+        tree: n,
+        isRegExp: !1,
+        haveRelativePattern: s.haveRelativePattern,
+        isWildMatchPattern: !1,
+        haveExcludePattern: !1,
+        isMatchPattern: !1
+      };
+    }
+  } else return b(e) && e[v] ? C(e.path) : $(e) ? {
+    entire: e.join("."),
+    segments: e.reduce((s, n) => s.concat(S(n)), []),
+    isRegExp: !1,
+    haveRelativePattern: !1,
+    isWildMatchPattern: !1,
+    haveExcludePattern: !1,
+    isMatchPattern: !1
+  } : O(e) ? {
+    entire: e,
+    segments: [],
+    isRegExp: !0,
+    haveRelativePattern: !1,
+    isWildMatchPattern: !1,
+    haveExcludePattern: !1,
+    isMatchPattern: !0
+  } : {
+    entire: "",
+    isRegExp: !1,
+    segments: e !== void 0 ? [e] : [],
+    haveRelativePattern: !1,
+    isWildMatchPattern: !1,
+    haveExcludePattern: !1,
+    isMatchPattern: !1
+  };
+}
+function S(e) {
+  if (R(e)) {
+    e = e.replace(/\s*/g, "");
+    try {
+      const { segments: t, isMatchPattern: s } = C(e);
+      return s ? e : t;
+    } catch {
+      return e;
+    }
+  } else if (e instanceof w)
+    return e.segments;
+  return e;
+}
+const g = class u {
+  constructor(t, s) {
+    r(this, "entire"), r(this, "segments"), r(this, "isMatchPattern"), r(this, "isWildMatchPattern"), r(this, "isRegExp"), r(this, "haveRelativePattern"), r(this, "haveExcludePattern"), r(this, "matchScore"), r(this, "tree"), r(this, "matchCache"), r(this, "includesCache"), r(this, "concat", (...i) => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be concat`);
+      const a = new u("");
+      return a.segments = this.segments.concat(...i.map((c) => S(c))), a.entire = a.segments.join("."), a;
+    }), r(this, "slice", (i, a) => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be slice`);
+      const c = new u("");
+      return c.segments = this.segments.slice(i, a), c.entire = c.segments.join("."), c;
+    }), r(this, "push", (...i) => this.concat(...i)), r(this, "pop", () => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be pop`);
+      return new u(this.segments.slice(0, this.segments.length - 1));
+    }), r(this, "splice", (i, a, ...c) => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be splice`);
+      c = c.reduce((f, d) => f.concat(S(d)), []);
+      const o = this.segments.slice();
+      return o.splice(i, a, ...c), new u(o);
+    }), r(this, "forEach", (i) => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be each`);
+      this.segments.forEach(i);
+    }), r(this, "map", (i) => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be map`);
+      return this.segments.map(i);
+    }), r(this, "reduce", (i, a) => {
+      if (this.isMatchPattern || this.isRegExp)
+        throw new Error(`${this.entire} cannot be reduce`);
+      return this.segments.reduce(i, a);
+    }), r(this, "parent", () => this.slice(0, this.length - 1)), r(this, "includes", (i) => {
+      const { entire: a, segments: c, isMatchPattern: o } = u.parse(i), f = this.includesCache.get(a);
+      if (f !== void 0)
+        return f;
+      const d = (l) => (this.includesCache.set(a, l), l);
+      if (this.isMatchPattern) {
+        if (o)
+          throw new Error(`${this.entire} cannot be used to match ${a}`);
+        return d(this.match(c));
+      }
+      if (o)
+        throw new Error(`${this.entire} cannot be used to match ${a}`);
+      if (c.length > this.segments.length)
+        return d(!1);
+      for (let l = 0; l < c.length; l++)
+        if (!V(String(c[l]), String(this.segments[l])))
+          return d(!1);
+      return d(!0);
+    }), r(this, "transform", (i, a) => {
+      if (!b(a))
+        return "";
+      if (this.isMatchPattern)
+        throw new Error(`${this.entire} cannot be transformed`);
+      const c = new RegExp(i), o = this.segments.filter((f) => c.test(f));
+      return a(...o);
+    }), r(this, "match", (i) => {
+      var a, c;
+      const o = u.parse(i), f = this.matchCache.get(o.entire);
+      if (f !== void 0)
+        return f.record && f.record.score !== void 0 && (this.matchScore = f.record.score), f.matched;
+      const d = (l) => (this.matchCache.set(o.entire, l), l);
+      if (o.isMatchPattern) {
+        if (this.isMatchPattern)
+          throw new Error(`${o.entire} cannot match ${this.entire}`);
+        return this.matchScore = 0, d(o.match(this.segments));
+      } else if (this.isMatchPattern) {
+        if (this.isRegExp)
+          try {
+            return (c = (a = this.entire) == null ? void 0 : a.test) == null ? void 0 : c.call(a, o.entire);
+          } finally {
+            this.entire.lastIndex = 0;
+          }
+        const l = {
+          score: 0
+        }, p = d(new j(this.tree, l).match(o.segments));
+        return this.matchScore = l.score, p.matched;
+      } else {
+        const l = {
+          score: 0
+        }, p = d(j.matchSegments(this.segments, o.segments, l));
+        return this.matchScore = l.score, p.matched;
+      }
+    }), r(this, "matchAliasGroup", (i, a) => {
+      const c = u.parse(i), o = u.parse(a), f = this.match(c), d = this.matchScore, l = this.match(o), p = this.matchScore;
+      return this.haveExcludePattern ? d >= p ? f : l : f || l;
+    }), r(this, "existIn", (i, a = 0) => B(this.segments, i, a)), r(this, "getIn", (i) => E(this.segments, i)), r(this, "setIn", (i, a) => (M(this.segments, i, a), i)), r(this, "deleteIn", (i) => (y(this.segments, i), i)), r(this, "ensureIn", (i, a) => {
+      const c = this.getIn(i);
+      return c === void 0 ? (this.setIn(i, a), this.getIn(i)) : c;
+    });
+    const { tree: n, segments: h, entire: m, isRegExp: N, isMatchPattern: F, isWildMatchPattern: H, haveRelativePattern: T, haveExcludePattern: q } = C(t, s);
+    this.entire = m, this.segments = h, this.isMatchPattern = F, this.isWildMatchPattern = H, this.haveRelativePattern = T, this.isRegExp = N, this.haveExcludePattern = q, this.tree = n, this.matchCache = /* @__PURE__ */ new Map(), this.includesCache = /* @__PURE__ */ new Map();
+  }
+  toString() {
+    var t;
+    return (t = this.entire) == null ? void 0 : t.toString();
+  }
+  toArr() {
+    var t;
+    return (t = this.segments) == null ? void 0 : t.slice();
+  }
+  get length() {
+    return this.segments.length;
+  }
+  static match(t) {
+    const s = u.parse(t), n = (h) => s.match(h);
+    return n[v] = !0, n.path = s, n;
+  }
+  static isPathPattern(t) {
+    return !!(R(t) || $(t) || O(t) || b(t) && t[v]);
+  }
+  static transform(t, s, n) {
+    return u.parse(t).transform(s, n);
+  }
+  static parse(t = "", s) {
+    if (t instanceof u) {
+      const n = x.get(t.entire);
+      return n || (x.set(t.entire, t), t);
+    } else {
+      if (t && t[v])
+        return u.parse(t.path);
+      {
+        const n = s ? u.parse(s) : "", h = `${t}:${n}`, m = x.get(h);
+        return m || (t = new u(t, s), x.set(h, t), t);
+      }
+    }
+  }
+};
+r(g, "getIn", (e, t) => g.parse(t).getIn(e));
+r(g, "setIn", (e, t, s) => g.parse(t).setIn(e, s));
+r(g, "deleteIn", (e, t) => g.parse(t).deleteIn(e));
+r(g, "existIn", (e, t, s) => g.parse(t).existIn(e, s));
+r(g, "ensureIn", (e, t, s) => g.parse(t).ensureIn(e, s));
+let w = g;
+export {
+  w as Path
+};

package/dist/es/node_modules/.pnpm/@king-one_path@1.0.4/node_modules/@king-one/path/dist/es/src/matcher.mjs

@@ -0,0 +1,83 @@
+import { isWildcardOperator as u, isExpandOperator as c, isDotOperator as f, isIdentifier as m, isIgnoreExpression as x, isDestructorExpression as g, isGroupExpression as d, isRangeExpression as E } from "./types.mjs";
+import { isEqual as n, toArr as p, isSegmentEqual as v } from "./shared.mjs";
+var k = Object.defineProperty, N = (s, t, e) => t in s ? k(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, h = (s, t, e) => N(s, typeof t != "symbol" ? t + "" : t, e);
+class I {
+  constructor(t, e) {
+    h(this, "tree"), h(this, "stack"), h(this, "record"), h(this, "excluding"), h(this, "wildcards"), h(this, "path"), this.tree = t, this.stack = [], this.excluding = !1, this.wildcards = [], this.record = e;
+  }
+  next(t, e) {
+    if (t.after)
+      return this.matchNode(t.after, e);
+    if (u(t) && !t.filter)
+      return this.excluding ? !1 : e === 0 || t.optional ? !0 : !!this.take(e);
+    if (e === this.path.length - 1)
+      return !!this.take(e);
+    {
+      const i = this.wildcards.pop();
+      if (i && i.after)
+        return this.next(i, e);
+    }
+    return !1;
+  }
+  shot() {
+    var t;
+    ((t = this.record) == null ? void 0 : t.score) >= 0 && this.record.score++;
+  }
+  take(t) {
+    return String(this.path[t] ?? "");
+  }
+  matchExcludeIdentifier(t, e, r) {
+    const i = r === this.path.length - 1, a = r < this.path.length;
+    if (e.after || (this.excluding = !1), t) {
+      if (e.after)
+        return this.next(e, r);
+      if (i)
+        return !1;
+    }
+    return i ? !0 : a;
+  }
+  matchIdentifier(t, e) {
+    const r = this.take(e);
+    let i = !1;
+    return c(t.after) ? (r.indexOf(t.value) === 0 && (this.shot(), i = !0), this.excluding ? this.matchExcludeIdentifier(i, t.after, e) : i && this.next(t.after, e)) : (r === t.value && (this.shot(), i = !0), this.excluding ? this.matchExcludeIdentifier(i, t, e) : i && this.next(t, e));
+  }
+  matchIgnoreExpression(t, e) {
+    return n(t.value, this.take(e)) && this.next(t, e);
+  }
+  matchDestructorExpression(t, e) {
+    return n(t.source, this.take(e)) && this.next(t, e);
+  }
+  matchExpandOperator(t, e) {
+    return this.next(t, e);
+  }
+  matchWildcardOperator(t, e) {
+    let r = !1;
+    return t.filter ? (this.stack.push(t), r = this.matchNode(t.filter, e), this.stack.pop()) : r = this.next(t, e), r;
+  }
+  matchGroupExpression(t, e) {
+    let r = !1;
+    return t.isExclude && (r = !this.excluding), p(t.value)[r ? "every" : "some"]((i) => (this.wildcards = this.stack.slice(), this.excluding = r, this.matchNode(i, e)));
+  }
+  matchRangeExpression(t, e) {
+    const r = Number(this.take(e));
+    return t.start ? t.end ? r >= Number(t.start.value) && r <= Number(t.end.value) : r >= Number(t.start.value) : t.end ? r <= Number(t.end.value) : (this.wildcards = this.stack.slice(), this.next(t, e));
+  }
+  matchNode(t, e = 0) {
+    return f(t) ? this.next(t, e + 1) : m(t) ? this.matchIdentifier(t, e) : x(t) ? this.matchIgnoreExpression(t, e) : g(t) ? this.matchDestructorExpression(t, e) : c(t) ? this.matchExpandOperator(t, e) : u(t) ? this.matchWildcardOperator(t, e) : d(t) ? this.matchGroupExpression(t, e) : E(t) ? this.matchRangeExpression(t, e) : !1;
+  }
+  match(t) {
+    return this.path = t, { matched: this.matchNode(this.tree), record: this.record };
+  }
+  static matchSegments(t, e, r) {
+    if (t.length !== e.length)
+      return { matched: !1, record: r };
+    const i = (a = 0) => {
+      const l = v(t[a], e[a]);
+      return (r == null ? void 0 : r.score) >= 0 && r.score++, l && (a < t.length - 1 ? i(a + 1) : !0);
+    };
+    return { matched: i(), record: r };
+  }
+}
+export {
+  I as Matcher
+};