@gravity-ui/dynamic-forms 5.18.0 → 5.19.0

package/build/esm/lib/unstable/core/types/schema.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,39 @@
+import type { SchemaToValueType } from './helpers';
+import type { JsonSchema } from './schema';
+import type { ObjectValue } from './values';
+type ArrayError = SyncValidateError[];
+interface ObjectError extends Record<string, SyncValidateError> {
+}
+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 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;
+}
+export {};

package/build/esm/lib/unstable/core/types/validation.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export type ArrayValue = FieldValue[];
+export interface ObjectValue extends Record<string, FieldValue> {
+}
+export type FieldValue = number | boolean | string | ArrayValue | ObjectValue | null | undefined;

package/build/esm/lib/unstable/core/types/values.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export declare const ENTITY_SERVICE_FIELD = "ENTITY_SERVICE_FIELD";

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

@@ -0,0 +1 @@
+export const ENTITY_SERVICE_FIELD = 'ENTITY_SERVICE_FIELD';

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

@@ -0,0 +1,2 @@
+export { useEntitiesState } from './useEntitiesState';
+export { useSchemaRendererMutators } from './useSchemaRendererMutators';

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

@@ -0,0 +1,2 @@
+export { useEntitiesState } from './useEntitiesState';
+export { useSchemaRendererMutators } from './useSchemaRendererMutators';

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

@@ -0,0 +1,7 @@
+export declare const useEntitiesState: (name: string) => {
+    config: import("../..").SchemaRendererConfig | undefined;
+    error: import("../..").SyncValidateError;
+    headName: string | undefined;
+    mode: import("../..").SchemaRendererMode | undefined;
+    rootSchema: import("../..").JsonSchema | undefined;
+};

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import { useField, useForm } from 'react-final-form';
+import { ENTITY_SERVICE_FIELD } from '../constants';
+import { guessHeadName } from '../utils';
+export const useEntitiesState = (name) => {
+    var _a;
+    const form = useForm();
+    const headName = React.useMemo(() => guessHeadName(form.getRegisteredFields(), name), [form, name]);
+    const field = useField(`${ENTITY_SERVICE_FIELD}.${headName}`, { subscription: { data: true } });
+    const { config, errorsRef, mode, schema: rootSchema } = (field.meta.data || {});
+    const error = (_a = errorsRef === null || errorsRef === void 0 ? void 0 : errorsRef.current) === null || _a === void 0 ? void 0 : _a[name];
+    const state = React.useMemo(() => ({
+        config,
+        error,
+        headName,
+        mode,
+        rootSchema,
+    }), [config, error, headName, mode, rootSchema]);
+    return state;
+};

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

@@ -0,0 +1,10 @@
+import type { RemoveExternalErrorsMutator, RemoveSchemaMutatorsMutator, SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator, SetExternalErrorsMutator, SetSchemaMutatorsMutator, TriggerFieldsMutator } from '../mutators';
+export declare const useSchemaRendererMutators: () => {
+    removeExternalErrors: RemoveExternalErrorsMutator | undefined;
+    removeSchemaMutators: RemoveSchemaMutatorsMutator | undefined;
+    setAsyncValidationCache: SetAsyncValidationCacheMutator | undefined;
+    setAsyncValidationWaiters: SetAsyncValidationWaitersMutator | undefined;
+    setExternalErrors: SetExternalErrorsMutator | undefined;
+    setSchemaMutators: SetSchemaMutatorsMutator | undefined;
+    triggerFields: TriggerFieldsMutator | undefined;
+};

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

@@ -0,0 +1,13 @@
+import { useForm } from 'react-final-form';
+export const useSchemaRendererMutators = () => {
+    const { removeExternalErrors, removeSchemaMutators, setAsyncValidationCache, setAsyncValidationWaiters, setExternalErrors, setSchemaMutators, triggerFields, } = useForm().mutators;
+    return {
+        removeExternalErrors,
+        removeSchemaMutators,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setExternalErrors,
+        setSchemaMutators,
+        triggerFields,
+    };
+};

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

@@ -0,0 +1,3 @@
+export { useEntitiesState, useSchemaRendererMutators } from './hooks';
+export { schemaRendererMutators } from './mutators';
+export { type UseSchemaRendererParams, type UseSchemaRendererReturn, useSchemaRenderer, } from './useSchemaRenderer';

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

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

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/async-validation.d.ts

@@ -0,0 +1,3 @@
+import type { SetAsyncValidationCacheFunction, SetAsyncValidationWaitersFunction } from './types';
+export declare const setAsyncValidationWaiters: SetAsyncValidationWaitersFunction;
+export declare const setAsyncValidationCache: SetAsyncValidationCacheFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/async-validation.js

@@ -0,0 +1,29 @@
+import isEqual from 'lodash/isEqual';
+import omit from 'lodash/omit';
+export const setAsyncValidationWaiters = ([{ headName, waiters }], mutableState) => {
+    const field = mutableState.fields[headName];
+    if (field && waiters) {
+        Object.keys(waiters).forEach((waiterName) => {
+            field.data = Object.assign(Object.assign({}, field.data), { waiters: Object.assign(Object.assign({}, field.data.waiters), { [waiterName]: waiters[waiterName] }) });
+            const waiterField = mutableState.fields[waiterName];
+            if (waiterField) {
+                waiterField.validating = true;
+            }
+        });
+    }
+};
+export const setAsyncValidationCache = ([{ headName, cache }], mutableState) => {
+    const field = mutableState.fields[headName];
+    if (field && cache) {
+        Object.keys(cache).forEach((cacheName) => {
+            var _a, _b;
+            field.data = Object.assign(Object.assign({}, field.data), { cache: Object.assign(Object.assign({}, field.data.cache), { [cacheName]: [...(((_a = field.data.cache) === null || _a === void 0 ? void 0 : _a[cacheName]) || []), cache[cacheName]] }) });
+            const cacheField = mutableState.fields[cacheName];
+            const waiter = (_b = field.data.waiters) === null || _b === void 0 ? void 0 : _b[cacheName];
+            if (cacheField && waiter && isEqual(waiter, omit(cache[cacheName], 'result'))) {
+                field.data.waiters = omit(field.data.waiters, cacheName);
+                cacheField.validating = false;
+            }
+        });
+    }
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './async-validation';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/index.js

@@ -0,0 +1,2 @@
+export * from './async-validation';
+export * from './types';

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

@@ -0,0 +1,34 @@
+import type { MutableState, Tools } from 'final-form';
+import type { FieldValue, JsonSchema, SyncValidateError, Validator } from '../../../types';
+export interface AsyncValidationWaiter {
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}
+export interface AsyncValidationCache extends AsyncValidationWaiter {
+    result: SyncValidateError;
+}
+export interface AsyncValidationState {
+    cache?: {
+        [key: string]: AsyncValidationCache[] | undefined;
+    };
+    waiters?: {
+        [key: string]: AsyncValidationWaiter | undefined;
+    };
+}
+export interface SetAsyncValidationWaitersParams {
+    headName: string;
+    waiters: {
+        [key: string]: AsyncValidationWaiter;
+    };
+}
+export type SetAsyncValidationWaitersFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationWaitersParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetAsyncValidationWaitersMutator = (params: SetAsyncValidationWaitersParams) => void;
+export interface SetAsyncValidationCacheParams {
+    cache: {
+        [key: string]: AsyncValidationCache;
+    };
+    headName: string;
+}
+export type SetAsyncValidationCacheFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationCacheParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetAsyncValidationCacheMutator = (params: SetAsyncValidationCacheParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/external-errors.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveExternalErrorsFunction, SetExternalErrorsFunction } from './types';
+export declare const setExternalErrors: SetExternalErrorsFunction;
+export declare const removeExternalErrors: RemoveExternalErrorsFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/external-errors.js

@@ -0,0 +1,54 @@
+import omit from 'lodash/omit';
+import { ENTITY_SERVICE_FIELD } from '../../constants';
+import { guessHeadName } from '../../utils';
+export const setExternalErrors = ([{ priorityErrors, regularErrors }], mutableState) => {
+    const registeredFields = Object.keys(mutableState.fields);
+    Object.entries(priorityErrors || {}).forEach(([key, value]) => {
+        const headName = guessHeadName(registeredFields, key);
+        if (headName) {
+            const field = mutableState.fields[headName];
+            if (field) {
+                field.data = Object.assign(Object.assign({}, field.data), { priorityErrors: Object.assign(Object.assign({}, field.data.priorityErrors), { [key]: value }) });
+            }
+        }
+    });
+    Object.entries(regularErrors || {}).forEach(([key, value]) => {
+        const headName = guessHeadName(registeredFields, key);
+        if (headName) {
+            const field = mutableState.fields[headName];
+            if (field) {
+                field.data = Object.assign(Object.assign({}, field.data), { regularErrors: Object.assign(Object.assign({}, field.data.regularErrors), { [key]: value }) });
+            }
+        }
+    });
+};
+export const removeExternalErrors = ([{ removeFunctionOrNames }], mutableState) => {
+    const registeredFields = Object.keys(mutableState.fields);
+    if (Array.isArray(removeFunctionOrNames)) {
+        removeFunctionOrNames.forEach((name) => {
+            const headName = guessHeadName(registeredFields, name);
+            if (headName) {
+                const field = mutableState.fields[headName];
+                if (field) {
+                    field.data = Object.assign(Object.assign({}, field.data), { priorityErrors: omit(Object.assign({}, field.data.priorityErrors), name), regularErrors: omit(Object.assign({}, field.data.regularErrors), name) });
+                }
+            }
+        });
+    }
+    else {
+        registeredFields.forEach((fieldName) => {
+            if (fieldName.startsWith(ENTITY_SERVICE_FIELD)) {
+                const headName = fieldName.slice(`${ENTITY_SERVICE_FIELD}.`.length);
+                const field = mutableState.fields[headName];
+                if (field) {
+                    const { priorityErrors, regularErrors } = removeFunctionOrNames(headName, {
+                        priorityErrors: field.data.priorityErrors,
+                        regularErrors: field.data.regularErrors,
+                    });
+                    field.data = Object.assign(Object.assign({}, field.data), { priorityErrors,
+                        regularErrors });
+                }
+            }
+        });
+    }
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './external-errors';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/index.js

@@ -0,0 +1,2 @@
+export * from './external-errors';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/types.d.ts

@@ -0,0 +1,25 @@
+import type { MutableState, Tools } from 'final-form';
+import type { SyncValidateError } from '../../../types';
+export interface ExternalErrorsState {
+    priorityErrors?: {
+        [key: string]: SyncValidateError;
+    };
+    regularErrors?: {
+        [key: string]: SyncValidateError;
+    };
+}
+export interface SetExternalErrorsParams {
+    priorityErrors?: {
+        [key: string]: SyncValidateError;
+    };
+    regularErrors?: {
+        [key: string]: SyncValidateError;
+    };
+}
+export type SetExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetExternalErrorsMutator = (params: SetExternalErrorsParams) => void;
+export interface RemoveExternalErrorsParams {
+    removeFunctionOrNames: string[] | ((headName: string, state: ExternalErrorsState) => ExternalErrorsState);
+}
+export type RemoveExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type RemoveExternalErrorsMutator = (params: RemoveExternalErrorsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+export type * from './async-validation';
+export type * from './external-errors';
+export type * from './schema-mutators';
+export type * from './trigger-fields';
+export declare const schemaRendererMutators: {
+    removeExternalErrors: import("./external-errors").RemoveExternalErrorsFunction;
+    removeSchemaMutators: import("./schema-mutators").RemoveSchemaMutatorsFunction;
+    setAsyncValidationCache: import("./async-validation").SetAsyncValidationCacheFunction;
+    setAsyncValidationWaiters: import("./async-validation").SetAsyncValidationWaitersFunction;
+    setExternalErrors: import("./external-errors").SetExternalErrorsFunction;
+    setSchemaMutators: import("./schema-mutators").SetSchemaMutatorsFunction;
+    triggerFields: import("./trigger-fields").TriggerFieldsFunction;
+};

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

@@ -0,0 +1,13 @@
+import { setAsyncValidationCache, setAsyncValidationWaiters } from './async-validation';
+import { removeExternalErrors, setExternalErrors } from './external-errors';
+import { removeSchemaMutators, setSchemaMutators } from './schema-mutators';
+import { triggerFields } from './trigger-fields';
+export const schemaRendererMutators = {
+    removeExternalErrors,
+    removeSchemaMutators,
+    setAsyncValidationCache,
+    setAsyncValidationWaiters,
+    setExternalErrors,
+    setSchemaMutators,
+    triggerFields,
+};

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

@@ -0,0 +1,2 @@
+export * from './schema-mutators';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/index.js

@@ -0,0 +1,2 @@
+export * from './schema-mutators';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/schema-mutators.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveSchemaMutatorsFunction, SetSchemaMutatorsFunction } from './types';
+export declare const setSchemaMutators: SetSchemaMutatorsFunction;
+export declare const removeSchemaMutators: RemoveSchemaMutatorsFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/schema-mutators.js

@@ -0,0 +1,75 @@
+import cloneDeep from 'lodash/cloneDeep';
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import { getSchemaPath, getValuePaths, parseSchemaPath, smartSet } from '../../../utils';
+import { guessHeadName } from '../../utils';
+const applyMutators = ({ mutableState, mutators, }) => {
+    const registeredFields = Object.keys(mutableState.fields);
+    mutators.forEach((m) => {
+        const headName = guessHeadName(registeredFields, m.name);
+        if (headName) {
+            const headField = mutableState.fields[headName];
+            const data = headField === null || headField === void 0 ? void 0 : headField.data;
+            const mutatedSchema = data === null || data === void 0 ? void 0 : data.schema;
+            if (mutatedSchema) {
+                const schemaPath = getSchemaPath(m.name, headName, mutatedSchema);
+                if (schemaPath) {
+                    smartSet(mutatedSchema, schemaPath, m.schema);
+                    const schemaField = mutableState.fields[m.name];
+                    if (schemaField) {
+                        schemaField.data = Object.assign(Object.assign({}, schemaField.data), { schema: get(mutatedSchema, schemaPath) });
+                    }
+                    headField.data.mutators = [...((data === null || data === void 0 ? void 0 : data.mutators) || []), m];
+                    headField.data.schema = mutatedSchema;
+                    const mutatedPaths = getValuePaths(m.schema).map((path) => [
+                        ...schemaPath,
+                        ...path,
+                    ]);
+                    Object.values(mutableState.fields).forEach((field) => {
+                        var _a;
+                        const data = field === null || field === void 0 ? void 0 : field.data;
+                        if (((_a = data === null || data === void 0 ? void 0 : data.schema) === null || _a === void 0 ? void 0 : _a.$ref) && (data === null || data === void 0 ? void 0 : data.headName) === headName) {
+                            const refPath = parseSchemaPath(data.schema.$ref);
+                            const mutationAffectRefSchema = mutatedPaths.some((mutatedPath) => refPath.every((subpath, index) => mutatedPath[index] === subpath));
+                            const fieldSchemaPath = getSchemaPath(field.name, headName, mutatedSchema);
+                            if (mutationAffectRefSchema && fieldSchemaPath) {
+                                field.data = Object.assign(Object.assign({}, field.data), { schema: Object.assign({}, get(mutatedSchema, fieldSchemaPath)) });
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    });
+};
+export const setSchemaMutators = ([{ mutators }], mutableState) => {
+    applyMutators({ mutableState, mutators });
+};
+export const removeSchemaMutators = ([{ mutatorsToRemove }], mutableState) => {
+    const registeredFields = Object.keys(mutableState.fields);
+    [...new Set(mutatorsToRemove.map((m) => guessHeadName(registeredFields, m.name)))].forEach((name) => {
+        if (name) {
+            const headField = mutableState.fields[name];
+            const data = headField === null || headField === void 0 ? void 0 : headField.data;
+            const originalSchema = data === null || data === void 0 ? void 0 : data.originalSchema;
+            const mutators = (data === null || data === void 0 ? void 0 : data.mutators) || [];
+            if (headField && originalSchema) {
+                applyMutators({
+                    mutableState,
+                    mutators: mutators.map((m) => {
+                        const schemaPath = getSchemaPath(m.name, name, originalSchema);
+                        return Object.assign(Object.assign({}, m), { schema: schemaPath
+                                ? cloneDeep(get(originalSchema, schemaPath))
+                                : {} });
+                    }),
+                });
+                headField.data.mutators = [];
+                applyMutators({
+                    mutableState,
+                    mutators: mutators.filter((m) => !mutatorsToRemove.some(({ name, schema }) => name === m.name &&
+                        (isEqual(m.schema, schema) || schema === true))),
+                });
+            }
+        }
+    });
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/types.d.ts

@@ -0,0 +1,26 @@
+import type { MutableState, Tools } from 'final-form';
+import type { JsonSchema } from '../../../types';
+export interface SchemaMutatorsState {
+    mutators?: {
+        name: string;
+        schema: JsonSchema;
+    }[];
+    originalSchema?: JsonSchema;
+    schema?: JsonSchema;
+}
+export interface SetSchemaMutatorsParams {
+    mutators: {
+        name: string;
+        schema: JsonSchema;
+    }[];
+}
+export type SetSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetSchemaMutatorsMutator = (params: SetSchemaMutatorsParams) => void;
+export interface RemoveSchemaMutatorsParams {
+    mutatorsToRemove: {
+        name: string;
+        schema: JsonSchema | true;
+    }[];
+}
+export type RemoveSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type RemoveSchemaMutatorsMutator = (params: RemoveSchemaMutatorsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/index.d.ts

@@ -0,0 +1,2 @@
+export * from './trigger-fields';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/index.js

@@ -0,0 +1,2 @@
+export * from './trigger-fields';
+export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/trigger-fields.d.ts

@@ -0,0 +1,2 @@
+import type { TriggerFieldsFunction } from './types';
+export declare const triggerFields: TriggerFieldsFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/trigger-fields.js

@@ -0,0 +1,8 @@
+export const triggerFields = ([{ fields }], mutableState) => {
+    fields.forEach((fieldName) => {
+        const field = mutableState.fields[fieldName];
+        if (field) {
+            field.data = Object.assign(Object.assign({}, field.data), { count: (field.data.count || 0) + 1 });
+        }
+    });
+};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/types.d.ts

@@ -0,0 +1,6 @@
+import type { MutableState, Tools } from 'final-form';
+export interface TriggerFieldsParams {
+    fields: string[];
+}
+export type TriggerFieldsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [TriggerFieldsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type TriggerFieldsMutator = (params: TriggerFieldsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import type { ErrorObject } from 'ajv';
+import type { SchemaRendererMode } from '../constants';
+import type { FieldValue, JsonSchema, SchemaRendererConfig, SyncValidateError, Validator } from '../types';
+import type { AsyncValidationState, ExternalErrorsState, SchemaMutatorsState } from './mutators';
+export type EntityParametersError = ErrorObject<'entityParameters', {
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}>;
+export interface ValidateErrorItem {
+    error: SyncValidateError;
+    path: string[];
+}
+export interface EntitiesState {
+    config?: SchemaRendererConfig;
+    errorsRef?: React.RefObject<Record<string, SyncValidateError>>;
+    headName?: string;
+    mode?: SchemaRendererMode;
+    schema?: SchemaMutatorsState['schema'];
+}
+export interface SchemaRendererState extends AsyncValidationState, ExternalErrorsState, SchemaMutatorsState {
+}

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

@@ -0,0 +1 @@
+export {};

package/build/esm/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;
+};