@reformer/core 11.0.0-beta.1 → 11.0.0-beta.3

package/dist/form-model-DhW2HZOB.js

@@ -0,0 +1,323 @@
+import { batch as k, signal as _, computed as O } from "@preact/signals-core";
+const h = /* @__PURE__ */ new WeakMap();
+function F(e) {
+  h.set(e, (h.get(e) ?? 0) + 1);
+}
+function K(e) {
+  const t = h.get(e);
+  t !== void 0 && (t <= 1 ? h.delete(e) : h.set(e, t - 1));
+}
+function P(e) {
+  return h.has(e);
+}
+const p = (e) => !(e === null || typeof e != "object" || Array.isArray(e) || e instanceof Date || typeof Blob < "u" && e instanceof Blob || typeof File < "u" && e instanceof File), c = (e, t) => e === "" ? String(t) : `${e}.${t}`, m = (e) => /^\d+$/.test(e), l = (e) => {
+  if (Array.isArray(e)) return e.map(l);
+  if (p(e)) {
+    const t = {};
+    for (const i of Object.keys(e)) t[i] = l(e[i]);
+    return t;
+  }
+  return e;
+}, g = (e, t) => {
+  if (e === t) return !0;
+  if (Array.isArray(e) && Array.isArray(t))
+    return e.length !== t.length ? !1 : e.every((i, r) => g(i, t[r]));
+  if (p(e) && p(t)) {
+    const i = Object.keys(e), r = Object.keys(t);
+    return i.length !== r.length ? !1 : i.every((n) => g(e[n], t[n]));
+  }
+  return !1;
+};
+class j {
+  constructor(t, i) {
+    this.path = i;
+    const r = _(t);
+    r.__path = i, this.signal = r, this.initial = l(t);
+  }
+  kind = "leaf";
+  signal;
+  initial;
+  rebase(t) {
+    this.path = t, this.signal.__path = t;
+  }
+  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+  read() {
+    return this.signal.value;
+  }
+  /** Нереактивный снимок. */
+  peek() {
+    return this.signal.peek();
+  }
+  set(t) {
+    this.signal.value = t;
+  }
+  resetToInitial() {
+    this.signal.value = l(this.initial);
+  }
+  captureInitial() {
+    this.initial = l(this.signal.peek());
+  }
+  dirty() {
+    return !g(this.signal.peek(), this.initial);
+  }
+}
+class x {
+  constructor(t, i) {
+    this.path = i;
+    for (const r of Object.keys(t))
+      this.children.set(r, d(t[r], c(i, r)));
+  }
+  kind = "group";
+  children = /* @__PURE__ */ new Map();
+  rebase(t) {
+    this.path = t;
+    for (const [i, r] of this.children) r.rebase(c(t, i));
+  }
+  /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
+  read() {
+    const t = {};
+    for (const [i, r] of this.children) t[i] = r.read();
+    return t;
+  }
+  peek() {
+    const t = {};
+    for (const [i, r] of this.children) t[i] = r.peek();
+    return t;
+  }
+  set(t) {
+    if (t == null || typeof t != "object") return;
+    const i = t;
+    k(() => {
+      for (const [r, n] of this.children)
+        r in i && (n.kind === "leaf" && P(n.signal) || n.set(i[r]));
+    });
+  }
+  resetToInitial() {
+    k(() => {
+      for (const t of this.children.values()) t.resetToInitial();
+    });
+  }
+  captureInitial() {
+    for (const t of this.children.values()) t.captureInitial();
+  }
+  dirty() {
+    for (const t of this.children.values()) if (t.dirty()) return !0;
+    return !1;
+  }
+}
+class N {
+  constructor(t, i) {
+    this.path = i, this.items = _(t.map((r, n) => d(r, c(i, n)))), this.initial = l(t);
+  }
+  kind = "array";
+  items;
+  initial;
+  rebase(t) {
+    this.path = t, this.items.peek().forEach((i, r) => i.rebase(c(t, r)));
+  }
+  reindex() {
+    this.items.peek().forEach((t, i) => t.rebase(c(this.path, i)));
+  }
+  push(t) {
+    const i = this.items.peek();
+    this.items.value = [...i, d(t, c(this.path, i.length))];
+  }
+  insertAt(t, i) {
+    const r = [...this.items.peek()];
+    r.splice(t, 0, d(i, c(this.path, t))), this.items.value = r, this.reindex();
+  }
+  removeAt(t) {
+    const i = [...this.items.peek()];
+    i.splice(t, 1), this.items.value = i, this.reindex();
+  }
+  move(t, i) {
+    const r = [...this.items.peek()], [n] = r.splice(t, 1);
+    n && r.splice(i, 0, n), this.items.value = r, this.reindex();
+  }
+  swap(t, i) {
+    const r = [...this.items.peek()];
+    t < 0 || i < 0 || t >= r.length || i >= r.length || t === i || ([r[t], r[i]] = [r[i], r[t]], this.items.value = r, this.reindex());
+  }
+  clear() {
+    this.items.value = [];
+  }
+  /**
+   * Реактивное чтение массива. Читаем `items.value` (а не `.peek()`) — внутри effect/computed это
+   * подписка на СОСТАВ массива, поэтому push/removeAt/move ретригерят наравне с правкой элемента.
+   */
+  read() {
+    return this.items.value.map((t) => t.read());
+  }
+  peek() {
+    return this.items.peek().map((t) => t.peek());
+  }
+  set(t) {
+    const i = Array.isArray(t) ? t : [];
+    this.items.value = i.map((r, n) => d(r, c(this.path, n)));
+  }
+  resetToInitial() {
+    this.set(l(this.initial));
+  }
+  captureInitial() {
+    this.initial = l(this.peek());
+  }
+  dirty() {
+    return !g(this.peek(), this.initial);
+  }
+}
+function d(e, t) {
+  return Array.isArray(e) ? new N(e, t) : p(e) ? new x(e, t) : new j(e, t);
+}
+function f(e) {
+  if (e)
+    return e.kind === "group" ? S(e) : e.kind === "array" ? E(e) : e.read();
+}
+function E(e) {
+  const t = {
+    get length() {
+      return e.items.value.length;
+    },
+    push: (i) => e.push(i),
+    insertAt: (i, r) => e.insertAt(i, r),
+    removeAt: (i) => e.removeAt(i),
+    move: (i, r) => e.move(i, r),
+    swap: (i, r) => e.swap(i, r),
+    clear: () => e.clear(),
+    at: (i) => f(e.items.value[i]),
+    map: (i) => e.items.value.map((r, n) => i(f(r), n)),
+    forEach: (i) => e.items.value.forEach((r, n) => i(f(r), n)),
+    toArray: () => e.peek(),
+    [Symbol.iterator]: function* () {
+      const i = e.items.value;
+      for (let r = 0; r < i.length; r++) yield f(i[r]);
+    }
+  };
+  return new Proxy(t, {
+    get: (i, r, n) => r === "__path" ? e.path : typeof r == "string" && m(r) ? f(e.items.value[Number(r)]) : Reflect.get(i, r, n),
+    has: (i, r) => typeof r == "string" && m(r) ? Number(r) < e.items.value.length : Reflect.has(i, r)
+  });
+}
+const A = /* @__PURE__ */ new WeakMap();
+function M(e) {
+  const t = O(() => e.read());
+  return {
+    get value() {
+      return t.value;
+    },
+    peek: () => t.peek(),
+    subscribe: (i) => t.subscribe(i),
+    valueOf: () => t.value,
+    toString: () => String(t.value),
+    toJSON: () => t.value,
+    brand: t.brand
+  };
+}
+function I(e) {
+  if (e.kind === "leaf") return e.signal;
+  const t = A.get(e);
+  if (t) return t;
+  const i = M(e), r = e.kind === "group", n = (o) => r ? e.children.get(o) : m(o) ? e.items.value[Number(o)] : void 0, s = r ? {} : {
+    get length() {
+      return e.items.value.length;
+    }
+  }, u = new Proxy(s, {
+    get: (o, a, D) => {
+      if (a === "__path") return e.path;
+      if (a === "__kind") return e.kind;
+      if (typeof a != "string") return Reflect.get(i, a, i);
+      const v = n(a);
+      return v ? I(v) : !r && Reflect.has(o, a) ? Reflect.get(o, a, D) : Reflect.get(i, a, i);
+    },
+    has: (o, a) => typeof a == "string" && (n(a) !== void 0 || !r && Reflect.has(o, a)),
+    ownKeys: () => r ? [...e.children.keys()] : Reflect.ownKeys(s),
+    getOwnPropertyDescriptor: (o, a) => typeof a == "string" && n(a) ? { enumerable: !0, configurable: !0 } : r ? void 0 : Reflect.getOwnPropertyDescriptor(o, a)
+  });
+  return A.set(e, u), u;
+}
+function W(e) {
+  if (e == null || typeof e != "object") return !1;
+  const t = e.__kind;
+  return t === "group" || t === "array";
+}
+function T(e, t) {
+  if (!t) return;
+  let i = e;
+  for (const r of t.split(".")) {
+    if (!i) return;
+    if (i.kind === "group") i = i.children.get(r);
+    else if (i.kind === "array") i = i.items.peek()[Number(r)];
+    else return;
+  }
+  return i && i.kind === "leaf" ? i.signal : void 0;
+}
+const b = /* @__PURE__ */ new Set([
+  "$",
+  "get",
+  "set",
+  "patch",
+  "isDirty",
+  "reset",
+  "captureInitial",
+  "signalAt"
+]), w = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap();
+function S(e) {
+  const t = w.get(e);
+  if (t) return t;
+  const i = {
+    $: I(e),
+    get: () => e.peek(),
+    set: (n) => e.set(n),
+    patch: (n) => e.set(n),
+    isDirty: () => e.dirty(),
+    reset: () => e.resetToInitial(),
+    captureInitial: () => e.captureInitial(),
+    signalAt: (n) => T(e, n)
+  }, r = new Proxy(
+    {},
+    {
+      get: (n, s) => {
+        if (s === "__path") return e.path;
+        if (typeof s != "string") return;
+        const u = e.children.get(s);
+        if (u) return f(u);
+        if (b.has(s)) return i[s];
+      },
+      set: (n, s, u) => {
+        if (typeof s != "string") return !1;
+        const o = e.children.get(s);
+        return o ? (o.set(u), !0) : !1;
+      },
+      has: (n, s) => typeof s == "string" && (e.children.has(s) || b.has(s)),
+      ownKeys: () => [...e.children.keys()],
+      getOwnPropertyDescriptor: (n, s) => typeof s == "string" && e.children.has(s) ? { enumerable: !0, configurable: !0 } : void 0
+    }
+  );
+  return w.set(e, r), R.set(r, e), r;
+}
+function y(e, t) {
+  if (e.kind === "leaf") {
+    t(e.signal);
+    return;
+  }
+  if (e.kind === "group") {
+    for (const i of e.children.values()) y(i, t);
+    return;
+  }
+  for (const i of e.items.value) y(i, t);
+}
+function B(e, t) {
+  const i = R.get(e);
+  i && y(i, t);
+}
+function C(e) {
+  const t = new x(e, "");
+  return S(t);
+}
+export {
+  P as a,
+  C as c,
+  B as e,
+  W as i,
+  F as m,
+  K as u
+};