@gxp-dev/mod-ui 2.0.0

package/.storybook/main.ts

@@ -0,0 +1,28 @@
+import type { StorybookConfig } from "@storybook/vue3-vite"
+import { fileURLToPath, URL } from "node:url"
+
+const config: StorybookConfig = {
+  stories: ["../src/**/*.stories.@(ts|tsx)"],
+  addons: [
+    "@storybook/addon-docs",
+    "@storybook/addon-a11y",
+    "@storybook/addon-themes",
+  ],
+  framework: {
+    name: "@storybook/vue3-vite",
+    options: {},
+  },
+  docs: {
+    autodocs: "tag",
+  },
+  viteFinal: async (config) => {
+    config.resolve = config.resolve ?? {}
+    config.resolve.alias = {
+      ...(config.resolve.alias as Record<string, string>),
+      "@": fileURLToPath(new URL("../src", import.meta.url)),
+    }
+    return config
+  },
+}
+
+export default config

package/.storybook/preview.ts

@@ -0,0 +1,61 @@
+import type { Preview } from "@storybook/vue3-vite"
+import { setup } from "@storybook/vue3-vite"
+import { withThemeByClassName } from "@storybook/addon-themes"
+import { createPinia } from "pinia"
+
+import "../src/styles/tailwind.css"
+import "../src/styles/themes/default.css"
+import "../src/styles/themes/dark.css"
+import "../src/styles/themes/kiosk.css"
+
+/**
+ * Install Pinia on Storybook's Vue app instance. This is required so
+ * stories that mount stateful compositions (FormBuilder, the dispatch
+ * wrappers, anything that calls a Pinia store) can resolve a store
+ * instance.
+ *
+ * Without this, useFormDataStore() / useFormBuilderStore() throw with
+ *   "can't access property '_s', r is undefined"
+ * — the `_s` is Pinia's internal store registry, accessed before the
+ * plugin has been installed on the app.
+ */
+setup((app) => {
+  app.use(createPinia())
+})
+
+const preview: Preview = {
+  parameters: {
+    controls: {
+      matchers: {
+        color: /(background|color)$/i,
+        date: /Date$/i,
+      },
+    },
+    backgrounds: {
+      default: "default",
+      values: [
+        { name: "default", value: "hsl(0 0% 100%)" },
+        { name: "dark", value: "hsl(240 10% 4%)" },
+        { name: "kiosk", value: "#000466" },
+      ],
+    },
+    layout: "padded",
+  },
+  decorators: [
+    withThemeByClassName({
+      themes: {
+        default: "",
+        dark: "dark",
+        kiosk: "kiosk",
+      },
+      defaultTheme: "default",
+    }),
+    (story) => ({
+      components: { story },
+      template:
+        '<div class="gxp-storybook-wrapper bg-background text-foreground p-6 min-h-screen"><story /></div>',
+    }),
+  ],
+}
+
+export default preview

package/README.md

@@ -0,0 +1,173 @@
+# @gxp-dev/adminkit
+
+JSON-driven Vue 3 admin component library for the GxP platform.
+Provides shadcn-vue primitives, props-based composition components,
+a templating engine (`IndexPage` / `ShowPage`), and a `FormBuilder`
+ecosystem. Designed to be a drop-in replacement for the legacy
+`Components/Mod` and `Components/Mod/v2` systems in the experience
+portal.
+
+> Status: **2.0.0-alpha.0** — feature-complete for rendering and JSON
+> drop-in. 1410 passing tests across 124 files. See
+> [CHANGELOG.md](./CHANGELOG.md) for details and known limitations.
+
+## Two APIs in one library
+
+**Props-based** (use any composition directly, no JSON, no schema):
+
+```vue
+<script setup lang="ts">
+import { TextInput, DatePicker, Button } from "@gxp-dev/adminkit"
+</script>
+
+<template>
+  <TextInput v-model="firstName" label="First name" required />
+  <DatePicker v-model="startDate" label="Start date" />
+  <Button variant="default" @click="save">Save</Button>
+</template>
+```
+
+**JSON-driven** (pass a config, the engine resolves and renders):
+
+```vue
+<script setup lang="ts">
+import { ShowPage } from "@gxp-dev/adminkit"
+import type { ShowPageConfig } from "@gxp-dev/adminkit"
+
+const config: ShowPageConfig = {
+  title: "User",
+  tabsList: [
+    {
+      title: "Details",
+      tabId: "details",
+      cards: [
+        {
+          // v1 (`fields_list`) is auto-translated at the boundary.
+          // Native v2: `cardType: "element-list"`.
+          type: "fields_list",
+          fieldsList: [
+            { type: "text", name: "first_name", label: "First name" },
+            { type: "email", name: "email", label: "Email" },
+          ],
+        },
+      ],
+    },
+  ],
+  updateConfig: {
+    update: { route: "api.users.update", method: "patch" },
+  },
+}
+</script>
+
+<template>
+  <ShowPage :config="config" :item="user" />
+</template>
+```
+
+The same `ShowPage` accepts both v1 and v2 schemas — the adapter
+detects the shape at the boundary.
+
+## What's in the box
+
+| Layer | What lives here | Purpose |
+| --- | --- | --- |
+| `components/ui/` | 30 shadcn-vue primitives (Button, Input, Dialog, Select, FieldFrame, …) | Atom-level building blocks built on reka-ui. |
+| `components/compositions/elements/` | 79 props-based element compositions (TextInput, DatePicker, ColorPicker, RichTextEditor, ChartDisplay, …) | Self-contained Vue components with `defineModel('modelValue')`. Mountable in any app. |
+| `components/compositions/cards/` | 7 card compositions (ElementList, DataTable, CardList, TabList, Info, GridView, ElementDisplay) | Container compositions that render resolved children. |
+| `pages/` | `IndexPage`, `ShowPage` | Top-level templating consumers; take a JSON config. |
+| `definitions/` | TypeScript schema source of truth (no Vue) | `Defaults`, `EditConfig`, and interfaces per element/card. |
+| `engine/` | `ElementRenderer`, `CardRenderer`, loaders, `legacyPropRemap` | JSON → props dispatch. Resolves type, calls `useFormData`, strips schema-only keys, forwards as v-bind. |
+| `adapters/` | v1 ↔ v2 schema translation, `normalisePageConfig` | Drop-in support for legacy v1 JSON. |
+| `stores/` | 9 Pinia stores | Per-form data binding; per-builder schema state. |
+
+## Architectural principles
+
+1. **Compositions take normal Vue props.** Every renderer under
+   `components/compositions/` is a self-contained Vue component with
+   `defineModel<T>('modelValue')`, typed individual props, and standard
+   events. Each is directly mountable in any Vue app without any
+   knowledge of the JSON schema or Pinia.
+2. **The engine is the JSON ↔ props bridge.** `ElementRenderer` and
+   `CardRenderer` look up the matching composition by `element.type` /
+   `card.cardType`, call `useFormData(element.name)` for the form
+   binding, strip schema-only keys, and forward the rest as v-bind
+   props. Compositions never import schema types.
+3. **TypeScript definitions are the schema source.** Each element
+   category has a single dot-notation discriminator (`"input.text"`,
+   `"picker.date-picker"`, …) — no separate `style` field. The
+   runtime registry and adapters derive from these definitions.
+4. **Tree-shakeable.** Direct deep imports work alongside the barrel.
+5. **Code-split.** The engine resolves the composition path via
+   `import.meta.glob` + `defineAsyncComponent` — a `ShowPage` only
+   downloads the elements it actually renders.
+6. **No mdbootstrap, no Bootstrap CSS.** Pure Tailwind v4 + CSS
+   variables. reka-ui for a11y primitives.
+7. **Themes are CSS variables.** Override any token in `:root` (or a
+   scoped class like `.kiosk`) and the whole library retunes.
+
+## Install
+
+```bash
+pnpm add @gxp-dev/adminkit
+```
+
+`vue`, `pinia`, and `reka-ui` are peer dependencies — modern package
+managers (pnpm 9+, npm 7+, yarn 3+) auto-install them, so the single
+command above is usually enough. If your manager warns about
+unresolved peers, add them explicitly: `pnpm add vue pinia reka-ui`.
+
+## Themes
+
+```html
+<!-- Activate dark mode anywhere in the tree. -->
+<body class="dark">
+
+<!-- Activate the kiosk theme. -->
+<body class="kiosk">
+```
+
+```css
+/* Override individual tokens. */
+:root {
+  --primary: oklch(0.5 0.2 270);
+  --radius: 1rem;
+}
+```
+
+Default, dark, and kiosk themes ship in `dist/styles/themes/`.
+
+## Develop
+
+```bash
+pnpm install
+pnpm dev            # vite dev server (rarely used; storybook is the demo)
+pnpm storybook      # storybook on :6006
+pnpm test           # vitest watch
+pnpm test:run       # one-shot
+pnpm typecheck      # vue-tsc --noEmit
+pnpm build          # library build (dist/)
+```
+
+## Migrating from `Components/Mod` (v1) or `Components/Mod/v2`
+
+The `adapters/` module accepts both shapes and emits the v2-internal
+structure. `ShowPage` / `IndexPage` apply the adapter automatically
+at the page boundary, so existing v1 JSON renders without code
+changes in the consumer.
+
+For direct schema migration without rendering:
+
+```ts
+import { v1ToV2, v2ToV1, normalisePageConfig } from "@gxp-dev/adminkit"
+```
+
+### v2 schema notes
+
+- Elements use a single `type` field in dot notation: `"input.text"`,
+  `"picker.date-picker"`, `"option-select.select"`, etc. The separate
+  `style` field that v2 used early on is gone (it collided with HTML
+  `style` attribute fallthrough).
+- A small `legacyPropRemap` shim handles known legacy v2 key renames
+  (`selectOptions` → `nestedElements`, `triggerButtonLabel` →
+  `triggerLabel`, etc.) and variant aliases (`variant: "primary"` →
+  `"default"`) automatically at the engine boundary.

package/dist/adapters/cardTypeMap.d.ts

@@ -0,0 +1,19 @@
+import { CardType } from '../definitions/shared/base';
+/**
+ * v1 → v2 card type mapping. The v1 docs schema uses snake_case
+ * (`fields_list`, `data_table`, ...) while v2's internal `cardType`
+ * is kebab-case (`element-list`, `datatable`, ...).
+ *
+ * Two v1 card types don't map to v2 cards at all:
+ *   - `button_group` — in v2 this is an `action` ELEMENT with
+ *     style=`button-group`, not a card. The adapter rewrites these
+ *     into a one-element `element-list` card with the button-group
+ *     element inside.
+ *   - `form_builder`  — in v2 this is a `builder` ELEMENT with
+ *     style=`form-builder`. Same rewrite as button_group.
+ */
+export declare const V1_TO_V2_CARD_TYPE: Record<string, CardType>;
+export declare const V2_TO_V1_CARD_TYPE: Record<CardType, string>;
+/** v1 card types that map to an element wrapped in an element-list, not a card. */
+export declare const V1_ELEMENT_AS_CARD: ReadonlySet<string>;
+//# sourceMappingURL=cardTypeMap.d.ts.map

package/dist/adapters/cardTypeMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardTypeMap.d.ts","sourceRoot":"","sources":["../../src/adapters/cardTypeMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAEzD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAgBvD,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAQvD,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAGjD,CAAA"}

package/dist/adapters/cardTypeMap.js

@@ -0,0 +1,34 @@
+const t = {
+  fields_list: "element-list",
+  data_table: "datatable",
+  card_list: "card-list",
+  tabs_list: "tab-list",
+  info_card: "info-card",
+  grid_view: "grid-view",
+  component: "element-display",
+  // Also pass through the v2 names so callers can mix-and-match.
+  "element-list": "element-list",
+  datatable: "datatable",
+  "card-list": "card-list",
+  "tab-list": "tab-list",
+  "info-card": "info-card",
+  "grid-view": "grid-view",
+  "element-display": "element-display"
+}, e = {
+  "element-list": "fields_list",
+  datatable: "data_table",
+  "card-list": "card_list",
+  "tab-list": "tabs_list",
+  "info-card": "info_card",
+  "grid-view": "grid_view",
+  "element-display": "component"
+}, i = /* @__PURE__ */ new Set([
+  "button_group",
+  "form_builder"
+]);
+export {
+  i as V1_ELEMENT_AS_CARD,
+  t as V1_TO_V2_CARD_TYPE,
+  e as V2_TO_V1_CARD_TYPE
+};
+//# sourceMappingURL=cardTypeMap.js.map

package/dist/adapters/cardTypeMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardTypeMap.js","sources":["../../src/adapters/cardTypeMap.ts"],"sourcesContent":["import type { CardType } from \"@/definitions/shared/base\"\n\n/**\n * v1 → v2 card type mapping. The v1 docs schema uses snake_case\n * (`fields_list`, `data_table`, ...) while v2's internal `cardType`\n * is kebab-case (`element-list`, `datatable`, ...).\n *\n * Two v1 card types don't map to v2 cards at all:\n *   - `button_group` — in v2 this is an `action` ELEMENT with\n *     style=`button-group`, not a card. The adapter rewrites these\n *     into a one-element `element-list` card with the button-group\n *     element inside.\n *   - `form_builder`  — in v2 this is a `builder` ELEMENT with\n *     style=`form-builder`. Same rewrite as button_group.\n */\nexport const V1_TO_V2_CARD_TYPE: Record<string, CardType> = {\n  fields_list: \"element-list\",\n  data_table: \"datatable\",\n  card_list: \"card-list\",\n  tabs_list: \"tab-list\",\n  info_card: \"info-card\",\n  grid_view: \"grid-view\",\n  component: \"element-display\",\n  // Also pass through the v2 names so callers can mix-and-match.\n  \"element-list\": \"element-list\",\n  datatable: \"datatable\",\n  \"card-list\": \"card-list\",\n  \"tab-list\": \"tab-list\",\n  \"info-card\": \"info-card\",\n  \"grid-view\": \"grid-view\",\n  \"element-display\": \"element-display\",\n}\n\nexport const V2_TO_V1_CARD_TYPE: Record<CardType, string> = {\n  \"element-list\": \"fields_list\",\n  datatable: \"data_table\",\n  \"card-list\": \"card_list\",\n  \"tab-list\": \"tabs_list\",\n  \"info-card\": \"info_card\",\n  \"grid-view\": \"grid_view\",\n  \"element-display\": \"component\",\n}\n\n/** v1 card types that map to an element wrapped in an element-list, not a card. */\nexport const V1_ELEMENT_AS_CARD: ReadonlySet<string> = new Set([\n  \"button_group\",\n  \"form_builder\",\n])\n"],"names":["V1_TO_V2_CARD_TYPE","V2_TO_V1_CARD_TYPE","V1_ELEMENT_AS_CARD"],"mappings":"AAeO,MAAMA,IAA+C;AAAA,EAC1D,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA;AAAA,EAEX,gBAAgB;AAAA,EAChB,WAAW;AAAA,EACX,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,aAAa;AAAA,EACb,mBAAmB;AACrB,GAEaC,IAA+C;AAAA,EAC1D,gBAAgB;AAAA,EAChB,WAAW;AAAA,EACX,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,aAAa;AAAA,EACb,mBAAmB;AACrB,GAGaC,wBAA8C,IAAI;AAAA,EAC7D;AAAA,EACA;AACF,CAAC;"}

package/dist/adapters/conditionMap.d.ts

@@ -0,0 +1,21 @@
+import { ConditionLogic, ConditionParam, ConditionParamV1 } from '../definitions/shared/conditions';
+import { ResponsiveColumns, ResponsiveColumnsV1 } from '../definitions/shared/responsive';
+/** v1 `{field, operator, value}` → v2 `{name, logic, value}`. */
+export declare function v1ConditionParamToV2(param: ConditionParamV1): ConditionParam;
+/** v2 `{name, logic, value}` → v1 `{field, operator, value}`. */
+export declare function v2ConditionParamToV1(param: ConditionParam): ConditionParamV1;
+/**
+ * Convert a v1 conditionParams array (or undefined) to a v2 array.
+ * Returns undefined when the input is empty so the converted JSON
+ * doesn't carry a useless empty array.
+ */
+export declare function v1ConditionParamsToV2(params: ConditionParamV1[] | undefined): ConditionParam[] | undefined;
+/** v1 `cols/colsSm/colsMd/...` → v2 `columns/columnsSm/columnsMd/...`. */
+export declare function v1ColumnsToV2(input: ResponsiveColumnsV1): ResponsiveColumns;
+/** v2 → v1 reverse for the columns shape. */
+export declare function v2ColumnsToV1(input: ResponsiveColumns): ResponsiveColumnsV1;
+export declare const __testing: {
+    V1_OPERATOR_TO_V2_LOGIC: Record<string, ConditionLogic>;
+    V2_LOGIC_TO_V1_OPERATOR: Record<ConditionLogic, string>;
+};
+//# sourceMappingURL=conditionMap.d.ts.map

package/dist/adapters/conditionMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionMap.d.ts","sourceRoot":"","sources":["../../src/adapters/conditionMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,gBAAgB,EACjB,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAA;AAyF7F,iEAAiE;AACjE,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,GACtB,cAAc,CAMhB;AAED,iEAAiE;AACjE,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,cAAc,GACpB,gBAAgB,CAMlB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,gBAAgB,EAAE,GAAG,SAAS,GACrC,cAAc,EAAE,GAAG,SAAS,CAK9B;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,mBAAmB,GAAG,iBAAiB,CAqB3E;AAED,6CAA6C;AAC7C,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,mBAAmB,CAqB3E;AAED,eAAO,MAAM,SAAS;;;CAGrB,CAAA"}

package/dist/adapters/conditionMap.js

@@ -0,0 +1,110 @@
+const o = {
+  equals: "==",
+  "=": "==",
+  "==": "==",
+  "===": "==",
+  not_equals: "!=",
+  "!=": "!=",
+  "!==": "!=",
+  greater_than: ">",
+  gt: ">",
+  ">": ">",
+  greater_than_or_equal: ">=",
+  gte: ">=",
+  ">=": ">=",
+  less_than: "<",
+  lt: "<",
+  "<": "<",
+  less_than_or_equal: "<=",
+  lte: "<=",
+  "<=": "<=",
+  in: "in-array",
+  in_array: "in-array",
+  "in-array": "in-array",
+  not_in: "not-in-array",
+  not_in_array: "not-in-array",
+  "not-in-array": "not-in-array",
+  contains: "contains",
+  not_contains: "not-contains",
+  "not-contains": "not-contains",
+  starts_with: "starts-with",
+  "starts-with": "starts-with",
+  ends_with: "ends-with",
+  "ends-with": "ends-with",
+  matches: "matches",
+  regex: "matches",
+  is_truthy: "is-truthy",
+  truthy: "is-truthy",
+  is_falsy: "is-falsy",
+  falsy: "is-falsy",
+  is_null: "is-null",
+  is_not_null: "is-not-null",
+  is_odd: "is-odd",
+  is_even: "is-even",
+  is_empty: "zero-length",
+  zero_length: "zero-length",
+  has_items: "g0length",
+  length_eq: "length-eq-value",
+  length_gt: "length-gt-value",
+  length_lt: "length-lt-value"
+}, s = {
+  "==": "equals",
+  "!=": "not_equals",
+  ">": "greater_than",
+  ">=": "greater_than_or_equal",
+  "<": "less_than",
+  "<=": "less_than_or_equal",
+  "in-array": "in",
+  "not-in-array": "not_in",
+  "starts-with": "starts_with",
+  "ends-with": "ends_with",
+  contains: "contains",
+  "not-contains": "not_contains",
+  matches: "matches",
+  "is-odd": "is_odd",
+  "is-even": "is_even",
+  "is-truthy": "is_truthy",
+  "is-falsy": "is_falsy",
+  "is-null": "is_null",
+  "is-not-null": "is_not_null",
+  g0length: "has_items",
+  n0length: "is_empty",
+  "length-eq-value": "length_eq",
+  "length-gt-value": "length_gt",
+  "length-lt-value": "length_lt",
+  "zero-length": "is_empty"
+};
+function t(n) {
+  return {
+    name: n.field,
+    logic: o[n.operator] ?? n.operator,
+    value: n.value
+  };
+}
+function e(n) {
+  return {
+    field: n.name,
+    operator: s[n.logic] ?? String(n.logic),
+    value: n.value
+  };
+}
+function i(n) {
+  if (!(!n || n.length === 0))
+    return n.map(t);
+}
+function a(n) {
+  const l = {};
+  return n.cols !== void 0 && (l.columns = n.cols), n.colsSm !== void 0 && (l.columnsSm = n.colsSm), n.colsMd !== void 0 && (l.columnsMd = n.colsMd), n.colsLg !== void 0 && (l.columnsLg = n.colsLg), n.colsXl !== void 0 && (l.columnsXl = n.colsXl), n.colsXxl !== void 0 && (l.columnsXxl = n.colsXxl), l;
+}
+function r(n) {
+  const l = {};
+  return n.columns !== void 0 && (l.cols = n.columns), n.columnsSm !== void 0 && (l.colsSm = n.columnsSm), n.columnsMd !== void 0 && (l.colsMd = n.columnsMd), n.columnsLg !== void 0 && (l.colsLg = n.columnsLg), n.columnsXl !== void 0 && (l.colsXl = n.columnsXl), n.columnsXxl !== void 0 && (l.colsXxl = n.columnsXxl), l;
+}
+export {
+  a as v1ColumnsToV2,
+  t as v1ConditionParamToV2,
+  i as v1ConditionParamsToV2,
+  r as v2ColumnsToV1,
+  e as v2ConditionParamToV1
+};
+//# sourceMappingURL=conditionMap.js.map

package/dist/adapters/conditionMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionMap.js","sources":["../../src/adapters/conditionMap.ts"],"sourcesContent":["import type {\n  ConditionLogic,\n  ConditionParam,\n  ConditionParamV1,\n} from \"@/definitions/shared/conditions\"\nimport type { ResponsiveColumns, ResponsiveColumnsV1 } from \"@/definitions/shared/responsive\"\n\n/**\n * v1 condition operator → v2 logic string.\n *\n * The v1 docs only documented `\"equals\"`; this table also covers\n * common variants that show up in the wild (`\"==\"`, `\"!=\"`, `\"gt\"`,\n * `\"lt\"`, `\"contains\"`, ...). Unknown operators pass through verbatim\n * — useful for forward-compat and easier to debug than a silent fallback.\n */\nconst V1_OPERATOR_TO_V2_LOGIC: Record<string, ConditionLogic> = {\n  equals: \"==\",\n  \"=\": \"==\",\n  \"==\": \"==\",\n  \"===\": \"==\",\n  not_equals: \"!=\",\n  \"!=\": \"!=\",\n  \"!==\": \"!=\",\n  greater_than: \">\",\n  gt: \">\",\n  \">\": \">\",\n  greater_than_or_equal: \">=\",\n  gte: \">=\",\n  \">=\": \">=\",\n  less_than: \"<\",\n  lt: \"<\",\n  \"<\": \"<\",\n  less_than_or_equal: \"<=\",\n  lte: \"<=\",\n  \"<=\": \"<=\",\n  in: \"in-array\",\n  in_array: \"in-array\",\n  \"in-array\": \"in-array\",\n  not_in: \"not-in-array\",\n  not_in_array: \"not-in-array\",\n  \"not-in-array\": \"not-in-array\",\n  contains: \"contains\",\n  not_contains: \"not-contains\",\n  \"not-contains\": \"not-contains\",\n  starts_with: \"starts-with\",\n  \"starts-with\": \"starts-with\",\n  ends_with: \"ends-with\",\n  \"ends-with\": \"ends-with\",\n  matches: \"matches\",\n  regex: \"matches\",\n  is_truthy: \"is-truthy\",\n  truthy: \"is-truthy\",\n  is_falsy: \"is-falsy\",\n  falsy: \"is-falsy\",\n  is_null: \"is-null\",\n  is_not_null: \"is-not-null\",\n  is_odd: \"is-odd\",\n  is_even: \"is-even\",\n  is_empty: \"zero-length\",\n  zero_length: \"zero-length\",\n  has_items: \"g0length\",\n  length_eq: \"length-eq-value\",\n  length_gt: \"length-gt-value\",\n  length_lt: \"length-lt-value\",\n}\n\nconst V2_LOGIC_TO_V1_OPERATOR: Record<ConditionLogic, string> = {\n  \"==\": \"equals\",\n  \"!=\": \"not_equals\",\n  \">\": \"greater_than\",\n  \">=\": \"greater_than_or_equal\",\n  \"<\": \"less_than\",\n  \"<=\": \"less_than_or_equal\",\n  \"in-array\": \"in\",\n  \"not-in-array\": \"not_in\",\n  \"starts-with\": \"starts_with\",\n  \"ends-with\": \"ends_with\",\n  contains: \"contains\",\n  \"not-contains\": \"not_contains\",\n  matches: \"matches\",\n  \"is-odd\": \"is_odd\",\n  \"is-even\": \"is_even\",\n  \"is-truthy\": \"is_truthy\",\n  \"is-falsy\": \"is_falsy\",\n  \"is-null\": \"is_null\",\n  \"is-not-null\": \"is_not_null\",\n  g0length: \"has_items\",\n  n0length: \"is_empty\",\n  \"length-eq-value\": \"length_eq\",\n  \"length-gt-value\": \"length_gt\",\n  \"length-lt-value\": \"length_lt\",\n  \"zero-length\": \"is_empty\",\n}\n\n/** v1 `{field, operator, value}` → v2 `{name, logic, value}`. */\nexport function v1ConditionParamToV2(\n  param: ConditionParamV1,\n): ConditionParam {\n  return {\n    name: param.field,\n    logic: (V1_OPERATOR_TO_V2_LOGIC[param.operator] ?? param.operator) as ConditionLogic,\n    value: param.value,\n  }\n}\n\n/** v2 `{name, logic, value}` → v1 `{field, operator, value}`. */\nexport function v2ConditionParamToV1(\n  param: ConditionParam,\n): ConditionParamV1 {\n  return {\n    field: param.name,\n    operator: V2_LOGIC_TO_V1_OPERATOR[param.logic] ?? String(param.logic),\n    value: param.value,\n  }\n}\n\n/**\n * Convert a v1 conditionParams array (or undefined) to a v2 array.\n * Returns undefined when the input is empty so the converted JSON\n * doesn't carry a useless empty array.\n */\nexport function v1ConditionParamsToV2(\n  params: ConditionParamV1[] | undefined,\n): ConditionParam[] | undefined {\n  if (!params || params.length === 0) {\n    return undefined\n  }\n  return params.map(v1ConditionParamToV2)\n}\n\n/** v1 `cols/colsSm/colsMd/...` → v2 `columns/columnsSm/columnsMd/...`. */\nexport function v1ColumnsToV2(input: ResponsiveColumnsV1): ResponsiveColumns {\n  const out: ResponsiveColumns = {}\n  if (input.cols !== undefined) {\n    out.columns = input.cols\n  }\n  if (input.colsSm !== undefined) {\n    out.columnsSm = input.colsSm\n  }\n  if (input.colsMd !== undefined) {\n    out.columnsMd = input.colsMd\n  }\n  if (input.colsLg !== undefined) {\n    out.columnsLg = input.colsLg\n  }\n  if (input.colsXl !== undefined) {\n    out.columnsXl = input.colsXl\n  }\n  if (input.colsXxl !== undefined) {\n    out.columnsXxl = input.colsXxl\n  }\n  return out\n}\n\n/** v2 → v1 reverse for the columns shape. */\nexport function v2ColumnsToV1(input: ResponsiveColumns): ResponsiveColumnsV1 {\n  const out: ResponsiveColumnsV1 = {}\n  if (input.columns !== undefined) {\n    out.cols = input.columns\n  }\n  if (input.columnsSm !== undefined) {\n    out.colsSm = input.columnsSm\n  }\n  if (input.columnsMd !== undefined) {\n    out.colsMd = input.columnsMd\n  }\n  if (input.columnsLg !== undefined) {\n    out.colsLg = input.columnsLg\n  }\n  if (input.columnsXl !== undefined) {\n    out.colsXl = input.columnsXl\n  }\n  if (input.columnsXxl !== undefined) {\n    out.colsXxl = input.columnsXxl\n  }\n  return out\n}\n\nexport const __testing = {\n  V1_OPERATOR_TO_V2_LOGIC,\n  V2_LOGIC_TO_V1_OPERATOR,\n}\n"],"names":["V1_OPERATOR_TO_V2_LOGIC","V2_LOGIC_TO_V1_OPERATOR","v1ConditionParamToV2","param","v2ConditionParamToV1","v1ConditionParamsToV2","params","v1ColumnsToV2","input","out","v2ColumnsToV1"],"mappings":"AAeA,MAAMA,IAA0D;AAAA,EAC9D,QAAQ;AAAA,EACR,KAAK;AAAA,EACL,MAAM;AAAA,EACN,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,MAAM;AAAA,EACN,OAAO;AAAA,EACP,cAAc;AAAA,EACd,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,uBAAuB;AAAA,EACvB,KAAK;AAAA,EACL,MAAM;AAAA,EACN,WAAW;AAAA,EACX,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,oBAAoB;AAAA,EACpB,KAAK;AAAA,EACL,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,QAAQ;AAAA,EACR,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,UAAU;AAAA,EACV,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAAA,EACf,WAAW;AAAA,EACX,aAAa;AAAA,EACb,SAAS;AAAA,EACT,OAAO;AAAA,EACP,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,SAAS;AAAA,EACT,aAAa;AAAA,EACb,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,aAAa;AAAA,EACb,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AACb,GAEMC,IAA0D;AAAA,EAC9D,MAAM;AAAA,EACN,MAAM;AAAA,EACN,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,eAAe;AAAA,EACf,aAAa;AAAA,EACb,UAAU;AAAA,EACV,gBAAgB;AAAA,EAChB,SAAS;AAAA,EACT,UAAU;AAAA,EACV,WAAW;AAAA,EACX,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,eAAe;AAAA,EACf,UAAU;AAAA,EACV,UAAU;AAAA,EACV,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,eAAe;AACjB;AAGO,SAASC,EACdC,GACgB;AAChB,SAAO;AAAA,IACL,MAAMA,EAAM;AAAA,IACZ,OAAQH,EAAwBG,EAAM,QAAQ,KAAKA,EAAM;AAAA,IACzD,OAAOA,EAAM;AAAA,EAAA;AAEjB;AAGO,SAASC,EACdD,GACkB;AAClB,SAAO;AAAA,IACL,OAAOA,EAAM;AAAA,IACb,UAAUF,EAAwBE,EAAM,KAAK,KAAK,OAAOA,EAAM,KAAK;AAAA,IACpE,OAAOA,EAAM;AAAA,EAAA;AAEjB;AAOO,SAASE,EACdC,GAC8B;AAC9B,MAAI,GAACA,KAAUA,EAAO,WAAW;AAGjC,WAAOA,EAAO,IAAIJ,CAAoB;AACxC;AAGO,SAASK,EAAcC,GAA+C;AAC3E,QAAMC,IAAyB,CAAA;AAC/B,SAAID,EAAM,SAAS,WACjBC,EAAI,UAAUD,EAAM,OAElBA,EAAM,WAAW,WACnBC,EAAI,YAAYD,EAAM,SAEpBA,EAAM,WAAW,WACnBC,EAAI,YAAYD,EAAM,SAEpBA,EAAM,WAAW,WACnBC,EAAI,YAAYD,EAAM,SAEpBA,EAAM,WAAW,WACnBC,EAAI,YAAYD,EAAM,SAEpBA,EAAM,YAAY,WACpBC,EAAI,aAAaD,EAAM,UAElBC;AACT;AAGO,SAASC,EAAcF,GAA+C;AAC3E,QAAMC,IAA2B,CAAA;AACjC,SAAID,EAAM,YAAY,WACpBC,EAAI,OAAOD,EAAM,UAEfA,EAAM,cAAc,WACtBC,EAAI,SAASD,EAAM,YAEjBA,EAAM,cAAc,WACtBC,EAAI,SAASD,EAAM,YAEjBA,EAAM,cAAc,WACtBC,EAAI,SAASD,EAAM,YAEjBA,EAAM,cAAc,WACtBC,EAAI,SAASD,EAAM,YAEjBA,EAAM,eAAe,WACvBC,EAAI,UAAUD,EAAM,aAEfC;AACT;"}

package/dist/adapters/detect.d.ts

@@ -0,0 +1,20 @@
+import { V1PageConfig, V2PageConfig } from './v1ToV2';
+/**
+ * Detect the schema version of a page config and normalise it to the
+ * v2 shape. ShowPage / IndexPage call this at the boundary so a
+ * consumer can pass either shape transparently.
+ *
+ * Detection heuristics (any one of these indicates v1):
+ *   - `cards` is an Array (v2 uses a Record<string, Card>).
+ *   - any tab's `cards[]` contains an object with a `type` string
+ *     instead of `cardType`.
+ *   - top-level `headers` / `options` exist without `cards` / `elements`
+ *     (the IndexPage shorthand).
+ *
+ * When `schemaVersion` is explicitly set on the config, the heuristic
+ * is bypassed — useful for force-routing legacy or new shapes.
+ */
+export declare function normalisePageConfig(config: V1PageConfig | V2PageConfig | (V1PageConfig & {
+    schemaVersion?: "v1" | "v2";
+})): V2PageConfig;
+//# sourceMappingURL=detect.d.ts.map

package/dist/adapters/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/adapters/detect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAG1D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,YAAY,GAAG,YAAY,GAAG,CAAC,YAAY,GAAG;IAAE,aAAa,CAAC,EAAE,IAAI,GAAG,IAAI,CAAA;CAAE,CAAC,GACrF,YAAY,CASd"}

package/dist/adapters/detect.js

@@ -0,0 +1,32 @@
+import { v1ToV2 as o } from "./v1ToV2.js";
+function d(r) {
+  const t = r.schemaVersion;
+  return t === "v2" ? i(r) : t === "v1" || u(r) ? o(r) : i(r);
+}
+function i(r) {
+  return {
+    ...r,
+    cards: r.cards ?? {},
+    elements: r.elements ?? {}
+  };
+}
+function u(r) {
+  const t = r;
+  if (Array.isArray(t.cards) || (t.headers !== void 0 || t.options !== void 0 || t.listKey !== void 0) && !t.cards && !t.elements)
+    return !0;
+  const e = t.tabsList;
+  if (Array.isArray(e))
+    for (const n of e) {
+      const s = n.cards;
+      if (Array.isArray(s)) {
+        for (const a of s)
+          if (typeof a.type == "string" && a.cardType === void 0)
+            return !0;
+      }
+    }
+  return !1;
+}
+export {
+  d as normalisePageConfig
+};
+//# sourceMappingURL=detect.js.map

package/dist/adapters/detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.js","sources":["../../src/adapters/detect.ts"],"sourcesContent":["import type { V1PageConfig, V2PageConfig } from \"./v1ToV2\"\nimport { v1ToV2 } from \"./v1ToV2\"\n\n/**\n * Detect the schema version of a page config and normalise it to the\n * v2 shape. ShowPage / IndexPage call this at the boundary so a\n * consumer can pass either shape transparently.\n *\n * Detection heuristics (any one of these indicates v1):\n *   - `cards` is an Array (v2 uses a Record<string, Card>).\n *   - any tab's `cards[]` contains an object with a `type` string\n *     instead of `cardType`.\n *   - top-level `headers` / `options` exist without `cards` / `elements`\n *     (the IndexPage shorthand).\n *\n * When `schemaVersion` is explicitly set on the config, the heuristic\n * is bypassed — useful for force-routing legacy or new shapes.\n */\nexport function normalisePageConfig(\n  config: V1PageConfig | V2PageConfig | (V1PageConfig & { schemaVersion?: \"v1\" | \"v2\" }),\n): V2PageConfig {\n  const explicit = (config as { schemaVersion?: \"v1\" | \"v2\" }).schemaVersion\n  if (explicit === \"v2\") {\n    return ensureMaps(config as V2PageConfig)\n  }\n  if (explicit === \"v1\" || isLikelyV1(config)) {\n    return v1ToV2(config as V1PageConfig)\n  }\n  return ensureMaps(config as V2PageConfig)\n}\n\nfunction ensureMaps(config: V2PageConfig): V2PageConfig {\n  return {\n    ...config,\n    cards: config.cards ?? {},\n    elements: config.elements ?? {},\n  }\n}\n\nfunction isLikelyV1(config: V1PageConfig | V2PageConfig): boolean {\n  const c = config as Record<string, unknown>\n  // v2 always carries `cards` as a Record. An Array means v1.\n  if (Array.isArray(c.cards)) {\n    return true\n  }\n  // v1 IndexPage shorthand: top-level `headers` / `options` / `listKey`\n  // without a `cards`/`elements` map.\n  if (\n    (c.headers !== undefined || c.options !== undefined || c.listKey !== undefined) &&\n    !c.cards &&\n    !c.elements\n  ) {\n    return true\n  }\n  // v1 tabs: each tab's `cards` is an array of objects with `type`\n  // (string) rather than `cardType`.\n  const tabsList = c.tabsList as Array<Record<string, unknown>> | undefined\n  if (Array.isArray(tabsList)) {\n    for (const tab of tabsList) {\n      const tabCards = tab.cards as Array<Record<string, unknown>> | undefined\n      if (Array.isArray(tabCards)) {\n        for (const card of tabCards) {\n          if (typeof card.type === \"string\" && card.cardType === undefined) {\n            return true\n          }\n        }\n      }\n    }\n  }\n  return false\n}\n"],"names":["normalisePageConfig","config","explicit","ensureMaps","isLikelyV1","v1ToV2","c","tabsList","tab","tabCards","card"],"mappings":";AAkBO,SAASA,EACdC,GACc;AACd,QAAMC,IAAYD,EAA2C;AAC7D,SAAIC,MAAa,OACRC,EAAWF,CAAsB,IAEtCC,MAAa,QAAQE,EAAWH,CAAM,IACjCI,EAAOJ,CAAsB,IAE/BE,EAAWF,CAAsB;AAC1C;AAEA,SAASE,EAAWF,GAAoC;AACtD,SAAO;AAAA,IACL,GAAGA;AAAA,IACH,OAAOA,EAAO,SAAS,CAAA;AAAA,IACvB,UAAUA,EAAO,YAAY,CAAA;AAAA,EAAC;AAElC;AAEA,SAASG,EAAWH,GAA8C;AAChE,QAAMK,IAAIL;AAOV,MALI,MAAM,QAAQK,EAAE,KAAK,MAMtBA,EAAE,YAAY,UAAaA,EAAE,YAAY,UAAaA,EAAE,YAAY,WACrE,CAACA,EAAE,SACH,CAACA,EAAE;AAEH,WAAO;AAIT,QAAMC,IAAWD,EAAE;AACnB,MAAI,MAAM,QAAQC,CAAQ;AACxB,eAAWC,KAAOD,GAAU;AAC1B,YAAME,IAAWD,EAAI;AACrB,UAAI,MAAM,QAAQC,CAAQ;AACxB,mBAAWC,KAAQD;AACjB,cAAI,OAAOC,EAAK,QAAS,YAAYA,EAAK,aAAa;AACrD,mBAAO;AAAA;AAAA,IAIf;AAEF,SAAO;AACT;"}

package/dist/adapters/fieldTypeMap.d.ts

@@ -0,0 +1,28 @@
+import { ElementType } from '../definitions/shared/base';
+/**
+ * v1 field-type strings → v2 dot-notation `type` (with optional extras).
+ *
+ * v1's schema used a single string like `"text"`, `"select"`, `"date"`
+ * for the field type. v2 combines the category + variant into a
+ * dot-notation string like `"input.text"`, `"option-select.select"`,
+ * `"picker.date-picker"`. This table is the canonical map; the
+ * adapter consults it once per field.
+ *
+ * Some v1 types (the `heading-N` variants) map to a single v2 type
+ * (`display.type`) plus an extra `contentType` payload. Those entries
+ * carry an `extras` block that's spread onto the converted element.
+ */
+export interface V2Discriminator {
+    /** Dot-notation v2 type, e.g. `"input.text"`. */
+    type: ElementType;
+    /** Extra fields to merge into the converted element. */
+    extras?: Record<string, unknown>;
+}
+export declare const V1_TO_V2_FIELD_TYPE: Record<string, V2Discriminator>;
+/**
+ * v2 dot-notation `type` → v1 single-string field type. Picks the
+ * canonical v1 name when multiple existed (e.g. `editor.code-editor`
+ * → `"codeEditor"`).
+ */
+export declare function v2ToV1FieldType(type: string): string;
+//# sourceMappingURL=fieldTypeMap.d.ts.map

package/dist/adapters/fieldTypeMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldTypeMap.d.ts","sourceRoot":"","sources":["../../src/adapters/fieldTypeMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,IAAI,EAAE,WAAW,CAAA;IACjB,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACjC;AAED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CA0H/D,CAAA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD"}