@gxp-dev/mod-ui 2.0.0

package/dist/definitions/shared/validation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Validation contract used by every input-bearing element.
+ *
+ * Two layered shapes are supported:
+ *   - `rules`: Laravel-style rule strings ("required", "min:3", "email").
+ *     These are translated to the runtime validator inside the engine.
+ *   - `messages`: optional per-rule overrides keyed by rule name.
+ */
+export type ValidationRule = "required" | "nullable" | "email" | "url" | "uuid" | "alpha" | "alpha_num" | "alpha_dash" | "numeric" | "integer" | "boolean" | "json" | "date" | "after" | "before" | "confirmed" | "different" | "same" | "unique" | "exists" | `min:${number}` | `max:${number}` | `between:${number},${number}` | `size:${number}` | `gt:${number}` | `gte:${number}` | `lt:${number}` | `lte:${number}` | `regex:${string}` | `in:${string}` | `not_in:${string}` | (string & {});
+export interface ValidationConfig {
+    rules?: ValidationRule[];
+    messages?: Record<string, string>;
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/definitions/shared/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB,UAAU,GACV,UAAU,GACV,OAAO,GACP,KAAK,GACL,MAAM,GACN,OAAO,GACP,WAAW,GACX,YAAY,GACZ,SAAS,GACT,SAAS,GACT,SAAS,GACT,MAAM,GACN,MAAM,GACN,OAAO,GACP,QAAQ,GACR,WAAW,GACX,WAAW,GACX,MAAM,GACN,QAAQ,GACR,QAAQ,GAGR,OAAO,MAAM,EAAE,GACf,OAAO,MAAM,EAAE,GACf,WAAW,MAAM,IAAI,MAAM,EAAE,GAC7B,QAAQ,MAAM,EAAE,GAChB,MAAM,MAAM,EAAE,GACd,OAAO,MAAM,EAAE,GACf,MAAM,MAAM,EAAE,GACd,OAAO,MAAM,EAAE,GACf,SAAS,MAAM,EAAE,GACjB,MAAM,MAAM,EAAE,GACd,UAAU,MAAM,EAAE,GAElB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEjB,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,cAAc,EAAE,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC"}

package/dist/engine/CardRenderer.vue.d.ts

@@ -0,0 +1,20 @@
+import { CardElement } from '../definitions/elements';
+import { DisplayCard } from '../definitions/cards';
+import { EvaluationContext } from './useDisplayConditions';
+interface Props {
+    card: DisplayCard;
+    item?: Record<string, unknown>;
+    /** Page-level element registry: id → CardElement JSON. */
+    elements?: Record<string, CardElement>;
+    /** Page-level card registry: id → DisplayCard JSON (for nested cards). */
+    cards?: Record<string, DisplayCard>;
+    evaluationContext?: EvaluationContext;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    cards: Record<string, DisplayCard>;
+    elements: Record<string, CardElement>;
+    item: Record<string, unknown>;
+    evaluationContext: EvaluationContext;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=CardRenderer.vue.d.ts.map

package/dist/engine/CardRenderer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CardRenderer.vue.d.ts","sourceRoot":"","sources":["../../src/engine/CardRenderer.vue"],"names":[],"mappings":"AA4PA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGtD,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,wBAAwB,CAAA;AAE/B,UAAU,KAAK;IACb,IAAI,EAAE,WAAW,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACtC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACnC,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;CACtC;;WAFS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;cAFxB,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;UAF/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;uBAKV,iBAAiB;;AA8OvC,wBAOG"}

package/dist/engine/CardRenderer.vue.js

@@ -0,0 +1,118 @@
+import { defineComponent as b, computed as d, openBlock as u, createElementBlock as h, normalizeClass as v, createBlock as A, resolveDynamicComponent as x, normalizeProps as k, guardReactiveProps as w, createCommentVNode as P } from "vue";
+import { cn as S } from "../lib/utils.js";
+import { getCardComponent as T } from "./useCardLoader.js";
+import { shouldRender as j } from "./useDisplayConditions.js";
+const I = ["data-card-id", "data-card-type"], M = /* @__PURE__ */ b({
+  __name: "CardRenderer",
+  props: {
+    card: {},
+    item: { default: () => ({}) },
+    elements: { default: () => ({}) },
+    cards: { default: () => ({}) },
+    evaluationContext: { default: () => ({}) }
+  },
+  setup(l) {
+    const e = l, f = d(
+      () => j(e.card, e.item, e.evaluationContext)
+    ), p = d(() => T(e.card.cardType)), y = /* @__PURE__ */ new Set([
+      "cardType",
+      "conditionParams",
+      "conditionGroupLogic",
+      "condition",
+      "features",
+      "permissions",
+      "columns",
+      "columnsSm",
+      "columnsMd",
+      "columnsLg",
+      "columnsXl",
+      "columnsXxl",
+      "wrapperClassList",
+      "columnClassList",
+      "order",
+      // ID-referenced child lists — resolved below into concrete arrays.
+      "elementList",
+      "cardList",
+      "tabList",
+      "elementId"
+    ]), L = d(() => {
+      const t = e.card, n = {};
+      for (const [r, o] of Object.entries(t))
+        y.has(r) || (n[r] = o);
+      if (n.item = e.item, Array.isArray(t.elementList)) {
+        const r = t.elementList, o = [];
+        for (const c of r) {
+          const s = e.elements[c];
+          s && o.push(s);
+        }
+        n.elements = o;
+      }
+      if (Array.isArray(t.cardList)) {
+        const r = t.cardList, o = [];
+        for (const c of r) {
+          const s = e.cards[c];
+          s && o.push(s);
+        }
+        n.cards = o;
+      }
+      if (Array.isArray(t.tabList)) {
+        const r = t.tabList, o = [];
+        for (const c of r) {
+          const s = e.cards[c];
+          s && o.push(s);
+        }
+        n.tabs = o;
+      }
+      if (e.card.cardType === "grid-view" && typeof t.gridLayout == "object" && t.gridLayout !== null) {
+        const r = t.gridLayout, o = /* @__PURE__ */ new Set();
+        for (const c of Object.values(r))
+          if (Array.isArray(c)) {
+            for (const s of c)
+              if (s && typeof s == "object" && "i" in s) {
+                const m = s.i;
+                typeof m == "string" && e.elements[m] && o.add(m);
+              }
+          }
+        o.size > 0 && (n.gridElements = Array.from(o).map((c) => e.elements[c]).filter(Boolean));
+      }
+      const a = t.elementId;
+      if (typeof a == "string" && a.length > 0) {
+        const r = e.elements[a];
+        r && (n.element = r);
+      }
+      return n;
+    }), g = d(
+      () => S(
+        "gxp-card",
+        `gxp-card--${e.card.cardType}`,
+        i("col", e.card.columns),
+        i("col-sm", e.card.columnsSm),
+        i("col-md", e.card.columnsMd),
+        i("col-lg", e.card.columnsLg),
+        i("col-xl", e.card.columnsXl),
+        C(e.card.wrapperClassList)
+      )
+    );
+    function i(t, n) {
+      if (typeof n != "number")
+        return;
+      const a = Math.max(0, Math.min(12, n)) / 12;
+      return t === "col" ? `basis-[${(a * 100).toFixed(4)}%]` : `${t}:basis-[${(a * 100).toFixed(4)}%]`;
+    }
+    function C(t) {
+      return t ? Array.isArray(t) ? t.join(" ") : t : "";
+    }
+    return (t, n) => f.value ? (u(), h("div", {
+      key: 0,
+      class: v(g.value),
+      "data-card-id": l.card.id,
+      "data-card-type": l.card.cardType
+    }, [
+      (u(), A(x(p.value), k(w(L.value)), null, 16))
+    ], 10, I)) : P("", !0);
+  }
+});
+export {
+  M as default
+};
+//# sourceMappingURL=CardRenderer.vue.js.map

package/dist/engine/CardRenderer.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CardRenderer.vue.js","sources":["../../src/engine/CardRenderer.vue"],"sourcesContent":["<script setup lang=\"ts\">\n/**\n * Renders a single DisplayCard by dispatching its JSON definition into\n * the matching composition under `components/compositions/cards/`.\n *\n * The renderer is the bridge layer:\n *   - resolves the composition by `card.cardType` via the registry\n *   - evaluates the card's visibility (`shouldRender`)\n *   - applies responsive layout + classList chrome at the wrapper level\n *   - resolves ID-referenced child lists against the page-level\n *     `elements` / `cards` maps:\n *       - `card.elementList: string[]` → pass as `elements: CardElement[]`\n *       - `card.cardList: string[]`    → pass as `cards: DisplayCard[]`\n *       - `card.tabList: string[]`     → pass as `tabs: DisplayCard[]`\n *       - `card.elementId: string`     → pass as `element: CardElement`\n *   - strips schema-only keys (cardType, conditionParams, columns*, ...)\n *     and passes the rest through as Vue props\n *\n * Compositions don't know about the page-level maps or the JSON schema —\n * they receive resolved children + display props and emit normal Vue\n * events. They're directly mountable in any app.\n */\nimport { computed } from \"vue\"\nimport type { CardElement } from \"@/definitions/elements\"\nimport type { DisplayCard } from \"@/definitions/cards\"\nimport { cn } from \"@/lib/utils\"\nimport { getCardComponent } from \"./useCardLoader\"\nimport {\n  shouldRender,\n  type EvaluationContext,\n} from \"./useDisplayConditions\"\n\ninterface Props {\n  card: DisplayCard\n  item?: Record<string, unknown>\n  /** Page-level element registry: id → CardElement JSON. */\n  elements?: Record<string, CardElement>\n  /** Page-level card registry: id → DisplayCard JSON (for nested cards). */\n  cards?: Record<string, DisplayCard>\n  evaluationContext?: EvaluationContext\n}\n\nconst props = withDefaults(defineProps<Props>(), {\n  item: () => ({}),\n  elements: () => ({}),\n  cards: () => ({}),\n  evaluationContext: () => ({}),\n})\n\nconst visible = computed(() =>\n  shouldRender(props.card, props.item, props.evaluationContext),\n)\n\nconst resolved = computed(() => getCardComponent(props.card.cardType))\n\n/**\n * Keys that live on every DisplayCard and are NOT meant to flow\n * through to the composition as props. These are either consumed by\n * this renderer (`columns*`, `conditionParams`, `cardType`, ...) or\n * resolved into their concrete child arrays below.\n */\nconst STRIPPED_KEYS = new Set<string>([\n  \"cardType\",\n  \"conditionParams\",\n  \"conditionGroupLogic\",\n  \"condition\",\n  \"features\",\n  \"permissions\",\n  \"columns\",\n  \"columnsSm\",\n  \"columnsMd\",\n  \"columnsLg\",\n  \"columnsXl\",\n  \"columnsXxl\",\n  \"wrapperClassList\",\n  \"columnClassList\",\n  \"order\",\n  // ID-referenced child lists — resolved below into concrete arrays.\n  \"elementList\",\n  \"cardList\",\n  \"tabList\",\n  \"elementId\",\n])\n\n/**\n * Compute the props object to pass to the resolved composition.\n *\n * - Strips schema-only keys (`cardType`, `conditionParams`, ...).\n * - Resolves `elementList` / `cardList` / `tabList` / `elementId` against\n *   the page-level registries and exposes them as concrete arrays /\n *   objects under composition-facing prop names.\n * - Forwards `item` as-is for child renderers to use.\n */\nconst compositionProps = computed<Record<string, unknown>>(() => {\n  const c = props.card as unknown as Record<string, unknown>\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(c)) {\n    if (!STRIPPED_KEYS.has(key)) {\n      result[key] = value\n    }\n  }\n\n  // Pass through the data model.\n  result.item = props.item\n\n  // Resolve `elementList: string[]` → `elements: CardElement[]`.\n  if (Array.isArray((c as { elementList?: unknown }).elementList)) {\n    const ids = (c as { elementList: string[] }).elementList\n    const out: CardElement[] = []\n    for (const id of ids) {\n      const el = props.elements[id]\n      if (el) {\n        out.push(el)\n      }\n    }\n    result.elements = out\n  }\n\n  // Resolve `cardList: string[]` → `cards: DisplayCard[]`.\n  if (Array.isArray((c as { cardList?: unknown }).cardList)) {\n    const ids = (c as { cardList: string[] }).cardList\n    const out: DisplayCard[] = []\n    for (const id of ids) {\n      const child = props.cards[id]\n      if (child) {\n        out.push(child)\n      }\n    }\n    result.cards = out\n  }\n\n  // Resolve `tabList: string[]` → `tabs: DisplayCard[]`.\n  if (Array.isArray((c as { tabList?: unknown }).tabList)) {\n    const ids = (c as { tabList: string[] }).tabList\n    const out: DisplayCard[] = []\n    for (const id of ids) {\n      const child = props.cards[id]\n      if (child) {\n        out.push(child)\n      }\n    }\n    result.tabs = out\n  }\n\n  // For GridViewCard: resolve element refs that appear inside\n  // `gridLayout[breakpoint][n].i` against the page-level elements\n  // map. Card refs at the same position already work because the\n  // composition resolves them against `cards` (resolved above).\n  // Elements need a separate `gridElements` array on the composition.\n  if (\n    props.card.cardType === \"grid-view\" &&\n    typeof (c as { gridLayout?: unknown }).gridLayout === \"object\" &&\n    (c as { gridLayout?: unknown }).gridLayout !== null\n  ) {\n    const layout = (c as { gridLayout: Record<string, unknown> }).gridLayout\n    const elementIds = new Set<string>()\n    for (const breakpoint of Object.values(layout)) {\n      if (Array.isArray(breakpoint)) {\n        for (const item of breakpoint) {\n          if (item && typeof item === \"object\" && \"i\" in item) {\n            const id = (item as { i: unknown }).i\n            if (typeof id === \"string\" && props.elements[id]) {\n              elementIds.add(id)\n            }\n          }\n        }\n      }\n    }\n    if (elementIds.size > 0) {\n      result.gridElements = Array.from(elementIds)\n        .map((id) => props.elements[id]!)\n        .filter(Boolean)\n    }\n  }\n\n  // Resolve `elementId: string` → `element: CardElement`.\n  const elementId = (c as { elementId?: unknown }).elementId\n  if (typeof elementId === \"string\" && elementId.length > 0) {\n    const el = props.elements[elementId]\n    if (el) {\n      result.element = el\n    }\n  }\n\n  return result\n})\n\nconst wrapperClass = computed(() =>\n  cn(\n    \"gxp-card\",\n    `gxp-card--${props.card.cardType}`,\n    columnClass(\"col\", props.card.columns),\n    columnClass(\"col-sm\", props.card.columnsSm),\n    columnClass(\"col-md\", props.card.columnsMd),\n    columnClass(\"col-lg\", props.card.columnsLg),\n    columnClass(\"col-xl\", props.card.columnsXl),\n    normalizeClasses(props.card.wrapperClassList),\n  ),\n)\n\nfunction columnClass(prefix: string, n?: number): string | undefined {\n  if (typeof n !== \"number\") {\n    return undefined\n  }\n  const pct = Math.max(0, Math.min(12, n)) / 12\n  return prefix === \"col\"\n    ? `basis-[${(pct * 100).toFixed(4)}%]`\n    : `${prefix}:basis-[${(pct * 100).toFixed(4)}%]`\n}\n\nfunction normalizeClasses(value: string | string[] | undefined): string {\n  if (!value) {\n    return \"\"\n  }\n  return Array.isArray(value) ? value.join(\" \") : value\n}\n</script>\n\n<template>\n  <div\n    v-if=\"visible\"\n    :class=\"wrapperClass\"\n    :data-card-id=\"card.id\"\n    :data-card-type=\"card.cardType\"\n  >\n    <component :is=\"resolved\" v-bind=\"compositionProps\" />\n  </div>\n</template>\n"],"names":["props","__props","visible","computed","shouldRender","resolved","getCardComponent","STRIPPED_KEYS","compositionProps","c","result","key","value","ids","out","id","el","child","layout","elementIds","breakpoint","item","elementId","wrapperClass","cn","columnClass","normalizeClasses","prefix","pct","_createElementBlock","_createBlock","_resolveDynamicComponent","_normalizeProps","_guardReactiveProps"],"mappings":"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"}

package/dist/engine/CardRenderer.vue2.js

@@ -0,0 +1,5 @@
+import f from "./CardRenderer.vue.js";
+export {
+  f as default
+};
+//# sourceMappingURL=CardRenderer.vue2.js.map

package/dist/engine/CardRenderer.vue2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CardRenderer.vue2.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/engine/ElementRenderer.vue.d.ts

@@ -0,0 +1,13 @@
+import { CardElement } from '../definitions/elements';
+import { EvaluationContext } from './useDisplayConditions';
+interface Props {
+    element: CardElement;
+    item?: Record<string, unknown>;
+    evaluationContext?: EvaluationContext;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    item: Record<string, unknown>;
+    evaluationContext: EvaluationContext;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=ElementRenderer.vue.d.ts.map

package/dist/engine/ElementRenderer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementRenderer.vue.d.ts","sourceRoot":"","sources":["../../src/engine/ElementRenderer.vue"],"names":[],"mappings":"AAmMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAGzD,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,wBAAwB,CAAA;AAI/B,UAAU,KAAK;IACb,OAAO,EAAE,WAAW,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;CACtC;;UAFQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;uBACV,iBAAiB;;AAiMvC,wBAOG"}

package/dist/engine/ElementRenderer.vue.js

@@ -0,0 +1,83 @@
+import { defineComponent as L, computed as s, openBlock as p, createElementBlock as b, normalizeClass as h, createBlock as M, resolveDynamicComponent as k, mergeProps as w, createCommentVNode as E } from "vue";
+import { cn as P } from "../lib/utils.js";
+import { getElementComponent as S } from "./useElementLoader.js";
+import { shouldRender as _ } from "./useDisplayConditions.js";
+import { useFormData as R } from "./useFormData.js";
+import { applyLegacyRemaps as $ } from "./legacyPropRemap.js";
+const B = ["data-element-id", "data-element-type"], N = /* @__PURE__ */ L({
+  __name: "ElementRenderer",
+  props: {
+    element: {},
+    item: { default: () => ({}) },
+    evaluationContext: { default: () => ({}) }
+  },
+  setup(m) {
+    const e = m, f = s(
+      () => _(e.element, e.item, e.evaluationContext)
+    ), v = s(() => S(e.element.type)), a = s(() => R(e.element.name ?? "")), y = /* @__PURE__ */ new Set([
+      "type",
+      "conditionParams",
+      "conditionGroupLogic",
+      "condition",
+      "features",
+      "permissions",
+      "columns",
+      "columnsSm",
+      "columnsMd",
+      "columnsLg",
+      "columnsXl",
+      "columnsXxl",
+      "wrapperClassList",
+      "columnClassList",
+      "labelClassList",
+      "classList",
+      "previewMode",
+      "order",
+      "defaultValue",
+      "modelValue"
+    ]), C = s(() => {
+      const t = e.element, l = {};
+      for (const [d, x] of Object.entries(t))
+        y.has(d) || (l[d] = x);
+      const o = e.element.name ?? "", r = o ? a.value.value.value : void 0, i = o ? e.item[o] : void 0, u = t.defaultValue;
+      return r != null ? l.modelValue = r : i != null ? l.modelValue = i : u != null ? l.modelValue = u : l.modelValue = "", l.errors = a.value.errors.value, $(e.element.type, l);
+    });
+    function V(t) {
+      e.element.name && a.value.setValue(t);
+    }
+    const g = s(
+      () => P(
+        "gxp-element",
+        `gxp-element--${e.element.type.replace(/\./g, "-")}`,
+        n("col", e.element.columns),
+        n("col-sm", e.element.columnsSm),
+        n("col-md", e.element.columnsMd),
+        n("col-lg", e.element.columnsLg),
+        n("col-xl", e.element.columnsXl),
+        c(e.element.columnClassList),
+        c(e.element.wrapperClassList)
+      )
+    );
+    function n(t, l) {
+      if (typeof l != "number")
+        return;
+      const o = Math.max(0, Math.min(12, l)) / 12;
+      return t === "col" ? `basis-[${(o * 100).toFixed(4)}%]` : `${t}:basis-[${(o * 100).toFixed(4)}%]`;
+    }
+    function c(t) {
+      return t ? Array.isArray(t) ? t.join(" ") : t : "";
+    }
+    return (t, l) => f.value ? (p(), b("div", {
+      key: 0,
+      class: h(g.value),
+      "data-element-id": m.element.id,
+      "data-element-type": m.element.type
+    }, [
+      (p(), M(k(v.value), w(C.value, { "onUpdate:modelValue": V }), null, 16))
+    ], 10, B)) : E("", !0);
+  }
+});
+export {
+  N as default
+};
+//# sourceMappingURL=ElementRenderer.vue.js.map

package/dist/engine/ElementRenderer.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementRenderer.vue.js","sources":["../../src/engine/ElementRenderer.vue"],"sourcesContent":["<script setup lang=\"ts\">\n/**\n * Renders a single CardElement by dispatching its JSON definition into\n * the matching composition under `components/compositions/elements/`.\n *\n * The renderer is the bridge layer:\n *   - resolves the composition by `element.type` via the registry\n *   - evaluates the element's visibility (`shouldRender`)\n *   - applies responsive layout + classList chrome at the wrapper level\n *   - binds `useFormData(element.name)` to the form-data store and\n *     forwards `modelValue` + `errors` + the `@update:modelValue`\n *     handler to the composition\n *   - strips schema-only keys (type, conditionParams, columns*, ...)\n *     and passes the rest through as Vue props\n *\n * Compositions don't know about the form-data store, the JSON schema,\n * or this renderer's layout — they receive normal Vue props and emit\n * `update:modelValue`. They're directly mountable in any app.\n */\nimport { computed } from \"vue\"\nimport type { CardElement } from \"@/definitions/elements\"\nimport { cn } from \"@/lib/utils\"\nimport { getElementComponent } from \"./useElementLoader\"\nimport {\n  shouldRender,\n  type EvaluationContext,\n} from \"./useDisplayConditions\"\nimport { useFormData } from \"./useFormData\"\nimport { applyLegacyRemaps } from \"./legacyPropRemap\"\n\ninterface Props {\n  element: CardElement\n  item?: Record<string, unknown>\n  evaluationContext?: EvaluationContext\n}\n\nconst props = withDefaults(defineProps<Props>(), {\n  item: () => ({}),\n  evaluationContext: () => ({}),\n})\n\nconst visible = computed(() =>\n  shouldRender(props.element, props.item, props.evaluationContext),\n)\n\nconst resolved = computed(() => getElementComponent(props.element.type))\n\nconst bindings = computed(() => useFormData(props.element.name ?? \"\"))\n\n/**\n * Keys that live on every CardElement and are NOT meant to flow\n * through to the composition as props. These are either consumed by\n * this renderer (`columns*`, `conditionParams`, ...) or used only by\n * the engine (`type`, `id` — well, `id` IS passed through, see below).\n */\nconst STRIPPED_KEYS = new Set<string>([\n  \"type\",\n  \"conditionParams\",\n  \"conditionGroupLogic\",\n  \"condition\",\n  \"features\",\n  \"permissions\",\n  \"columns\",\n  \"columnsSm\",\n  \"columnsMd\",\n  \"columnsLg\",\n  \"columnsXl\",\n  \"columnsXxl\",\n  \"wrapperClassList\",\n  \"columnClassList\",\n  \"labelClassList\",\n  \"classList\",\n  \"previewMode\",\n  \"order\",\n  \"defaultValue\",\n  \"modelValue\",\n])\n\n/**\n * Compute the props object to pass to the resolved composition.\n *\n * - `modelValue` comes from the form-data store, falling back to\n *   `item[element.name]`, then `element.defaultValue`. Compositions\n *   declare `modelValue` and Vue picks it up.\n * - `errors` comes from the form-data store.\n * - All other element keys (label, placeholder, required, ...) are\n *   passed through; Vue's prop validation silently drops anything the\n *   composition doesn't declare.\n */\nconst compositionProps = computed<Record<string, unknown>>(() => {\n  const el = props.element as unknown as Record<string, unknown>\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(el)) {\n    if (!STRIPPED_KEYS.has(key)) {\n      result[key] = value\n    }\n  }\n\n  // Resolve the effective modelValue.\n  const fieldName = props.element.name ?? \"\"\n  const storeValue = fieldName ? bindings.value.value.value : undefined\n  const itemValue = fieldName ? props.item[fieldName] : undefined\n  const defaultValue = (el as { defaultValue?: unknown }).defaultValue\n  if (storeValue !== undefined && storeValue !== null) {\n    result.modelValue = storeValue\n  } else if (itemValue !== undefined && itemValue !== null) {\n    result.modelValue = itemValue\n  } else if (defaultValue !== undefined && defaultValue !== null) {\n    result.modelValue = defaultValue\n  } else {\n    result.modelValue = \"\"\n  }\n\n  result.errors = bindings.value.errors.value\n\n  // Legacy JSON → new composition prop names + value aliases.\n  return applyLegacyRemaps(props.element.type, result)\n})\n\nfunction onUpdateModelValue(value: unknown): void {\n  if (!props.element.name) {\n    return\n  }\n  bindings.value.setValue(value)\n}\n\nconst wrapperClass = computed(() =>\n  cn(\n    \"gxp-element\",\n    `gxp-element--${props.element.type.replace(/\\./g, \"-\")}`,\n    columnClass(\"col\", props.element.columns),\n    columnClass(\"col-sm\", props.element.columnsSm),\n    columnClass(\"col-md\", props.element.columnsMd),\n    columnClass(\"col-lg\", props.element.columnsLg),\n    columnClass(\"col-xl\", props.element.columnsXl),\n    normalizeClasses(props.element.columnClassList),\n    normalizeClasses(props.element.wrapperClassList),\n  ),\n)\n\nfunction columnClass(prefix: string, n?: number): string | undefined {\n  if (typeof n !== \"number\") {\n    return undefined\n  }\n  // 12-column grid — render width as a Tailwind percentage utility so\n  // we don't depend on Bootstrap's col-* classes.\n  const pct = Math.max(0, Math.min(12, n)) / 12\n  return prefix === \"col\"\n    ? `basis-[${(pct * 100).toFixed(4)}%]`\n    : `${prefix}:basis-[${(pct * 100).toFixed(4)}%]`\n}\n\nfunction normalizeClasses(value: string | string[] | undefined): string {\n  if (!value) {\n    return \"\"\n  }\n  return Array.isArray(value) ? value.join(\" \") : value\n}\n</script>\n\n<template>\n  <div\n    v-if=\"visible\"\n    :class=\"wrapperClass\"\n    :data-element-id=\"element.id\"\n    :data-element-type=\"element.type\"\n  >\n    <component\n      :is=\"resolved\"\n      v-bind=\"compositionProps\"\n      @update:model-value=\"onUpdateModelValue\"\n    />\n  </div>\n</template>\n"],"names":["props","__props","visible","computed","shouldRender","resolved","getElementComponent","bindings","useFormData","STRIPPED_KEYS","compositionProps","el","result","key","value","fieldName","storeValue","itemValue","defaultValue","applyLegacyRemaps","onUpdateModelValue","wrapperClass","cn","columnClass","normalizeClasses","prefix","n","pct","_createElementBlock","_createBlock","_resolveDynamicComponent","_mergeProps"],"mappings":";;;;;;;;;;;;;;AAoCA,UAAMA,IAAQC,GAKRC,IAAUC;AAAA,MAAS,MACvBC,EAAaJ,EAAM,SAASA,EAAM,MAAMA,EAAM,iBAAiB;AAAA,IAAA,GAG3DK,IAAWF,EAAS,MAAMG,EAAoBN,EAAM,QAAQ,IAAI,CAAC,GAEjEO,IAAWJ,EAAS,MAAMK,EAAYR,EAAM,QAAQ,QAAQ,EAAE,CAAC,GAQ/DS,wBAAoB,IAAY;AAAA,MACpC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA,CACD,GAaKC,IAAmBP,EAAkC,MAAM;AAC/D,YAAMQ,IAAKX,EAAM,SACXY,IAAkC,CAAA;AACxC,iBAAW,CAACC,GAAKC,CAAK,KAAK,OAAO,QAAQH,CAAE;AAC1C,QAAKF,EAAc,IAAII,CAAG,MACxBD,EAAOC,CAAG,IAAIC;AAKlB,YAAMC,IAAYf,EAAM,QAAQ,QAAQ,IAClCgB,IAAaD,IAAYR,EAAS,MAAM,MAAM,QAAQ,QACtDU,IAAYF,IAAYf,EAAM,KAAKe,CAAS,IAAI,QAChDG,IAAgBP,EAAkC;AACxD,aAAgCK,KAAe,OAC7CJ,EAAO,aAAaI,IACgBC,KAAc,OAClDL,EAAO,aAAaK,IACmBC,KAAiB,OACxDN,EAAO,aAAaM,IAEpBN,EAAO,aAAa,IAGtBA,EAAO,SAASL,EAAS,MAAM,OAAO,OAG/BY,EAAkBnB,EAAM,QAAQ,MAAMY,CAAM;AAAA,IACrD,CAAC;AAED,aAASQ,EAAmBN,GAAsB;AAChD,MAAKd,EAAM,QAAQ,QAGnBO,EAAS,MAAM,SAASO,CAAK;AAAA,IAC/B;AAEA,UAAMO,IAAelB;AAAA,MAAS,MAC5BmB;AAAA,QACE;AAAA,QACA,gBAAgBtB,EAAM,QAAQ,KAAK,QAAQ,OAAO,GAAG,CAAC;AAAA,QACtDuB,EAAY,OAAOvB,EAAM,QAAQ,OAAO;AAAA,QACxCuB,EAAY,UAAUvB,EAAM,QAAQ,SAAS;AAAA,QAC7CuB,EAAY,UAAUvB,EAAM,QAAQ,SAAS;AAAA,QAC7CuB,EAAY,UAAUvB,EAAM,QAAQ,SAAS;AAAA,QAC7CuB,EAAY,UAAUvB,EAAM,QAAQ,SAAS;AAAA,QAC7CwB,EAAiBxB,EAAM,QAAQ,eAAe;AAAA,QAC9CwB,EAAiBxB,EAAM,QAAQ,gBAAgB;AAAA,MAAA;AAAA,IACjD;AAGF,aAASuB,EAAYE,GAAgBC,GAAgC;AACnE,UAAI,OAAOA,KAAM;AACf;AAIF,YAAMC,IAAM,KAAK,IAAI,GAAG,KAAK,IAAI,IAAID,CAAC,CAAC,IAAI;AAC3C,aAAOD,MAAW,QACd,WAAWE,IAAM,KAAK,QAAQ,CAAC,CAAC,OAChC,GAAGF,CAAM,YAAYE,IAAM,KAAK,QAAQ,CAAC,CAAC;AAAA,IAChD;AAEA,aAASH,EAAiBV,GAA8C;AACtE,aAAKA,IAGE,MAAM,QAAQA,CAAK,IAAIA,EAAM,KAAK,GAAG,IAAIA,IAFvC;AAAA,IAGX;qBAKUZ,EAAA,cADR0B,EAWM,OAAA;AAAA;MATH,SAAOP,EAAA,KAAY;AAAA,MACnB,mBAAiBpB,EAAA,QAAQ;AAAA,MACzB,qBAAmBA,EAAA,QAAQ;AAAA,IAAA;YAE5B4B,EAIEC,EAHKzB,OAAQ,GADf0B,EAEUrB,EAER,OAFwB,EACvB,uBAAoBU,EAAA,CAAkB,GAAA,MAAA,EAAA;AAAA,IAAA;;;"}

package/dist/engine/ElementRenderer.vue2.js

@@ -0,0 +1,5 @@
+import f from "./ElementRenderer.vue.js";
+export {
+  f as default
+};
+//# sourceMappingURL=ElementRenderer.vue2.js.map

package/dist/engine/ElementRenderer.vue2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementRenderer.vue2.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/engine/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Engine — the runtime layer that turns JSON definitions into rendered
+ * Vue trees. Consumers typically use `IndexPage` / `ShowPage` rather
+ * than these low-level pieces directly.
+ *
+ * Public surface:
+ *   - `ElementRenderer`, `CardRenderer`         : the <component :is> wrappers
+ *   - `getElementComponent`, `getCardComponent` : lower-level resolvers
+ *   - `preloadElement`, `preloadCard`           : eager chunk preload helpers
+ *   - `shouldRender`                            : condition evaluator
+ *   - `useFormData`, `provideFormId`            : form-state binding
+ *   - registry constants for advanced use cases
+ */
+export { default as ElementRenderer } from './ElementRenderer.vue';
+export { default as CardRenderer } from './CardRenderer.vue';
+export { getElementComponent, preloadElement, __clearElementCache, } from './useElementLoader';
+export { getCardComponent, preloadCard, __clearCardCache, } from './useCardLoader';
+export { shouldRender, type EvaluationContext, __testing as __conditionsTesting, } from './useDisplayConditions';
+export { useFormData, provideFormId, FORM_ID_KEY, type UseFormDataBindings, } from './useFormData';
+export { cardRegistry, elementDefaultStyle, elementRegistry, resolveCardPath, resolveElementPath, type CardPath, type ElementPath, type ElementRegistry, } from './registry';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAE5D,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,mBAAmB,GACpB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,YAAY,EACZ,KAAK,iBAAiB,EACtB,SAAS,IAAI,mBAAmB,GACjC,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EACL,WAAW,EACX,aAAa,EACb,WAAW,EACX,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAA"}

package/dist/engine/legacyPropRemap.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Legacy-JSON → composition-prop remapping.
+ *
+ * The composition layer was refactored to use shadcn-style normalised
+ * prop names, but plenty of JSON in the wild still uses the old v2
+ * names (`triggerButtonLabel` instead of `triggerLabel`, GxP variant
+ * aliases like `"primary"` instead of `"default"`, etc).
+ *
+ * This module is consulted by `ElementRenderer` after stripping
+ * schema-only keys and before spreading the result onto the resolved
+ * composition. It's a thin compatibility layer — every entry here is
+ * a known legacy form. Renderers themselves stay schema-agnostic.
+ *
+ * Adding a new alias:
+ *   - For a prop-name rename, add to `PROP_RENAMES[<category>]`.
+ *   - For a value-only alias (e.g. variant strings), add to
+ *     `VALUE_ALIASES[<category>].<prop>`.
+ */
+/**
+ * Per-category prop-name renames. The string on the left is the legacy
+ * JSON key; the string on the right is the new composition prop name.
+ *
+ * Matched against the element's category prefix (`element.type` split
+ * at the dot). `*` is a wildcard that applies to every element.
+ */
+export declare const PROP_RENAMES: Record<string, Record<string, string>>;
+/**
+ * Per-(category, prop) value aliases. Used when a prop's accepted value
+ * union changed and we want legacy JSON to still resolve. Lookups are
+ * case-sensitive; unknown values pass through untouched.
+ */
+export declare const VALUE_ALIASES: Record<string, Record<string, Record<string, string>>>;
+/**
+ * Apply prop renames + value aliases for an element. Returns a NEW
+ * object — never mutates input. Pass the result through `v-bind`.
+ */
+export declare function applyLegacyRemaps(type: string, props: Record<string, unknown>): Record<string, unknown>;
+export declare const __testing: {
+    PROP_RENAMES: Record<string, Record<string, string>>;
+    VALUE_ALIASES: Record<string, Record<string, Record<string, string>>>;
+};
+//# sourceMappingURL=legacyPropRemap.d.ts.map

package/dist/engine/legacyPropRemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyPropRemap.d.ts","sourceRoot":"","sources":["../../src/engine/legacyPropRemap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAW/D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAoBhF,CAAA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwBzB;AAED,eAAO,MAAM,SAAS;;;CAAkC,CAAA"}

package/dist/engine/legacyPropRemap.js

@@ -0,0 +1,52 @@
+const g = {
+  "configuration-block": {
+    selectOptions: "nestedElements",
+    triggerButtonLabel: "triggerLabel",
+    dialogTitle: "title",
+    modalTitle: "title",
+    addOptionButtonLabel: "addButtonLabel"
+  },
+  display: {
+    icon: "iconName"
+  }
+}, f = {
+  action: {
+    variant: {
+      primary: "default",
+      danger: "destructive",
+      "outline-primary": "outline",
+      "outline-danger": "outline",
+      "outline-secondary": "outline",
+      "btn-success": "success",
+      "btn-warning": "warning",
+      "btn-info": "info",
+      light: "ghost",
+      dark: "default"
+    }
+  },
+  boolean: {
+    variant: {
+      // Boolean controls don't have variant aliases yet — reserved.
+    }
+  }
+};
+function b(i, a) {
+  const s = i.indexOf("."), r = s < 0 ? i : i.slice(0, s), t = g[r], n = f[r];
+  if (!t && !n)
+    return a;
+  const u = {};
+  for (const [c, e] of Object.entries(a)) {
+    const o = (t == null ? void 0 : t[c]) ?? c;
+    if (o !== c && o in a)
+      continue;
+    const l = n == null ? void 0 : n[o], d = typeof e == "string" && l && l[e] !== void 0 ? l[e] : e;
+    u[o] = d;
+  }
+  return u;
+}
+export {
+  g as PROP_RENAMES,
+  f as VALUE_ALIASES,
+  b as applyLegacyRemaps
+};
+//# sourceMappingURL=legacyPropRemap.js.map

package/dist/engine/legacyPropRemap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyPropRemap.js","sources":["../../src/engine/legacyPropRemap.ts"],"sourcesContent":["/**\n * Legacy-JSON → composition-prop remapping.\n *\n * The composition layer was refactored to use shadcn-style normalised\n * prop names, but plenty of JSON in the wild still uses the old v2\n * names (`triggerButtonLabel` instead of `triggerLabel`, GxP variant\n * aliases like `\"primary\"` instead of `\"default\"`, etc).\n *\n * This module is consulted by `ElementRenderer` after stripping\n * schema-only keys and before spreading the result onto the resolved\n * composition. It's a thin compatibility layer — every entry here is\n * a known legacy form. Renderers themselves stay schema-agnostic.\n *\n * Adding a new alias:\n *   - For a prop-name rename, add to `PROP_RENAMES[<category>]`.\n *   - For a value-only alias (e.g. variant strings), add to\n *     `VALUE_ALIASES[<category>].<prop>`.\n */\n\n/**\n * Per-category prop-name renames. The string on the left is the legacy\n * JSON key; the string on the right is the new composition prop name.\n *\n * Matched against the element's category prefix (`element.type` split\n * at the dot). `*` is a wildcard that applies to every element.\n */\nexport const PROP_RENAMES: Record<string, Record<string, string>> = {\n  \"configuration-block\": {\n    selectOptions: \"nestedElements\",\n    triggerButtonLabel: \"triggerLabel\",\n    dialogTitle: \"title\",\n    modalTitle: \"title\",\n    addOptionButtonLabel: \"addButtonLabel\",\n  },\n  display: {\n    icon: \"iconName\",\n  },\n}\n\n/**\n * Per-(category, prop) value aliases. Used when a prop's accepted value\n * union changed and we want legacy JSON to still resolve. Lookups are\n * case-sensitive; unknown values pass through untouched.\n */\nexport const VALUE_ALIASES: Record<string, Record<string, Record<string, string>>> = {\n  action: {\n    variant: {\n      primary: \"default\",\n      danger: \"destructive\",\n      \"outline-primary\": \"outline\",\n      \"outline-danger\": \"outline\",\n      \"outline-secondary\": \"outline\",\n      \"btn-success\": \"success\",\n      \"btn-warning\": \"warning\",\n      \"btn-info\": \"info\",\n      light: \"ghost\",\n      dark: \"default\",\n    },\n  },\n  boolean: {\n    variant: {\n      // Boolean controls don't have variant aliases yet — reserved.\n    },\n  },\n}\n\n/**\n * Apply prop renames + value aliases for an element. Returns a NEW\n * object — never mutates input. Pass the result through `v-bind`.\n */\nexport function applyLegacyRemaps(\n  type: string,\n  props: Record<string, unknown>,\n): Record<string, unknown> {\n  const dot = type.indexOf(\".\")\n  const category = dot < 0 ? type : type.slice(0, dot)\n  const renames = PROP_RENAMES[category]\n  const aliases = VALUE_ALIASES[category]\n  if (!renames && !aliases) {\n    return props\n  }\n\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(props)) {\n    const renamedKey = renames?.[key] ?? key\n    // Don't overwrite a key the consumer already provided in the new name.\n    if (renamedKey !== key && renamedKey in props) {\n      continue\n    }\n    const aliasMap = aliases?.[renamedKey]\n    const aliased =\n      typeof value === \"string\" && aliasMap && aliasMap[value] !== undefined\n        ? aliasMap[value]\n        : value\n    out[renamedKey] = aliased\n  }\n  return out\n}\n\nexport const __testing = { PROP_RENAMES, VALUE_ALIASES }\n"],"names":["PROP_RENAMES","VALUE_ALIASES","applyLegacyRemaps","type","props","dot","category","renames","aliases","out","key","value","renamedKey","aliasMap","aliased"],"mappings":"AA0BO,MAAMA,IAAuD;AAAA,EAClE,uBAAuB;AAAA,IACrB,eAAe;AAAA,IACf,oBAAoB;AAAA,IACpB,aAAa;AAAA,IACb,YAAY;AAAA,IACZ,sBAAsB;AAAA,EAAA;AAAA,EAExB,SAAS;AAAA,IACP,MAAM;AAAA,EAAA;AAEV,GAOaC,IAAwE;AAAA,EACnF,QAAQ;AAAA,IACN,SAAS;AAAA,MACP,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,mBAAmB;AAAA,MACnB,kBAAkB;AAAA,MAClB,qBAAqB;AAAA,MACrB,eAAe;AAAA,MACf,eAAe;AAAA,MACf,YAAY;AAAA,MACZ,OAAO;AAAA,MACP,MAAM;AAAA,IAAA;AAAA,EACR;AAAA,EAEF,SAAS;AAAA,IACP,SAAS;AAAA;AAAA,IAAA;AAAA,EAET;AAEJ;AAMO,SAASC,EACdC,GACAC,GACyB;AACzB,QAAMC,IAAMF,EAAK,QAAQ,GAAG,GACtBG,IAAWD,IAAM,IAAIF,IAAOA,EAAK,MAAM,GAAGE,CAAG,GAC7CE,IAAUP,EAAaM,CAAQ,GAC/BE,IAAUP,EAAcK,CAAQ;AACtC,MAAI,CAACC,KAAW,CAACC;AACf,WAAOJ;AAGT,QAAMK,IAA+B,CAAA;AACrC,aAAW,CAACC,GAAKC,CAAK,KAAK,OAAO,QAAQP,CAAK,GAAG;AAChD,UAAMQ,KAAaL,KAAA,gBAAAA,EAAUG,OAAQA;AAErC,QAAIE,MAAeF,KAAOE,KAAcR;AACtC;AAEF,UAAMS,IAAWL,KAAA,gBAAAA,EAAUI,IACrBE,IACJ,OAAOH,KAAU,YAAYE,KAAYA,EAASF,CAAK,MAAM,SACzDE,EAASF,CAAK,IACdA;AACN,IAAAF,EAAIG,CAAU,IAAIE;AAAA,EACpB;AACA,SAAOL;AACT;"}

package/dist/engine/registry.d.ts

@@ -0,0 +1,74 @@
+import { CardType, ElementCategory } from '../definitions/shared/base';
+import { ActionStyle } from '../definitions/elements/ActionElement';
+import { BooleanStyle } from '../definitions/elements/BooleanElement';
+import { BuilderStyle } from '../definitions/elements/BuilderElement';
+import { CardStyle } from '../definitions/elements/CardLayoutElement';
+import { CodeStyle } from '../definitions/elements/CodeElement';
+import { ComponentsStyle } from '../definitions/elements/ComponentsElement';
+import { ConfigurationBlockStyle } from '../definitions/elements/ConfigurationBlockElement';
+import { DisplayStyle } from '../definitions/elements/DisplayElement';
+import { EditorStyle } from '../definitions/elements/EditorElement';
+import { FileStyle } from '../definitions/elements/FileElement';
+import { InputStyle } from '../definitions/elements/InputElement';
+import { OptionSelectStyle } from '../definitions/elements/OptionSelectElement';
+import { PickerStyle } from '../definitions/elements/PickerElement';
+/**
+ * A path under `src/elements/`, without the `./` prefix or the `.vue`
+ * extension. e.g. `"input/TextInput"` resolves to
+ * `src/elements/input/TextInput.vue`.
+ */
+export type ElementPath = string;
+/**
+ * A path under `src/cards/`. e.g. `"ElementListCard"` resolves to
+ * `src/cards/ElementListCard.vue`.
+ */
+export type CardPath = string;
+/**
+ * Per-type map of style → path. Each top-level key is an ElementType;
+ * the inner object covers every style variant for that type.
+ *
+ * Using `Record<Style, ElementPath>` here means TS errors if a new
+ * style is added to the definitions but not given a renderer path.
+ */
+export interface ElementRegistry {
+    action: Record<ActionStyle, ElementPath>;
+    boolean: Record<BooleanStyle, ElementPath>;
+    builder: Record<BuilderStyle, ElementPath>;
+    card: Record<CardStyle, ElementPath>;
+    code: Record<CodeStyle, ElementPath>;
+    components: Record<ComponentsStyle, ElementPath>;
+    "configuration-block": Record<ConfigurationBlockStyle, ElementPath>;
+    display: Record<DisplayStyle, ElementPath>;
+    editor: Record<EditorStyle, ElementPath>;
+    file: Record<FileStyle, ElementPath>;
+    input: Record<InputStyle, ElementPath>;
+    "option-select": Record<OptionSelectStyle, ElementPath>;
+    picker: Record<PickerStyle, ElementPath>;
+}
+export declare const elementRegistry: ElementRegistry;
+/**
+ * Per-cardType map. Cards have no style discriminator — `cardType`
+ * alone resolves the renderer.
+ */
+export declare const cardRegistry: Record<CardType, CardPath>;
+/**
+ * Default style picked when an element JSON omits the dot suffix
+ * (e.g. `type: "input"` is normalised to `"input.text"`). Each
+ * ElementCategory must have a default registered.
+ */
+export declare const elementDefaultStyle: Record<ElementCategory, string>;
+/**
+ * Returns the relative element path for a given dot-notation `type`
+ * (e.g. `"input.text"`), or `null` when the type isn't registered.
+ *
+ * A bare category (e.g. `"input"`) is auto-completed using the
+ * category's default style. The loader uses the returned path to look
+ * up a Vue component module from `import.meta.glob`.
+ */
+export declare function resolveElementPath(type: string): ElementPath | null;
+/**
+ * Returns the relative card path for a given `cardType`, or `null` if
+ * unregistered.
+ */
+export declare function resolveCardPath(cardType: string): CardPath | null;
+//# sourceMappingURL=registry.d.ts.map

package/dist/engine/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/engine/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAA;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAA;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAA;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0CAA0C,CAAA;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAA;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAA;AAC/F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAA;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAA;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAA;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAA;AACnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAA;AAEvE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAA;AAEhC;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAA;AAE7B;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;IACxC,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CAAA;IAC1C,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CAAA;IAC1C,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAAA;IACpC,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAAA;IACpC,UAAU,EAAE,MAAM,CAAC,eAAe,EAAE,WAAW,CAAC,CAAA;IAChD,qBAAqB,EAAE,MAAM,CAAC,uBAAuB,EAAE,WAAW,CAAC,CAAA;IACnE,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CAAA;IAC1C,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;IACxC,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAAA;IACpC,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,CAAA;IACtC,eAAe,EAAE,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAA;IACvD,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;CACzC;AAED,eAAO,MAAM,eAAe,EAAE,eAiH7B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAQnD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAc/D,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAgBnE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAEjE"}