@ea-lab/reactive-json 0.7.0 → 1.0.0-alpha.0

package/dist/index-OhHUX6nj.js

@@ -0,0 +1,460 @@
+import { d as ft } from "./index-CACLSxWi.js";
+import { h as ht } from "./index-Bzk15m61.js";
+import { Count as gt } from "./component/element/special/Count.js";
+import { DataFilter as Dt } from "./component/element/special/DataFilter.js";
+import { DelayedActions as yt, getReactionFunctionsToExecute as Ct } from "./component/element/special/DelayedActions.js";
+import { PageControls as Pt } from "./component/element/special/PageControls.js";
+import { Phantom as vt } from "./component/element/special/Phantom.js";
+import { ReactiveJsonBasicComponentWrapper as bt } from "./component/element/special/ReactiveJsonBasicComponentWrapper.js";
+import { jsx as y, jsxs as K, Fragment as Et } from "react/jsx-runtime";
+import { V as wt, d as nt, b as rt, A as xt } from "./TemplateSystem-kQJEKjik.js";
+import "./engine/EventDispatcherContext.js";
+import { EventDispatcherProvider as St } from "./engine/EventDispatcherProvider.js";
+import { GlobalDataContext as It } from "./engine/GlobalDataContext.js";
+import "./engine/PaginationContext.js";
+import { a as X } from "./httpRequestCommon-BFntjNdS.js";
+import { l as Ot } from "./lodash-CYNxjS-I.js";
+import { useReducer as Tt, useState as N, useRef as At, useEffect as H, useContext as at } from "react";
+import { r as kt } from "./dnd-kit-sortable-tree.esm-Cz1RJyIg.js";
+import { c as Nt } from "./index-BA09SSaJ.js";
+import { coreDataMappingComponents as Vt } from "./component/dataMapping/index.js";
+import { coreDataProcessorComponents as _t } from "./component/dataProcessor/index.js";
+import "./component/element/debug/VariablesDebug/VariablesDebug.js";
+import "./component/element/html/FolderSortableTree.js";
+import "./component/element/html/FormatNumeral.js";
+import "./component/element/html/LabelFromValue.js";
+import "./component/element/html/PreformattedMarkup.js";
+import "./component/element/html/SortableTreeItemCollapseButton.js";
+import { Switch as Jt } from "./component/element/special/Switch.js";
+import { coreReactionComponents as Mt } from "./component/reaction/index.js";
+import { mergeComponentCollections as zt } from "./engine/ComponentCollector.js";
+import { GlobalDataContextProvider as Gt } from "./engine/GlobalDataContextProvider.js";
+import Lt from "./engine/ParsingDebugDisplay/ParsingDebugDisplay.js";
+import { TemplateContext as it } from "./engine/TemplateContext.js";
+import { alterData as Rt } from "./engine/utility/alterData.js";
+import { applyDataMapping as $t } from "./engine/utility/dataMappingSystem.js";
+import { parseRjBuild as qt } from "./engine/utility/parseRjBuild.js";
+import { stringToBoolean as jt } from "./engine/utility/stringToBoolean.js";
+import { analyzeDataOverrideReferences as Kt } from "./engine/utility/analyzeDataOverrideReferences.js";
+import "./js-yaml-Bw0KO4XO.js";
+const ot = {
+  action: Nt,
+  dataMapping: Vt,
+  dataProcessor: _t,
+  element: Yt,
+  reaction: Mt
+}, Xt = ({
+  dataOverride: o,
+  dataFetchMethod: D,
+  dataUrl: C,
+  debugMode: p,
+  DebugModeContentWrapper: P,
+  DebugModeDataWrapper: E,
+  DebugModeRootWrapper: G,
+  headersForData: T,
+  headersForRjBuild: l,
+  maybeRawAppData: V,
+  maybeRawAppRjBuild: u,
+  plugins: _,
+  rjBuildFetchMethod: v,
+  rjBuildUrl: d,
+  upstreamUpdateCallbacks: A
+}) => {
+  const m = [];
+  D && (m.push({
+    deprecatedProperty: "dataFetchMethod",
+    newProperty: "rjBuildFetchMethod"
+  }), v = D), C && (m.push({
+    deprecatedProperty: "dataUrl",
+    newProperty: "rjBuildUrl"
+  }), d = C), T && (m.push({
+    deprecatedProperty: "headersForData",
+    newProperty: "headersForRjBuild"
+  }), l = T), V && (m.push({
+    deprecatedProperty: "maybeRawAppData",
+    newProperty: "maybeRawAppRjBuild"
+  }), u = V), m.length > 0 && console.warn(
+    "A ReactiveJsonRoot component got the following deprecated properties that must be replaced: " + m.map((t) => t.deprecatedProperty + " -> " + t.newProperty).join(", ")
+  );
+  const [w, x] = Tt(
+    (t, a) => {
+      switch (a.type) {
+        case "setData":
+          return { updateId: 0, realCurrentData: a.data };
+        case "updateData":
+          return mt(t, a.path, a.value, a.updateMode);
+        default:
+          return t;
+      }
+    },
+    { updateId: 0, realCurrentData: {} }
+  ), [st, ct] = N({}), [lt, Q] = N({}), [pt, Y] = N([]), [J, L] = N(() => {
+    if (u)
+      return typeof u == "string" ? u : JSON.stringify(u);
+  }), [R, Z] = N(null), i = At(null);
+  H(() => () => {
+    typeof document < "u" && i.current && i.current.parentNode && (i.current.parentNode.removeChild(i.current), i.current = null);
+  }, []);
+  const M = _ ? zt([ot, _]) : ot;
+  H(() => {
+    d && (typeof v == "string" && v.toLowerCase() === "post" ? X.post(d, {
+      headers: l
+    }).then((t) => {
+      L(t.data);
+    }) : X.get(d, {
+      headers: l
+    }).then((t) => {
+      L(t.data);
+    }));
+  }, [d, l]), H(() => {
+    if (!J)
+      return;
+    const t = qt(J);
+    if (!t.success) {
+      if (console.group(
+        `Tried to load the app's RjBuild but the ${t.format} content could not be parsed.`
+      ), console.error(t.error.message), console.debug("Context:", {
+        rjBuildUrl: d,
+        rjBuildFetchMethod: v,
+        headersForRjBuild: l,
+        maybeRawAppRjBuild: u,
+        dataOverride: o
+      }), console.debug("Error details:", t.error), console.groupEnd(), typeof document < "u") {
+        let e = document.getElementById("rj-parsing-error-root");
+        if (e || (e = document.createElement("div"), e.id = "rj-parsing-error-root", document.body.appendChild(e)), !i.current) {
+          const h = document.createElement("div");
+          e.appendChild(h), i.current = h;
+        }
+        Z(
+          kt.createPortal(
+            /* @__PURE__ */ y(
+              Lt,
+              {
+                processedRjBuild: t,
+                errorContext: {
+                  rjBuildUrl: d,
+                  rjBuildFetchMethod: v,
+                  headersForRjBuild: l,
+                  maybeRawAppRjBuild: u
+                }
+              }
+            ),
+            i.current,
+            () => {
+              i.current && (i.current.parentNode.removeChild(i.current), i.current = null);
+            }
+          )
+        );
+      }
+      return;
+    }
+    R && (Z(null), typeof document < "u" && i.current && i.current.parentNode && (i.current.parentNode.removeChild(i.current), i.current = null));
+    const a = t.data;
+    ct(a.templates ?? a.listForms), !a.templates && a.listForms && console.log(
+      "'listForms' needs to be renamed to 'templates'. The support for 'listForms' will be removed in the next releases of reactive-json."
+    );
+    let c = o === void 0 ? a.data : o;
+    const s = a.additionalDataSource;
+    if (!Array.isArray(s) || s.length === 0) {
+      x({ type: "setData", data: c }), Q(a.renderView), Y(Object.keys(a.renderView));
+      return;
+    }
+    const b = {
+      headersForRjBuild: l,
+      templateData: c,
+      templatePath: "data",
+      setData: F,
+      updateData: W
+    }, r = {
+      templateData: c,
+      templatePath: "data"
+    }, f = s.filter((e) => e.blocking === !0), k = s.filter((e) => e.blocking !== !0), n = async (e, h) => {
+      var S;
+      try {
+        if (!e.src) {
+          console.warn("additionalDataSource item number " + h + " missing 'src' property.", e);
+          return;
+        }
+        const I = {
+          method: ((S = e.method) == null ? void 0 : S.toUpperCase()) || "GET",
+          url: e.src
+        };
+        l && Object.keys(l).length > 0 && (I.headers = l);
+        const z = await X(I), ut = {
+          url: I.url,
+          method: I.method,
+          headers: I.headers || {},
+          body: I.data
+        }, dt = {
+          headers: z.headers || {},
+          status: z.status,
+          data: z.data
+        }, O = Rt({
+          requestContext: ut,
+          responseContext: dt,
+          responseBody: z.data,
+          // additionalDataSource always processes raw data, not RjBuild.
+          isRjBuild: !1,
+          dataProcessors: (M == null ? void 0 : M.dataProcessor) || {}
+        });
+        if (e.dataMapping)
+          try {
+            $t({
+              dataMapping: e.dataMapping,
+              responseData: O,
+              globalDataContext: b,
+              templateContext: r
+            });
+            return;
+          } catch (g) {
+            console.error("Error applying dataMapping for additionalDataSource:", g);
+          }
+        if (!e.path) {
+          if (typeof O != "object" || Array.isArray(O)) {
+            console.warn(
+              "additionalDataSource data cannot be merged at root - must be an object:",
+              O
+            );
+            return;
+          }
+          Object.entries(O).forEach(([g, j]) => {
+            x({
+              type: "updateData",
+              path: g,
+              value: j
+            });
+          });
+          return;
+        }
+        try {
+          const g = nt({
+            dataLocation: e.path,
+            currentPath: "data",
+            globalDataContext: b,
+            templateContext: r
+          });
+          if (typeof g != "string") {
+            console.warn(
+              "additionalDataSource path evaluation did not result in a string:",
+              e.path,
+              "->",
+              g
+            );
+            return;
+          }
+          const j = g.substring(5);
+          x({
+            type: "updateData",
+            path: j,
+            value: O
+          });
+        } catch (g) {
+          console.error("Error evaluating additionalDataSource path:", e.path, g);
+        }
+      } catch (et) {
+        console.error("Error fetching additional data source:", e.src, et);
+      }
+    };
+    x({ type: "setData", data: c }), (async () => {
+      if (f.length > 0) {
+        const e = f.map((h, S) => n(h, S));
+        await Promise.allSettled(e).catch((h) => {
+          console.error("Error processing blocking additionalDataSource:", h);
+        });
+      }
+      if (Q(a.renderView), Y(Object.keys(a.renderView)), k.length > 0) {
+        const e = k.map(
+          (h, S) => n(h, f.length + S)
+        );
+        Promise.allSettled(e);
+      }
+    })();
+  }, [J, o, l]);
+  function U(t, a, c) {
+    if (!A || A.size === 0)
+      return !1;
+    for (const [s, b] of A)
+      if (t === s || t.startsWith(s + ".") || s === "") {
+        const r = s === "" ? t : t.substring(s.length + 1);
+        try {
+          return b(a, r, c), !0;
+        } catch (f) {
+          console.warn("Error during upstream update:", f);
+          break;
+        }
+      }
+    return !1;
+  }
+  function W(t, a, c = void 0) {
+    let s = a.replace("data.", "");
+    U(s, t, c) || x({
+      type: "updateData",
+      path: s,
+      value: t,
+      updateMode: c
+    });
+  }
+  function F(t) {
+    U("", t, void 0) || x({
+      type: "setData",
+      data: t
+    });
+  }
+  function mt(t, a, c, s = void 0) {
+    const b = a.split(".");
+    (typeof t.realCurrentData != "object" || t.realCurrentData === null || Array.isArray(t.realCurrentData)) && (t.realCurrentData = {});
+    let r = t.realCurrentData;
+    for (let f = 0, k = b.length; f < k; f++) {
+      const n = b[f];
+      if (f === k - 1) {
+        if (s === "remove" && Array.isArray(r))
+          r.splice(n, 1);
+        else if (s === "move")
+          if (c.increment) {
+            if (!Array.isArray(r))
+              return t;
+            const q = Math.min(
+              r.length,
+              Math.max(0, parseInt(n) + parseInt(c.increment))
+            );
+            if (q === parseInt(n))
+              return t;
+            const e = r.splice(n, 1);
+            if (e.length < 1)
+              return t;
+            r.splice(q, 0, e[0]);
+          } else
+            return t;
+        else if (c === void 0)
+          delete r[n];
+        else {
+          if (Ot.isEqual(c, r[n]))
+            return t;
+          s === "add" ? (r[n] === void 0 && (r[n] = []), r[n].push(c)) : r[n] = c;
+        }
+        return {
+          // Using modulo in case of massive update counts in long frontend sessions.
+          updateId: (t.updateId ?? 0) % (Number.MAX_SAFE_INTEGER - 1) + 1,
+          realCurrentData: t.realCurrentData
+        };
+      }
+      if (r.hasOwnProperty(n)) {
+        (typeof r[n] != "object" || r[n] === null) && (r[n] = {}), r = r[n];
+        continue;
+      }
+      r[n] = {}, r = r[n];
+    }
+    throw new Error("Could not update data.");
+  }
+  if (!J)
+    return null;
+  const B = pt.map((t) => {
+    var a;
+    return /* @__PURE__ */ y(
+      wt,
+      {
+        datafield: t,
+        props: lt[t],
+        path: "data." + t,
+        currentData: (a = w.realCurrentData) == null ? void 0 : a[t]
+      },
+      t
+    );
+  }), $ = jt(p), tt = /* @__PURE__ */ y(St, { children: /* @__PURE__ */ K(
+    Gt,
+    {
+      value: {
+        element: st,
+        headersForRjBuild: l,
+        plugins: M,
+        setData: F,
+        setRawAppRjBuild: L,
+        templateData: w.realCurrentData,
+        templatePath: "data",
+        updateData: W
+      },
+      children: [
+        /* @__PURE__ */ y(
+          it.Provider,
+          {
+            value: {
+              templateData: w.realCurrentData,
+              templatePath: "data"
+            },
+            children: $ && P ? /* @__PURE__ */ y(P, { children: B }) : B
+          }
+        ),
+        $ ? E && /* @__PURE__ */ y(E, { children: JSON.stringify(w.realCurrentData, null, "  ") }) : null
+      ]
+    }
+  ) });
+  return $ && P ? /* @__PURE__ */ K(G, { children: [
+    tt,
+    R
+  ] }) : /* @__PURE__ */ K(Et, { children: [
+    tt,
+    R
+  ] });
+}, Ht = ({ props: o }) => {
+  var T;
+  const D = at(It), C = at(it), p = rt({
+    valueToEvaluate: o == null ? void 0 : o.rjOptions,
+    globalDataContext: D,
+    templateContext: C
+  }) || {};
+  if (typeof p != "object")
+    return;
+  let P;
+  if ((o == null ? void 0 : o.sharedUpdates) === !0 && ((T = o == null ? void 0 : o.rjOptions) != null && T.dataOverride)) {
+    const l = Kt(o.rjOptions.dataOverride);
+    if (l.size > 0) {
+      P = /* @__PURE__ */ new Map();
+      for (const [V, u] of l) {
+        const _ = (v, d, A) => {
+          try {
+            const m = nt({
+              dataLocation: u,
+              currentPath: C.templatePath,
+              globalDataContext: D,
+              templateContext: C
+            }), w = d ? `${m}.${d}` : m;
+            D.updateData(v, w, A);
+          } catch (m) {
+            console.warn(`Error during upstream propagation for ${u}:`, m);
+          }
+        };
+        P.set(V, _);
+      }
+    }
+  }
+  const E = Number.isInteger(parseInt(o == null ? void 0 : o.dataOverrideEvaluationDepth)) ? parseInt(o == null ? void 0 : o.dataOverrideEvaluationDepth) : 10;
+  p != null && p.dataOverride && Number.isInteger(E) && E !== 0 && (p.dataOverride = rt({
+    valueToEvaluate: p == null ? void 0 : p.dataOverride,
+    globalDataContext: D,
+    templateContext: C,
+    evaluationDepth: E
+  }) || {});
+  const G = D.plugins ?? {};
+  return /* @__PURE__ */ y(xt, { ...o, children: /* @__PURE__ */ y(Xt, { ...p, plugins: G, upstreamUpdateCallbacks: P }) });
+}, Qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Count: gt,
+  DataFilter: Dt,
+  DelayedActions: yt,
+  PageControls: Pt,
+  Phantom: vt,
+  ReactiveJsonBasicComponentWrapper: bt,
+  ReactiveJsonSubroot: Ht,
+  Switch: Jt,
+  getReactionFunctionsToExecute: Ct
+}, Symbol.toStringTag, { value: "Module" })), Yt = {
+  ...ft,
+  ...ht,
+  ...Qt
+};
+export {
+  Ht as R,
+  Xt as a,
+  ot as b,
+  Yt as c
+};