@gravity-ui/dynamic-forms 5.18.0 → 5.19.1

package/build/cjs/lib/unstable/core/useSchemaRenderer/useSchemaRenderer.d.ts

@@ -0,0 +1,37 @@
+import type { FieldValidator } from 'final-form';
+import { type SchemaRendererMode } from '../constants';
+import type { ErrorMessages, FieldValue, JsonSchema, SchemaRendererConfig } from '../types';
+export interface UseSchemaRendererParams {
+    config: SchemaRendererConfig;
+    connectValidate?: boolean;
+    errorMessages?: ErrorMessages;
+    mode: SchemaRendererMode;
+    /**
+     * The `name` prop must be a non-empty string.
+     *
+     * In `final-form` and `react-final-form`, the `name` is used as a key to register
+     * the field within the form. If you pass an empty string (`name=""`), the field will
+     * not be registered, its value will not be tracked, and validation will not work.
+     *
+     * This can lead to:
+     * - the field being missing from the form `values`;
+     * - the `validate` function not being called;
+     * - no error or touched state updates;
+     * - inconsistent or broken form behavior.
+     *
+     * Always provide a unique, non-empty string for the field name.
+     */
+    name: string;
+    schema: JsonSchema;
+}
+export type UseSchemaRendererReturn = {
+    schema: JsonSchema | undefined;
+    validate: FieldValidator<FieldValue> | undefined;
+};
+export declare const useSchemaRenderer: ({ config, connectValidate, errorMessages, mode, name, schema: originalSchema, }: UseSchemaRendererParams) => {
+    schema: JsonSchema | undefined;
+    validate?: undefined;
+} | {
+    schema: JsonSchema | undefined;
+    validate: (value?: FieldValue) => any;
+};

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSchemaRenderer = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
+const noop_1 = tslib_1.__importDefault(require("lodash/noop"));
+const react_final_form_1 = require("react-final-form");
+const constants_1 = require("../constants");
+const constants_2 = require("./constants");
+const hooks_1 = require("./hooks");
+const utils_1 = require("./utils");
+const useSchemaRenderer = ({ config, connectValidate = true, errorMessages = constants_1.EMPTY_OBJECT, mode, name, schema: originalSchema, }) => {
+    const form = (0, react_final_form_1.useForm)();
+    const { setAsyncValidationCache, setAsyncValidationWaiters, triggerFields } = (0, hooks_1.useSchemaRendererMutators)();
+    const errorsRef = react_1.default.useRef({});
+    const schemaRef = react_1.default.useRef(undefined);
+    const [schema, setSchema] = react_1.default.useState(undefined);
+    const [fieldsToTrigger, setFieldsToTrigger] = react_1.default.useState([]);
+    const setErrors = react_1.default.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_1.default.useMemo(() => (0, utils_1.getValidate)({
+        config,
+        errorMessages,
+        name,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setErrors,
+    }), [
+        config,
+        errorMessages,
+        name,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setErrors,
+    ]);
+    const returnValue = react_1.default.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_1.default.useEffect(() => {
+        schemaRef.current = (0, cloneDeep_1.default)(originalSchema);
+        setSchema(schemaRef.current);
+    }, [originalSchema]);
+    react_1.default.useEffect(() => {
+        const data = { originalSchema, schema: schemaRef.current };
+        const getValidator = connectValidate ? () => validate : undefined;
+        const unsubscribe = form.registerField(name, noop_1.default, constants_1.EMPTY_OBJECT, { data, getValidator });
+        return () => unsubscribe();
+    }, [connectValidate, form, name, originalSchema, validate]);
+    react_1.default.useEffect(() => {
+        const data = { config, errorsRef, headName: name, mode, schema: schemaRef.current };
+        const unsubscribe = form.registerField(`${constants_2.ENTITY_SERVICE_FIELD}.${name}`, noop_1.default, constants_1.EMPTY_OBJECT, { data });
+        return () => unsubscribe();
+    }, [config, form, mode, name]);
+    react_1.default.useEffect(() => {
+        if (fieldsToTrigger.length) {
+            triggerFields === null || triggerFields === void 0 ? void 0 : triggerFields({ fields: fieldsToTrigger });
+        }
+    }, [fieldsToTrigger, triggerFields]);
+    return returnValue;
+};
+exports.useSchemaRenderer = useSchemaRenderer;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessHeadName = void 0;
+const constants_1 = require("../constants");
+const guessHeadName = (registeredFields, name) => {
+    const registeredServiceFields = registeredFields
+        .filter((n) => n.startsWith(constants_1.ENTITY_SERVICE_FIELD))
+        .map((n) => n.slice(`${constants_1.ENTITY_SERVICE_FIELD}.`.length));
+    return registeredServiceFields.find((n) => name === n || name.startsWith(`${n}.`) || name.startsWith(`${n}[`));
+};
+exports.guessHeadName = guessHeadName;

package/build/cjs/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/cjs/lib/unstable/core/useSchemaRenderer/utils/get-ajv-validate.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAjvValidate = void 0;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const getAjvValidate = ({ config, schema }) => {
+    function entityParametersValidate(_, value, schema) {
+        if (schema && schema.entityParameters) {
+            const entityType = (0, get_1.default)(schema, 'entityParameters.type');
+            const validatorType = schema.entityParameters.validatorType;
+            const validator = (0, get_1.default)(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_1.default({
+        allErrors: true,
+        allowMatchingProperties: true,
+        keywords: [
+            {
+                errors: true,
+                keyword: 'entityParameters',
+                validate: entityParametersValidate,
+            },
+        ],
+    });
+    const ajvValidate = ajv.compile(schema);
+    return ajvValidate;
+};
+exports.getAjvValidate = getAjvValidate;

package/build/cjs/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/cjs/lib/unstable/core/useSchemaRenderer/utils/get-validate.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidate = void 0;
+const tslib_1 = require("tslib");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const isBoolean_1 = tslib_1.__importDefault(require("lodash/isBoolean"));
+const isObjectLike_1 = tslib_1.__importDefault(require("lodash/isObjectLike"));
+const isString_1 = tslib_1.__importDefault(require("lodash/isString"));
+const utils_1 = require("../../utils");
+const get_ajv_validate_1 = require("./get-ajv-validate");
+const process_ajv_validate_errors_1 = require("./process-ajv-validate-errors");
+const process_errors_state_1 = require("./process-errors-state");
+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 = (0, get_ajv_validate_1.getAjvValidate)({ config, schema });
+        }
+        ajvValidate(value);
+        const { ajvErrorItems, entityParametersErrorItems, waiters } = (0, process_ajv_validate_errors_1.processAjvValidateErrors)({
+            ajvValidateErrors: ajvValidate.errors || [],
+            allValues: allValues,
+            errorMessages,
+            name,
+            schema,
+            setAsyncValidationCache,
+            validationState: data,
+        });
+        const { externalPriorityErrorItems, externalRegularErrorItems } = (0, process_errors_state_1.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 ((0, isObjectLike_1.default)(item.error)) {
+                (0, utils_1.getValuePaths)(item.error).forEach((childPath) => {
+                    result.errors[(0, utils_1.formatFinalFormPath)([name, ...item.path, ...childPath])] = (0, get_1.default)(item.error, childPath);
+                });
+                return;
+            }
+            if ((0, isBoolean_1.default)(item.error) || (0, isString_1.default)(item.error)) {
+                result.errors[(0, utils_1.formatFinalFormPath)([name, ...item.path])] = item.error;
+                return;
+            }
+        });
+        setErrors(result.errors);
+        return Object.keys(result.errors).length ? 'error' : false;
+    };
+};
+exports.getValidate = getValidate;

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidate = exports.guessHeadName = void 0;
+var common_1 = require("./common");
+Object.defineProperty(exports, "guessHeadName", { enumerable: true, get: function () { return common_1.guessHeadName; } });
+var get_validate_1 = require("./get-validate");
+Object.defineProperty(exports, "getValidate", { enumerable: true, get: function () { return get_validate_1.getValidate; } });

package/build/cjs/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/cjs/lib/unstable/core/useSchemaRenderer/utils/process-ajv-error.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAjvError = void 0;
+const tslib_1 = require("tslib");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const isString_1 = tslib_1.__importDefault(require("lodash/isString"));
+const utils_1 = require("../../utils");
+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 = (0, get_1.default)(schema, `entityParameters.errorMessages.${keyword}`);
+        const message = (0, isString_1.default)(errorOrMap)
+            ? errorOrMap
+            : (0, get_1.default)(errorOrMap, propertyName);
+        return message;
+    };
+    onError({
+        path: (0, utils_1.parseInstancePath)(instancePath),
+        error: getErrorMessageBySchema((0, utils_1.getSchemaBySchemaPath)(schemaPath, schema)) ||
+            getErrorMessageBySchema((0, utils_1.getSchemaBySchemaPath)(schemaPath.slice(0, -`/${keyword}`.length), schema)) ||
+            getErrorMessageBySchema((0, utils_1.getSchemaByInstancePath)(instancePath, schema)) ||
+            errorMessages[keyword] ||
+            error.message,
+    });
+};
+exports.processAjvError = processAjvError;

package/build/cjs/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/cjs/lib/unstable/core/useSchemaRenderer/utils/process-ajv-validate-errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAjvValidateErrors = void 0;
+const process_ajv_error_1 = require("./process-ajv-error");
+const process_entity_parameters_error_1 = require("./process-entity-parameters-error");
+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;
+            (0, process_entity_parameters_error_1.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;
+            (0, process_ajv_error_1.processAjvError)({
+                error,
+                errorMessages,
+                schema,
+                onError: (e) => ajvErrorItems.push(e),
+            });
+        }
+    });
+    return { ajvErrorItems, entityParametersErrorItems, waiters };
+};
+exports.processAjvValidateErrors = processAjvValidateErrors;

package/build/cjs/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/cjs/lib/unstable/core/useSchemaRenderer/utils/process-entity-parameters-error.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEntityParametersError = void 0;
+const tslib_1 = require("tslib");
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const utils_1 = require("../../utils");
+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) => (0, isEqual_1.default)(error.params, (0, omit_1.default)(item, 'result')));
+    if (cacheItem === null || cacheItem === void 0 ? void 0 : cacheItem.result) {
+        onError({
+            error: cacheItem.result,
+            path: (0, utils_1.parseInstancePath)(error.instancePath),
+        });
+    }
+    else if (!waiter || !(0, isEqual_1.default)(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: (0, utils_1.parseInstancePath)(error.instancePath),
+            });
+        }
+    }
+};
+exports.processEntityParametersError = processEntityParametersError;

package/build/cjs/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/cjs/lib/unstable/core/useSchemaRenderer/utils/process-errors-state.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processErrorsState = void 0;
+const tslib_1 = require("tslib");
+const mapValues_1 = tslib_1.__importDefault(require("lodash/mapValues"));
+const utils_1 = require("../../utils");
+const processErrorsState = ({ errorsState, name, }) => {
+    const getErrorItems = (errors) => Object.values((0, mapValues_1.default)(errors, (value, key) => ({
+        path: (0, utils_1.parseFinalFormName)(key).slice((0, utils_1.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),
+    };
+};
+exports.processErrorsState = processErrorsState;

package/build/cjs/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) => {};