@nivaro/react 0.3.32 → 0.3.34

package/dist/shared/components/item-edit/usePersonalDefaults.js

@@ -0,0 +1,358 @@
+import { useQueryClient as Le, useQuery as Ne } from "@tanstack/react-query";
+import { useRef as h, useMemo as Pe, useState as ne, useEffect as L, useCallback as a, createContext as Qe, useContext as ze } from "react";
+import { useNivaroClient as Te } from "../../context.js";
+import { get as Ye, del as Ee, put as Re } from "../../lib/commands.js";
+import { isEmptyValue as w, pickDefault as se, cascadeParents as V, orderTopDown as He, captureContext as Be } from "../../lib/personal-defaults.js";
+import { titleCase as Je } from "../../lib/utils.js";
+const We = Qe(null);
+function rt() {
+  return ze(We);
+}
+function N(u) {
+  return ["field-defaults", u];
+}
+function J(u) {
+  return Array.isArray(u) ? u.map(J) : u && typeof u == "object" && "id" in u ? u.id : u;
+}
+function S(u, f) {
+  if (w(u) && w(f)) return !0;
+  const m = (P) => {
+    const x = J(P);
+    return Array.isArray(x) ? x.map((b) => String(b)).sort() : String(x);
+  };
+  return JSON.stringify(m(u)) === JSON.stringify(m(f));
+}
+function nt(u, f) {
+  let m = 0;
+  for (const [P, x] of u) {
+    const b = f.get(P);
+    for (const k of x) b != null && b.has(String(k)) || m++;
+  }
+  return m;
+}
+function Ge(u) {
+  return Array.isArray(u) ? u : w(u) ? [] : [u];
+}
+function st(u) {
+  const { collection: f, isNew: m, disabled: P, enabled: x = !0, ready: b = !0 } = u, k = Te(), F = Le(), d = h(u);
+  d.current = u;
+  const { data: Q } = Ne({
+    queryKey: N(f),
+    queryFn: () => k.request(Ye("/field-defaults/mine", { collection: f })).then((e) => e.data ?? []),
+    staleTime: 5 * 6e4,
+    enabled: !!f && x
+  }), z = Pe(() => {
+    const e = /* @__PURE__ */ new Map();
+    for (const t of Q ?? []) {
+      const r = e.get(t.field) ?? [];
+      r.push(t), e.set(t.field, r);
+    }
+    return e;
+  }, [Q]), W = h(z);
+  W.current = z;
+  const i = h(/* @__PURE__ */ new Map()), [G, Me] = ne(() => /* @__PURE__ */ new Map()), v = h(/* @__PURE__ */ new Map()), [ce, qe] = ne(() => /* @__PURE__ */ new Map()), R = h(/* @__PURE__ */ new Set()), T = h(!0);
+  L(() => (T.current = !0, () => {
+    T.current = !1;
+  }), []);
+  const p = a(() => {
+    T.current && (Me((e) => {
+      const t = i.current;
+      return e.size === t.size && [...t].every(([r, n]) => e.get(r) === n) ? e : new Map(t);
+    }), qe((e) => {
+      const t = v.current;
+      return e.size === t.size && [...t].every(([r, n]) => e.get(r) === n) ? e : new Map(t);
+    }));
+  }, []), l = a((e) => {
+    var n;
+    const t = d.current, r = (n = t.readValue) == null ? void 0 : n.call(t, e);
+    return r !== void 0 ? r : t.draftRef.current[e];
+  }, []), A = a(
+    (e) => {
+      const t = {};
+      for (const r of e) t[r] = l(r);
+      return t;
+    },
+    [l]
+  ), M = a(async (e, t) => {
+    const r = d.current, s = (await Promise.all(
+      Ge(J(t)).map(async (o) => {
+        if (!r.valueLabel) return String(o);
+        try {
+          return await r.valueLabel(e, o) ?? null;
+        } catch {
+          return null;
+        }
+      })
+    )).filter((o) => !!o);
+    return s.length > 0 ? s.join(", ") : null;
+  }, []), q = h(0), Y = a(
+    async (e, t, r) => {
+      const n = await t;
+      q.current === r && (v.current.set(e, n), p());
+    },
+    [p]
+  ), I = a(
+    async (e, t) => {
+      var s, o;
+      const r = ((o = (s = d.current).fieldLabel) == null ? void 0 : o.call(s, e)) ?? e, n = await M(e, t);
+      return n ? `Your default is for ${r} “${n}”` : `Your saved default is for a different ${r}`;
+    },
+    [M]
+  ), E = a((e, t, r) => {
+    const n = d.current;
+    if (n.setFieldValue(e, t, r), w(t)) {
+      i.current.delete(e);
+      return;
+    }
+    i.current.set(e, t), v.current.delete(e), n.markAutoFilled([e]);
+  }, []), ue = a(
+    async (e, t) => {
+      var ke, ve, be, Fe, xe, Ae;
+      const r = d.current, n = () => q.current !== t, s = W.current.get(e) ?? [];
+      if (s.length === 0 || !r.layoutAllows(e)) return [];
+      if (R.current.has(e) || !(((ke = r.canFill) == null ? void 0 : ke.call(r, e)) ?? !0)) return [];
+      const o = l(e), y = !w(o);
+      if (y && !(((ve = r.replaceable) == null ? void 0 : ve.call(r, e, o)) ?? !1)) return [];
+      const K = new Set(s.flatMap((c) => Object.keys(c.context ?? {}))), we = A(K), { pick: j, fillParents: te, blockedBy: C } = se(s, we);
+      if (!j) {
+        if (C) {
+          const c = (be = s.find(
+            (g) => g.context && C in g.context && !S(g.context[C], we[C])
+          )) == null ? void 0 : be.context[C];
+          await Y(e, I(C, c), t);
+        }
+        return [];
+      }
+      const ge = V(e, r.rulesFor).reverse(), je = [
+        ...ge.filter((c) => c in te),
+        ...Object.keys(te).filter((c) => !ge.includes(c))
+      ], re = [], O = () => {
+        for (const [c, g] of re.reverse())
+          S(l(c), g) ? E(c, null, g) : i.current.delete(c);
+      };
+      for (const c of je) {
+        const g = te[c], Se = r.layoutAllows(c) && !R.current.has(c) && (((Fe = r.canFill) == null ? void 0 : Fe.call(r, c)) ?? !0) ? await r.revalidate(c, g) : !1;
+        if (n()) return [];
+        if (Se === null)
+          return O(), [];
+        if (!Se || !w(l(c)))
+          return O(), await Y(e, I(c, g), t), [];
+        E(c, g), re.push([c, g]);
+      }
+      const he = await r.revalidate(e, j.value);
+      if (n()) return [];
+      if (he === null)
+        return O(), [];
+      if (!he)
+        return O(), await Y(
+          e,
+          M(e, j.value).then(
+            (c) => c ? `Your default "${c}" is no longer available` : "Your saved default is no longer available"
+          ),
+          t
+        ), [];
+      if (!S(l(e), o) || !(((xe = r.canFill) == null ? void 0 : xe.call(r, e)) ?? !0))
+        return O(), [];
+      const me = se(s, A(K));
+      return ((Ae = me.pick) == null ? void 0 : Ae.id) !== j.id || Object.keys(me.fillParents).length > 0 ? (O(), "stale") : (E(e, j.value, y ? o : void 0), [...re.map(([c]) => c), e]);
+    },
+    [l, A, Y, I, M, E]
+  ), oe = a(
+    async (e, t) => {
+      for (let r = 0; r < 3; r++) {
+        const n = await ue(e, t);
+        if (n !== "stale") return n;
+      }
+      return [];
+    },
+    [ue]
+  ), U = a(
+    async (e) => {
+      var n, s;
+      const t = q.current, r = /* @__PURE__ */ new Set();
+      for (const o of e) {
+        if (!T.current || q.current !== t) return;
+        for (const y of await oe(o, t)) r.add(y);
+        p();
+      }
+      if (q.current === t) {
+        for (const o of r)
+          i.current.has(o) && ((s = (n = d.current).afterApply) == null || s.call(n, o, i.current.get(o)));
+        p();
+      }
+    },
+    [oe, p]
+  ), X = a(() => {
+    const e = d.current;
+    return He(
+      [...W.current.keys()].filter((t) => e.layoutAllows(t)),
+      e.rulesFor
+    );
+  }, []), Z = h(!1);
+  L(() => {
+    !m || P || !b || Z.current || Q === void 0 || (Z.current = !0, U(X()));
+  }, [m, P, b, Q, U, X]), L(() => {
+    let e = !1;
+    for (const [t, r] of i.current)
+      S(l(t), r) || (i.current.delete(t), e = !0);
+    for (const t of v.current.keys())
+      w(l(t)) || (v.current.delete(t), e = !0);
+    e && p();
+  });
+  const D = h(/* @__PURE__ */ new Set()), $ = h(/* @__PURE__ */ new Map()), [Ce, Oe] = ne(0), Ve = a(
+    (e) => {
+      let t = i.current.delete(e);
+      if (v.current.delete(e) && (t = !0), R.current.delete(e), $.current.delete(e), !d.current.isNew) {
+        t && p();
+        return;
+      }
+      const r = d.current.rulesFor;
+      for (const [n, s] of [...i.current])
+        V(n, r).includes(e) && ($.current.set(n, s), i.current.delete(n), t = !0);
+      t && p(), D.current.add(e), Oe((n) => n + 1);
+    },
+    [p]
+  );
+  L(() => {
+    if (D.current.size === 0 || d.current.disabled) return;
+    const e = [...D.current];
+    D.current.clear();
+    const t = new Map($.current);
+    $.current.clear();
+    const r = d.current, n = [];
+    for (const s of X()) {
+      if (t.has(s)) {
+        const y = t.get(s), K = l(s);
+        if (S(K, y)) r.setFieldValue(s, null, y);
+        else if (!w(K)) continue;
+        n.push(s);
+        continue;
+      }
+      const o = V(s, r.rulesFor);
+      e.some((y) => o.includes(y)) && v.current.has(s) && w(l(s)) && (v.current.delete(s), n.push(s));
+    }
+    p(), n.length > 0 && U(n);
+  }, [Ce]);
+  const _ = a(
+    (e) => {
+      const t = d.current;
+      if (!i.current.has(e)) return;
+      const r = [
+        e,
+        ...[...i.current.keys()].filter(
+          (n) => n !== e && V(n, t.rulesFor).includes(e)
+        )
+      ];
+      for (const n of r) {
+        const s = i.current.get(n);
+        S(l(n), s) && t.setFieldValue(n, null, s), i.current.delete(n);
+      }
+      R.current.add(e), p();
+    },
+    [l, p]
+  ), De = a(
+    (e) => {
+      if (!i.current.has(e)) return;
+      const t = i.current.get(e);
+      S(l(e), t) && d.current.setFieldValue(e, null, t), i.current.delete(e), R.current.add(e), p();
+    },
+    [l, p]
+  ), H = `${f}|${m ? "new" : "saved"}|${u.resetKey ?? ""}`, ae = h(H);
+  L(() => {
+    ae.current !== H && (ae.current = H, i.current.clear(), v.current.clear(), R.current.clear(), $.current.clear(), D.current.clear(), Z.current = !1, q.current += 1, p());
+  }, [H, p]);
+  const ee = a((e) => ce.get(e) ?? null, [ce]), $e = a(() => i.current, []), B = a(
+    (e) => {
+      const t = z.get(e) ?? [];
+      if (t.length === 0) return null;
+      const r = new Set(t.flatMap((n) => Object.keys(n.context ?? {})));
+      return se(t, A(r)).pick;
+    },
+    [z, A]
+  ), le = a(() => {
+    F.invalidateQueries({ queryKey: N(f) });
+  }, [F, f]), ie = a(
+    (e) => !w(l(e)),
+    [l]
+  ), fe = a(
+    async (e) => {
+      const t = d.current, r = [
+        ...[...V(e, t.rulesFor)].reverse().filter((n) => t.layoutAllows(n) && !w(l(n))),
+        e
+      ];
+      return Promise.all(
+        // A value with no label says which field it is, never its stored id ("Save 4521 · …").
+        r.map(
+          async (n) => {
+            var s;
+            return await M(n, l(n)) ?? ((s = t.fieldLabel) == null ? void 0 : s.call(t, n)) ?? Je(n);
+          }
+        )
+      );
+    },
+    [l, M]
+  ), de = a(
+    async (e) => {
+      const t = d.current, r = l(e);
+      if (w(r)) throw new Error("Pick a value first");
+      const n = V(e, t.rulesFor), s = A([e, ...n]), o = (y) => k.request(
+        Re("/field-defaults/mine", {
+          collection: f,
+          field: y,
+          value: J(s[y]),
+          context: Be(y, s, t.rulesFor)
+        })
+      );
+      try {
+        await o(e);
+        for (const y of [...n].reverse())
+          t.layoutAllows(y) && !w(s[y]) && await o(y);
+      } finally {
+        await F.invalidateQueries({ queryKey: N(f) });
+      }
+    },
+    [k, F, f, l, A]
+  ), ye = a(
+    async (e) => {
+      const t = B(e);
+      return t ? (await k.request(Ee(`/field-defaults/mine/${t.id}`)), await F.invalidateQueries({ queryKey: N(f) }), t) : null;
+    },
+    [k, F, f, B]
+  ), pe = a(
+    async (e) => {
+      await k.request(
+        Re("/field-defaults/mine", {
+          collection: f,
+          field: e.field,
+          value: e.value,
+          context: e.context ?? {}
+        })
+      ), await F.invalidateQueries({ queryKey: N(f) });
+    },
+    [k, F, f]
+  ), Ke = Pe(
+    () => ({
+      allowed: (e) => d.current.layoutAllows(e),
+      defaultFor: B,
+      save: de,
+      clear: ye,
+      restore: pe,
+      refresh: le,
+      hasValue: ie,
+      describeSave: fe,
+      applied: (e) => G.has(e),
+      hintFor: ee,
+      undo: _
+    }),
+    [B, de, ye, pe, le, ie, fe, G, ee, _]
+  );
+  return { ledger: G, hintFor: ee, undo: _, onPersonChange: Ve, release: De, appliedNow: $e, context: Ke };
+}
+export {
+  We as PersonalDefaultsContext,
+  nt as linksBeyond,
+  N as personalDefaultsKey,
+  S as sameDefaultValue,
+  st as usePersonalDefaults,
+  rt as usePersonalDefaultsApi
+};