@ea-lab/reactive-json 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/engine/ReactiveJsonRoot.js

@@ -1,20 +1,375 @@
-import "react/jsx-runtime";
-import "../httpRequestCommon-DUo2Oxgl.js";
-import "../lodash-CYNxjS-I.js";
-import "react";
-import "../dnd-kit-sortable-tree.esm-Cz1RJyIg.js";
-import { a as g } from "../index-CBEHeXej.js";
-import "./ComponentCollector.js";
-import "./EventDispatcherProvider.js";
-import "./GlobalDataContextProvider.js";
-import "./ParsingDebugDisplay/ParsingDebugDisplay.js";
-import "./TemplateContext.js";
-import "./TemplateSystem.js";
-import "./utility/alterData.js";
-import "./utility/dataMappingSystem.js";
-import "./utility/parseRjBuild.js";
-import "./utility/stringToBoolean.js";
-import "./View.js";
+import { jsx as C, jsxs as L, Fragment as pt } from "react/jsx-runtime";
+import { a as _ } from "../httpRequestCommon-DUo2Oxgl.js";
+import { l as ut } from "../lodash-CYNxjS-I.js";
+import { useReducer as dt, useState as v, useRef as ft, useEffect as q } from "react";
+import { r as mt } from "../dnd-kit-sortable-tree.esm-Cz1RJyIg.js";
+import { coreComponentsPlugin as tt } from "../coreComponentsPlugin.js";
+import { mergeComponentCollections as ht } from "./ComponentCollector.js";
+import { EventDispatcherProvider as gt } from "./EventDispatcherProvider.js";
+import { GlobalDataContextProvider as yt } from "./GlobalDataContextProvider.js";
+import Dt from "./ParsingDebugDisplay/ParsingDebugDisplay.js";
+import { TemplateContext as Pt } from "./TemplateContext.js";
+import { dataLocationToPath as Ct } from "./TemplateSystem.js";
+import { alterData as bt } from "./utility/alterData.js";
+import { applyDataMapping as Et } from "./utility/dataMappingSystem.js";
+import { parseRjBuild as vt } from "./utility/parseRjBuild.js";
+import { stringToBoolean as wt } from "./utility/stringToBoolean.js";
+import { View as St } from "./View.js";
+const xt = ({
+  dataOverride: w,
+  dataFetchMethod: M,
+  dataUrl: z,
+  debugMode: et,
+  DebugModeContentWrapper: A,
+  DebugModeDataWrapper: K,
+  DebugModeRootWrapper: rt,
+  headersForData: X,
+  headersForRjBuild: c,
+  maybeRawAppData: $,
+  maybeRawAppRjBuild: d,
+  plugins: H,
+  rjBuildFetchMethod: b,
+  rjBuildUrl: f,
+  upstreamUpdateCallbacks: N
+}) => {
+  const h = [];
+  M && (h.push({
+    deprecatedProperty: "dataFetchMethod",
+    newProperty: "rjBuildFetchMethod"
+  }), b = M), z && (h.push({
+    deprecatedProperty: "dataUrl",
+    newProperty: "rjBuildUrl"
+  }), f = z), X && (h.push({
+    deprecatedProperty: "headersForData",
+    newProperty: "headersForRjBuild"
+  }), c = X), $ && (h.push({
+    deprecatedProperty: "maybeRawAppData",
+    newProperty: "maybeRawAppRjBuild"
+  }), d = $), h.length > 0 && console.warn(
+    "A ReactiveJsonRoot component got the following deprecated properties that must be replaced: " + h.map((t) => t.deprecatedProperty + " -> " + t.newProperty).join(", ")
+  );
+  const [S, g] = dt(
+    (t, a) => {
+      switch (a.type) {
+        case "setData":
+          return { updateId: 0, realCurrentData: a.data };
+        case "updateData":
+          return it(t, a.path, a.value, a.updateMode);
+        default:
+          return t;
+      }
+    },
+    { updateId: 0, realCurrentData: {} }
+  ), [at, ot] = v({}), [nt, Q] = v({}), [st, Y] = v([]), [x, T] = v(() => {
+    if (d)
+      return typeof d == "string" ? d : JSON.stringify(d);
+  }), [V, Z] = v(null), n = ft(null);
+  q(() => () => {
+    typeof document < "u" && n.current && n.current.parentNode && (n.current.parentNode.removeChild(n.current), n.current = null);
+  }, []);
+  const I = H ? ht([tt, H]) : tt;
+  q(() => {
+    f && (typeof b == "string" && b.toLowerCase() === "post" ? _.post(f, {
+      headers: c
+    }).then((t) => {
+      T(t.data);
+    }) : _.get(f, {
+      headers: c
+    }).then((t) => {
+      T(t.data);
+    }));
+  }, [f, c]), q(() => {
+    if (!x)
+      return;
+    const t = vt(x);
+    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: f,
+        rjBuildFetchMethod: b,
+        headersForRjBuild: c,
+        maybeRawAppRjBuild: d,
+        dataOverride: w
+      }), 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)), !n.current) {
+          const p = document.createElement("div");
+          e.appendChild(p), n.current = p;
+        }
+        Z(
+          mt.createPortal(
+            /* @__PURE__ */ C(
+              Dt,
+              {
+                processedRjBuild: t,
+                errorContext: {
+                  rjBuildUrl: f,
+                  rjBuildFetchMethod: b,
+                  headersForRjBuild: c,
+                  maybeRawAppRjBuild: d
+                }
+              }
+            ),
+            n.current,
+            () => {
+              n.current && (n.current.parentNode.removeChild(n.current), n.current = null);
+            }
+          )
+        );
+      }
+      return;
+    }
+    V && (Z(null), typeof document < "u" && n.current && n.current.parentNode && (n.current.parentNode.removeChild(n.current), n.current = null));
+    const a = t.data;
+    ot(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 i = w === void 0 ? a.data : w;
+    const s = a.additionalDataSource;
+    if (!Array.isArray(s) || s.length === 0) {
+      g({ type: "setData", data: i }), Q(a.renderView), Y(Object.keys(a.renderView));
+      return;
+    }
+    const m = {
+      headersForRjBuild: c,
+      templateData: i,
+      templatePath: "data",
+      setData: R,
+      updateData: W
+    }, r = {
+      templateData: i,
+      templatePath: "data"
+    }, l = s.filter((e) => e.blocking === !0), E = s.filter((e) => e.blocking !== !0), o = async (e, p) => {
+      var y;
+      try {
+        if (!e.src) {
+          console.warn("additionalDataSource item number " + p + " missing 'src' property.", e);
+          return;
+        }
+        const D = {
+          method: ((y = e.method) == null ? void 0 : y.toUpperCase()) || "GET",
+          url: e.src
+        };
+        c && Object.keys(c).length > 0 && (D.headers = c);
+        const k = await _(D), ct = {
+          url: D.url,
+          method: D.method,
+          headers: D.headers || {},
+          body: D.data
+        }, lt = {
+          headers: k.headers || {},
+          status: k.status,
+          data: k.data
+        }, P = bt({
+          requestContext: ct,
+          responseContext: lt,
+          responseBody: k.data,
+          // additionalDataSource always processes raw data, not RjBuild.
+          isRjBuild: !1,
+          dataProcessors: (I == null ? void 0 : I.dataProcessor) || {}
+        });
+        if (e.dataMapping)
+          try {
+            Et({
+              dataMapping: e.dataMapping,
+              responseData: P,
+              globalDataContext: m,
+              templateContext: r
+            });
+            return;
+          } catch (u) {
+            console.error("Error applying dataMapping for additionalDataSource:", u);
+          }
+        if (!e.path) {
+          if (typeof P != "object" || Array.isArray(P)) {
+            console.warn(
+              "additionalDataSource data cannot be merged at root - must be an object:",
+              P
+            );
+            return;
+          }
+          Object.entries(P).forEach(([u, G]) => {
+            g({
+              type: "updateData",
+              path: u,
+              value: G
+            });
+          });
+          return;
+        }
+        try {
+          const u = Ct({
+            dataLocation: e.path,
+            currentPath: "data",
+            globalDataContext: m,
+            templateContext: r
+          });
+          if (typeof u != "string") {
+            console.warn(
+              "additionalDataSource path evaluation did not result in a string:",
+              e.path,
+              "->",
+              u
+            );
+            return;
+          }
+          const G = u.substring(5);
+          g({
+            type: "updateData",
+            path: G,
+            value: P
+          });
+        } catch (u) {
+          console.error("Error evaluating additionalDataSource path:", e.path, u);
+        }
+      } catch (B) {
+        console.error("Error fetching additional data source:", e.src, B);
+      }
+    };
+    g({ type: "setData", data: i }), (async () => {
+      if (l.length > 0) {
+        const e = l.map((p, y) => o(p, y));
+        await Promise.allSettled(e).catch((p) => {
+          console.error("Error processing blocking additionalDataSource:", p);
+        });
+      }
+      if (Q(a.renderView), Y(Object.keys(a.renderView)), E.length > 0) {
+        const e = E.map(
+          (p, y) => o(p, l.length + y)
+        );
+        Promise.allSettled(e);
+      }
+    })();
+  }, [x, w, c]);
+  function j(t, a, i) {
+    if (!N || N.size === 0)
+      return !1;
+    for (const [s, m] of N)
+      if (t === s || t.startsWith(s + ".") || s === "") {
+        const r = s === "" ? t : t.substring(s.length + 1);
+        try {
+          return m(a, r, i), !0;
+        } catch (l) {
+          console.warn("Error during upstream update:", l);
+          break;
+        }
+      }
+    return !1;
+  }
+  function W(t, a, i = void 0) {
+    let s = a.replace("data.", "");
+    j(s, t, i) || g({
+      type: "updateData",
+      path: s,
+      value: t,
+      updateMode: i
+    });
+  }
+  function R(t) {
+    j("", t, void 0) || g({
+      type: "setData",
+      data: t
+    });
+  }
+  function it(t, a, i, s = void 0) {
+    const m = a.split(".");
+    (typeof t.realCurrentData != "object" || t.realCurrentData === null || Array.isArray(t.realCurrentData)) && (t.realCurrentData = {});
+    let r = t.realCurrentData;
+    for (let l = 0, E = m.length; l < E; l++) {
+      const o = m[l];
+      if (l === E - 1) {
+        if (s === "remove" && Array.isArray(r))
+          r.splice(o, 1);
+        else if (s === "move")
+          if (i.increment) {
+            if (!Array.isArray(r))
+              return t;
+            const J = Math.min(
+              r.length,
+              Math.max(0, parseInt(o) + parseInt(i.increment))
+            );
+            if (J === parseInt(o))
+              return t;
+            const e = r.splice(o, 1);
+            if (e.length < 1)
+              return t;
+            r.splice(J, 0, e[0]);
+          } else
+            return t;
+        else if (i === void 0)
+          delete r[o];
+        else {
+          if (ut.isEqual(i, r[o]))
+            return t;
+          s === "add" ? (r[o] === void 0 && (r[o] = []), r[o].push(i)) : r[o] = i;
+        }
+        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(o)) {
+        (typeof r[o] != "object" || r[o] === null) && (r[o] = {}), r = r[o];
+        continue;
+      }
+      r[o] = {}, r = r[o];
+    }
+    throw new Error("Could not update data.");
+  }
+  if (!x)
+    return null;
+  const U = st.map((t) => {
+    var a;
+    return /* @__PURE__ */ C(
+      St,
+      {
+        datafield: t,
+        props: nt[t],
+        path: "data." + t,
+        currentData: (a = S.realCurrentData) == null ? void 0 : a[t]
+      },
+      t
+    );
+  }), O = wt(et), F = /* @__PURE__ */ C(gt, { children: /* @__PURE__ */ L(
+    yt,
+    {
+      value: {
+        element: at,
+        headersForRjBuild: c,
+        plugins: I,
+        // Expose the root component to avoid import cycles in core plugins.
+        ReactiveJsonRoot: xt,
+        setData: R,
+        setRawAppRjBuild: T,
+        templateData: S.realCurrentData,
+        templatePath: "data",
+        updateData: W
+      },
+      children: [
+        /* @__PURE__ */ C(
+          Pt.Provider,
+          {
+            value: {
+              templateData: S.realCurrentData,
+              templatePath: "data"
+            },
+            children: O && A ? /* @__PURE__ */ C(A, { children: U }) : U
+          }
+        ),
+        O ? K && /* @__PURE__ */ C(K, { children: JSON.stringify(S.realCurrentData, null, "  ") }) : null
+      ]
+    }
+  ) });
+  return O && A ? /* @__PURE__ */ L(rt, { children: [
+    F,
+    V
+  ] }) : /* @__PURE__ */ L(pt, { children: [
+    F,
+    V
+  ] });
+};
 export {
-  g as ReactiveJsonRoot
+  xt as ReactiveJsonRoot
 };

package/dist/engine/index.js

@@ -2,46 +2,48 @@ import { ActionDependant as o, isValid as r } from "./Actions.js";
 import { mergeComponentCollections as p } from "./ComponentCollector.js";
 import { EventDispatcherContext as m } from "./EventDispatcherContext.js";
 import { EventDispatcherProvider as l, addEventListener as x, removeEventListener as f } from "./EventDispatcherProvider.js";
-import { GlobalDataContext as v } from "./GlobalDataContext.js";
+import { GlobalDataContext as u } from "./GlobalDataContext.js";
 import { GlobalDataContextProvider as d } from "./GlobalDataContextProvider.js";
-import { PaginationContext as C } from "./PaginationContext.js";
-import { a as b } from "../index-CBEHeXej.js";
-import { TemplateContext as T } from "./TemplateContext.js";
-import { dataLocationToPath as R, evaluateAttributes as V, evaluateTemplateValue as A, evaluateTemplateValueCollection as P, isTemplateValue as h, useEvaluatedAttributes as y } from "./TemplateSystem.js";
+import { PaginationContext as D } from "./PaginationContext.js";
+import { ReactiveJsonRoot as T } from "./ReactiveJsonRoot.js";
+import { TemplateContext as g } from "./TemplateContext.js";
+import { dataLocationToPath as A, evaluateAttributes as E, evaluateTemplateValue as P, evaluateTemplateValueCollection as R, isTemplateValue as h, useEvaluatedAttributes as L } from "./TemplateSystem.js";
 import { alterData as z } from "./utility/alterData.js";
 import { analyzeDataOverrideReferences as F } from "./utility/analyzeDataOverrideReferences.js";
 import { applyDataMapping as J } from "./utility/dataMappingSystem.js";
 import { formatString as j, maybeFormatString as w } from "./utility/formatString.js";
-import { parseRjBuild as O } from "./utility/parseRjBuild.js";
-import { normalizeAttributesForReactJsx as q } from "./utility/reactJsxHelpers.js";
-import { stringToBoolean as I } from "./utility/stringToBoolean.js";
-import { View as N } from "./View.js";
+import { propsDataLocationToPathAndValue as O } from "./utility/formElementsCommon.js";
+import { parseRjBuild as q } from "./utility/parseRjBuild.js";
+import { normalizeAttributesForReactJsx as I } from "./utility/reactJsxHelpers.js";
+import { stringToBoolean as N } from "./utility/stringToBoolean.js";
+import { View as U } from "./View.js";
 export {
   o as ActionDependant,
   m as EventDispatcherContext,
   l as EventDispatcherProvider,
-  v as GlobalDataContext,
+  u as GlobalDataContext,
   d as GlobalDataContextProvider,
-  C as PaginationContext,
-  b as ReactiveJsonRoot,
-  T as TemplateContext,
-  N as View,
+  D as PaginationContext,
+  T as ReactiveJsonRoot,
+  g as TemplateContext,
+  U as View,
   x as addEventListener,
   z as alterData,
   F as analyzeDataOverrideReferences,
   J as applyDataMapping,
-  R as dataLocationToPath,
-  V as evaluateAttributes,
-  A as evaluateTemplateValue,
-  P as evaluateTemplateValueCollection,
+  A as dataLocationToPath,
+  E as evaluateAttributes,
+  P as evaluateTemplateValue,
+  R as evaluateTemplateValueCollection,
   j as formatString,
   h as isTemplateValue,
   r as isValid,
   w as maybeFormatString,
   p as mergeComponentCollections,
-  q as normalizeAttributesForReactJsx,
-  O as parseRjBuild,
+  I as normalizeAttributesForReactJsx,
+  q as parseRjBuild,
+  O as propsDataLocationToPathAndValue,
   f as removeEventListener,
-  I as stringToBoolean,
-  y as useEvaluatedAttributes
+  N as stringToBoolean,
+  L as useEvaluatedAttributes
 };

package/dist/engine/utility/index.js

@@ -1,17 +1,19 @@
-import { alterData as o } from "./alterData.js";
-import { analyzeDataOverrideReferences as a } from "./analyzeDataOverrideReferences.js";
+import { alterData as t } from "./alterData.js";
+import { analyzeDataOverrideReferences as e } from "./analyzeDataOverrideReferences.js";
 import { applyDataMapping as m } from "./dataMappingSystem.js";
-import { formatString as i, maybeFormatString as n } from "./formatString.js";
-import { parseRjBuild as l } from "./parseRjBuild.js";
-import { normalizeAttributesForReactJsx as g } from "./reactJsxHelpers.js";
-import { stringToBoolean as D } from "./stringToBoolean.js";
+import { formatString as n, maybeFormatString as i } from "./formatString.js";
+import { propsDataLocationToPathAndValue as l } from "./formElementsCommon.js";
+import { parseRjBuild as g } from "./parseRjBuild.js";
+import { normalizeAttributesForReactJsx as c } from "./reactJsxHelpers.js";
+import { stringToBoolean as u } from "./stringToBoolean.js";
 export {
-  o as alterData,
-  a as analyzeDataOverrideReferences,
+  t as alterData,
+  e as analyzeDataOverrideReferences,
   m as applyDataMapping,
-  i as formatString,
-  n as maybeFormatString,
-  g as normalizeAttributesForReactJsx,
-  l as parseRjBuild,
-  D as stringToBoolean
+  n as formatString,
+  i as maybeFormatString,
+  c as normalizeAttributesForReactJsx,
+  g as parseRjBuild,
+  l as propsDataLocationToPathAndValue,
+  u as stringToBoolean
 };

package/dist/index-Ya6_R5yr.js

@@ -0,0 +1,23 @@
+import { Count as o } from "./component/element/special/Count.js";
+import { DataFilter as t } from "./component/element/special/DataFilter.js";
+import { DelayedActions as e, getReactionFunctionsToExecute as r } from "./component/element/special/DelayedActions.js";
+import { PageControls as m } from "./component/element/special/PageControls.js";
+import { Phantom as i } from "./component/element/special/Phantom.js";
+import { ReactiveJsonBasicComponentWrapper as n } from "./component/element/special/ReactiveJsonBasicComponentWrapper.js";
+import { ReactiveJsonSubroot as p } from "./component/element/special/ReactiveJsonSubroot.js";
+import { Switch as a } from "./component/element/special/Switch.js";
+const S = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Count: o,
+  DataFilter: t,
+  DelayedActions: e,
+  PageControls: m,
+  Phantom: i,
+  ReactiveJsonBasicComponentWrapper: n,
+  ReactiveJsonSubroot: p,
+  Switch: a,
+  getReactionFunctionsToExecute: r
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  S as s
+};