@gravity-ui/dynamic-forms 5.20.0 → 5.21.0

package/build/esm/lib/unstable/core/types/validation.d.ts

@@ -1,39 +1,37 @@
 import type { SchemaToValueType } from './helpers';
+import type { JSLErrors } from './jsl-errors';
 import type { JsonSchema } from './schema';
 import type { ObjectValue } from './values';
-type ArrayError = SyncValidateError[];
-interface ObjectError extends Record<string, SyncValidateError> {
+type ArrayError = Error[];
+interface ObjectError extends Record<string, Error> {
 }
-export type SyncValidateError = ArrayError | boolean | string | ObjectError | undefined;
-export type AsyncValidateError = Promise<SyncValidateError>;
-export type SyncValidator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => SyncValidateError;
-export type AsyncValidator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => AsyncValidateError;
-export type Validator<Schema extends JsonSchema> = SyncValidator<Schema> | AsyncValidator<Schema>;
+export type ValidationError = ArrayError | ObjectError | boolean | string | undefined;
+export type Validator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => ValidationError | Promise<ValidationError>;
 export interface ErrorMessages {
-    additionalItems?: string;
-    additionalProperties?: string;
-    anyOf?: string;
-    const?: string;
-    contains?: string;
-    dependencies?: string;
-    enum?: string;
-    exclusiveMaximum?: string;
-    exclusiveMinimum?: string;
-    maxItems?: string;
-    maxLength?: string;
-    maxProperties?: string;
-    maximum?: string;
-    minItems?: string;
-    minLength?: string;
-    minProperties?: string;
-    minimum?: string;
-    multipleOf?: string;
-    not?: string;
-    oneOf?: string;
-    pattern?: string;
-    propertyNames?: string;
-    required?: string;
-    type?: string;
-    uniqueItems?: string;
+    additionalItems?: ((e: JSLErrors.AdditionalItems) => string) | string;
+    additionalProperties?: ((e: JSLErrors.AdditionalProperties) => string) | string;
+    anyOf?: ((e: JSLErrors.AnyOf) => string) | string;
+    const?: ((e: JSLErrors.Const) => string) | string;
+    contains?: ((e: JSLErrors.ContainsAny) => string) | string;
+    dependencies?: ((e: JSLErrors.Dependencies) => string) | string;
+    enum?: ((e: JSLErrors.Enum) => string) | string;
+    exclusiveMaximum?: ((e: JSLErrors.ExclusiveMaximum) => string) | string;
+    exclusiveMinimum?: ((e: JSLErrors.ExclusiveMinimum) => string) | string;
+    maxItems?: ((e: JSLErrors.MaxItems) => string) | string;
+    maxLength?: ((e: JSLErrors.MaxLength) => string) | string;
+    maxProperties?: ((e: JSLErrors.MaxProperties) => string) | string;
+    maximum?: ((e: JSLErrors.Maximum) => string) | string;
+    minItems?: ((e: JSLErrors.MinItems) => string) | string;
+    minLength?: ((e: JSLErrors.MinLength) => string) | string;
+    minProperties?: ((e: JSLErrors.MinProperties) => string) | string;
+    minimum?: ((e: JSLErrors.Minimum) => string) | string;
+    multipleOf?: ((e: JSLErrors.MultipleOf) => string) | string;
+    not?: ((e: JSLErrors.Not) => string) | string;
+    oneOf?: ((e: JSLErrors.OneOf) => string) | string;
+    pattern?: ((e: JSLErrors.Pattern) => string) | string;
+    propertyNames?: ((e: JSLErrors.PropertyNames) => string) | string;
+    required?: ((e: JSLErrors.Required) => string) | string;
+    type?: ((e: JSLErrors.Type) => string) | string;
+    uniqueItems?: ((e: JSLErrors.UniqueItems) => string) | string;
 }
 export {};

package/build/esm/lib/unstable/core/useSchemaRenderer/constants.d.ts

@@ -1 +1 @@
-export declare const ENTITY_SERVICE_FIELD = "ENTITY_SERVICE_FIELD";
+export declare const SCHEMA_RENDERER_SERVICE_FIELD = "SCHEMA_RENDERER_SERVICE_FIELD";

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

@@ -1 +1 @@
-export const ENTITY_SERVICE_FIELD = 'ENTITY_SERVICE_FIELD';
+export const SCHEMA_RENDERER_SERVICE_FIELD = 'SCHEMA_RENDERER_SERVICE_FIELD';

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

@@ -1,3 +1,3 @@
-export { useEntitiesState, useSchemaRendererMutators } from './hooks';
-export { schemaRendererMutators } from './mutators';
-export { type UseSchemaRendererParams, type UseSchemaRendererReturn, useSchemaRenderer, } from './useSchemaRenderer';
+export { SCHEMA_RENDERER_SERVICE_FIELD } from './constants';
+export type { SchemaRendererState, SchemaPatch, SchemaPatchRemover } from './types';
+export { type UseSchemaRendererParams, useSchemaRenderer } from './useSchemaRenderer';

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

@@ -1,3 +1,2 @@
-export { useEntitiesState, useSchemaRendererMutators } from './hooks';
-export { schemaRendererMutators } from './mutators';
-export { useSchemaRenderer, } from './useSchemaRenderer';
+export { SCHEMA_RENDERER_SERVICE_FIELD } from './constants';
+export { useSchemaRenderer } from './useSchemaRenderer';

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

@@ -0,0 +1,4 @@
+export * from './patches';
+export * from './state';
+export * from './subscription';
+export * from './validation';

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

@@ -0,0 +1,4 @@
+export * from './patches';
+export * from './state';
+export * from './subscription';
+export * from './validation';

package/build/esm/lib/unstable/core/useSchemaRenderer/types/patches.d.ts

@@ -0,0 +1,21 @@
+import type { JsonSchema } from '../../types';
+export type SchemaPatch = {
+    headName: string;
+    name: string;
+    schema: JsonSchema;
+    replace?: boolean;
+} | {
+    headName: string;
+    schemaPath: string;
+    schema: JsonSchema;
+    replace?: boolean;
+};
+export type SchemaPatchRemover = {
+    headName: string;
+    name: string;
+    schema: JsonSchema | true;
+} | {
+    headName: string;
+    schemaPath: string;
+    schema: JsonSchema | true;
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/types/state.d.ts

@@ -0,0 +1,34 @@
+import type { MonacoEditorProps } from 'react-monaco-editor/lib/types';
+import type { SchemaRendererMode } from '../../constants';
+import type { ErrorMessages, JsonSchema, NodesConfig, ValidationError } from '../../types';
+import type { SchemaPatch } from './patches';
+import type { SchemaRendererEvent, SchemaRendererSubscriber } from './subscription';
+import type { ValidationCache, ValidationWaiter } from './validation';
+export interface SchemaRendererState<UserContext extends Record<string, unknown> = Record<string, unknown>> {
+    cache: Record<string, ValidationCache[] | undefined>;
+    config: NodesConfig;
+    dispatchEvent: (events: SchemaRendererEvent[]) => void;
+    errors: Record<string, ValidationError>;
+    errorMessages: ErrorMessages;
+    mode: SchemaRendererMode;
+    originalSchema: JsonSchema;
+    patches: SchemaPatch[];
+    priorityErrors: Record<string, ValidationError>;
+    regularErrors: Record<string, ValidationError>;
+    runValidate: () => void;
+    schema: JsonSchema;
+    settings: {
+        jsonDefaultValues: boolean;
+    };
+    subscribe: (subscriber: SchemaRendererSubscriber) => string;
+    subscribers: {
+        byId: Record<string, SchemaRendererSubscriber>;
+        byName: Map<string, Set<string>>;
+        byPath: Map<string, Set<string>>;
+    };
+    unsubscribe: (id: string) => void;
+    userContext: {
+        MonacoEditor?: React.ComponentType<MonacoEditorProps>;
+    } & UserContext;
+    waiters: Record<string, ValidationWaiter | undefined>;
+}

package/build/esm/lib/unstable/core/useSchemaRenderer/types/subscription.d.ts

@@ -0,0 +1,13 @@
+import type { SchemaRendererEventType } from '../../constants';
+export interface SchemaRendererSubscriber {
+    callback: (events: SchemaRendererEvent[]) => void;
+    name?: string;
+    schemaPaths?: string[];
+    subscription: Partial<Record<SchemaRendererEventType, boolean>>;
+}
+export interface SchemaRendererEvent {
+    type: SchemaRendererEventType;
+    all?: boolean;
+    names?: string[];
+    paths?: string[][];
+}

package/build/esm/lib/unstable/core/useSchemaRenderer/types/validation.d.ts

@@ -0,0 +1,10 @@
+import type { FieldValue, JsonSchema, ValidationError, Validator } from '../../types';
+export interface ValidationWaiter {
+    promise: Promise<ValidationError>;
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}
+export interface ValidationCache extends Omit<ValidationWaiter, 'promise'> {
+    result: ValidationError;
+}

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

@@ -1,37 +1,16 @@
 import type { FieldValidator } from 'final-form';
 import { type SchemaRendererMode } from '../constants';
-import type { ErrorMessages, FieldValue, JsonSchema, SchemaRendererConfig } from '../types';
+import type { ErrorMessages, FieldValue, JsonSchema, NodesConfig } from '../types';
+import type { SchemaRendererState } from './types';
 export interface UseSchemaRendererParams {
-    config: SchemaRendererConfig;
+    config?: NodesConfig;
     connectValidate?: boolean;
     errorMessages?: ErrorMessages;
+    jsonDefaultValues?: boolean;
     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;
+    validateOnBlur: boolean;
+    userContext?: SchemaRendererState['userContext'];
 }
-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;
-};
+export declare const useSchemaRenderer: ({ config, connectValidate, errorMessages, jsonDefaultValues, mode, name: headName, schema: originalSchema, validateOnBlur, userContext, }: UseSchemaRendererParams) => FieldValidator<FieldValue>;

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

@@ -1,81 +1,107 @@
+/* eslint-disable complexity */
 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, }) => {
+import { SchemaRendererEventType } from '../constants';
+import { getServiceFieldName } from '../utils';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from './constants';
+import { getDispatch, getRunValidate, getSubscribe, getValidate } from './utils';
+export const useSchemaRenderer = ({ config, connectValidate = true, errorMessages, jsonDefaultValues = false, mode, name: headName, schema: originalSchema, validateOnBlur, userContext, }) => {
     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;
-                }
+    const stateRef = React.useRef(null);
+    const prevParamsRef = React.useRef(null);
+    const unsubscribeRef = React.useRef(null);
+    const { subscribe, unsubscribe } = React.useMemo(() => getSubscribe(form, headName), [form, headName]);
+    const dispatchEvent = React.useMemo(() => getDispatch(form, headName), [form, headName]);
+    const runValidate = React.useMemo(() => getRunValidate(form, headName, validateOnBlur), [form, headName, validateOnBlur]);
+    const validate = React.useMemo(() => getValidate(form, headName), [form, headName]);
+    React.useMemo(() => {
+        var _a;
+        (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
+        const prevParams = prevParamsRef.current;
+        const prevState = stateRef.current;
+        const configUpdated = config !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.config);
+        const errorMessagesUpdated = errorMessages !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.errorMessages);
+        const nameUpdated = headName !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.name);
+        const modeUpdated = mode !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.mode);
+        const schemaUpdated = originalSchema !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.schema);
+        const userContextUpdated = userContext !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.userContext);
+        const settingsUpdated = jsonDefaultValues !== (prevParams === null || prevParams === void 0 ? void 0 : prevParams.jsonDefaultValues);
+        const initialState = {
+            cache: nameUpdated || schemaUpdated || !(prevState === null || prevState === void 0 ? void 0 : prevState.cache) ? {} : prevState.cache,
+            config: config || {},
+            dispatchEvent,
+            errors: nameUpdated || schemaUpdated || !(prevState === null || prevState === void 0 ? void 0 : prevState.errors) ? {} : prevState.errors,
+            errorMessages: errorMessages || {},
+            mode,
+            originalSchema,
+            patches: nameUpdated || schemaUpdated || !(prevState === null || prevState === void 0 ? void 0 : prevState.patches) ? [] : prevState.patches,
+            priorityErrors: nameUpdated || schemaUpdated || !(prevState === null || prevState === void 0 ? void 0 : prevState.priorityErrors)
+                ? {}
+                : prevState.priorityErrors,
+            regularErrors: nameUpdated || schemaUpdated || !(prevState === null || prevState === void 0 ? void 0 : prevState.regularErrors)
+                ? {}
+                : prevState.regularErrors,
+            runValidate,
+            settings: { jsonDefaultValues },
+            schema: nameUpdated || schemaUpdated ? cloneDeep(originalSchema) : (prevState === null || prevState === void 0 ? void 0 : prevState.schema) || {},
+            subscribe,
+            subscribers: (prevState === null || prevState === void 0 ? void 0 : prevState.subscribers) || { byId: {}, byName: new Map(), byPath: new Map() },
+            unsubscribe,
+            userContext: userContextUpdated ? userContext || {} : (prevState === null || prevState === void 0 ? void 0 : prevState.userContext) || {},
+            waiters: nameUpdated || schemaUpdated || !(prevState === null || prevState === void 0 ? void 0 : prevState.waiters) ? {} : prevState.waiters,
+        };
+        const getValidator = connectValidate ? () => validate : undefined;
+        let initialEvents = [
+            ...(configUpdated ? [SchemaRendererEventType.Config] : []),
+            ...(errorMessagesUpdated ? [SchemaRendererEventType.ErrorMessages] : []),
+            ...(nameUpdated ? [SchemaRendererEventType.Name] : []),
+            ...(modeUpdated ? [SchemaRendererEventType.Mode] : []),
+            ...(schemaUpdated ? [SchemaRendererEventType.Schema] : []),
+            ...(userContextUpdated ? [SchemaRendererEventType.UserContext] : []),
+            ...(settingsUpdated ? [SchemaRendererEventType.Settings] : []),
+        ].map((type) => ({ type, all: true }));
+        unsubscribeRef.current = form.registerField(getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName), (f) => {
+            var _a;
+            const state = (_a = f.data) === null || _a === void 0 ? void 0 : _a.state;
+            if (state && initialEvents.length) {
+                state.dispatchEvent(initialEvents);
+                initialEvents = [];
             }
-            return false;
-        });
-        errorsRef.current = errors;
-        if (fieldsToTrigger.length) {
-            setFieldsToTrigger(fieldsToTrigger);
-        }
-    }, [form]);
-    const validate = React.useMemo(() => getValidate({
-        config,
-        errorMessages,
-        name,
-        setAsyncValidationCache,
-        setAsyncValidationWaiters,
-        setErrors,
-    }), [
+        }, { data: true }, { data: { state: initialState }, getValidator, validateFields: [headName] });
+        prevParamsRef.current = {
+            config,
+            errorMessages,
+            jsonDefaultValues,
+            name: headName,
+            mode,
+            schema: originalSchema,
+            userContext,
+            validateOnBlur,
+        };
+        stateRef.current = initialState;
+    }, [
         config,
+        connectValidate,
+        dispatchEvent,
         errorMessages,
-        name,
-        setAsyncValidationCache,
-        setAsyncValidationWaiters,
-        setErrors,
+        form,
+        jsonDefaultValues,
+        headName,
+        mode,
+        originalSchema,
+        runValidate,
+        subscribe,
+        unsubscribe,
+        validate,
+        validateOnBlur,
+        userContext,
     ]);
-    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;
+        return () => {
+            var _a;
+            (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
+        };
+    }, []);
+    return validate;
 };

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

@@ -0,0 +1,3 @@
+import { type FormApi } from 'final-form';
+import type { SchemaRendererEvent } from '../types';
+export declare const getDispatch: (form: FormApi, headName: string) => (events: SchemaRendererEvent[]) => void;

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

@@ -0,0 +1,50 @@
+import { getServiceFieldName } from '../../utils';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../constants';
+export const getDispatch = (form, headName) => {
+    const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    return (events) => {
+        var _a;
+        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 (events.length && srState) {
+            const { subscribers } = srState;
+            const notified = new Set();
+            events.forEach((ep) => {
+                var _a, _b;
+                if (ep.all) {
+                    Object.entries(subscribers.byId).forEach(([id, s]) => {
+                        if (s.subscription[ep.type] && !notified.has(id)) {
+                            notified.add(id);
+                            s.callback(events);
+                        }
+                    });
+                    return;
+                }
+                (_a = ep.paths) === null || _a === void 0 ? void 0 : _a.forEach((p) => {
+                    let current = '';
+                    p.forEach((path) => {
+                        var _a;
+                        current = current.length ? `${current}/${path}` : path;
+                        (_a = subscribers.byPath.get(current)) === null || _a === void 0 ? void 0 : _a.forEach((id) => {
+                            const s = subscribers.byId[id];
+                            if (s.subscription[ep.type] && !notified.has(id)) {
+                                notified.add(id);
+                                s.callback(events);
+                            }
+                        });
+                    });
+                });
+                (_b = ep.names) === null || _b === void 0 ? void 0 : _b.forEach((n) => {
+                    var _a;
+                    (_a = subscribers.byName.get(n)) === null || _a === void 0 ? void 0 : _a.forEach((id) => {
+                        const s = subscribers.byId[id];
+                        if (s.subscription[ep.type] && !notified.has(id)) {
+                            notified.add(id);
+                            s.callback(events);
+                        }
+                    });
+                });
+            });
+        }
+    };
+};

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

@@ -0,0 +1,2 @@
+import { type FormApi } from 'final-form';
+export declare const getRunValidate: (form: FormApi, headName: string, validateOnBlur: boolean) => () => void;

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

@@ -0,0 +1,15 @@
+import { getServiceFieldName } from '../../utils';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../constants';
+export const getRunValidate = (form, headName, validateOnBlur) => {
+    const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    return () => {
+        if (validateOnBlur) {
+            form.blur(srName);
+        }
+        else {
+            form.setConfig('validateOnBlur', true);
+            form.blur(srName);
+            form.setConfig('validateOnBlur', false);
+        }
+    };
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/get-schema-root-node.d.ts

@@ -0,0 +1,11 @@
+import { type Keyword } from 'json-schema-library';
+import type { JsonSchema, NodesConfig } from '../../types';
+export interface GetSchemaRootNodeParams {
+    config?: NodesConfig;
+    keywords?: Keyword[];
+    schema: JsonSchema;
+}
+export declare const getSchemaRootNode: ({ config, keywords, schema: rootSchema, }: GetSchemaRootNodeParams) => import("json-schema-library").SchemaNode & {
+    schemaErrors?: import("json-schema-library").JsonError[];
+    schemaAnnotations: import("json-schema-library").JsonAnnotation[];
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/get-schema-root-node.js

@@ -0,0 +1,131 @@
+/* eslint-disable complexity */
+import Decimal from 'decimal.js';
+import { addKeywords, compileSchema, draft07, getTypeOf } from 'json-schema-library';
+import get from 'lodash/get';
+import isString from 'lodash/isString';
+import { JsonSchemaType } from '../../constants';
+export const getSchemaRootNode = ({ config, keywords, schema: rootSchema, }) => {
+    const nodeParametersKeyword = {
+        id: 'nodeParameters',
+        keyword: 'nodeParameters',
+        addValidate: (node) => { var _a; return ((_a = node.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.validator) !== undefined; },
+        validate: ({ node, data: value, pointer }) => {
+            const schema = node.schema;
+            if (schema.nodeParameters) {
+                let validator;
+                if (isString(schema.nodeParameters.validator)) {
+                    const nodeType = schema.nodeParameters.type;
+                    const validatorType = schema.nodeParameters.validator;
+                    validator = get(config, `${nodeType}.validators.${validatorType}`);
+                }
+                else {
+                    validator = schema.nodeParameters.validator;
+                }
+                if (validator) {
+                    return node.createError('node-parameters-error', { pointer, schema, value, validator }, '');
+                }
+            }
+            return undefined;
+        },
+    };
+    const stringNumberKeyword = {
+        id: 'stringNumber',
+        keyword: 'stringNumber',
+        addValidate: (node) => node.schema.stringNumber !== undefined,
+        validate: ({ node, data: value, pointer }) => {
+            const schema = node.schema;
+            const stringNumber = schema.stringNumber;
+            if (!stringNumber) {
+                return undefined;
+            }
+            const isStringInt = (v) => /^-?(0|[1-9][0-9]*)$/.test(`${v}`);
+            const isStringFloat = (v) => /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(`${v}`);
+            const isStringNumber = (v) => isStringInt(v) || isStringFloat(v);
+            if (stringNumber.type) {
+                const types = Array.isArray(stringNumber.type)
+                    ? stringNumber.type
+                    : [stringNumber.type];
+                const satisfactoryByType = {
+                    [JsonSchemaType.Integer]: isStringInt(value),
+                    [JsonSchemaType.Number]: isStringFloat(value),
+                    [JsonSchemaType.Null]: value === null,
+                };
+                if (!types.some((type) => satisfactoryByType[type])) {
+                    return node.createError('type-error', {
+                        pointer,
+                        schema,
+                        value,
+                        received: getTypeOf(value),
+                        expected: types.join(', '),
+                    });
+                }
+            }
+            if (stringNumber.exclusiveMaximum &&
+                isStringNumber(stringNumber.exclusiveMaximum) &&
+                isStringNumber(value) &&
+                !new Decimal(`${value}`).lessThan(stringNumber.exclusiveMaximum)) {
+                return node.createError('exclusive-maximum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    maximum: stringNumber.exclusiveMaximum,
+                    length: value,
+                });
+            }
+            if (stringNumber.exclusiveMinimum &&
+                isStringNumber(stringNumber.exclusiveMinimum) &&
+                isStringNumber(value) &&
+                !new Decimal(`${value}`).greaterThan(stringNumber.exclusiveMinimum)) {
+                return node.createError('exclusive-minimum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    minimum: stringNumber.exclusiveMinimum,
+                    length: value,
+                });
+            }
+            if (stringNumber.maximum &&
+                isStringNumber(stringNumber.maximum) &&
+                isStringNumber(value) &&
+                !new Decimal(`${value}`).lessThanOrEqualTo(stringNumber.maximum)) {
+                return node.createError('maximum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    maximum: stringNumber.maximum,
+                    length: value,
+                });
+            }
+            if (stringNumber.minimum &&
+                isStringNumber(stringNumber.minimum) &&
+                isStringNumber(value) &&
+                !new Decimal(`${value}`).greaterThanOrEqualTo(stringNumber.minimum)) {
+                return node.createError('minimum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    minimum: stringNumber.minimum,
+                    length: value,
+                });
+            }
+            if (stringNumber.multipleOf &&
+                isStringNumber(stringNumber.multipleOf) &&
+                stringNumber.multipleOf !== '0' &&
+                isStringNumber(value) &&
+                !new Decimal(`${value}`).mod(stringNumber.multipleOf).isZero()) {
+                return node.createError('multiple-of-error', {
+                    pointer,
+                    schema,
+                    value,
+                    multipleOf: stringNumber.multipleOf,
+                });
+            }
+            return undefined;
+        },
+    };
+    const draft = addKeywords(draft07, ...(keywords || []), nodeParametersKeyword, stringNumberKeyword);
+    return compileSchema(rootSchema, {
+        drafts: [draft],
+        formatAssertion: false,
+    });
+};

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

@@ -0,0 +1,6 @@
+import type { FormApi } from 'final-form';
+import type { SchemaRendererSubscriber } from '../types';
+export declare const getSubscribe: (form: FormApi, headName: string) => {
+    subscribe: (subscriber: SchemaRendererSubscriber) => string;
+    unsubscribe: (id: string) => void;
+};