@jsonui/core 0.9.0 → 0.10.8

package/dist/esm/index.js

@@ -1,682 +1,1118 @@
-import {__rest}from'tslib';import {jsx}from'react/jsx-runtime';import orderBy from'lodash/orderBy';import traverse from'traverse';import jsonpointer from'jsonpointer';import cloneDeep from'lodash/cloneDeep';import findIndex from'lodash/findIndex';import pull from'lodash/pull';import Ajv from'ajv';import keyValueReplace from'key-value-replace';import {createContext}from'react';import jsonata$1 from'jsonata';import {combineReducers}from'redux';import {produce,current}from'immer';import ajvErrors from'ajv-errors';import ajvFormats from'ajv-formats';class Stock {
-    constructor(newStock, Wrapper, reduxStore) {
-        this.init = ({ components, functions }) => {
-            this.stock.components = Object.assign(Object.assign({}, this.stock.components), components);
-            this.stock.functions = Object.assign(Object.assign({}, this.stock.functions), functions);
-        };
-        this.registerComponent = (key, value) => {
-            if (!!key && typeof key === 'string' && key.length > 0 && !(key in this.stock.components)) {
-                this.stock.components[key] = value;
-            }
-        };
-        this.registerFunction = (key, value) => {
-            if (!!key && typeof key === 'string' && key.length > 0 && !(key in this.stock.functions)) {
-                this.stock.functions[key] = value;
-            }
-        };
-        this.callFunction = (name, attr, props, callerArgs) => {
-            if (!!attr && !!name && name in this.stock.functions) {
-                const result = this.stock.functions[name](attr, props, callerArgs, this);
-                return result;
-            }
-            return null;
-        };
-        this.getComponent = (componentName) => !!componentName && componentName in this.stock.components
-            ? this.stock.components[componentName]
-            : // eslint-disable-next-line no-underscore-dangle
-                this.stock.components._Undefined;
-        this.stock = {
-            components: {},
-            functions: {},
-        };
-        this.Wrapper = Wrapper;
-        this.validations = [];
-        this.reduxStore = reduxStore;
-        this.init(newStock);
-    }
-}const SEPARATOR = '/';
-const STORE_ERROR_POSTFIX = '.error';
-const STORE_TOUCH_POSTFIX = '.touch';
-const PATH_MODIFIERS_KEY = '$pathModifiers';
-const MODIFIER_KEY = '$modifier';
+import Ajv from'ajv';import addFormats from'ajv-formats';import ajvErrors from'ajv-errors';const V_COMP = '$comp';
+const V_CHILDREN = '$children';
 const ACTION_KEY = '$action';
-const REF_ASSETS = '$assetsRef';
-const REF_LOCALES = '$locales';
-const REF_VALIDATES = '$validations';
-const STYLE_WEB_NAME = 'styleWeb';
-const STYLE_RN_NAME = 'styleRN';
-const REDUX_GET_FUNCTION = 'get';
-const REDUX_SET_FUNCTION = 'set';
-const REDUX_FUNCTIONS = [REDUX_GET_FUNCTION, REDUX_SET_FUNCTION];
-const PATHNAME = 'path';
-const SIMPLE_DATA_TYPES = ['string', 'number', 'boolean', 'null'];
-const V_CHILDREN_NAME = '$children';
-const V_COMP_NAME = '$comp';
+const MODIFIER_KEY = '$modifier';
+const PATH_MODIFIERS_KEY = '$pathModifiers';
 const LIST_SEMAPHORE = '$isList';
 const LIST_ITEM = '$listItem';
+/** Main JsonUI list pagination keys (parity). */
 const LIST_PAGE = '$page';
 const LIST_ITEM_PER_PAGE = '$itemPerPage';
 const LIST_LENGTH = '$listLength';
-const LIST_ITEM_PER_PAGE_DEFAULT = 10;
-const REDUX_PATHS = '$$reduxPaths';
-const V_CHILDREN_PREFIX = '$child';
-const PARENT_PROP_NAME = '__parentprop';
-const CURRENT_PATH_NAME = '__currentPaths';
-const REDUX_GET_SUBSCRIBERS_NAME = '__subscriberPaths';
-const UNDEFINED_COMP_NAME = '_Undefined';
-const PRIMITIVE_COMP_NAME = '_PrimitiveProp'; // TODO check all literal and replace with this constant
-const FRAGMENT_COMP_NAME = 'Fragment'; // TODO check all literal and replace with this constant
-var constants=/*#__PURE__*/Object.freeze({__proto__:null,ACTION_KEY:ACTION_KEY,CURRENT_PATH_NAME:CURRENT_PATH_NAME,FRAGMENT_COMP_NAME:FRAGMENT_COMP_NAME,LIST_ITEM:LIST_ITEM,LIST_ITEM_PER_PAGE:LIST_ITEM_PER_PAGE,LIST_ITEM_PER_PAGE_DEFAULT:LIST_ITEM_PER_PAGE_DEFAULT,LIST_LENGTH:LIST_LENGTH,LIST_PAGE:LIST_PAGE,LIST_SEMAPHORE:LIST_SEMAPHORE,MODIFIER_KEY:MODIFIER_KEY,PARENT_PROP_NAME:PARENT_PROP_NAME,PATHNAME:PATHNAME,PATH_MODIFIERS_KEY:PATH_MODIFIERS_KEY,PRIMITIVE_COMP_NAME:PRIMITIVE_COMP_NAME,REDUX_FUNCTIONS:REDUX_FUNCTIONS,REDUX_GET_FUNCTION:REDUX_GET_FUNCTION,REDUX_GET_SUBSCRIBERS_NAME:REDUX_GET_SUBSCRIBERS_NAME,REDUX_PATHS:REDUX_PATHS,REDUX_SET_FUNCTION:REDUX_SET_FUNCTION,REF_ASSETS:REF_ASSETS,REF_LOCALES:REF_LOCALES,REF_VALIDATES:REF_VALIDATES,SEPARATOR:SEPARATOR,SIMPLE_DATA_TYPES:SIMPLE_DATA_TYPES,STORE_ERROR_POSTFIX:STORE_ERROR_POSTFIX,STORE_TOUCH_POSTFIX:STORE_TOUCH_POSTFIX,STYLE_RN_NAME:STYLE_RN_NAME,STYLE_WEB_NAME:STYLE_WEB_NAME,UNDEFINED_COMP_NAME:UNDEFINED_COMP_NAME,V_CHILDREN_NAME:V_CHILDREN_NAME,V_CHILDREN_PREFIX:V_CHILDREN_PREFIX,V_COMP_NAME:V_COMP_NAME});const findLastIndex = (arr, func) => {
-    const reverseIdx = [...arr].reverse().findIndex(func);
-    return reverseIdx === -1 ? reverseIdx : arr.length - (reverseIdx + 1);
+/** Field-level inline validation spec key on a node. */
+const V_VALIDATIONS = '$validations';
+// Store-name suffixes for parallel trees (errors, touch-state, etc.).
+const ERROR_STORE_SUFFIX = '.error';
+/** Shadow store for field touched state (aligned with main JsonUI `.touch`). */
+const TOUCH_STORE_SUFFIX = '.touch';
+const JSON_SEPARATOR = '/';
+// Single-root store layout helper.
+// All logical stores live under `/storeRoot/{storeName}/...`.
+const STORE_ROOT_PATH = '/storeRoot';/**
+ * Shared helpers for function handlers.
+ */
+const hasAnyError$1 = (value) => {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value)) {
+        return value.some((v) => hasAnyError$1(v));
+    }
+    if (typeof value === 'object') {
+        return Object.values(value).some((v) => hasAnyError$1(v));
+    }
+    // Any non-null / non-undefined primitive counts as "has error".
+    return true;
 };
-const drop = (arr, n = 1) => arr.slice(n);
-const isNumber = (a) => typeof a === 'number';
-const jsonPointerFix = (path) => {
-    if (path !== null && path !== undefined && typeof path === 'string') {
-        let str = path;
-        str = str.charAt(str.length - 1) === SEPARATOR ? str.slice(0, -1) : str;
-        str = str.startsWith(SEPARATOR) ? str : `${SEPARATOR}${str}`;
-        return str;
-    }
-    return SEPARATOR;
+const hasAnyTouched$1 = (value) => {
+    if (value === true)
+        return true;
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value)) {
+        return value.some((v) => hasAnyTouched$1(v));
+    }
+    if (typeof value === 'object') {
+        return Object.values(value).some((v) => hasAnyTouched$1(v));
+    }
+    return false;
 };
-const jsonPointerGet = (json, path) => {
-    if (json === undefined || path === null || path === undefined || typeof path !== 'string')
-        return undefined;
-    if (path === SEPARATOR /* || path === '' same effect */)
-        return json;
-    try {
-        return jsonpointer.get(json, jsonPointerFix(path));
+/**
+ * Throws if value contains anything that cannot round-trip through JSON:
+ * undefined, function, symbol, bigint, NaN, non-finite numbers, or circular references.
+ */
+const assertJsonCompatible = (value, seen = new WeakSet()) => {
+    if (value === null)
+        return;
+    if (value === undefined)
+        throw new Error('undefined is not JSON-compatible');
+    const type = typeof value;
+    if (type === 'string' || type === 'boolean')
+        return;
+    if (type === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error(`Non-finite number is not JSON-compatible: ${value}`);
+        return;
     }
-    catch (_a) {
-        return undefined;
+    if (type === 'function' || type === 'symbol' || type === 'bigint') {
+        throw new Error(`${type} is not JSON-compatible`);
+    }
+    const obj = value;
+    if (seen.has(obj))
+        throw new Error('Circular reference is not JSON-compatible');
+    seen.add(obj);
+    if (Array.isArray(value)) {
+        for (const item of value)
+            assertJsonCompatible(item, seen);
     }
+    else {
+        for (const v of Object.values(value))
+            assertJsonCompatible(v, seen);
+    }
+    seen.delete(obj);
 };
-const jsonPointerSet = (json, path, value) => {
-    if (json === undefined || path === null || path === undefined || typeof path !== 'string')
-        return json;
-    if (path === SEPARATOR || path === '') {
+/**
+ * Deep clone helper used by get() so callers cannot mutate the internal store state.
+ * Only JSON-compatible values are accepted; functions and other non-JSON types throw.
+ */
+const cloneDeep = (value) => {
+    if (value === null || value === undefined)
+        return value;
+    const type = typeof value;
+    if (type !== 'object') {
+        if (type === 'function' || type === 'symbol' || type === 'bigint') {
+            throw new Error(`${type} is not JSON-compatible`);
+        }
+        if (type === 'number' && !Number.isFinite(value)) {
+            throw new Error(`Non-finite number is not JSON-compatible: ${value}`);
+        }
         return value;
     }
-    try {
-        jsonpointer.set(json, jsonPointerFix(path), value);
-        return json;
-        // eslint-disable-next-line no-empty
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneDeep(item));
+    }
+    const obj = value;
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        result[key] = cloneDeep(obj[key]);
     }
-    catch (_a) {
-        return json;
+    return result;
+};/**
+ * Minimal JSON Pointer implementation (RFC 6901).
+ * Supports get, set, and path resolution (absolute, relative, ./ ../).
+ *
+ * Paths and nesting are unbounded: e.g. /a/b/c/0/d/e/1/f is valid;
+ * segments can be object keys or array indices (numeric strings).
+ */
+/**
+ * Normalize a path: remove empty segments and trailing/leading slashes.
+ * Prevents accidental keys like "" from paths such as "//" or "/a/".
+ * Does not decode segments (e.g. ~1 stays so one segment is preserved).
+ */
+const normalizePath = (pathStr) => {
+    if (!pathStr || pathStr === '/')
+        return '/';
+    const trimmed = pathStr.startsWith('/') ? pathStr.slice(1) : pathStr;
+    const segments = trimmed.split(JSON_SEPARATOR).filter((s) => s !== '');
+    return segments.length === 0 ? '/' : JSON_SEPARATOR + segments.join(JSON_SEPARATOR);
+};
+const parsePath = (pathStr) => {
+    if (!pathStr || pathStr === '/')
+        return [];
+    if (!pathStr.startsWith(JSON_SEPARATOR)) {
+        throw new Error(`Invalid JSON Pointer path: ${pathStr}`);
     }
+    return pathStr.slice(1).split(JSON_SEPARATOR).map(decode);
 };
-const pathArrayToPathString = (array) => array.map((i, index) => (Number.isInteger(i) ? `[${i}]` : `${index > 0 ? '.' : ''}${i}`)).join('');
-const pathArrayToJsonPointer = (array) => `/${array.join('/')}`;
-function isOnlyObject(item) {
-    return !!item && typeof item === 'object' && !Array.isArray(item);
-}
-const mergePath = (target, newState) => {
-    if (!newState || typeof newState !== 'object')
-        return target;
-    let newTarget = cloneDeep(target);
-    Object.entries(newState).forEach(([key, value]) => {
-        newTarget = jsonPointerSet(newTarget, key, value);
-    });
-    return newTarget;
+const decode = (segment) => {
+    for (let i = 0; i < segment.length; i++) {
+        if (segment[i] === '~') {
+            const next = segment[i + 1];
+            if (next !== '0' && next !== '1') {
+                throw new Error(`Invalid JSON Pointer escape in segment: ${segment}`);
+            }
+            i += 1;
+        }
+    }
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+};
+const encode = (segment) => {
+    return String(segment).replace(/~/g, '~0').replace(/\//g, '~1');
+};
+const get$1 = (obj, pathStr) => {
+    const segments = parsePath(pathStr); // parsePath normalizes, so /a//b/ -> /a/b
+    let current = obj;
+    for (const seg of segments) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[seg];
+    }
+    return current;
+};
+/**
+ * Resolve a path against a base path (for relative paths like ./x, ../y).
+ * Supports arbitrary depth; excess ".." yields root then appends remaining segments.
+ */
+const resolvePath = (basePath, relativePath) => {
+    if (relativePath.startsWith('/'))
+        return normalizePath(relativePath);
+    const baseSegments = parsePath(basePath);
+    const relSegments = relativePath.split(JSON_SEPARATOR).filter(Boolean);
+    for (const seg of relSegments) {
+        if (seg === '..') {
+            baseSegments.pop();
+        }
+        else if (seg !== '.') {
+            baseSegments.push(decode(seg));
+        }
+    }
+    return JSON_SEPARATOR + baseSegments.map(encode).join(JSON_SEPARATOR);
+};/**
+ * Tree-shaped state management with multiple stores.
+ * Similar to Redux but tailored for JSON UI: per-store trees, JSON Pointer paths.
+ *
+ * Store paths are unbounded and can be arbitrarily nested (objects and arrays),
+ * e.g. /a/b/c/2/d/e/0/f. Logical paths are resolved via resolveStorePath and
+ * applied consistently in get/set.
+ */
+const isTouchOrErrorShadowStore = (storeName) => {
+    return storeName.endsWith(TOUCH_STORE_SUFFIX) || storeName.endsWith(ERROR_STORE_SUFFIX);
 };
-// eslint-disable-next-line import/prefer-default-export
-const changeRelativePath = (path) => {
-    let pathArray = path.split(SEPARATOR);
-    // remove last /
-    if (pathArray && pathArray.length > 1 && pathArray[pathArray.length - 1] === '' && !(pathArray.length === 2 && pathArray[0] === '')) {
-        pathArray.pop();
-    }
-    // the last / is meaningful
-    const absolutepathIndex = findLastIndex(pathArray, (i) => i === '');
-    if (absolutepathIndex > 0) {
-        pathArray = drop(pathArray, absolutepathIndex);
-    }
-    // all . need to remove because is just pointing the prev level
-    pathArray = pull(pathArray, '.');
-    let count = 0;
-    let relativepathIndex = -1;
-    do {
-        count += 1;
-        relativepathIndex = findIndex(pathArray, (i) => i === '..');
-        if (relativepathIndex !== -1) {
-            pathArray.splice(relativepathIndex, 1);
-            pathArray.splice(relativepathIndex - 1, 1);
-        }
-    } while (relativepathIndex !== -1 && count < 100);
-    pathArray = pull(pathArray, '..');
-    if (pathArray.length === 1 && pathArray[0] !== '') {
-        pathArray = ['', ...pathArray];
-    }
-    return pathArray.join(SEPARATOR);
+class FormStore {
+    constructor() {
+        this.state = {};
+        this.changeListeners = new Set();
+    }
+    getState() {
+        return cloneDeep(this.state);
+    }
+    /**
+     * Logical JsonUI stores snapshot — same shape as `JsonUI` `defaultValues`:
+     * `{ data: {...}, "data.touch": {...}, "data.error": {...} }`.
+     * Omits the internal `/storeRoot` wrapper returned by {@link getState}.
+     */
+    getLogicalStoresMap() {
+        const slice = get$1(this.state, STORE_ROOT_PATH);
+        if (slice === undefined || slice === null || typeof slice !== 'object' || Array.isArray(slice)) {
+            return {};
+        }
+        return cloneDeep(slice);
+    }
+    /**
+     * Initialise a logical store root without marking fields as touched.
+     */
+    initializeStore(storeName, value) {
+        this.set(storeName, '/', value, false);
+    }
+    getByPointer(path) {
+        const value = get$1(this.state, path);
+        return cloneDeep(value);
+    }
+    setByPointer(path, value) {
+        assertJsonCompatible(value);
+        this.state = setImmutable(this.state, path, value);
+        this.notify();
+    }
+    /**
+     * Convenience helpers that work with logical store names and logical paths,
+     * instead of requiring callers to compose `/storeRoot/{storeName}/...`.
+     *
+     * Store isolation: each storeName (e.g. "data", "data.error", "data.touch") is
+     * a distinct store. get/set only read/write that store's subtree;
+     * "data.error" cannot access "data" or any other store.
+     *
+     * When trackTouch is true, set also writes to `${storeName}.touch` at
+     * the same logicalPath; path normalization applies (no empty segments).
+     */
+    set(storeName, logicalPath, value, trackTouch = true) {
+        const internalPath = makeStorePath(storeName, logicalPath);
+        this.setByPointer(internalPath, value);
+        if (trackTouch && !isTouchOrErrorShadowStore(storeName)) {
+            const touchStoreName = `${storeName}${TOUCH_STORE_SUFFIX}`;
+            this.setByPointer(makeStorePath(touchStoreName, logicalPath), true);
+        }
+        // Notify fine-grained listeners with logical store name + path so
+        // JsonUI can re-resolve only components that depend on this slice.
+        this.notifyChange(storeName, logicalPath);
+    }
+    get(storeName, logicalPath) {
+        const internalPath = makeStorePath(storeName, logicalPath);
+        return this.getByPointer(internalPath);
+    }
+    // Backward-compatible aliases for existing consumers.
+    setForStore(storeName, logicalPath, value, trackTouch = true) {
+        this.set(storeName, logicalPath, value, trackTouch);
+    }
+    // Backward-compatible aliases for existing consumers.
+    getForStore(storeName, logicalPath) {
+        return this.get(storeName, logicalPath);
+    }
+    notify() {
+        // No coarse-grained subscription API is exposed intentionally.
+    }
+    subscribeChange(listener) {
+        this.changeListeners.add(listener);
+        return () => this.changeListeners.delete(listener);
+    }
+    notifyChange(storeName, logicalPath) {
+        this.changeListeners.forEach((l) => l(storeName, logicalPath));
+    }
+}
+const makeStorePath = (storeName, path) => {
+    if (!storeName || storeName.length === 0) {
+        throw new Error('storeName must be a non-empty string');
+    }
+    const base = `${STORE_ROOT_PATH}/${storeName}`;
+    const pointerPath = !path || path === '/' ? '/' : path.startsWith('/') ? path : `/${path}`;
+    const normalized = normalizePath(pointerPath);
+    if (normalized === '/')
+        return base;
+    return base + normalized;
 };
 /**
- * Deep merge two objects.
- * @param target
- * @param ...sources
+ * Immutable variant of ptrSet: returns a new root object with the change applied,
+ * without mutating the original tree. Only the objects/arrays along the path are
+ * shallow-copied; unrelated subtrees are structurally shared for performance.
  */
-function mergeDeep(target, ...sources) {
-    if (!sources.length)
-        return target;
-    const source = sources.shift();
-    if (isOnlyObject(target) && isOnlyObject(source)) {
-        // eslint-disable-next-line no-restricted-syntax
-        for (const key in source) {
-            if (isOnlyObject(source[key])) {
-                if (!target[key])
-                    Object.assign(target, { [key]: {} });
-                mergeDeep(target[key], source[key]);
+const setImmutable = (root, pathStr, value) => {
+    const segments = parsePath(pathStr);
+    if (segments.length === 0)
+        return root;
+    const originalRoot = root;
+    const cloneContainer = (container) => {
+        if (Array.isArray(container)) {
+            return container.slice();
+        }
+        if (container && typeof container === 'object') {
+            return { ...container };
+        }
+        return {};
+    };
+    const setAt = (current, index) => {
+        const isLast = index === segments.length - 1;
+        const seg = segments[index];
+        const container = cloneContainer(current);
+        if (isLast) {
+            const lastSeg = seg;
+            const lastKey = lastSeg === '' || /^\d+$/.test(lastSeg) ? parseInt(lastSeg, 10) : lastSeg;
+            if (Array.isArray(container)) {
+                container[lastKey] = value;
             }
             else {
-                Object.assign(target, { [key]: source[key] });
+                container[lastSeg] = value;
             }
+            return { cloned: container, result: container };
         }
+        const nextSeg = segments[index + 1];
+        const nextKey = nextSeg === '' || /^\d+$/.test(nextSeg) ? parseInt(nextSeg, 10) : nextSeg;
+        // Non-last segment: ensure child container exists before descending.
+        const keyForChild = seg;
+        let next = Array.isArray(container) && /^\d+$/.test(seg) ? container[parseInt(seg, 10)] : container[seg];
+        if (next == null ||
+            typeof next !== 'object' ||
+            (Array.isArray(next) && typeof nextKey === 'string') ||
+            (!Array.isArray(next) && typeof nextKey === 'number')) {
+            next = typeof nextKey === 'number' ? [] : {};
+        }
+        const { result: childClone } = setAt(next, index + 1);
+        if (Array.isArray(container) && /^\d+$/.test(String(keyForChild))) {
+            container[parseInt(String(keyForChild), 10)] = childClone;
+        }
+        else {
+            container[String(keyForChild)] = childClone;
+        }
+        return { cloned: container, result: container };
+    };
+    const { result } = setAt(originalRoot, 0);
+    return result;
+};
+/**
+ * Resolve a path for a given store, using pathModifiers (from list context) and currentPath for relative paths.
+ * - Absolute path: /firstname -> unchanged (then normalized).
+ * - Relative path: firstname -> resolved against currentPath (or pathModifiers[storeName] when in list context).
+ * - pathModifiers apply per store: only pathModifiers[storeName] is used for that store; "data.error" cannot
+ *   access "data" or any other store.
+ * Returns a normalized path (no empty segments, no trailing slash).
+ */
+const resolveStorePath = (pathStr, currentPath, pathModifiers, storeName) => {
+    let resolved;
+    const modifier = pathModifiers !== undefined && storeName !== undefined && Object.prototype.hasOwnProperty.call(pathModifiers, storeName)
+        ? pathModifiers[storeName]
+        : undefined;
+    if (modifier !== undefined) {
+        resolved = resolvePath(modifier.path, pathStr);
     }
-    return mergeDeep(target, ...sources);
-}
-const collectObjMerge = (refConst, json) => {
-    const res = {};
-    if (refConst && json && typeof json === 'object') {
-        const refs = [];
-        // eslint-disable-next-line func-names
-        traverse(json).forEach(function (x) {
-            if (x && !!x[refConst] && !!this && !this.circular) {
-                refs.push(x[refConst]);
-            }
-        });
-        refs.filter((i) => !!i).forEach((i) => mergeDeep(res, i));
+    else if (pathStr.startsWith('/')) {
+        resolved = pathStr;
     }
-    return res;
+    else {
+        resolved = resolvePath(currentPath, pathStr);
+    }
+    return normalizePath(resolved);
+};const createSetAction = (formStore) => {
+    return async (params, ctx) => {
+        const storeName = params.store;
+        const path = params.path;
+        let value = params.value;
+        const jsonataDef = params.jsonataDef;
+        if (!storeName || storeName.length === 0)
+            return;
+        if (typeof jsonataDef === 'string' && jsonataDef) {
+            try {
+                const jsonata = (await import('jsonata')).default;
+                const expr = jsonata(jsonataDef);
+                value = await expr.evaluate(value);
+            }
+            catch {
+                value = params.value;
+            }
+        }
+        const logicalPath = resolveStorePath(path, ctx?.currentPath ?? '/', ctx?.pathModifiers, storeName);
+        formStore.set(storeName, logicalPath, value);
+    };
+};const set = (params, ctx) => {
+    const setFn = createSetAction(ctx.formStore);
+    return setFn(params, ctx);
+};const actions = {
+    set,
+};/**
+ * Expands simplified node format into full JSON UI node so components receive
+ * value, onChange, error, etc. without the model having to specify every binding.
+ *
+ * When a node has store + path (non-empty store, string path), we add:
+ * - value: { $modifier: 'get', store, path }
+ * - onChange: { $action: 'set', store, path }
+ * - error / fieldErrors: { $modifier: 'get', store: store + '.error', path }
+ * - fieldTouched: { $modifier: 'get', store: store + '.touch', path }
+ *
+ * The component is unchanged; RenderNode uses the expanded node for prop
+ * resolution and the expanded props are passed through normally.
+ */
+const isSimplifiedNode = (node) => {
+    if (typeof node !== 'object' || node === null)
+        return false;
+    const r = node;
+    const store = r.store;
+    const path = r.path;
+    return typeof store === 'string' && store.length > 0 && typeof path === 'string';
 };
-const collectObjToArray = (refConst, json, flatten = false) => {
-    if (refConst && json && typeof json === 'object') {
-        const refs = [];
-        // eslint-disable-next-line func-names
-        traverse(json).forEach(function (x) {
-            if (x && !!x[refConst] && !!this && !this.circular) {
-                refs.push(x[refConst]);
+/**
+ * Returns an expanded node with value, onChange, error, fieldErrors, fieldTouched
+ * derived from store + path. Strips store and path from the result so they are
+ * not passed as component props.
+ * If the node is not simplified, returns the same node reference.
+ */
+const expandSimplifiedNode = (node) => {
+    if (!isSimplifiedNode(node) && node[V_COMP] !== 'SubmitButton') {
+        return node;
+    }
+    const { store, path, ...rest } = node;
+    const expanded = {
+        ...(node[V_COMP] === 'SubmitButton'
+            ? {
+                onClick: {
+                    [ACTION_KEY]: 'submit',
+                },
             }
-        });
-        return flatten === true ? refs.flat() : refs;
+            : {}),
+        ...(isSimplifiedNode(node)
+            ? {
+                value: {
+                    [MODIFIER_KEY]: 'get',
+                    store,
+                    path,
+                },
+                onChange: {
+                    [ACTION_KEY]: 'set',
+                    store,
+                    path,
+                },
+                fieldErrors: {
+                    [MODIFIER_KEY]: 'get',
+                    store,
+                    path,
+                    type: 'ERROR',
+                },
+                fieldTouched: {
+                    [MODIFIER_KEY]: 'get',
+                    store,
+                    path,
+                    type: 'TOUCH',
+                },
+            }
+            : {
+                //if is not a simplified node, we should add store and path props
+                store,
+                path,
+            }),
+        ...rest,
+    };
+    return expanded;
+};const computeListSliceRange = ({ realDataLength, page: pageRaw, itemPerPage: itemPerPageRaw, listLength: listLengthRaw, }) => {
+    const coerceNonNegInt = (v, fallback) => {
+        if (typeof v === 'number' && Number.isInteger(v) && v >= 0)
+            return v;
+        return fallback;
+    };
+    let listLength = coerceNonNegInt(listLengthRaw, realDataLength);
+    if (listLengthRaw === undefined) {
+        listLength = realDataLength;
     }
-    return [];
+    const itemPerPage = coerceNonNegInt(itemPerPageRaw, listLength);
+    const page = coerceNonNegInt(pageRaw, 0);
+    const offset = page * itemPerPage <= listLength ? page * itemPerPage : 0;
+    const end = Math.min(listLength, offset + itemPerPage);
+    const indices = [];
+    for (let i = offset; i < end; i++)
+        indices.push(i);
+    return { offset, end, indices };
+};const getOwnPathModifiers = (node) => {
+    return node[PATH_MODIFIERS_KEY];
 };
-const isValidJson = (d) => {
-    try {
-        JSON.stringify(d);
+const mergeEffectivePathModifiers = ({ ownPathModifiers, pathModifiers, currentPath, }) => {
+    if (!ownPathModifiers || typeof ownPathModifiers !== 'object') {
+        return pathModifiers;
+    }
+    const merged = {
+        ...(pathModifiers ?? {}),
+    };
+    for (const [storeName, spec] of Object.entries(ownPathModifiers)) {
+        if (typeof spec !== 'object')
+            continue;
+        const rawPath = spec.path;
+        if (typeof rawPath !== 'string' || rawPath.length === 0)
+            continue;
+        const resolved = resolveStorePath(rawPath, currentPath, pathModifiers, storeName);
+        merged[storeName] = { path: resolved };
     }
-    catch (_a) {
+    return merged;
+};/** Segment-aware path overlap check (aligned with validation.ts). */
+const isPathPrefix$1 = (rulePath, targetPath) => {
+    const r = rulePath === '' ? '/' : rulePath;
+    const t = targetPath === '' ? '/' : targetPath;
+    if (r === '/')
+        return true;
+    if (t === r)
+        return true;
+    return t.startsWith(r.endsWith('/') ? r : `${r}/`);
+};const hasAnyError = (value) => {
+    if (value === null || value === undefined)
         return false;
+    if (Array.isArray(value)) {
+        return value.some((v) => hasAnyError(v));
+    }
+    if (typeof value === 'object') {
+        return Object.values(value).some((v) => hasAnyError(v));
     }
     return true;
 };
-const isPrimitiveValue = (value, emptyStringAllowed = false) => value !== 'undefined' && value !== null && ['string', 'boolean', 'number', 'bigint'].includes(typeof value) && (value !== '' || emptyStringAllowed);
-const hasLeaf = (obj, emptyStringAllowed) => {
-    if (typeof obj === 'object') {
-        // eslint-disable-next-line no-restricted-syntax
-        for (const key in obj) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (obj.hasOwnProperty(key)) {
-                const value = obj[key];
-                if (typeof value === 'object') {
-                    return hasLeaf(value);
-                }
-                return isPrimitiveValue(value, emptyStringAllowed);
-            }
-        }
+const hasAnyTouched = (value) => {
+    if (value === true)
+        return true;
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value)) {
+        return value.some((v) => hasAnyTouched(v));
     }
-    return isPrimitiveValue(obj, emptyStringAllowed);
-};var jsonUtils=/*#__PURE__*/Object.freeze({__proto__:null,changeRelativePath:changeRelativePath,collectObjMerge:collectObjMerge,collectObjToArray:collectObjToArray,drop:drop,findLastIndex:findLastIndex,hasLeaf:hasLeaf,isNumber:isNumber,isOnlyObject:isOnlyObject,isPrimitiveValue:isPrimitiveValue,isValidJson:isValidJson,jsonPointerFix:jsonPointerFix,jsonPointerGet:jsonPointerGet,jsonPointerSet:jsonPointerSet,mergeDeep:mergeDeep,mergePath:mergePath,pathArrayToJsonPointer:pathArrayToJsonPointer,pathArrayToPathString:pathArrayToPathString});const getFilteredPath = (_a, func) => {
-    var _b = PARENT_PROP_NAME; _a[_b]; var propsNew = __rest(_a, [_b + ""]);
-    const paths = [];
-    function* jsonTraverse(o) {
-        const memory = new Set();
-        function* innerTraversal(oo, path = []) {
-            var _a;
-            if (memory.has(oo)) {
-                return; // circular
+    if (typeof value === 'object') {
+        return Object.values(value).some((v) => hasAnyTouched(v));
+    }
+    return false;
+};
+const createGetModifier = (formStore) => {
+    return async (params, ctx) => {
+        const storeName = params.store;
+        const path = params.path;
+        const type = params.type;
+        const jsonataDef = params.jsonataDef;
+        const resolvedStoreName = type === 'ERROR' ? `${storeName}${ERROR_STORE_SUFFIX}` : type === 'TOUCH' ? `${storeName}${TOUCH_STORE_SUFFIX}` : storeName;
+        // Path modifiers are keyed by the logical/base store (e.g. "data"),
+        // not by shadow stores like "data.error".
+        const logicalPath = resolveStorePath(path, ctx.currentPath, ctx.pathModifiers, storeName);
+        let value = formStore.get(resolvedStoreName, logicalPath);
+        // For ERROR lookups, leaf-less containers (e.g. { players: [{}] })
+        // mean there is no actual validation message in the subtree.
+        if (type === 'ERROR' && !hasAnyError(value)) {
+            value = undefined;
+        }
+        // TODO need to test hasAnyTouched and hasAnyError
+        if (type === 'TOUCH') {
+            value = hasAnyTouched(value);
+        }
+        if (jsonataDef && value !== undefined) {
+            try {
+                const jsonata = (await import('jsonata')).default;
+                const expr = jsonata(jsonataDef);
+                value = await expr.evaluate(value);
             }
-            memory.add(oo);
-            // eslint-disable-next-line no-restricted-syntax
-            for (const i of Object.keys(oo)) {
-                const itemPath = path.concat(i);
-                if (itemPath && itemPath.length > 1 && typeof oo[i] === 'object' && ((_a = oo[i]) === null || _a === void 0 ? void 0 : _a[V_COMP_NAME])) {
-                    // eslint-disable-next-line no-continue
-                    continue;
-                }
-                if (i === PARENT_PROP_NAME || i === CURRENT_PATH_NAME || i === LIST_ITEM) {
-                    // eslint-disable-next-line no-continue
-                    continue;
-                }
-                if (func({ key: i, value: oo[i], path, parent: oo, level: path.length })) {
-                    yield { key: i, value: oo[i], path, parent: oo, level: path.length };
-                }
-                if (oo[i] !== null && typeof oo[i] === 'object') {
-                    yield* innerTraversal(oo[i], itemPath);
-                }
+            catch {
+                // fallback
             }
         }
-        yield* innerTraversal(o);
+        return value;
+    };
+};/**
+ * Resolves $modifier (and nested values) anywhere in the tree.
+ * Modifiers can appear at component root (value, onChange, etc.), in nested
+ * structures (e.g. style.fontSize, style.base.padding), or in $child* slot content.
+ * We recurse into objects and arrays so every occurrence is resolved.
+ */
+//TODO add unit test to the resolveModifier
+async function resolveModifier(value, modifiers, ctx) {
+    // If it's a direct modifier object: { $modifier: 'x', ...params }
+    if (value != null && typeof value === 'object' && MODIFIER_KEY in value) {
+        const { [MODIFIER_KEY]: mod, ...params } = value;
+        const resolvedParams = {};
+        for (const [k, v] of Object.entries(params)) {
+            resolvedParams[k] = await resolveModifier(v, modifiers, ctx);
+        }
+        const handler = modifiers[mod] ?? (mod === 'get' ? createGetModifier(ctx.formStore) : undefined);
+        if (!handler)
+            return undefined;
+        const result = handler(resolvedParams, ctx);
+        return result instanceof Promise ? await result : result;
+    }
+    // If it's an array, resolve modifiers in each element.
+    if (Array.isArray(value)) {
+        const resolved = await Promise.all(value.map((item) => resolveModifier(item, modifiers, ctx)));
+        return resolved;
     }
-    // eslint-disable-next-line no-restricted-syntax
-    for (const filteredvalue of jsonTraverse(propsNew)) {
-        paths.push(filteredvalue);
+    // If it's a plain object without $modifier, traverse its properties
+    // so nested fields like www2.bbb or payload.value get resolved.
+    if (value != null && typeof value === 'object') {
+        const obj = value;
+        const entries = Object.entries(obj);
+        if (entries.length === 0)
+            return value;
+        const resolvedObj = {};
+        for (const [k, v] of entries) {
+            resolvedObj[k] = await resolveModifier(v, modifiers, ctx);
+        }
+        return resolvedObj;
     }
-    return paths;
+    // Primitive or null – nothing to do.
+    return value;
+}/**
+ * Style types for the shared style layer (web + React Native).
+ * Canonical style is a subset of CSS-like keys that we support and map to both platforms.
+ */
+/** Default breakpoint width thresholds (min-width in px) */
+const DEFAULT_BREAKPOINTS = {
+    base: 0,
+    xs: 0,
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
 };
-const actionBuilder = (props, stock) => {
-    const _a = props, _b = PARENT_PROP_NAME; _a[_b]; const propsNew = __rest(_a, [_b + ""]);
-    const paths = getFilteredPath(propsNew, ({ key }) => key === ACTION_KEY);
-    orderBy(paths, ['level'], ['desc']).forEach((i) => {
-        const _a = traverse(props).get(i.path), _b = ACTION_KEY, functionName = _a[_b], functionParams = __rest(_a, [_b + ""]);
-        traverse(props).set(i.path, (...callerArgs) => {
-            stock.callFunction(functionName, functionParams, props, callerArgs);
-        });
-    });
+/** Order for merging: base first, then xs..xl */
+const BREAKPOINT_ORDER = ['base', 'xs', 'sm', 'md', 'lg', 'xl'];/**
+ * Resolves canonical or responsive style to platform-specific style (web or React Native).
+ * Pure and synchronous; no dependencies.
+ */
+const isResponsiveStyle = (style) => {
+    if (typeof style !== 'object')
+        return false;
+    const keys = Object.keys(style);
+    return keys.some((k) => BREAKPOINT_ORDER.includes(k));
 };
-const calculatePropsFromModifier = (props, stock) => {
-    const reduxPaths = [];
-    const _a = props, _b = PARENT_PROP_NAME; _a[_b]; const propsNew = __rest(_a, [_b + ""]);
-    const paths = getFilteredPath(propsNew, ({ key }) => key === MODIFIER_KEY);
-    orderBy(paths, ['level'], ['desc']).forEach((i) => {
-        const _a = traverse(props).get(i.path), _b = MODIFIER_KEY, functionName = _a[_b], functionParams = __rest(_a, [_b + ""]);
-        if (typeof functionName === 'string' && functionName === REDUX_GET_FUNCTION) {
-            reduxPaths.push(functionParams);
-        }
-        traverse(props).set(i.path, stock.callFunction(functionName, functionParams, props));
-    });
-    return reduxPaths;
+/**
+ * Merge responsive style into a single style: base + all breakpoints up to and including current.
+ * Mobile-first: current breakpoint index determines how many layers we merge.
+ */
+const mergeResponsive = (responsive, currentBreakpoint) => {
+    const idx = BREAKPOINT_ORDER.indexOf(currentBreakpoint);
+    const merged = {};
+    for (let i = 0; i <= idx; i++) {
+        const key = BREAKPOINT_ORDER[i];
+        const block = responsive[key];
+        if (block && typeof block === 'object') {
+            Object.assign(merged, block);
+        }
+    }
+    return merged;
 };
-const getCurrentPaths = (props, pathModifier) => {
-    const currentPaths = Object.assign({}, props[CURRENT_PATH_NAME]);
-    if (pathModifier && Object.keys(pathModifier).length !== 0) {
-        Object.keys(pathModifier).forEach((key) => {
-            if (!!key && !!pathModifier[key] && pathModifier[key][PATHNAME] !== undefined && pathModifier[key][PATHNAME] !== null) {
-                const path = pathModifier[key][PATHNAME];
-                const parent = currentPaths[key];
-                if (`${path}`.startsWith(SEPARATOR) || !(parent && parent[PATHNAME])) {
-                    currentPaths[key] = { [PATHNAME]: path };
-                }
-                else {
-                    currentPaths[key] = { [PATHNAME]: changeRelativePath(`${parent[PATHNAME]}${SEPARATOR}${path}`) };
-                }
-                if (!!currentPaths[key] && !`${currentPaths[key][PATHNAME]}`.startsWith(SEPARATOR)) {
-                    currentPaths[key][PATHNAME] = `${SEPARATOR}${currentPaths[key][PATHNAME]}`;
-                }
-            }
-        });
+/**
+ * Parse "1px solid #ccc" or similar border shorthand into parts.
+ */
+const parseBorder = (value) => {
+    const parts = value.trim().split(/\s+/);
+    const result = {};
+    for (const p of parts) {
+        if (/^\d+(\.\d+)?(px)?$/.test(p)) {
+            result.width = parseFloat(p);
+        }
+        else if (['solid', 'dashed', 'dotted', 'none'].includes(p)) {
+            result.style = p;
+        }
+        else if (p.startsWith('#') || p.startsWith('rgb')) {
+            result.color = p;
+        }
     }
-    return currentPaths;
+    return result;
 };
-const normalisePrimitives = (props, parentComp) => {
-    if (!!props && Array.isArray(props)) {
-        return { [V_COMP_NAME]: FRAGMENT_COMP_NAME, [V_CHILDREN_NAME]: props, [PARENT_PROP_NAME]: parentComp };
+/**
+ * Convert canonical style to React Native-compatible style.
+ * - border shorthand -> borderWidth, borderColor, borderStyle
+ * - cursor is not supported on RN, omit
+ * - numeric values kept as-is where RN expects numbers
+ */
+const toNativeStyle = (canonical) => {
+    const out = {};
+    for (const [key, value] of Object.entries(canonical)) {
+        if (value === undefined)
+            continue;
+        if (key === 'cursor')
+            continue; // not supported on RN
+        if (key === 'border' && typeof value === 'string') {
+            const { width, style, color } = parseBorder(value);
+            if (width !== undefined)
+                out.borderWidth = width;
+            if (style)
+                out.borderStyle = style;
+            if (color)
+                out.borderColor = color;
+            continue;
+        }
+        if (key === 'borderRadius' && typeof value === 'number') {
+            out.borderRadius = value;
+            continue;
+        }
+        if ((key === 'borderTop' || key === 'borderBottom' || key === 'borderLeft' || key === 'borderRight') && typeof value === 'string') {
+            const { width, style, color } = parseBorder(value);
+            if (width !== undefined)
+                out[`${key}Width`] = width;
+            if (style)
+                out[`${key}Style`] = style;
+            if (color)
+                out[`${key}Color`] = color;
+            continue;
+        }
+        out[key] = value;
     }
-    if (props === null || SIMPLE_DATA_TYPES.includes(typeof props)) {
-        return { [V_COMP_NAME]: PRIMITIVE_COMP_NAME, [V_CHILDREN_NAME]: props, [PARENT_PROP_NAME]: parentComp };
+    return out;
+};
+/**
+ * Length-like style keys that need a unit (px) when the value is a bare number
+ * or numeric string (e.g. from a store/modifier like sliderValue).
+ */
+const LENGTH_KEYS = new Set([
+    'fontSize',
+    'width',
+    'height',
+    'minWidth',
+    'minHeight',
+    'maxWidth',
+    'maxHeight',
+    'margin',
+    'marginTop',
+    'marginRight',
+    'marginBottom',
+    'marginLeft',
+    'padding',
+    'paddingTop',
+    'paddingRight',
+    'paddingBottom',
+    'paddingLeft',
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'gap',
+]);
+const ensureLengthUnit = (key, value) => {
+    if (value === undefined)
+        return value;
+    if (!LENGTH_KEYS.has(key))
+        return value;
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (typeof value === 'string' && /^\d+(\.\d+)?$/.test(value.trim())) {
+        return `${value.trim()}px`;
     }
-    return Object.assign(Object.assign({}, props), { [PARENT_PROP_NAME]: parentComp });
+    return value;
 };
-const genChildenFromListItem = (props, stock) => {
-    let page = !!props[LIST_PAGE] && isNumber(props[LIST_PAGE]) ? props[LIST_PAGE] : 0;
-    let listLength = !!props[LIST_LENGTH] && isNumber(props[LIST_LENGTH]) ? props[LIST_LENGTH] : undefined;
-    let itemPerPage = !!props[LIST_ITEM_PER_PAGE] && isNumber(props[LIST_ITEM_PER_PAGE]) ? props[LIST_ITEM_PER_PAGE] : undefined;
-    const listItem = props[LIST_ITEM];
-    if (!listItem)
-        return undefined;
-    const currentPaths = props[CURRENT_PATH_NAME];
-    if (!currentPaths)
-        return undefined;
-    const store = Object.keys(currentPaths)[0];
-    if (!store)
+/**
+ * Web: pass through with minimal changes. Normalize length props (e.g. fontSize)
+ * so numeric or numeric-string values get "px" and the browser applies them.
+ */
+const toWebStyle = (canonical) => {
+    const out = {};
+    for (const [key, value] of Object.entries(canonical)) {
+        out[key] = ensureLengthUnit(key, value);
+    }
+    return out;
+};
+/**
+ * Resolve style input (canonical or responsive) to platform-specific style.
+ * - If style is responsive (has base/xs/sm/md/lg/xl), merge up to current breakpoint, then resolve.
+ * - If no breakpoint is provided for a responsive style, only "base" is used.
+ */
+const resolveStyle = (style, options) => {
+    if (!style || typeof style !== 'object')
         return undefined;
-    const { path } = currentPaths[store];
-    if (currentPaths && !listLength) {
-        if (path) {
-            const list = stock.callFunction(REDUX_GET_FUNCTION, { store, path });
-            listLength = !!list && Array.isArray(list) ? list.length : 0;
-        }
+    let canonical;
+    if (isResponsiveStyle(style)) {
+        const breakpoint = options.breakpoint ?? 'base';
+        canonical = mergeResponsive(style, breakpoint);
     }
-    if (!itemPerPage) {
-        itemPerPage = listLength;
+    else {
+        canonical = style;
     }
-    page = Number.isInteger(page) && page >= 0 ? page : 0;
-    itemPerPage = !!itemPerPage && Number.isInteger(itemPerPage) && itemPerPage >= 0 ? itemPerPage : 0;
-    listLength = !!listLength && Number.isInteger(listLength) && listLength >= 0 ? listLength : 0;
-    const offset = page * itemPerPage <= listLength ? page * itemPerPage : 0;
-    const children = [];
-    // eslint-disable-next-line no-plusplus
-    for (let i = offset; i < listLength && i < offset + itemPerPage; i++) {
-        children.push(Object.assign(Object.assign({}, listItem), { [PATH_MODIFIERS_KEY]: {
-                [store]: {
-                    path: `.${SEPARATOR}${i}`,
-                },
-            } }));
+    if (Object.keys(canonical).length === 0)
+        return undefined;
+    return options.platform === 'native' ? toNativeStyle(canonical) : toWebStyle(canonical);
+};let inlineAjv = null;
+const getInlineAjv = () => {
+    if (!inlineAjv) {
+        // TODO why it's no strict?
+        inlineAjv = new Ajv({ allErrors: true, strict: false });
+        addFormats(inlineAjv);
+        ajvErrors(inlineAjv);
     }
-    return children.length > 0 ? children : undefined;
+    return inlineAjv;
 };
-const getRootWrapperProps = (props, stock) => {
-    const subscriberPaths = calculatePropsFromModifier(props, stock);
-    actionBuilder(props, stock);
-    if (props[LIST_SEMAPHORE]) {
-        // eslint-disable-next-line no-param-reassign
-        props[V_CHILDREN_NAME] = genChildenFromListItem(props, stock);
-    }
-    // eslint-disable-next-line no-param-reassign
-    props[REDUX_GET_SUBSCRIBERS_NAME] = subscriberPaths;
-};
-const isChildrenProp = (propName) => !!propName && typeof propName === 'string' && propName.startsWith(V_CHILDREN_PREFIX);
-const getParentProps = (props) => {
-    return props && typeof props === 'object' && !Array.isArray(props)
-        ? Object.keys(props)
-            .filter((key) => !isChildrenProp(key) && key !== PARENT_PROP_NAME)
-            .reduce((newObj, key) => {
-            // eslint-disable-next-line no-param-reassign
-            newObj[key] = props[key];
-            return newObj;
-        }, {})
-        : {};
-};
-const getPropsChildrenFilter = ({ props, filter }) => props && typeof props === 'object' && !Array.isArray(props)
-    ? Object.keys(props)
-        .filter((key) => ((filter === 'withoutChildren' && !isChildrenProp(key)) || (filter === 'onlyChildren' && isChildrenProp(key))) && key !== PARENT_PROP_NAME)
-        .reduce((newObj, key) => {
-        // eslint-disable-next-line no-param-reassign
-        newObj[key] = props[key];
-        return newObj;
-    }, {})
-    : {};
-const getChildrensForRoot = (props, children, Wrapper) => {
-    // eslint-disable-next-line no-nested-ternary
-    if (!!props && Array.isArray(children)) {
-        return children.map((childrenItem, index) => {
-            // eslint-disable-next-line react/no-array-index-key
-            return jsx(Wrapper, { props: normalisePrimitives(childrenItem, getParentProps(props)) }, index);
-        });
+const stringifyValidationError = (error) => {
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string') {
+        return error.message;
     }
-    if (!!props && !!children) {
-        return jsx(Wrapper, { props: normalisePrimitives(children, getParentProps(props)) });
+    try {
+        return String(error);
     }
-    return undefined;
-};
-const generateChildren = (props, { Wrapper }) => props[V_COMP_NAME] !== '_PrimitiveProp' ? getChildrensForRoot(props, props[V_CHILDREN_NAME], Wrapper) : props[V_CHILDREN_NAME];
-const generateNewChildren = (props, { Wrapper }) => {
-    // eslint-disable-next-line no-nested-ternary
-    if (props) {
-        if (Array.isArray(props)) {
-            return props.map((childrenItem, index) => {
-                // eslint-disable-next-line react/no-array-index-key
-                return jsx(Wrapper, { props: normalisePrimitives(childrenItem, getParentProps(props)) }, index);
-            });
-        }
-        return jsx(Wrapper, { props: normalisePrimitives(props, getParentProps(props)) });
+    catch {
+        return 'error';
     }
-    return undefined;
 };
-const isTechnicalProp = (propName) => [
-    PARENT_PROP_NAME,
-    STYLE_WEB_NAME,
-    V_COMP_NAME,
-    PATH_MODIFIERS_KEY,
-    CURRENT_PATH_NAME,
-    PATH_MODIFIERS_KEY,
-    LIST_SEMAPHORE,
-    LIST_ITEM,
-    LIST_PAGE,
-    LIST_ITEM_PER_PAGE,
-    LIST_LENGTH,
-    REF_VALIDATES,
-    'style',
-    REDUX_GET_SUBSCRIBERS_NAME,
-].includes(propName);
-const removeTechnicalProps = (changeableProps) => {
-    const _a = changeableProps, _b = PARENT_PROP_NAME; _a[_b]; const { style } = _a, _c = STYLE_WEB_NAME; _a[_c]; const _d = V_COMP_NAME; _a[_d]; const _e = PATH_MODIFIERS_KEY; _a[_e]; const _f = CURRENT_PATH_NAME; _a[_f]; const _g = REDUX_GET_SUBSCRIBERS_NAME; _a[_g]; const _h = PATH_MODIFIERS_KEY; _a[_h]; const _j = LIST_SEMAPHORE; _a[_j]; const _k = LIST_ITEM; _a[_k]; const _l = LIST_PAGE; _a[_l]; const _m = LIST_ITEM_PER_PAGE; _a[_m]; const _o = LIST_LENGTH; _a[_o]; const _p = REF_VALIDATES; _a[_p]; const newProps = __rest(_a, [_b + "", "style", _c + "", _d + "", _e + "", _f + "", _g + "", _h + "", _j + "", _k + "", _l + "", _m + "", _o + "", _p + ""]);
-    return newProps;
-};var wrapperUtil=/*#__PURE__*/Object.freeze({__proto__:null,actionBuilder:actionBuilder,calculatePropsFromModifier:calculatePropsFromModifier,generateChildren:generateChildren,generateNewChildren:generateNewChildren,getChildrensForRoot:getChildrensForRoot,getCurrentPaths:getCurrentPaths,getFilteredPath:getFilteredPath,getParentProps:getParentProps,getPropsChildrenFilter:getPropsChildrenFilter,getRootWrapperProps:getRootWrapperProps,isChildrenProp:isChildrenProp,isTechnicalProp:isTechnicalProp,normalisePrimitives:normalisePrimitives,removeTechnicalProps:removeTechnicalProps});const I18nSchema = {
-    $id: 'http://example.com/schemas/schema.json',
-    type: 'object',
-    additionalProperties: {
-        type: 'object',
-        properties: {
-            translation: {
-                type: 'object',
-                additionalProperties: {
-                    type: 'string',
-                },
-                propertyNames: {
-                    type: 'string',
-                },
-                minProperties: 1,
-            },
-            additionalProperties: false,
-        },
-    },
-    propertyNames: {
-        pattern: '^[A-Za-z0-9_-]*$',
-        type: 'string',
-    },
-    minProperties: 1,
+const buildValidationRegistry = (rules) => {
+    const registry = {};
+    if (!rules || rules.length === 0)
+        return registry;
+    const ajv = new Ajv({ allErrors: true, strict: false });
+    // TODO: check test how looks like in jsonui
+    addFormats(ajv);
+    ajvErrors(ajv);
+    for (const rule of rules) {
+        if (rule.schema === undefined || rule.schema === null || !rule.store || !rule.path)
+            continue;
+        const validate = ajv.compile(rule.schema);
+        const byStore = registry[rule.store] ?? (registry[rule.store] = {});
+        const list = byStore[rule.path] ?? (byStore[rule.path] = []);
+        list.push(validate);
+    }
+    return registry;
 };
-class I18n {
-    // eslint-disable-next-line consistent-this
-    constructor({ language = 'en', resources, nonExistsHandler, keyPrefix = '{{', keyPostfix = '}}' }) {
-        this.getLocales = () => (this.language.includes('-') ? this.language.split('-') : this.language.split('_') || [])[0];
-        this.t = (key, options, language) => {
-            if (!(typeof key === 'string')) {
-                return key;
-            }
-            if (!this.resources || (!this.resources && !this.language && !language) || !this.resources[`${this.availableLanguageKey || language}`]) {
-                return key;
-            }
-            const value = this.resources[`${this.availableLanguageKey || language}`].translation[key];
-            if (value === undefined) {
-                if (this.nonExistsHandler && typeof this.nonExistsHandler === 'function') {
-                    return this.nonExistsHandler(key);
-                }
-                return key;
-            }
-            if (options) {
-                return keyValueReplace(value, options, [this.keyPrefix, this.keyPostfix]);
-            }
-            return value;
-        };
-        this.language = language;
-        this.nonExistsHandler = nonExistsHandler;
-        this.keyPrefix = keyPrefix;
-        this.keyPostfix = keyPostfix;
-        const ajv = new Ajv();
-        const validate = ajv.compile(I18nSchema);
-        const isValid = validate(resources);
-        if (isValid) {
-            this.resources = resources;
-        }
-        this.languages = Object.keys(resources);
-        if (this.languages && this.languages.includes(this.language)) {
-            this.availableLanguageKey = this.language;
-        }
-        else if (this.languages && this.languages.includes(this.getLocales())) {
-            this.availableLanguageKey = this.getLocales();
-        }
-    }
-}const StockContext = createContext(null);
-const PathModifierContext = createContext({});// eslint-disable-next-line no-shadow
-var ReduxPathTypeEnum;
-(function (ReduxPathTypeEnum) {
-    ReduxPathTypeEnum["ERROR"] = "ERROR";
-    ReduxPathTypeEnum["TOUCH"] = "TOUCH";
-    ReduxPathTypeEnum["NORMAL"] = "NORMAL";
-})(ReduxPathTypeEnum || (ReduxPathTypeEnum = {}));const getState = (state) => state === null || state === void 0 ? void 0 : state.root;
-const getValue = (state, store, path) => jsonPointerGet(state[store], path);
-const getStoreNameFromType = (store, type) => 
-// eslint-disable-next-line no-nested-ternary
-type === ReduxPathTypeEnum.ERROR ? `${store}${STORE_ERROR_POSTFIX}` : type === ReduxPathTypeEnum.TOUCH ? `${store}${STORE_TOUCH_POSTFIX}` : `${store}`;
-const getStateValue = (globalState, { store, path, type, jsonataDef }, currentPaths) => {
-    const state = getState(globalState);
-    if (state && store && path) {
-        const convertedPath = currentPaths && currentPaths[store] && currentPaths[store].path ? changeRelativePath(`${currentPaths[store].path}${SEPARATOR}${path}`) : path;
-        const storeName = getStoreNameFromType(store, type);
-        let value = getValue(state, storeName, convertedPath);
-        if (jsonataDef) {
-            try {
-                const expression = jsonata$1(jsonataDef);
-                value = expression.evaluate(value);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error('jsonata error', error, jsonataDef);
+/**
+ * Run a single inline (field-level) validation spec against the current store state.
+ *
+ * The component's own store name and resolved logical path are passed in directly —
+ * they come from the simplified component's `store`/`path` props, not from the spec.
+ *
+ * Supports two validation styles:
+ *   - schema: AJV JSON Schema validation
+ *   - jsonataDef + errorMessage (not mandatory): JSONata expression; error shown when result is
+ *     not null, undefined, empty string, or true. errorMessage may be a plain string
+ *     or a { $modifier: ... } expression resolved via resolveModifier.
+ */
+const runInlineValidation = async (spec, componentStoreName, componentLogicalPath, modifiers, ctx) => {
+    const { formStore } = ctx;
+    const errorStoreName = `${componentStoreName}${ERROR_STORE_SUFFIX}`;
+    const value = formStore.get(componentStoreName, componentLogicalPath);
+    if (spec.schema != null) {
+        const ajv = getInlineAjv();
+        const validate = ajv.compile(spec.schema);
+        const messages = [];
+        const valid = validate(value);
+        //TODO: need to outsource validation to separate function and test it
+        if (!valid && validate.errors) {
+            for (const err of validate.errors) {
+                if (err.message)
+                    messages.push(err.message);
             }
         }
-        if (type === ReduxPathTypeEnum.ERROR) {
-            // if we have error, need to show, the empty structure is not error, doesn't matter how deep is it
-            return hasLeaf(value) ? value : null;
+        const newError = messages.length > 0 ? messages.join('; ') : null;
+        const currentError = formStore.get(errorStoreName, componentLogicalPath);
+        if ((currentError ?? null) !== newError) {
+            formStore.set(errorStoreName, componentLogicalPath, newError, false);
         }
-        if (type === ReduxPathTypeEnum.TOUCH) {
-            return hasLeaf(value); // return true if is touched.
+        return;
+    }
+    if (spec.jsonataDef != null) {
+        let result;
+        try {
+            const jsonata = (await import('jsonata')).default;
+            const expr = jsonata(spec.jsonataDef);
+            result = await expr.evaluate(value);
         }
-        return value;
+        catch (e) {
+            result = stringifyValidationError(e);
+        }
+        const hasError = result !== null && result !== undefined && result !== '' && result !== true;
+        const newError = hasError ? (spec.errorMessage ? String(await resolveModifier(spec.errorMessage, modifiers, ctx)) : String(result)) : null;
+        const currentError = formStore.get(errorStoreName, componentLogicalPath);
+        if ((currentError ?? null) !== newError) {
+            formStore.set(errorStoreName, componentLogicalPath, newError, false);
+        }
+        return;
     }
-    return null;
 };
-const compSelectorHook = (currentPaths, subscriberPaths) => (state) => {
-    if (typeof subscriberPaths === 'object' && Array.isArray(subscriberPaths) && (subscriberPaths === null || subscriberPaths === void 0 ? void 0 : subscriberPaths.length) > 0) {
-        return subscriberPaths.map((subscriberPath) => getStateValue(state, subscriberPath, currentPaths));
+// Runs all validators whose rule path matches the changed path prefix for the given store.
+// Aggregates current validation messages and writes or clears them in the matching .error store paths.
+const runValidationsForPath = (registry, formStore, storeName, path) => {
+    const storeValidators = registry[storeName];
+    // No validators registered for this store at all
+    if (!storeValidators) {
+        return;
     }
-    return undefined;
-};const DATA_UPDATE = 'DATA_UPDATE';
-const set$1 = (payload) => ({
-    type: DATA_UPDATE,
-    payload,
-});const get = (attr, { [CURRENT_PATH_NAME]: currentPaths } = {}, callerArgs, stock) => {
-    const { store, path, type, jsonataDef } = attr;
-    const state = stock.reduxStore.getState();
-    return getStateValue(state, { store, path, type, jsonataDef }, currentPaths);
-};
-const set = (attr, props, callerArgs, stock) => {
-    stock.reduxStore.dispatch(set$1(Object.assign(Object.assign({}, attr), { value: attr && attr.value !== undefined ? attr.value : callerArgs[0], [CURRENT_PATH_NAME]: props[CURRENT_PATH_NAME], stock })));
-};
-const jsonata = (_a) => {
-    var { jsonataDef } = _a, attr = __rest(_a, ["jsonataDef"]);
-    if (jsonataDef) {
-        // console.log(' ---- jsonata ---- ')
-        // console.log('jsonataDef: ', jsonataDef)
-        // console.log('attr: ', attr)
-        try {
-            const expression = jsonata$1(jsonataDef);
-            const evaluate = expression.evaluate(attr);
-            // console.log('evaluate: ', evaluate)
-            return evaluate;
+    const errorStoreName = `${storeName}${ERROR_STORE_SUFFIX}`;
+    // Collect new error messages per *concrete* target path (e.g. '/players/0/score').
+    const perPathMessages = {};
+    const affectedErrorPaths = new Set();
+    // Include any existing error leaf paths under matching rule paths so we can clear
+    // them if they become valid.
+    const collectExistingPaths = (basePath, value) => {
+        if (value == null)
+            return;
+        if (typeof value !== 'object') {
+            affectedErrorPaths.add(basePath);
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((v, i) => {
+                collectExistingPaths(`${basePath}/${i}`, v);
+            });
+            return;
+        }
+        for (const [k, v] of Object.entries(value)) {
+            collectExistingPaths(basePath === '/' ? `/${k}` : `${basePath}/${k}`, v);
         }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            console.error('jsonata error', error, jsonataDef);
+    };
+    // Run all validators whose rule path is a prefix of the affected path.
+    // Example: action path '/a/b/c' should trigger validators registered for
+    // '/', '/a', '/a/b', and '/a/b/c'.
+    for (const [rulePath, validators] of Object.entries(storeValidators)) {
+        if (!validators)
+            continue;
+        if (!isPathPrefix(rulePath, path))
+            continue;
+        // Track existing error paths under this rule so we can clear them.
+        const existingSubtree = formStore.get(errorStoreName, rulePath);
+        if (existingSubtree !== undefined) {
+            collectExistingPaths(rulePath === '' ? '/' : rulePath, existingSubtree);
+        }
+        const valueAtRulePath = formStore.get(storeName, rulePath);
+        for (const validate of validators) {
+            const valid = validate(valueAtRulePath);
+            if (!valid && validate.errors) {
+                for (const err of validate.errors) {
+                    if (!err.message)
+                        continue;
+                    const instancePath = err.instancePath;
+                    // instancePath is relative to rulePath, e.g. '/0/score'
+                    let targetPath;
+                    if (rulePath === '' || rulePath === '/') {
+                        targetPath = instancePath && instancePath.length > 0 ? instancePath : '/';
+                    }
+                    else {
+                        targetPath = instancePath && instancePath.length > 0 ? `${rulePath}${instancePath}` : rulePath;
+                    }
+                    const list = perPathMessages[targetPath] ?? (perPathMessages[targetPath] = []);
+                    list.push(err.message);
+                    affectedErrorPaths.add(targetPath);
+                }
+            }
         }
     }
-    return null;
+    // Apply updates for all affected error paths (both existing and new).
+    for (const targetPath of affectedErrorPaths) {
+        const messages = perPathMessages[targetPath] ?? [];
+        const newError = messages.length > 0 ? messages.join('; ') : null;
+        const currentError = formStore.get(errorStoreName, targetPath);
+        if ((currentError ?? null) === newError)
+            continue;
+        formStore.set(errorStoreName, targetPath, newError, false);
+    }
 };
-var functions = {
-    get,
-    set,
-    jsonata,
-};const pathConverter = (path) => path.replace(/\./g, SEPARATOR);
-const errorConverter = (errors) => {
-    const res = {};
-    // convert error and add as an array item to the particular property
-    if (errors) {
-        errors.forEach((i) => {
-            var _a, _b, _c, _d, _e, _f;
-            if (i.keyword === 'required') {
-                // because it's not parent error, need to move that level
-                jsonpointer.set(res, `${pathConverter(`${i.instancePath}.${i.params.missingProperty}`)}/-`, i.message);
-            }
-            else if (i.keyword === 'errorMessage' && ((_c = (_b = (_a = i === null || i === void 0 ? void 0 : i.params) === null || _a === void 0 ? void 0 : _a.errors) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.keyword) === 'required') {
-                jsonpointer.set(res, `${pathConverter(`${i.instancePath}.${(_f = (_e = (_d = i === null || i === void 0 ? void 0 : i.params) === null || _d === void 0 ? void 0 : _d.errors) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.params.missingProperty}`)}/-`, i.message);
+/** Match whole segments only; works for paths of any depth (e.g. /a/b/0/c). */
+const isPathPrefix = (rulePath, targetPath) => {
+    const r = rulePath === '' ? '/' : rulePath;
+    const t = targetPath === '' ? '/' : targetPath;
+    if (r === '/')
+        return true;
+    if (t === r)
+        return true;
+    return t.startsWith(r.endsWith('/') ? r : `${r}/`);
+};/**
+ * Recursively walks a node's props value tree and collects all store path dependencies
+ * introduced by `$modifier: 'get'` entries. For each `get` modifier found, it resolves
+ * the logical store path (accounting for path modifiers and ERROR/TOUCH type variants)
+ * and appends it to the `deps` array. Nodes with a `$comp` key are skipped to avoid
+ * descending into nested component definitions.
+ */
+const collectGetModifierDependencies = (val, currentPath, deps, effectivePathModifiers) => {
+    if (val && typeof val === 'object' && !Array.isArray(val) && V_COMP in val) {
+        return;
+    }
+    if (val && typeof val === 'object' && !Array.isArray(val) && MODIFIER_KEY in val && val[MODIFIER_KEY] === 'get') {
+        const storeName = val.store;
+        const type = val.type;
+        const path = val.path;
+        const alteredStoreName = type === 'ERROR' ? `${storeName ?? ''}${ERROR_STORE_SUFFIX}` : type === 'TOUCH' ? `${storeName ?? ''}${TOUCH_STORE_SUFFIX}` : storeName;
+        if (storeName && alteredStoreName) {
+            if (typeof path === 'string' && path) {
+                const logicalPath = resolveStorePath(path, currentPath, effectivePathModifiers, storeName);
+                deps.push({ store: alteredStoreName, path: logicalPath });
             }
             else {
-                jsonpointer.set(res, `${pathConverter(i.instancePath)}/-`, i.message);
+                deps.push({ store: alteredStoreName, path: '/' });
             }
-        });
+        }
+        return;
+    }
+    if (Array.isArray(val)) {
+        val.forEach((v) => collectGetModifierDependencies(v, currentPath, deps, effectivePathModifiers));
+        return;
+    }
+    if (val && typeof val === 'object') {
+        for (const v of Object.values(val)) {
+            collectGetModifierDependencies(v, currentPath, deps, effectivePathModifiers);
+        }
+    }
+};const runValidationSpecsFromNode = async (node, modifiers, ctx, componentStoreName, componentLogicalPath) => {
+    const rawValidation = node[V_VALIDATIONS];
+    if (!rawValidation || !Array.isArray(rawValidation) || rawValidation.length === 0)
+        return;
+    if (!componentStoreName || componentLogicalPath == null)
+        return;
+    for (const item of rawValidation) {
+        if (item === null || typeof item !== 'object')
+            continue;
+        await runInlineValidation(item, componentStoreName, componentLogicalPath, modifiers, ctx);
     }
-    // TODO: if it's a root level validation, looks like : {-: 'should be email'} should be converted
-    return res && res['-'] ? res['-'] : res;
-};
-const validateJSON = (schema, data) => {
-    const ajv = new Ajv({ allErrors: true });
-    ajvErrors(ajv);
-    ajvFormats(ajv);
-    const validate = ajv.compile(schema);
-    const valid = validate(data);
-    return {
-        valid: validate(data),
-        error: valid ? null : errorConverter(validate.errors),
-    };
 };
-const validateJSONAndStore = (schema, store, data) => {
-    const { valid, error } = validateJSON(schema, data);
-    return {
-        store: `${store}${STORE_ERROR_POSTFIX}`,
-        valid,
-        value: error,
-    };
-};const initialState = {};
-const globalValidateNewState = (stock, newState, actionStore, actionPath) => {
-    if (stock === null || stock === void 0 ? void 0 : stock.validations) {
-        stock.validations.forEach((validateItem) => {
-            if (validateItem.store === actionStore && `${actionPath}`.startsWith(validateItem.path)) {
-                if (validateItem.schema) {
-                    const state = current(newState);
-                    const stateToBeValidated = jsonPointerGet(state, `${SEPARATOR}${actionStore}${validateItem.path}`);
-                    const errors = validateJSONAndStore(validateItem.schema, actionStore, stateToBeValidated);
-                    // eslint-disable-next-line no-param-reassign
-                    newState = jsonPointerSet(newState, `${SEPARATOR}${errors.store}${validateItem.path}`, errors.value);
-                }
+const runRenderNodeResolution = async ({ node, modifiers, ctx, currentPath, effectivePathModifiers, stylePlatform, styleBreakpoint, componentStore, componentPath, }) => {
+    const props = {};
+    const deps = [];
+    const resolvedSlots = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key.startsWith('$child') || !key.startsWith('$')) {
+            collectGetModifierDependencies(value, currentPath, deps, effectivePathModifiers);
+            if (key.startsWith('$child')) {
+                resolvedSlots[key] = await resolveModifier(value, modifiers, ctx);
+            }
+            else if (!key.startsWith('$')) {
+                props[key] = await resolveModifier(value, modifiers, ctx);
             }
+        }
+    }
+    if (props.style != null && typeof props.style === 'object') {
+        const resolved = resolveStyle(props.style, {
+            platform: stylePlatform,
+            breakpoint: styleBreakpoint,
         });
+        props.style = resolved ?? props.style;
     }
-};
-const reducer = (state = initialState, action) => {
-    switch (action === null || action === void 0 ? void 0 : action.type) {
-        case DATA_UPDATE: {
-            const { store = undefined, path = undefined, value = undefined, jsonataDef = undefined, [CURRENT_PATH_NAME]: currentPaths = undefined, stock = undefined, } = (action === null || action === void 0 ? void 0 : action.payload) || {};
-            if (store && path && isValidJson(value)) {
-                const storekey = `${store}`;
-                let convertedPath = currentPaths && currentPaths[storekey] && currentPaths[storekey].path
-                    ? changeRelativePath(`${currentPaths[storekey].path}${SEPARATOR}${path}`)
-                    : changeRelativePath(path);
-                convertedPath = jsonPointerFix(convertedPath);
-                const absolutePathWithStoreKey = `${SEPARATOR}${storekey}${convertedPath}`;
-                const newState = produce(state, (draft) => {
-                    if (jsonataDef) {
-                        try {
-                            const expression = jsonata$1(jsonataDef);
-                            const newValue = expression.evaluate(value);
-                            // eslint-disable-next-line no-param-reassign
-                            draft = jsonPointerSet(draft, absolutePathWithStoreKey, newValue);
-                        }
-                        catch (error) {
-                            // eslint-disable-next-line no-console
-                            console.error('jsonata error', error, jsonataDef);
-                            // eslint-disable-next-line no-param-reassign
-                            draft = jsonPointerSet(draft, absolutePathWithStoreKey, value);
-                        }
-                    }
-                    else {
-                        // eslint-disable-next-line no-param-reassign
-                        draft = jsonPointerSet(draft, absolutePathWithStoreKey, value);
-                    }
-                    // set, if a leaf touched
-                    // TODO if array or object touched, can easily overwite the leaf touched
-                    // eslint-disable-next-line no-param-reassign
-                    draft = jsonPointerSet(draft, `${SEPARATOR}${storekey}${STORE_TOUCH_POSTFIX}${convertedPath}`, true);
-                    // if validatior has match, need to validate it synchronously
-                    globalValidateNewState(stock, draft, store, convertedPath);
-                });
-                return newState;
-            }
-            return state;
+    const resolvedComponentPath = componentStore && componentPath != null ? resolveStorePath(componentPath, currentPath, effectivePathModifiers, componentStore) : undefined;
+    await runValidationSpecsFromNode(node, modifiers, ctx, componentStore, resolvedComponentPath);
+    return {
+        state: { props, resolvedSlots },
+        deps,
+    };
+};const resolveAction = (value, actions, modifiers, ctx) => {
+    if (value != null && typeof value === 'object' && ACTION_KEY in value) {
+        const { [ACTION_KEY]: actionName, ...params } = value;
+        const hasExplicitValue = Object.prototype.hasOwnProperty.call(value, 'value');
+        // Extract modifiers from action ctx.
+        const { componentProps, validators, ...modifierCtx } = ctx;
+        let handler = actions[actionName];
+        if (!handler && actionName === 'set') {
+            handler = createSetAction(ctx.formStore);
         }
-        default:
-            return state;
+        if (!handler)
+            return undefined;
+        return async (e) => {
+            // TODO: research, why componentProps need
+            const resolvedParams = { ...componentProps, ...params };
+            // Case 1: value from event (input onChange) – only when the model
+            // did NOT define a value explicitly.
+            if (!hasExplicitValue && e != null && typeof e === 'object' && 'target' in e) {
+                const target = e.target;
+                if (target?.value !== undefined)
+                    resolvedParams.value = target.value;
+            }
+            // Cases 2 & 3: static JSON value or nested $modifier value – both
+            // flow through resolveModifier below and are preserved.
+            for (const [k, v] of Object.entries(resolvedParams)) {
+                resolvedParams[k] = await resolveModifier(v, modifiers, modifierCtx);
+            }
+            const result = handler(resolvedParams, ctx);
+            if (result instanceof Promise)
+                await result;
+            // Run validations for this store/path if configured
+            const storeName = resolvedParams.store;
+            const rawPath = resolvedParams.path;
+            if (validators && storeName && rawPath) {
+                // Resolve to logical path so validations work with lists, pathModifiers,
+                // and relative paths (e.g. "score" inside /players/0).
+                const logicalPath = resolveStorePath(rawPath, ctx.currentPath, ctx.pathModifiers, storeName);
+                runValidationsForPath(validators, ctx.formStore, storeName, logicalPath);
+            }
+        };
     }
-};const rootReducer = combineReducers({ root: reducer });export{I18n,PathModifierContext,Stock,StockContext,compSelectorHook,constants,functions as stockFunctions,rootReducer as storeReducers,jsonUtils as utils,wrapperUtil};//# sourceMappingURL=index.js.map
+    return undefined;
+};const get = (params, ctx) => {
+    const getFn = createGetModifier(ctx.formStore);
+    return getFn(params, ctx);
+};async function jsonata(params) {
+    const { jsonataDef, ...input } = params;
+    if (typeof jsonataDef !== 'string' || !jsonataDef)
+        return undefined;
+    try {
+        const jsonata = (await import('jsonata')).default;
+        const expr = jsonata(jsonataDef);
+        // Evaluate with the remaining params (e.g. { error, touched }) as input.
+        return await expr.evaluate(input);
+    }
+    catch {
+        // On any jsonata error, fall back to undefined so UI doesn't break.
+        return undefined;
+    }
+}const isNotTouchedOrHasError = (params) => {
+    const { error, touched } = params;
+    const hasError = hasAnyError$1(error);
+    const isTouched = hasAnyTouched$1(touched);
+    return !isTouched || hasError;
+};/**
+ * Translation function: looks up key in ctx.translations using active language.
+ */
+const t = (params, ctx) => {
+    const key = params.key;
+    if (!key)
+        return undefined;
+    const translations = ctx.translations ?? {};
+    const langParam = params.lang;
+    const baseLang = ctx.defaultLanguage || 'en';
+    const activeLang = langParam || ctx.activeLanguage || baseLang;
+    const entry = translations[key];
+    // If we're in the base language, or there is no translation table
+    // for this key, just return the key as-is (baseline text).
+    if (activeLang === baseLang || entry === undefined)
+        return key;
+    // Otherwise, use the requested language if available, falling back to key.
+    return entry[activeLang] ?? key;
+};const modifiers = {
+    get,
+    jsonata,
+    isNotTouchedOrHasError,
+    t,
+};export{ACTION_KEY,BREAKPOINT_ORDER,DEFAULT_BREAKPOINTS,ERROR_STORE_SUFFIX,FormStore,LIST_ITEM,LIST_ITEM_PER_PAGE,LIST_LENGTH,LIST_PAGE,LIST_SEMAPHORE,MODIFIER_KEY,PATH_MODIFIERS_KEY,TOUCH_STORE_SUFFIX,V_CHILDREN,V_COMP,V_VALIDATIONS,actions,buildValidationRegistry,computeListSliceRange,expandSimplifiedNode,getOwnPathModifiers,isPathPrefix$1 as isPathPrefix,mergeEffectivePathModifiers,modifiers,normalizePath,resolveAction,resolveStorePath,runRenderNodeResolution};//# sourceMappingURL=index.js.map