@gravity-ui/dynamic-forms 5.19.1 → 5.21.0

package/build/esm/lib/unstable/core/useSchemaRendererTools/useSchemaRendererTools.d.ts

@@ -0,0 +1,8 @@
+import { type AddExternalErrorsParams, type AddSchemaPatchesParams, type RemoveExternalErrorsParams, type RemoveSchemaPatchesParams, type UpdateUserContextParams } from './utils';
+export declare const useSchemaRendererTools: () => {
+    addExternalErrors: ({ headName, priorityErrors, regularErrors, }: Omit<AddExternalErrorsParams, "form">) => void;
+    addSchemaPatches: ({ patches }: Omit<AddSchemaPatchesParams, "form">) => void;
+    removeExternalErrors: ({ headName, removeFunctionOrNames, }: Omit<RemoveExternalErrorsParams, "form">) => void;
+    removeSchemaPatches: ({ patchesToRemove }: Omit<RemoveSchemaPatchesParams, "form">) => void;
+    updateUserContext: ({ headName, userContext, replace, }: Omit<UpdateUserContextParams, "form">) => void;
+};

package/build/esm/lib/unstable/core/useSchemaRendererTools/useSchemaRendererTools.js

@@ -0,0 +1,14 @@
+import React from 'react';
+import { useForm } from 'react-final-form';
+import { addExternalErrors, addSchemaPatches, removeExternalErrors, removeSchemaPatches, updateUserContext, } from './utils';
+export const useSchemaRendererTools = () => {
+    const form = useForm();
+    const tools = React.useMemo(() => ({
+        addExternalErrors: ({ headName, priorityErrors, regularErrors, }) => addExternalErrors({ form, headName, priorityErrors, regularErrors }),
+        addSchemaPatches: ({ patches }) => addSchemaPatches({ form, patches }),
+        removeExternalErrors: ({ headName, removeFunctionOrNames, }) => removeExternalErrors({ form, headName, removeFunctionOrNames }),
+        removeSchemaPatches: ({ patchesToRemove }) => removeSchemaPatches({ form, patchesToRemove }),
+        updateUserContext: ({ headName, userContext, replace, }) => updateUserContext({ form, headName, userContext, replace }),
+    }), [form]);
+    return tools;
+};

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/external-errors.d.ts

@@ -0,0 +1,18 @@
+import type { FormApi } from 'final-form';
+import type { ValidationError } from '../../types';
+export interface AddExternalErrorsParams {
+    form: FormApi;
+    headName: string;
+    priorityErrors?: Record<string, ValidationError>;
+    regularErrors?: Record<string, ValidationError>;
+}
+export declare const addExternalErrors: ({ form, headName, priorityErrors, regularErrors, }: AddExternalErrorsParams) => void;
+export interface RemoveExternalErrorsParams {
+    form: FormApi;
+    headName: string;
+    removeFunctionOrNames: string[] | ((priorityErrors: Record<string, ValidationError>, regularErrors: Record<string, ValidationError>) => {
+        priorityErrors: Record<string, ValidationError>;
+        regularErrors: Record<string, ValidationError>;
+    });
+}
+export declare const removeExternalErrors: ({ form, headName, removeFunctionOrNames, }: RemoveExternalErrorsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/external-errors.js

@@ -0,0 +1,32 @@
+import omit from 'lodash/omit';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../../useSchemaRenderer';
+import { getServiceFieldName } from '../../utils';
+export const addExternalErrors = ({ form, headName, priorityErrors, regularErrors, }) => {
+    var _a;
+    const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    const srField = form.getFieldState(srName);
+    const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+    if (srState && (priorityErrors || regularErrors)) {
+        srState.priorityErrors = Object.assign(Object.assign({}, srState.priorityErrors), priorityErrors);
+        srState.regularErrors = Object.assign(Object.assign({}, srState.regularErrors), regularErrors);
+        srState.runValidate();
+    }
+};
+export const removeExternalErrors = ({ form, headName, removeFunctionOrNames, }) => {
+    var _a;
+    const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    const srField = form.getFieldState(srName);
+    const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+    if (srState && removeFunctionOrNames) {
+        if (Array.isArray(removeFunctionOrNames)) {
+            srState.priorityErrors = omit(srState.priorityErrors, removeFunctionOrNames);
+            srState.regularErrors = omit(srState.regularErrors, removeFunctionOrNames);
+        }
+        else {
+            const { priorityErrors, regularErrors } = removeFunctionOrNames(Object.assign({}, srState.priorityErrors), Object.assign({}, srState.regularErrors));
+            srState.priorityErrors = priorityErrors;
+            srState.regularErrors = regularErrors;
+        }
+        srState.runValidate();
+    }
+};

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { type AddSchemaPatchesParams, type RemoveSchemaPatchesParams, addSchemaPatches, removeSchemaPatches, } from './schema-patch';
+export { type AddExternalErrorsParams, type RemoveExternalErrorsParams, addExternalErrors, removeExternalErrors, } from './external-errors';
+export { type UpdateUserContextParams, updateUserContext } from './user-context';

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/index.js

@@ -0,0 +1,3 @@
+export { addSchemaPatches, removeSchemaPatches, } from './schema-patch';
+export { addExternalErrors, removeExternalErrors, } from './external-errors';
+export { updateUserContext } from './user-context';

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/schema-patch.d.ts

@@ -0,0 +1,12 @@
+import type { FormApi } from 'final-form';
+import { type SchemaPatch, type SchemaPatchRemover } from '../../useSchemaRenderer';
+export interface AddSchemaPatchesParams {
+    form: FormApi;
+    patches: SchemaPatch[];
+}
+export declare const addSchemaPatches: ({ form, patches }: AddSchemaPatchesParams) => void;
+export interface RemoveSchemaPatchesParams {
+    form: FormApi;
+    patchesToRemove: SchemaPatchRemover[];
+}
+export declare const removeSchemaPatches: ({ form, patchesToRemove }: RemoveSchemaPatchesParams) => void;

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/schema-patch.js

@@ -0,0 +1,169 @@
+import cloneDeep from 'lodash/cloneDeep';
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import set from 'lodash/set';
+import { SchemaRendererEventType } from '../../constants';
+import { SCHEMA_RENDERER_SERVICE_FIELD, } from '../../useSchemaRenderer';
+import { getSchemaByPointer, getServiceFieldName, getValuePaths, pointerToArrayPath, } from '../../utils';
+export const addSchemaPatches = ({ form, patches }) => {
+    const changesByHeadName = {};
+    patches.forEach((p) => {
+        var _a, _b;
+        let schemaPath;
+        if ('schemaPath' in p) {
+            schemaPath = p.schemaPath;
+        }
+        else {
+            const nodeField = form.getFieldState(p.name);
+            const nodeState = (_a = nodeField === null || nodeField === void 0 ? void 0 : nodeField.data) === null || _a === void 0 ? void 0 : _a.state;
+            schemaPath = nodeState === null || nodeState === void 0 ? void 0 : nodeState.schemaPath;
+        }
+        if (schemaPath !== undefined) {
+            const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, p.headName);
+            const srField = form.getFieldState(srName);
+            const srState = (_b = srField === null || srField === void 0 ? void 0 : srField.data) === null || _b === void 0 ? void 0 : _b.state;
+            if (srState) {
+                const schemaArrPath = pointerToArrayPath(schemaPath);
+                const valuePaths = getValuePaths(p.schema);
+                const changedPaths = [];
+                if (p.replace) {
+                    [
+                        ...valuePaths,
+                        ...getValuePaths(getSchemaByPointer(srState.schema, schemaArrPath)),
+                    ].forEach((path) => {
+                        const current = get(srState.schema, [...schemaArrPath, ...path]);
+                        const next = get(p.schema, path);
+                        if (!isEqual(current, next)) {
+                            changedPaths.push(['#', ...schemaArrPath, ...path]);
+                        }
+                    });
+                    if (schemaArrPath.length) {
+                        set(srState.schema, schemaArrPath, p.schema);
+                    }
+                    else {
+                        srState.schema = p.schema;
+                    }
+                }
+                else {
+                    valuePaths.forEach((path) => {
+                        const current = get(srState.schema, [...schemaArrPath, ...path]);
+                        const next = get(p.schema, path);
+                        if (!isEqual(current, next)) {
+                            set(srState.schema, [...schemaArrPath, ...path], next);
+                            changedPaths.push(['#', ...schemaArrPath, ...path]);
+                        }
+                    });
+                }
+                srState.patches = [...srState.patches, p];
+                if (changedPaths.length) {
+                    changesByHeadName[p.headName] = [
+                        ...(changesByHeadName[p.headName] || []),
+                        ...changedPaths,
+                    ];
+                }
+            }
+        }
+    });
+    Object.entries(changesByHeadName).forEach(([headName, paths]) => {
+        var _a;
+        const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+        const srField = form.getFieldState(srName);
+        const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+        if (srState) {
+            srState.schema = Object.assign({}, srState.schema);
+            srState.dispatchEvent([{ type: SchemaRendererEventType.Patch, paths }]);
+            srState.runValidate();
+        }
+    });
+};
+export const removeSchemaPatches = ({ form, patchesToRemove }) => {
+    const patchesByHeadName = {};
+    patchesToRemove.forEach((p) => {
+        var _a;
+        let schemaPath;
+        if ('schemaPath' in p) {
+            schemaPath = p.schemaPath;
+        }
+        else {
+            const nodeField = form.getFieldState(p.name);
+            const nodeState = (_a = nodeField === null || nodeField === void 0 ? void 0 : nodeField.data) === null || _a === void 0 ? void 0 : _a.state;
+            schemaPath = nodeState === null || nodeState === void 0 ? void 0 : nodeState.schemaPath;
+        }
+        if (schemaPath !== undefined) {
+            patchesByHeadName[p.headName] = [...(patchesByHeadName[p.headName] || []), p];
+        }
+    });
+    Object.entries(patchesByHeadName).forEach(([headName, patchesToRemove]) => {
+        var _a;
+        const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+        const srField = form.getFieldState(srName);
+        const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+        if (srState) {
+            let schemaPatch = {};
+            srState.patches.forEach((p) => {
+                var _a;
+                let schemaPath;
+                if ('schemaPath' in p) {
+                    schemaPath = p.schemaPath;
+                }
+                else {
+                    const nodeField = form.getFieldState(p.name);
+                    const nodeState = (_a = nodeField === null || nodeField === void 0 ? void 0 : nodeField.data) === null || _a === void 0 ? void 0 : _a.state;
+                    schemaPath = nodeState === null || nodeState === void 0 ? void 0 : nodeState.schemaPath;
+                }
+                if (schemaPath) {
+                    const schemaArrPath = pointerToArrayPath(schemaPath);
+                    if (schemaArrPath.length) {
+                        set(schemaPatch, schemaArrPath, cloneDeep(get(srState.originalSchema, schemaArrPath)));
+                    }
+                    else {
+                        schemaPatch = cloneDeep(srState.originalSchema);
+                    }
+                }
+            });
+            const patches = srState.patches.filter((p) => {
+                var _a;
+                let pSchemaPath;
+                if ('schemaPath' in p) {
+                    pSchemaPath = p.schemaPath;
+                }
+                else {
+                    const nodeField = form.getFieldState(p.name);
+                    const nodeState = (_a = nodeField === null || nodeField === void 0 ? void 0 : nodeField.data) === null || _a === void 0 ? void 0 : _a.state;
+                    pSchemaPath = nodeState === null || nodeState === void 0 ? void 0 : nodeState.schemaPath;
+                }
+                const shouldRemove = patchesToRemove.some((ptr) => {
+                    var _a;
+                    let ptrSchemaPath;
+                    if ('schemaPath' in ptr) {
+                        ptrSchemaPath = ptr.schemaPath;
+                    }
+                    else {
+                        const nodeField = form.getFieldState(ptr.name);
+                        const nodeState = (_a = nodeField === null || nodeField === void 0 ? void 0 : nodeField.data) === null || _a === void 0 ? void 0 : _a.state;
+                        ptrSchemaPath = nodeState === null || nodeState === void 0 ? void 0 : nodeState.schemaPath;
+                    }
+                    if (pSchemaPath &&
+                        ptrSchemaPath &&
+                        pSchemaPath === ptrSchemaPath &&
+                        (isEqual(p.schema, ptr.schema) || ptr.schema === true)) {
+                        return true;
+                    }
+                    return false;
+                });
+                if (!shouldRemove && pSchemaPath) {
+                    const schemaArrPath = pointerToArrayPath(pSchemaPath);
+                    if (schemaArrPath.length) {
+                        set(schemaPatch, schemaArrPath, p.schema);
+                    }
+                    else {
+                        schemaPatch = p.schema;
+                    }
+                }
+                return !shouldRemove;
+            });
+            addSchemaPatches({ form, patches: [{ headName, schemaPath: '#', schema: schemaPatch }] });
+            srState.patches = patches;
+        }
+    });
+};

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/user-context.d.ts

@@ -0,0 +1,9 @@
+import type { FormApi } from 'final-form';
+import { type SchemaRendererState } from '../../useSchemaRenderer';
+export interface UpdateUserContextParams {
+    form: FormApi;
+    headName: string;
+    userContext: SchemaRendererState['userContext'];
+    replace?: boolean;
+}
+export declare const updateUserContext: ({ form, headName, userContext, replace, }: UpdateUserContextParams) => void;

package/build/esm/lib/unstable/core/useSchemaRendererTools/utils/user-context.js

@@ -0,0 +1,13 @@
+import { SchemaRendererEventType } from '../../constants';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../../useSchemaRenderer';
+import { getServiceFieldName } from '../../utils';
+export const updateUserContext = ({ form, headName, userContext, replace = false, }) => {
+    var _a;
+    const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    const srField = form.getFieldState(srName);
+    const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+    if (srState) {
+        srState.userContext = replace ? userContext : Object.assign(Object.assign({}, srState.userContext), userContext);
+        srState.dispatchEvent([{ type: SchemaRendererEventType.UserContext, all: true }]);
+    }
+};

package/build/esm/lib/unstable/core/utils/common.d.ts

@@ -1,32 +1,46 @@
 import type { JsonSchema } from '../types';
 /**
- * Parses an AJV `schemaPath` (JSON Pointer) into an array of path segments
- * suitable for lodash `get`.
+ * Parses a JSON Pointer into an array of path segments suitable for lodash `get`.
  *
- * Strips the `#/` prefix, decodes URI-encoded characters, splits on `/`,
- * and unescapes JSON Pointer tokens (`~1` → `/`, `~0` → `~`).
+ * Accepts fragment pointers (`#/…`) and document pointers (`/…`). Decodes
+ * URI-encoded characters, splits on `/`, and unescapes JSON Pointer tokens
+ * (`~1` → `/`, `~0` → `~`).
  *
- * Returns all segments unchanged; stripping a trailing validation keyword
- * (e.g. `minLength`) before lookup is the caller's responsibility.
+ * An empty pointer (`#` or `''`) yields an empty array.
  *
- * @param schemaPath - JSON Pointer string, e.g. `"#/properties/name/minLength"`.
- * @returns Path segments, e.g. `['properties', 'name', 'minLength']`.
+ * @param pointer - JSON Pointer string, e.g. `"#/properties/name"`.
+ * @returns Path segments, e.g. `['properties', 'name']`.
  */
-export declare const parseSchemaPath: (schemaPath: string) => string[];
-export declare const parseInstancePath: (instancePath: string) => string[];
-export declare const parseFinalFormName: (finalFormName: string) => string[];
-export declare const formatFinalFormPath: (finalFormPath: string[]) => string;
-export declare const getSchemaPath: (finalFormNameOrPath: string | string[], finalFormHeadName: string, schema: JsonSchema) => string[] | undefined;
+export declare const pointerToArrayPath: (pointer: string) => string[];
 /**
- * Resolves a sub-schema from the root schema by an AJV `schemaPath`.
+ * Parses a Final Form / lodash path (`a.b[0].c`) into an array of path segments.
  *
- * Parses `schemaPath` via `parseSchemaPath` and looks up the node with lodash `get`.
- * The path must point to a schema object, not to a validation keyword — callers
- * should strip the trailing keyword first (see `processAjvError`).
+ * Object keys are split on `.`. Array indices in bracket notation (`[0]`)
+ * become string segments (`'0'`).
+ *
+ * @param dotBracketPath - Dotted path with optional brackets, e.g. `"items[0].name"`.
+ * @returns Path segments, e.g. `['items', '0', 'name']`.
+ */
+export declare const dotBracketToArrayPath: (dotBracketPath: string) => string[];
+/**
+ * Builds a Final Form / lodash path from an array of path segments.
+ *
+ * Numeric segments become bracket indices (`[0]`). Other segments are joined
+ * with `.`.
+ *
+ * @param arrayPath - Path segments, e.g. `['items', '0', 'name']`.
+ * @returns Dotted path with brackets, e.g. `"items[0].name"`.
+ */
+export declare const arrayPathToDotBracket: (arrayPath: string[]) => string;
+/**
+ * Resolves a sub-schema from the root schema by a JSON Pointer.
+ *
+ * A string pointer is parsed via `pointerToArrayPath`. An array of segments is
+ * used as-is. Lookup is done with lodash `get`.
  *
- * @param schemaPath - JSON Pointer string pointing to a schema node,
- *   e.g. `"#/properties/name"`.
  * @param schema - The root JSON schema object.
+ * @param pointer - JSON Pointer (`"#/properties/name"`) or path segments
+ *   (`['properties', 'name']`).
  *
  * @example
  * const nameSchema = {
@@ -37,13 +51,10 @@ export declare const getSchemaPath: (finalFormNameOrPath: string | string[], fin
  *     name: nameSchema,
  *   },
  * };
- * getSchemaBySchemaPath("#/properties/name", objectSchema); // returns nameSchema
+ * getSchemaByPointer(objectSchema, '#/properties/name'); // returns nameSchema
  *
  * @returns The sub-schema at the given path, or the root schema when the path is empty.
  */
-export declare const getSchemaBySchemaPath: (schemaPath: string, schema: JsonSchema) => JsonSchema | undefined;
-export declare const getSchemaByInstancePath: (instancePath: string, schema: JsonSchema) => JsonSchema | undefined;
-export declare const getSchemaByFinalFormPath: (finalFormNameOrPath: string | string[], finalFormHeadName: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getSchemaByPointer: (schema: JsonSchema, pointer: string | string[]) => JsonSchema | undefined;
 export declare const getValuePaths: (value: unknown, path?: string[]) => string[][];
-export declare const smartSet: (object: object, path: string[], value: unknown) => object;
-export declare const smartMerge: (first: object, second: object, deep?: boolean) => {};
+export declare const getServiceFieldName: (serviceFieldName: string, headName: string) => string;

package/build/esm/lib/unstable/core/utils/common.js

@@ -1,38 +1,36 @@
 import get from 'lodash/get';
-import set from 'lodash/set';
 /**
- * Parses an AJV `schemaPath` (JSON Pointer) into an array of path segments
- * suitable for lodash `get`.
+ * Parses a JSON Pointer into an array of path segments suitable for lodash `get`.
  *
- * Strips the `#/` prefix, decodes URI-encoded characters, splits on `/`,
- * and unescapes JSON Pointer tokens (`~1` → `/`, `~0` → `~`).
+ * Accepts fragment pointers (`#/…`) and document pointers (`/…`). Decodes
+ * URI-encoded characters, splits on `/`, and unescapes JSON Pointer tokens
+ * (`~1` → `/`, `~0` → `~`).
  *
- * Returns all segments unchanged; stripping a trailing validation keyword
- * (e.g. `minLength`) before lookup is the caller's responsibility.
+ * An empty pointer (`#` or `''`) yields an empty array.
  *
- * @param schemaPath - JSON Pointer string, e.g. `"#/properties/name/minLength"`.
- * @returns Path segments, e.g. `['properties', 'name', 'minLength']`.
+ * @param pointer - JSON Pointer string, e.g. `"#/properties/name"`.
+ * @returns Path segments, e.g. `['properties', 'name']`.
  */
-export const parseSchemaPath = (schemaPath) => {
-    return decodeURIComponent(schemaPath)
+export const pointerToArrayPath = (pointer) => {
+    return decodeURIComponent(pointer)
         .split('/')
         .slice(1)
         .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
 };
-export const parseInstancePath = (instancePath) => {
-    if (!instancePath.length) {
-        return [];
-    }
-    return instancePath
-        .slice('/'.length)
-        .split('/')
-        .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
-};
-export const parseFinalFormName = (finalFormName) => {
+/**
+ * Parses a Final Form / lodash path (`a.b[0].c`) into an array of path segments.
+ *
+ * Object keys are split on `.`. Array indices in bracket notation (`[0]`)
+ * become string segments (`'0'`).
+ *
+ * @param dotBracketPath - Dotted path with optional brackets, e.g. `"items[0].name"`.
+ * @returns Path segments, e.g. `['items', '0', 'name']`.
+ */
+export const dotBracketToArrayPath = (dotBracketPath) => {
     const result = [];
     const regex = /([^[.\]]+)|\[(\d+)\]/g;
     let match;
-    while ((match = regex.exec(finalFormName)) !== null) {
+    while ((match = regex.exec(dotBracketPath)) !== null) {
         if (match[1] !== undefined) {
             result.push(match[1]);
         }
@@ -42,49 +40,32 @@ export const parseFinalFormName = (finalFormName) => {
     }
     return result;
 };
-export const formatFinalFormPath = (finalFormPath) => {
-    return finalFormPath.reduce((result, segment) => {
+/**
+ * Builds a Final Form / lodash path from an array of path segments.
+ *
+ * Numeric segments become bracket indices (`[0]`). Other segments are joined
+ * with `.`.
+ *
+ * @param arrayPath - Path segments, e.g. `['items', '0', 'name']`.
+ * @returns Dotted path with brackets, e.g. `"items[0].name"`.
+ */
+export const arrayPathToDotBracket = (arrayPath) => {
+    return arrayPath.reduce((result, segment) => {
         if (/^\d+$/.test(segment)) {
             return `${result}[${segment}]`;
         }
         return result ? `${result}.${segment}` : segment;
     }, '');
 };
-export const getSchemaPath = (finalFormNameOrPath, finalFormHeadName, schema) => {
-    const finalFormPath = Array.isArray(finalFormNameOrPath)
-        ? finalFormNameOrPath
-        : parseFinalFormName(finalFormNameOrPath);
-    const schemaPath = finalFormPath
-        .slice(parseFinalFormName(finalFormHeadName).length)
-        .reduce((path, segment, index) => {
-        if (path === undefined) {
-            return path;
-        }
-        const schemaByPath = index === 0 ? schema : get(schema, path);
-        if (get(schemaByPath, ['properties', segment])) {
-            return [...path, 'properties', segment];
-        }
-        const items = get(schemaByPath, 'items');
-        if (items) {
-            if (Array.isArray(items)) {
-                return [...path, 'items', segment];
-            }
-            return [...path, 'items'];
-        }
-        return undefined;
-    }, []);
-    return schemaPath;
-};
 /**
- * Resolves a sub-schema from the root schema by an AJV `schemaPath`.
+ * Resolves a sub-schema from the root schema by a JSON Pointer.
  *
- * Parses `schemaPath` via `parseSchemaPath` and looks up the node with lodash `get`.
- * The path must point to a schema object, not to a validation keyword — callers
- * should strip the trailing keyword first (see `processAjvError`).
+ * A string pointer is parsed via `pointerToArrayPath`. An array of segments is
+ * used as-is. Lookup is done with lodash `get`.
  *
- * @param schemaPath - JSON Pointer string pointing to a schema node,
- *   e.g. `"#/properties/name"`.
  * @param schema - The root JSON schema object.
+ * @param pointer - JSON Pointer (`"#/properties/name"`) or path segments
+ *   (`['properties', 'name']`).
  *
  * @example
  * const nameSchema = {
@@ -95,31 +76,17 @@ export const getSchemaPath = (finalFormNameOrPath, finalFormHeadName, schema) =>
  *     name: nameSchema,
  *   },
  * };
- * getSchemaBySchemaPath("#/properties/name", objectSchema); // returns nameSchema
+ * getSchemaByPointer(objectSchema, '#/properties/name'); // returns nameSchema
  *
  * @returns The sub-schema at the given path, or the root schema when the path is empty.
  */
-export const getSchemaBySchemaPath = (schemaPath, schema) => {
-    const pathArr = parseSchemaPath(schemaPath);
+export const getSchemaByPointer = (schema, pointer) => {
+    const pathArr = Array.isArray(pointer) ? pointer : pointerToArrayPath(pointer);
     if (!pathArr.length) {
         return schema;
     }
     return get(schema, pathArr);
 };
-export const getSchemaByInstancePath = (instancePath, schema) => {
-    const schemaPath = getSchemaPath(parseInstancePath(instancePath), '', schema);
-    if (schemaPath) {
-        return schemaPath.length ? get(schema, schemaPath) : schema;
-    }
-    return undefined;
-};
-export const getSchemaByFinalFormPath = (finalFormNameOrPath, finalFormHeadName, schema) => {
-    const schemaPath = getSchemaPath(finalFormNameOrPath, finalFormHeadName, schema);
-    if (schemaPath) {
-        return schemaPath.length ? get(schema, schemaPath) : schema;
-    }
-    return undefined;
-};
 export const getValuePaths = (value, path = []) => {
     const result = [];
     const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
@@ -138,28 +105,4 @@ export const getValuePaths = (value, path = []) => {
     }
     return result;
 };
-export const smartSet = (object, path, value) => {
-    const valuePaths = getValuePaths(value);
-    if (valuePaths.length) {
-        set(object, path, Object.assign({}, get(object, path)));
-        valuePaths.forEach((valuePath) => {
-            set(object, [...path, ...valuePath], get(value, valuePath));
-        });
-    }
-    return object;
-};
-export const smartMerge = (first, second, deep = false) => {
-    let result = {};
-    if (deep) {
-        getValuePaths(first).forEach((path) => {
-            set(result, path, get(first, path));
-        });
-    }
-    else {
-        result = Object.assign({}, first);
-    }
-    getValuePaths(second).forEach((path) => {
-        set(result, path, get(second, path));
-    });
-    return result;
-};
+export const getServiceFieldName = (serviceFieldName, headName) => headName ? `${serviceFieldName}.${headName}` : serviceFieldName;

package/build/esm/lib/unstable/core/utils/definers.d.ts

@@ -0,0 +1,58 @@
+import type { NodeType } from '../constants';
+import type { ErrorMessages, NodeEntity, NodeLayout, NodesConfig, Validator } from '../types';
+import type { EntityKind, ExtractNodeEntityProps, ExtractNodeLayoutProps, LayoutKind, NodeComponentProps, NodeTypeConfigKey, SchemaOfNodeType } from '../types/helpers';
+export declare const defineNodeEntityConfig: <Component extends NodeEntity<any>>(nodeEntityConfig: {
+    Component: Component;
+    independent?: boolean;
+    defaultProps?: ExtractNodeEntityProps<Component>;
+}) => {
+    Component: Component;
+    independent?: boolean;
+    defaultProps?: ExtractNodeEntityProps<Component>;
+};
+export declare const defineNodeLayoutConfig: <Component extends NodeLayout<any>>(nodeLayoutConfig: {
+    Component: Component;
+    defaultProps?: ExtractNodeLayoutProps<Component>;
+}) => {
+    Component: Component;
+    defaultProps?: ExtractNodeLayoutProps<Component>;
+};
+export declare const createNodeParametersDefiner: <Config extends NodesConfig>(_config: Config) => <Type extends NodeType, const Entity extends NodeTypeConfigKey<Config, Type, "formEntities"> | NodeTypeConfigKey<Config, Type, "overviewEntities"> | NodeEntity<SchemaOfNodeType<Type>> | undefined = undefined, const FormEntity extends NodeTypeConfigKey<Config, Type, "formEntities"> | NodeEntity<SchemaOfNodeType<Type>> | undefined = undefined, const OverviewEntity extends NodeTypeConfigKey<Config, Type, "overviewEntities"> | NodeEntity<SchemaOfNodeType<Type>> | undefined = undefined, const Layout extends NodeTypeConfigKey<Config, Type, "formLayouts"> | NodeTypeConfigKey<Config, Type, "overviewLayouts"> | NodeLayout<SchemaOfNodeType<Type>> | undefined = undefined, const FormLayout extends NodeTypeConfigKey<Config, Type, "formLayouts"> | NodeLayout<SchemaOfNodeType<Type>> | undefined = undefined, const OverviewLayout extends NodeTypeConfigKey<Config, Type, "overviewLayouts"> | NodeLayout<SchemaOfNodeType<Type>> | undefined = undefined, const ValidatorRef extends NodeTypeConfigKey<Config, Type, "validators"> | Validator<SchemaOfNodeType<Type>> | undefined = undefined>(nodeParameters: {
+    type: Type;
+    entity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | Entity;
+    entityProps?: NodeComponentProps<Config, Type, EntityKind, Entity>;
+    formEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NodeEntity<SchemaOfNodeType<Type>> | FormEntity;
+    formEntityProps?: NodeComponentProps<Config, Type, "formEntities", FormEntity>;
+    overviewEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | OverviewEntity;
+    overviewEntityProps?: NodeComponentProps<Config, Type, "overviewEntities", OverviewEntity>;
+    layout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | Layout;
+    layoutProps?: NodeComponentProps<Config, Type, LayoutKind, Layout>;
+    formLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | FormLayout;
+    formLayoutProps?: NodeComponentProps<Config, Type, "formLayouts", FormLayout>;
+    overviewLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | OverviewLayout;
+    overviewLayoutProps?: NodeComponentProps<Config, Type, "overviewLayouts", OverviewLayout>;
+    errorMessages?: Omit<ErrorMessages, "dependencies" | "required"> & {
+        dependencies?: ErrorMessages["dependencies"] | Record<string, ErrorMessages["dependencies"]>;
+        required?: ErrorMessages["required"] | Record<string, ErrorMessages["required"]>;
+    };
+    validator?: NoInfer<NodeTypeConfigKey<Config, Type, "validators">> | Validator<SchemaOfNodeType<Type>> | ValidatorRef;
+}) => {
+    type: Type;
+    entity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | Entity;
+    entityProps?: NodeComponentProps<Config, Type, EntityKind, Entity>;
+    formEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NodeEntity<SchemaOfNodeType<Type>> | FormEntity;
+    formEntityProps?: NodeComponentProps<Config, Type, "formEntities", FormEntity>;
+    overviewEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | OverviewEntity;
+    overviewEntityProps?: NodeComponentProps<Config, Type, "overviewEntities", OverviewEntity>;
+    layout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | Layout;
+    layoutProps?: NodeComponentProps<Config, Type, LayoutKind, Layout>;
+    formLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | FormLayout;
+    formLayoutProps?: NodeComponentProps<Config, Type, "formLayouts", FormLayout>;
+    overviewLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | OverviewLayout;
+    overviewLayoutProps?: NodeComponentProps<Config, Type, "overviewLayouts", OverviewLayout>;
+    errorMessages?: Omit<ErrorMessages, "dependencies" | "required"> & {
+        dependencies?: ErrorMessages["dependencies"] | Record<string, ErrorMessages["dependencies"]>;
+        required?: ErrorMessages["required"] | Record<string, ErrorMessages["required"]>;
+    };
+    validator?: NoInfer<NodeTypeConfigKey<Config, Type, "validators">> | Validator<SchemaOfNodeType<Type>> | ValidatorRef;
+};

package/build/esm/lib/unstable/core/utils/definers.js

@@ -0,0 +1,3 @@
+export const defineNodeEntityConfig = (nodeEntityConfig) => nodeEntityConfig;
+export const defineNodeLayoutConfig = (nodeLayoutConfig) => nodeLayoutConfig;
+export const createNodeParametersDefiner = (_config) => (nodeParameters) => nodeParameters;

package/build/esm/lib/unstable/core/utils/index.d.ts

@@ -1 +1,2 @@
 export * from './common';
+export * from './definers';

package/build/esm/lib/unstable/core/utils/index.js

@@ -1 +1,2 @@
 export * from './common';
+export * from './definers';