@gravity-ui/dynamic-forms 5.18.0 → 5.19.0

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

@@ -0,0 +1,81 @@
+import React from 'react';
+import cloneDeep from 'lodash/cloneDeep';
+import noop from 'lodash/noop';
+import { useForm } from 'react-final-form';
+import { EMPTY_OBJECT } from '../constants';
+import { ENTITY_SERVICE_FIELD } from './constants';
+import { useSchemaRendererMutators } from './hooks';
+import { getValidate } from './utils';
+export const useSchemaRenderer = ({ config, connectValidate = true, errorMessages = EMPTY_OBJECT, mode, name, schema: originalSchema, }) => {
+    const form = useForm();
+    const { setAsyncValidationCache, setAsyncValidationWaiters, triggerFields } = useSchemaRendererMutators();
+    const errorsRef = React.useRef({});
+    const schemaRef = React.useRef(undefined);
+    const [schema, setSchema] = React.useState(undefined);
+    const [fieldsToTrigger, setFieldsToTrigger] = React.useState([]);
+    const setErrors = React.useCallback((errors) => {
+        const formState = form.getState();
+        const fieldsToTrigger = Object.keys(Object.assign(Object.assign({}, errorsRef.current), errors)).filter((key) => {
+            if (errorsRef.current[key] !== errors[key]) {
+                const field = form.getFieldState(key);
+                if ((field === null || field === void 0 ? void 0 : field.touched) || formState.submitFailed) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        errorsRef.current = errors;
+        if (fieldsToTrigger.length) {
+            setFieldsToTrigger(fieldsToTrigger);
+        }
+    }, [form]);
+    const validate = React.useMemo(() => getValidate({
+        config,
+        errorMessages,
+        name,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setErrors,
+    }), [
+        config,
+        errorMessages,
+        name,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setErrors,
+    ]);
+    const returnValue = React.useMemo(() => {
+        if (connectValidate) {
+            return { schema };
+        }
+        return {
+            schema,
+            validate: (value) => {
+                const allValues = form.getState().values;
+                const meta = form.getFieldState(name);
+                return validate(value, allValues, meta);
+            },
+        };
+    }, [connectValidate, form, name, schema, validate]);
+    React.useEffect(() => {
+        schemaRef.current = cloneDeep(originalSchema);
+        setSchema(schemaRef.current);
+    }, [originalSchema]);
+    React.useEffect(() => {
+        const data = { originalSchema, schema: schemaRef.current };
+        const getValidator = connectValidate ? () => validate : undefined;
+        const unsubscribe = form.registerField(name, noop, EMPTY_OBJECT, { data, getValidator });
+        return () => unsubscribe();
+    }, [connectValidate, form, name, originalSchema, validate]);
+    React.useEffect(() => {
+        const data = { config, errorsRef, headName: name, mode, schema: schemaRef.current };
+        const unsubscribe = form.registerField(`${ENTITY_SERVICE_FIELD}.${name}`, noop, EMPTY_OBJECT, { data });
+        return () => unsubscribe();
+    }, [config, form, mode, name]);
+    React.useEffect(() => {
+        if (fieldsToTrigger.length) {
+            triggerFields === null || triggerFields === void 0 ? void 0 : triggerFields({ fields: fieldsToTrigger });
+        }
+    }, [fieldsToTrigger, triggerFields]);
+    return returnValue;
+};

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

@@ -0,0 +1 @@
+export declare const guessHeadName: (registeredFields: string[], name: string) => string | undefined;

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

@@ -0,0 +1,7 @@
+import { ENTITY_SERVICE_FIELD } from '../constants';
+export const guessHeadName = (registeredFields, name) => {
+    const registeredServiceFields = registeredFields
+        .filter((n) => n.startsWith(ENTITY_SERVICE_FIELD))
+        .map((n) => n.slice(`${ENTITY_SERVICE_FIELD}.`.length));
+    return registeredServiceFields.find((n) => name === n || name.startsWith(`${n}.`) || name.startsWith(`${n}[`));
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/get-ajv-validate.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorObject, ValidateFunction } from 'ajv';
+import type { JsonSchema, SchemaRendererConfig } from '../../types';
+import type { EntityParametersError } from '../types';
+export interface GetAjvValidateParams {
+    config: SchemaRendererConfig;
+    schema: JsonSchema;
+}
+export interface GetAjvValidateReturn extends ValidateFunction {
+    errors?: (ErrorObject | EntityParametersError)[];
+}
+export declare const getAjvValidate: ({ config, schema }: GetAjvValidateParams) => GetAjvValidateReturn;

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/get-ajv-validate.js

@@ -0,0 +1,34 @@
+import Ajv from 'ajv';
+import get from 'lodash/get';
+export const getAjvValidate = ({ config, schema }) => {
+    function entityParametersValidate(_, value, schema) {
+        if (schema && schema.entityParameters) {
+            const entityType = get(schema, 'entityParameters.type');
+            const validatorType = schema.entityParameters.validatorType;
+            const validator = get(config, `${entityType}.validators.${validatorType}`);
+            if (validator) {
+                const error = {
+                    keyword: 'entityParameters',
+                    message: '',
+                    params: { validator, value, schema },
+                };
+                entityParametersValidate.errors = [error];
+                return false;
+            }
+        }
+        return true;
+    }
+    const ajv = new Ajv({
+        allErrors: true,
+        allowMatchingProperties: true,
+        keywords: [
+            {
+                errors: true,
+                keyword: 'entityParameters',
+                validate: entityParametersValidate,
+            },
+        ],
+    });
+    const ajvValidate = ajv.compile(schema);
+    return ajvValidate;
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/get-validate.d.ts

@@ -0,0 +1,14 @@
+import { type FieldValidator } from 'final-form';
+import type { ErrorMessages, FieldValue, SchemaRendererConfig, SyncValidateError } from '../../types';
+import type { SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator } from '../mutators';
+export type GetValidateParams = {
+    config: SchemaRendererConfig;
+    errorMessages: ErrorMessages;
+    name: string;
+    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
+    setAsyncValidationWaiters?: SetAsyncValidationWaitersMutator;
+    setErrors: (errors: Record<string, SyncValidateError>) => void;
+};
+type GetValidateReturn = FieldValidator<FieldValue>;
+export declare const getValidate: ({ config, errorMessages, name, setAsyncValidationCache, setAsyncValidationWaiters, setErrors, }: GetValidateParams) => GetValidateReturn;
+export {};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/get-validate.js

@@ -0,0 +1,62 @@
+import get from 'lodash/get';
+import isBoolean from 'lodash/isBoolean';
+import isObjectLike from 'lodash/isObjectLike';
+import isString from 'lodash/isString';
+import { formatFinalFormPath, getValuePaths } from '../../utils';
+import { getAjvValidate } from './get-ajv-validate';
+import { processAjvValidateErrors } from './process-ajv-validate-errors';
+import { processErrorsState } from './process-errors-state';
+export const getValidate = ({ config, errorMessages, name, setAsyncValidationCache, setAsyncValidationWaiters, setErrors, }) => {
+    let schema;
+    let ajvValidate;
+    return (value, allValues, meta) => {
+        const data = meta === null || meta === void 0 ? void 0 : meta.data;
+        if (!(data === null || data === void 0 ? void 0 : data.schema)) {
+            return false;
+        }
+        if (schema !== data.schema) {
+            schema = data.schema;
+            ajvValidate = getAjvValidate({ config, schema });
+        }
+        ajvValidate(value);
+        const { ajvErrorItems, entityParametersErrorItems, waiters } = processAjvValidateErrors({
+            ajvValidateErrors: ajvValidate.errors || [],
+            allValues: allValues,
+            errorMessages,
+            name,
+            schema,
+            setAsyncValidationCache,
+            validationState: data,
+        });
+        const { externalPriorityErrorItems, externalRegularErrorItems } = processErrorsState({
+            errorsState: data,
+            name,
+        });
+        if (Object.keys(waiters).length) {
+            setAsyncValidationWaiters === null || setAsyncValidationWaiters === void 0 ? void 0 : setAsyncValidationWaiters({ headName: name, waiters });
+        }
+        const result = { errors: {} };
+        [
+            ...externalRegularErrorItems,
+            ...ajvErrorItems,
+            ...entityParametersErrorItems,
+            ...externalPriorityErrorItems,
+        ].forEach((item) => {
+            if (!item.error) {
+                return;
+            }
+            if (isObjectLike(item.error)) {
+                getValuePaths(item.error).forEach((childPath) => {
+                    result.errors[formatFinalFormPath([name, ...item.path, ...childPath])] = get(item.error, childPath);
+                });
+                return;
+            }
+            if (isBoolean(item.error) || isString(item.error)) {
+                result.errors[formatFinalFormPath([name, ...item.path])] = item.error;
+                return;
+            }
+        });
+        setErrors(result.errors);
+        return Object.keys(result.errors).length ? 'error' : false;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { guessHeadName } from './common';
+export { getValidate } from './get-validate';

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

@@ -0,0 +1,2 @@
+export { guessHeadName } from './common';
+export { getValidate } from './get-validate';

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-ajv-error.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorObject } from 'ajv';
+import type { ErrorMessages, JsonSchema } from '../../types';
+import type { ValidateErrorItem } from '../types';
+export interface ProcessAjvErrorParams<Schema extends JsonSchema> {
+    error: ErrorObject;
+    errorMessages: ErrorMessages;
+    schema: Schema;
+    onError: (error: ValidateErrorItem) => void;
+}
+export declare const processAjvError: <Schema extends JsonSchema>({ error, errorMessages, schema, onError, }: ProcessAjvErrorParams<Schema>) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-ajv-error.js

@@ -0,0 +1,46 @@
+import get from 'lodash/get';
+import isString from 'lodash/isString';
+import { getSchemaByInstancePath, getSchemaBySchemaPath, parseInstancePath } from '../../utils';
+export const processAjvError = ({ error, errorMessages, schema, onError, }) => {
+    let instancePath = error.instancePath;
+    let keyword = error.keyword;
+    let schemaPath = error.schemaPath;
+    if (keyword === 'anyOf' ||
+        (keyword === 'if' &&
+            (error.params.failingKeyword === 'then' || error.params.failingKeyword === 'else')) ||
+        keyword === 'false schema') {
+        return;
+    }
+    if (error.propertyName) {
+        instancePath += `/${error.propertyName}`;
+    }
+    if (keyword === 'required') {
+        instancePath += `/${error.params.missingProperty}`;
+    }
+    else if (keyword === 'dependencies') {
+        instancePath += `/${error.params.missingProperty}`;
+        schemaPath =
+            schemaPath.slice(0, -'dependencies'.length) +
+                `properties/${error.params.missingProperty}/dependencies`;
+    }
+    else if (keyword === 'if') {
+        keyword = error.params.failingKeyword;
+        schemaPath = schemaPath.slice(0, -'if'.length) + error.params.failingKeyword;
+    }
+    const getErrorMessageBySchema = (schema) => {
+        const propertyName = instancePath.split('/').pop();
+        const errorOrMap = get(schema, `entityParameters.errorMessages.${keyword}`);
+        const message = isString(errorOrMap)
+            ? errorOrMap
+            : get(errorOrMap, propertyName);
+        return message;
+    };
+    onError({
+        path: parseInstancePath(instancePath),
+        error: getErrorMessageBySchema(getSchemaBySchemaPath(schemaPath, schema)) ||
+            getErrorMessageBySchema(getSchemaBySchemaPath(schemaPath.slice(0, -`/${keyword}`.length), schema)) ||
+            getErrorMessageBySchema(getSchemaByInstancePath(instancePath, schema)) ||
+            errorMessages[keyword] ||
+            error.message,
+    });
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-ajv-validate-errors.d.ts

@@ -0,0 +1,20 @@
+import type { ErrorObject } from 'ajv';
+import type { ErrorMessages, JsonSchema, ObjectValue } from '../../types';
+import type { AsyncValidationState, AsyncValidationWaiter, SetAsyncValidationCacheMutator } from '../mutators';
+import type { EntityParametersError, ValidateErrorItem } from '../types';
+export interface ProcessAjvValidateErrorsParams<Schema extends JsonSchema> {
+    ajvValidateErrors: (ErrorObject | EntityParametersError)[];
+    allValues: ObjectValue;
+    errorMessages: ErrorMessages;
+    name: string;
+    schema: Schema;
+    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
+    validationState: AsyncValidationState | undefined;
+}
+interface ProcessAjvValidateErrorsReturn {
+    ajvErrorItems: ValidateErrorItem[];
+    entityParametersErrorItems: ValidateErrorItem[];
+    waiters: Record<string, AsyncValidationWaiter>;
+}
+export declare const processAjvValidateErrors: <Schema extends JsonSchema>({ ajvValidateErrors, allValues, errorMessages, name, schema, setAsyncValidationCache, validationState, }: ProcessAjvValidateErrorsParams<Schema>) => ProcessAjvValidateErrorsReturn;
+export {};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-ajv-validate-errors.js

@@ -0,0 +1,39 @@
+import { processAjvError } from './process-ajv-error';
+import { processEntityParametersError } from './process-entity-parameters-error';
+export const processAjvValidateErrors = ({ ajvValidateErrors, allValues, errorMessages, name, schema, setAsyncValidationCache, validationState, }) => {
+    const waiters = {};
+    const ajvErrorItems = [];
+    const entityParametersErrorItems = [];
+    ajvValidateErrors.forEach((ajvOrEntityParametersError) => {
+        if (ajvOrEntityParametersError.keyword === 'entityParameters') {
+            const error = ajvOrEntityParametersError;
+            processEntityParametersError({
+                allValues,
+                error,
+                onAsyncError: (w) => {
+                    waiters[w.instancePath] = w.params;
+                    w.promise.then((result) => {
+                        setAsyncValidationCache === null || setAsyncValidationCache === void 0 ? void 0 : setAsyncValidationCache({
+                            headName: name,
+                            cache: {
+                                [w.instancePath]: Object.assign(Object.assign({}, w.params), { result }),
+                            },
+                        });
+                    });
+                },
+                onError: (e) => entityParametersErrorItems.push(e),
+                validationState,
+            });
+        }
+        else {
+            const error = ajvOrEntityParametersError;
+            processAjvError({
+                error,
+                errorMessages,
+                schema,
+                onError: (e) => ajvErrorItems.push(e),
+            });
+        }
+    });
+    return { ajvErrorItems, entityParametersErrorItems, waiters };
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-entity-parameters-error.d.ts

@@ -0,0 +1,15 @@
+import type { AsyncValidateError, ObjectValue } from '../../types';
+import type { AsyncValidationState } from '../mutators';
+import type { EntityParametersError, ValidateErrorItem } from '../types';
+export interface ProcessEntityParametersErrorParams {
+    allValues: ObjectValue;
+    error: EntityParametersError;
+    onAsyncError: (waiter: {
+        instancePath: string;
+        params: EntityParametersError['params'];
+        promise: AsyncValidateError;
+    }) => void;
+    onError: (error: ValidateErrorItem) => void;
+    validationState: AsyncValidationState | undefined;
+}
+export declare const processEntityParametersError: ({ allValues, error, onAsyncError, onError, validationState, }: ProcessEntityParametersErrorParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-entity-parameters-error.js

@@ -0,0 +1,31 @@
+import isEqual from 'lodash/isEqual';
+import omit from 'lodash/omit';
+import { parseInstancePath } from '../../utils';
+export const processEntityParametersError = ({ allValues, error, onAsyncError, onError, validationState, }) => {
+    var _a, _b;
+    const waiter = (_a = validationState === null || validationState === void 0 ? void 0 : validationState.waiters) === null || _a === void 0 ? void 0 : _a[error.instancePath];
+    const cache = (_b = validationState === null || validationState === void 0 ? void 0 : validationState.cache) === null || _b === void 0 ? void 0 : _b[error.instancePath];
+    const cacheItem = cache === null || cache === void 0 ? void 0 : cache.find((item) => isEqual(error.params, omit(item, 'result')));
+    if (cacheItem === null || cacheItem === void 0 ? void 0 : cacheItem.result) {
+        onError({
+            error: cacheItem.result,
+            path: parseInstancePath(error.instancePath),
+        });
+    }
+    else if (!waiter || !isEqual(error.params, waiter)) {
+        const errorOrPromise = error.params.validator(error.params.value, allValues);
+        if (errorOrPromise instanceof Promise) {
+            onAsyncError({
+                instancePath: error.instancePath,
+                params: error.params,
+                promise: errorOrPromise,
+            });
+        }
+        else {
+            onError({
+                error: errorOrPromise,
+                path: parseInstancePath(error.instancePath),
+            });
+        }
+    }
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-errors-state.d.ts

@@ -0,0 +1,12 @@
+import type { ExternalErrorsState } from '../mutators';
+import type { ValidateErrorItem } from '../types';
+interface ProcessErrorsStateParams {
+    errorsState: ExternalErrorsState | undefined;
+    name: string;
+}
+interface ProcessErrorsStateReturn {
+    externalPriorityErrorItems: ValidateErrorItem[];
+    externalRegularErrorItems: ValidateErrorItem[];
+}
+export declare const processErrorsState: ({ errorsState, name, }: ProcessErrorsStateParams) => ProcessErrorsStateReturn;
+export {};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-errors-state.js

@@ -0,0 +1,12 @@
+import mapValues from 'lodash/mapValues';
+import { parseFinalFormName } from '../../utils';
+export const processErrorsState = ({ errorsState, name, }) => {
+    const getErrorItems = (errors) => Object.values(mapValues(errors, (value, key) => ({
+        path: parseFinalFormName(key).slice(parseFinalFormName(name).length),
+        error: value,
+    })));
+    return {
+        externalPriorityErrorItems: getErrorItems(errorsState === null || errorsState === void 0 ? void 0 : errorsState.priorityErrors),
+        externalRegularErrorItems: getErrorItems(errorsState === null || errorsState === void 0 ? void 0 : errorsState.regularErrors),
+    };
+};

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

@@ -0,0 +1,49 @@
+import type { JsonSchema } from '../types';
+/**
+ * Parses an AJV `schemaPath` (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` → `~`).
+ *
+ * Returns all segments unchanged; stripping a trailing validation keyword
+ * (e.g. `minLength`) before lookup is the caller's responsibility.
+ *
+ * @param schemaPath - JSON Pointer string, e.g. `"#/properties/name/minLength"`.
+ * @returns Path segments, e.g. `['properties', 'name', 'minLength']`.
+ */
+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;
+/**
+ * Resolves a sub-schema from the root schema by an AJV `schemaPath`.
+ *
+ * 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`).
+ *
+ * @param schemaPath - JSON Pointer string pointing to a schema node,
+ *   e.g. `"#/properties/name"`.
+ * @param schema - The root JSON schema object.
+ *
+ * @example
+ * const nameSchema = {
+ *   minLength: 5,
+ * };
+ * const objectSchema = {
+ *   properties: {
+ *     name: nameSchema,
+ *   },
+ * };
+ * getSchemaBySchemaPath("#/properties/name", objectSchema); // 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 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) => {};

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

@@ -0,0 +1,165 @@
+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`.
+ *
+ * Strips the `#/` prefix, 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.
+ *
+ * @param schemaPath - JSON Pointer string, e.g. `"#/properties/name/minLength"`.
+ * @returns Path segments, e.g. `['properties', 'name', 'minLength']`.
+ */
+export const parseSchemaPath = (schemaPath) => {
+    return decodeURIComponent(schemaPath)
+        .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) => {
+    const result = [];
+    const regex = /([^[.\]]+)|\[(\d+)\]/g;
+    let match;
+    while ((match = regex.exec(finalFormName)) !== null) {
+        if (match[1] !== undefined) {
+            result.push(match[1]);
+        }
+        else if (match[2] !== undefined) {
+            result.push(match[2]);
+        }
+    }
+    return result;
+};
+export const formatFinalFormPath = (finalFormPath) => {
+    return finalFormPath.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`.
+ *
+ * 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`).
+ *
+ * @param schemaPath - JSON Pointer string pointing to a schema node,
+ *   e.g. `"#/properties/name"`.
+ * @param schema - The root JSON schema object.
+ *
+ * @example
+ * const nameSchema = {
+ *   minLength: 5,
+ * };
+ * const objectSchema = {
+ *   properties: {
+ *     name: nameSchema,
+ *   },
+ * };
+ * getSchemaBySchemaPath("#/properties/name", objectSchema); // 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);
+    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);
+    if (Array.isArray(value)) {
+        value.forEach((_, index) => {
+            result.push(...getValuePaths(value[index], [...path, `${index}`]));
+        });
+    }
+    else if (isObject(value)) {
+        Object.keys(value).forEach((key) => {
+            result.push(...getValuePaths(get(value, key), [...path, key]));
+        });
+    }
+    else if (path.length) {
+        result.push(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;
+};

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

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

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

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

package/build/esm/lib/unstable/kit/Accordeon.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { JsonSchema, WrapperProps } from '../core/types';
+export declare const Accordeon: <Schema extends JsonSchema>({ schema, input, meta, children, wrapperProps, }: WrapperProps<Schema>) => React.ReactNode;