@gravity-ui/dynamic-forms 5.19.1 → 5.21.0

package/build/cjs/unstable.d.ts

@@ -1,4 +1,2 @@
 export * from './lib/unstable/core';
-export { config, untypedConfig } from './lib/unstable/kit/constants';
-export * from './lib/unstable/kit/controls';
-export * from './lib/unstable/kit/wrappers';
+export * from './lib/unstable/kit';

package/build/cjs/unstable.js

@@ -1,10 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.untypedConfig = exports.config = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./lib/unstable/core"), exports);
-var constants_1 = require("./lib/unstable/kit/constants");
-Object.defineProperty(exports, "config", { enumerable: true, get: function () { return constants_1.config; } });
-Object.defineProperty(exports, "untypedConfig", { enumerable: true, get: function () { return constants_1.untypedConfig; } });
-tslib_1.__exportStar(require("./lib/unstable/kit/controls"), exports);
-tslib_1.__exportStar(require("./lib/unstable/kit/wrappers"), exports);
+tslib_1.__exportStar(require("./lib/unstable/kit"), exports);

package/build/esm/lib/core/components/Form/DynamicField.js

@@ -3,7 +3,7 @@ import get from 'lodash/get';
 import isFunction from 'lodash/isFunction';
 import isString from 'lodash/isString';
 import { isValidElementType } from 'react-is';
-import { isCorrectSpec } from '../../helpers';
+import { isCorrectSpec, warnAboutDottedPropertyKeys } from '../../helpers';
 import { Controller } from './Controller';
 import { useCreateContext, useCreateSearchContext, useDynamicFieldMirror, useFormSharedStore, useIntegrationFF, useMutators, useSearchStore, useStore, } from './hooks';
 import { getDefaultSearchFunction, isCorrectConfig } from './utils';
@@ -20,6 +20,9 @@ export const DynamicField = ({ name, spec, config, Monaco, generateRandomValue,
     const { mutatorsStore, mutateDFState } = useMutators(externalMutators);
     const { store: searchStore, setField, removeField, isHiddenField } = useSearchStore();
     const shared = useFormSharedStore(externalShared);
+    React.useEffect(() => {
+        warnAboutDottedPropertyKeys(spec);
+    }, [spec]);
     const context = React.useMemo(() => ({
         config,
         Monaco: isValidElementType(Monaco) ? Monaco : undefined,

package/build/esm/lib/core/components/View/DynamicView.js

@@ -1,12 +1,15 @@
 import React from 'react';
 import { isValidElementType } from 'react-is';
-import { isCorrectSpec } from '../../helpers';
+import { isCorrectSpec, warnAboutDottedPropertyKeys } from '../../helpers';
 import { ViewController } from './ViewController';
 import { isCorrectViewConfig } from './helpers';
 import { useCreateContext, useViewSharedStore } from './hooks';
 export const DynamicView = ({ value, spec, config, Link, Monaco, showLayoutDescription, shared: externalShared, }) => {
     const DynamicFormsCtx = useCreateContext();
     const shared = useViewSharedStore(externalShared);
+    React.useEffect(() => {
+        warnAboutDottedPropertyKeys(spec);
+    }, [spec]);
     const context = React.useMemo(() => ({
         config,
         value,

package/build/esm/lib/core/helpers.d.ts

@@ -1,7 +1,9 @@
-import type { ArraySpec, BooleanSpec, NumberSpec, ObjectSpec, StringSpec } from './types';
+import type { ArraySpec, BooleanSpec, NumberSpec, ObjectSpec, Spec, StringSpec } from './types';
 export declare const isCorrectSpec: (candidate: any) => boolean;
 export declare const isArraySpec: (candidate: any) => candidate is ArraySpec;
 export declare const isBooleanSpec: (candidate: any) => candidate is BooleanSpec;
 export declare const isNumberSpec: (candidate: any) => candidate is NumberSpec;
 export declare const isObjectSpec: (candidate: any) => candidate is ObjectSpec;
 export declare const isStringSpec: (candidate: any) => candidate is StringSpec;
+export declare const collectDottedPropertyKeys: (spec: Spec) => string[];
+export declare const warnAboutDottedPropertyKeys: (spec: Spec) => void;

package/build/esm/lib/core/helpers.js

@@ -14,3 +14,27 @@ export const isBooleanSpec = (candidate) => (candidate === null || candidate ===
 export const isNumberSpec = (candidate) => (candidate === null || candidate === void 0 ? void 0 : candidate.type) === SpecTypes.Number;
 export const isObjectSpec = (candidate) => (candidate === null || candidate === void 0 ? void 0 : candidate.type) === SpecTypes.Object;
 export const isStringSpec = (candidate) => (candidate === null || candidate === void 0 ? void 0 : candidate.type) === SpecTypes.String;
+export const collectDottedPropertyKeys = (spec) => {
+    var _a;
+    const dottedKeys = [];
+    if (isObjectSpec(spec) && isObjectLike(spec.properties)) {
+        Object.entries((_a = spec.properties) !== null && _a !== void 0 ? _a : {}).forEach(([key, childSpec]) => {
+            if (key.includes('.')) {
+                dottedKeys.push(key);
+            }
+            dottedKeys.push(...collectDottedPropertyKeys(childSpec));
+        });
+    }
+    if (isArraySpec(spec) && spec.items) {
+        dottedKeys.push(...collectDottedPropertyKeys(spec.items));
+    }
+    return dottedKeys;
+};
+export const warnAboutDottedPropertyKeys = (spec) => {
+    if (process.env.NODE_ENV !== 'production') {
+        const dottedKeys = collectDottedPropertyKeys(spec);
+        if (dottedKeys.length) {
+            console.warn(`[dynamic-forms] Spec property keys containing dots are not supported, their values will not be resolved: ${dottedKeys.join(', ')}. See docs/lib.md#dotted-property-keys`);
+        }
+    }
+};

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

@@ -1,8 +1,8 @@
 import React from 'react';
-import { Entity } from '../Entity';
+import { SchemaRendererNode } from '../SchemaRendererNode';
 import { useSchemaRenderer } from '../useSchemaRenderer';
 const SchemaRendererComponent = (props) => {
-    const { schema } = useSchemaRenderer(props);
-    return schema ? React.createElement(Entity, { name: props.name, schema: schema }) : null;
+    useSchemaRenderer(props);
+    return React.createElement(SchemaRendererNode, { headName: props.name, name: props.name, schemaPath: "#" });
 };
 export const SchemaRenderer = React.memo(SchemaRendererComponent);

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { SchemaRendererMode } from '../constants';
+import type { JsonSchema } from '../types';
+export interface SchemaRendererNodeProps {
+    headName: string;
+    modeOverride?: SchemaRendererMode;
+    name: string;
+    schemaOverride?: JsonSchema;
+    schemaPath: string;
+}
+export declare const SchemaRendererNode: React.NamedExoticComponent<SchemaRendererNodeProps>;

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

@@ -0,0 +1,127 @@
+import React from 'react';
+import noop from 'lodash/noop';
+import { useForm } from 'react-final-form';
+import { SchemaRendererEventType, SchemaRendererMode } from '../constants';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../useSchemaRenderer';
+import { useSchemaRendererState } from '../useSchemaRendererState';
+import { getServiceFieldName } from '../utils';
+import { getAccumulatedSchema, getRenderKit } from './utils';
+const SchemaRendererNodeComponent = ({ headName, modeOverride, name, schemaOverride, schemaPath, }) => {
+    var _a;
+    const form = useForm();
+    const firstRenderRef = React.useRef(true);
+    const pendingTicksRef = React.useRef({ input: 0, meta: 0 });
+    const fieldRef = React.useRef(null);
+    const unsubscribeRef = React.useRef(null);
+    const [ticks, setTicks] = React.useState({ input: 0, meta: 0 });
+    const srState = useSchemaRendererState({
+        headName,
+        name,
+        schemaPath,
+        subscriptions: [
+            SchemaRendererEventType.Config,
+            SchemaRendererEventType.Error,
+            SchemaRendererEventType.Mode,
+            SchemaRendererEventType.Name,
+            SchemaRendererEventType.Patch,
+            SchemaRendererEventType.Settings,
+            SchemaRendererEventType.Schema,
+        ],
+    });
+    const schema = React.useMemo(() => getAccumulatedSchema(schemaPath, srState === null || srState === void 0 ? void 0 : srState.schema, schemaOverride), [schemaOverride, schemaPath, srState === null || srState === void 0 ? void 0 : srState.schema]);
+    const error = srState === null || srState === void 0 ? void 0 : srState.errors[name];
+    const mode = modeOverride || (srState === null || srState === void 0 ? void 0 : srState.mode);
+    const jsonDefaultValues = ((_a = srState === null || srState === void 0 ? void 0 : srState.settings) === null || _a === void 0 ? void 0 : _a.jsonDefaultValues) || false;
+    const kit = React.useMemo(() => getRenderKit({ config: srState === null || srState === void 0 ? void 0 : srState.config, schema }), [schema, srState === null || srState === void 0 ? void 0 : srState.config]);
+    React.useMemo(() => {
+        var _a;
+        (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
+        const initialState = { schemaPath };
+        let defaultValue = schema === null || schema === void 0 ? void 0 : schema.default;
+        if (jsonDefaultValues && typeof defaultValue === 'string') {
+            try {
+                defaultValue = JSON.parse(defaultValue);
+            }
+            catch (_b) { }
+        }
+        unsubscribeRef.current = form.registerField(name, (f) => {
+            const prevF = fieldRef.current;
+            if (prevF) {
+                let inputTick = 0;
+                let metaTick = 0;
+                if (f.value !== prevF.value) {
+                    inputTick = 1;
+                }
+                if (prevF.submitFailed !== f.submitFailed ||
+                    prevF.touched !== f.touched ||
+                    prevF.validating !== f.validating) {
+                    metaTick = 1;
+                }
+                if (inputTick + metaTick) {
+                    if (firstRenderRef.current) {
+                        pendingTicksRef.current = { input: inputTick, meta: metaTick };
+                    }
+                    else {
+                        setTicks((t) => ({
+                            input: t.input + inputTick,
+                            meta: t.meta + metaTick,
+                        }));
+                    }
+                }
+            }
+            fieldRef.current = f;
+        }, { submitFailed: true, touched: true, validating: true, value: true }, {
+            data: { state: initialState },
+            defaultValue,
+            validateFields: [getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName)],
+        });
+    }, [form, jsonDefaultValues, headName, name, schema === null || schema === void 0 ? void 0 : schema.default, schema === null || schema === void 0 ? void 0 : schema.type, schemaPath]);
+    const input = React.useMemo(() => {
+        var _a;
+        const fieldState = form.getFieldState(name);
+        return {
+            name,
+            onBlur: (fieldState === null || fieldState === void 0 ? void 0 : fieldState.blur) || noop,
+            onChange: (fieldState === null || fieldState === void 0 ? void 0 : fieldState.change) || noop,
+            onFocus: (fieldState === null || fieldState === void 0 ? void 0 : fieldState.focus) || noop,
+            value: (_a = fieldState === null || fieldState === void 0 ? void 0 : fieldState.value) !== null && _a !== void 0 ? _a : undefined,
+        };
+    }, [name, form, ticks.input]);
+    const meta = React.useMemo(() => {
+        const fieldState = form.getFieldState(name);
+        return {
+            data: fieldState === null || fieldState === void 0 ? void 0 : fieldState.data,
+            error,
+            initial: fieldState === null || fieldState === void 0 ? void 0 : fieldState.initial,
+            submitFailed: fieldState === null || fieldState === void 0 ? void 0 : fieldState.submitFailed,
+            touched: fieldState === null || fieldState === void 0 ? void 0 : fieldState.touched,
+            validating: fieldState === null || fieldState === void 0 ? void 0 : fieldState.validating,
+        };
+    }, [error, form, name, ticks.meta]);
+    React.useEffect(() => {
+        firstRenderRef.current = false;
+        if (pendingTicksRef.current.input || pendingTicksRef.current.meta) {
+            setTicks((t) => ({
+                input: t.input + pendingTicksRef.current.input,
+                meta: t.meta + pendingTicksRef.current.meta,
+            }));
+        }
+        return () => {
+            var _a;
+            (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
+        };
+    }, []);
+    let content = null;
+    if ((mode === SchemaRendererMode.Overview && !(schema === null || schema === void 0 ? void 0 : schema.writeOnly)) ||
+        (mode === SchemaRendererMode.Form && !(schema === null || schema === void 0 ? void 0 : schema.readOnly))) {
+        const { Entity, Layout, entityProps, independent, layoutProps } = kit[mode];
+        if (Entity) {
+            content = (React.createElement(Entity, { Layout: independent ? Layout : undefined, headName: headName, input: input, layoutProps: independent ? layoutProps : undefined, meta: meta, mode: mode, props: entityProps, schema: schema, schemaPath: schemaPath }));
+            if (Layout && !independent) {
+                content = (React.createElement(Layout, { headName: headName, input: input, meta: meta, mode: mode, props: layoutProps, schema: schema, schemaPath: schemaPath }, content));
+            }
+        }
+    }
+    return content;
+};
+export const SchemaRendererNode = React.memo(SchemaRendererNodeComponent);

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

@@ -0,0 +1,3 @@
+export { SchemaRendererNode, type SchemaRendererNodeProps } from './SchemaRendererNode';
+export type { SchemaRendererNodeState } from './types';
+export { getAccumulatedSchema, getRenderKit } from './utils';

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

@@ -0,0 +1,2 @@
+export { SchemaRendererNode } from './SchemaRendererNode';
+export { getAccumulatedSchema, getRenderKit } from './utils';

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

@@ -0,0 +1,3 @@
+export interface SchemaRendererNodeState {
+    schemaPath: string;
+}

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

@@ -0,0 +1,25 @@
+import { SchemaRendererMode } from '../constants';
+import type { JsonSchema, NodeEntity, NodeLayout, NodesConfig } from '../types';
+type GetRenderKitParams<Schema extends JsonSchema> = {
+    config?: NodesConfig;
+    schema?: Schema;
+};
+type GetRenderKitReturn<Schema extends JsonSchema> = {
+    [SchemaRendererMode.Form]: {
+        Entity?: NodeEntity<Schema> | undefined;
+        Layout?: NodeLayout<Schema> | undefined;
+        entityProps: Record<string, any>;
+        layoutProps: Record<string, any>;
+        independent?: boolean | undefined;
+    };
+    [SchemaRendererMode.Overview]: {
+        Entity?: NodeEntity<Schema> | undefined;
+        Layout?: NodeLayout<Schema> | undefined;
+        entityProps: Record<string, any>;
+        layoutProps: Record<string, any>;
+        independent?: boolean | undefined;
+    };
+};
+export declare const getRenderKit: <Schema extends JsonSchema>({ config, schema, }: GetRenderKitParams<Schema>) => GetRenderKitReturn<Schema>;
+export declare const getAccumulatedSchema: (schemaPath: string, rootSchema?: JsonSchema, override?: JsonSchema, collectedPaths?: Set<string>) => JsonSchema;
+export {};

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

@@ -0,0 +1,156 @@
+import get from 'lodash/get';
+import isString from 'lodash/isString';
+import set from 'lodash/set';
+import { EMPTY_OBJECT, SchemaRendererMode } from '../constants';
+import { getSchemaByPointer, getValuePaths } from '../utils';
+const fixType = (value) => value;
+const mergeValues = (first, second) => {
+    const result = {};
+    getValuePaths(first).forEach((path) => {
+        set(result, path, get(first, path));
+    });
+    getValuePaths(second).forEach((path) => {
+        set(result, path, get(second, path));
+    });
+    return result;
+};
+// eslint-disable-next-line complexity
+export const getRenderKit = ({ config, schema, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+    const result = {
+        [SchemaRendererMode.Form]: {
+            entityProps: EMPTY_OBJECT,
+            layoutProps: EMPTY_OBJECT,
+        },
+        [SchemaRendererMode.Overview]: {
+            entityProps: EMPTY_OBJECT,
+            layoutProps: EMPTY_OBJECT,
+        },
+    };
+    const nodeType = get(schema, 'nodeParameters.type');
+    if ((_a = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.entity) {
+        const e = (_b = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _b === void 0 ? void 0 : _b.entity;
+        let fe;
+        let fep = ((_c = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _c === void 0 ? void 0 : _c.entityProps) || EMPTY_OBJECT;
+        let fi;
+        let oe;
+        let oep = ((_d = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _d === void 0 ? void 0 : _d.entityProps) || EMPTY_OBJECT;
+        let oi;
+        if (isString(e)) {
+            fe = get(config, `${nodeType}.formEntities.${e}.Component`);
+            fep = mergeValues(get(config, `${nodeType}.formEntities.${e}.defaultProps`), fep);
+            fi = get(config, `${nodeType}.formEntities.${e}.independent`);
+            oe = get(config, `${nodeType}.overviewEntities.${e}.Component`);
+            oep = mergeValues(get(config, `${nodeType}.overviewEntities.${e}.defaultProps`), oep);
+            oi = get(config, `${nodeType}.overviewEntities.${e}.independent`);
+        }
+        else {
+            fe = fixType(e);
+            oe = fixType(e);
+        }
+        result[SchemaRendererMode.Form].Entity = fe;
+        result[SchemaRendererMode.Form].entityProps = fep;
+        result[SchemaRendererMode.Form].independent = fi;
+        result[SchemaRendererMode.Overview].Entity = oe;
+        result[SchemaRendererMode.Overview].entityProps = oep;
+        result[SchemaRendererMode.Overview].independent = oi;
+    }
+    if ((_e = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _e === void 0 ? void 0 : _e.formEntity) {
+        const e = (_f = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _f === void 0 ? void 0 : _f.formEntity;
+        let fe;
+        let fep = ((_g = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _g === void 0 ? void 0 : _g.formEntityProps) || EMPTY_OBJECT;
+        let fi;
+        if (isString(e)) {
+            fe = get(config, `${nodeType}.formEntities.${e}.Component`);
+            fep = mergeValues(get(config, `${nodeType}.formEntities.${e}.defaultProps`), fep);
+            fi = get(config, `${nodeType}.formEntities.${e}.independent`);
+        }
+        else {
+            fe = fixType(e);
+        }
+        result[SchemaRendererMode.Form].Entity = fe;
+        result[SchemaRendererMode.Form].entityProps = fep;
+        result[SchemaRendererMode.Form].independent = fi;
+    }
+    if ((_h = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _h === void 0 ? void 0 : _h.overviewEntity) {
+        const e = (_j = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _j === void 0 ? void 0 : _j.overviewEntity;
+        let oe;
+        let oep = ((_k = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _k === void 0 ? void 0 : _k.overviewEntityProps) || EMPTY_OBJECT;
+        let oi;
+        if (isString(e)) {
+            oe = get(config, `${nodeType}.overviewEntities.${e}.Component`);
+            oep = mergeValues(get(config, `${nodeType}.overviewEntities.${e}.defaultProps`), oep);
+            oi = get(config, `${nodeType}.overviewEntities.${e}.independent`);
+        }
+        else {
+            oe = fixType(e);
+        }
+        result[SchemaRendererMode.Overview].Entity = oe;
+        result[SchemaRendererMode.Overview].entityProps = oep;
+        result[SchemaRendererMode.Overview].independent = oi;
+    }
+    if ((_l = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _l === void 0 ? void 0 : _l.layout) {
+        const l = (_m = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _m === void 0 ? void 0 : _m.layout;
+        let fl;
+        let flp = ((_o = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _o === void 0 ? void 0 : _o.layoutProps) || EMPTY_OBJECT;
+        let ol;
+        let olp = ((_p = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _p === void 0 ? void 0 : _p.layoutProps) || EMPTY_OBJECT;
+        if (isString(l)) {
+            fl = get(config, `${nodeType}.formLayouts.${l}.Component`);
+            flp = mergeValues(get(config, `${nodeType}.formLayouts.${l}.defaultProps`), flp);
+            ol = get(config, `${nodeType}.overviewLayouts.${l}.Component`);
+            olp = mergeValues(get(config, `${nodeType}.overviewLayouts.${l}.defaultProps`), olp);
+        }
+        else {
+            fl = fixType(l);
+            ol = fixType(l);
+        }
+        result[SchemaRendererMode.Form].Layout = fl;
+        result[SchemaRendererMode.Form].layoutProps = flp;
+        result[SchemaRendererMode.Overview].Layout = ol;
+        result[SchemaRendererMode.Overview].layoutProps = olp;
+    }
+    if ((_q = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _q === void 0 ? void 0 : _q.formLayout) {
+        const l = (_r = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _r === void 0 ? void 0 : _r.formLayout;
+        let fl;
+        let flp = ((_s = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _s === void 0 ? void 0 : _s.formLayoutProps) || EMPTY_OBJECT;
+        if (isString(l)) {
+            fl = get(config, `${nodeType}.formLayouts.${l}.Component`);
+            flp = mergeValues(get(config, `${nodeType}.formLayouts.${l}.defaultProps`), flp);
+        }
+        else {
+            fl = fixType(l);
+        }
+        result[SchemaRendererMode.Form].Layout = fl;
+        result[SchemaRendererMode.Form].layoutProps = flp;
+    }
+    if ((_t = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _t === void 0 ? void 0 : _t.overviewLayout) {
+        const l = (_u = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _u === void 0 ? void 0 : _u.overviewLayout;
+        let ol;
+        let olp = ((_v = schema === null || schema === void 0 ? void 0 : schema.nodeParameters) === null || _v === void 0 ? void 0 : _v.overviewLayoutProps) || EMPTY_OBJECT;
+        if (isString(l)) {
+            ol = get(config, `${nodeType}.overviewLayouts.${l}.Component`);
+            olp = mergeValues(get(config, `${nodeType}.overviewLayouts.${l}.defaultProps`), olp);
+        }
+        else {
+            ol = fixType(l);
+        }
+        result[SchemaRendererMode.Overview].Layout = ol;
+        result[SchemaRendererMode.Overview].layoutProps = olp;
+    }
+    return result;
+};
+export const getAccumulatedSchema = (schemaPath, rootSchema, override, collectedPaths = new Set()) => {
+    let accumulatedSchema = Object.assign({}, (rootSchema ? getSchemaByPointer(rootSchema, schemaPath) : {}));
+    if (override) {
+        accumulatedSchema = mergeValues(accumulatedSchema, override);
+    }
+    if (accumulatedSchema.$ref && !collectedPaths.has(accumulatedSchema.$ref)) {
+        collectedPaths.add(accumulatedSchema.$ref);
+        const schemaByRef = getAccumulatedSchema(accumulatedSchema.$ref, rootSchema, undefined, collectedPaths);
+        if (schemaByRef) {
+            accumulatedSchema = mergeValues(accumulatedSchema, schemaByRef);
+        }
+    }
+    return accumulatedSchema;
+};

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

@@ -2,6 +2,17 @@ export declare enum SchemaRendererMode {
     Form = "form",
     Overview = "overview"
 }
+export declare enum SchemaRendererEventType {
+    Config = "config",
+    Error = "error",
+    ErrorMessages = "errorMessages",
+    Mode = "mode",
+    Name = "name",
+    Patch = "patch",
+    Settings = "settings",
+    Schema = "schema",
+    UserContext = "userContext"
+}
 export declare enum JsonSchemaType {
     Array = "array",
     Boolean = "boolean",
@@ -11,7 +22,7 @@ export declare enum JsonSchemaType {
     Object = "object",
     String = "string"
 }
-export declare enum EntityType {
+export declare enum NodeType {
     Any = "any",
     Array = "array",
     Boolean = "boolean",

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

@@ -3,6 +3,18 @@ export var SchemaRendererMode;
     SchemaRendererMode["Form"] = "form";
     SchemaRendererMode["Overview"] = "overview";
 })(SchemaRendererMode || (SchemaRendererMode = {}));
+export var SchemaRendererEventType;
+(function (SchemaRendererEventType) {
+    SchemaRendererEventType["Config"] = "config";
+    SchemaRendererEventType["Error"] = "error";
+    SchemaRendererEventType["ErrorMessages"] = "errorMessages";
+    SchemaRendererEventType["Mode"] = "mode";
+    SchemaRendererEventType["Name"] = "name";
+    SchemaRendererEventType["Patch"] = "patch";
+    SchemaRendererEventType["Settings"] = "settings";
+    SchemaRendererEventType["Schema"] = "schema";
+    SchemaRendererEventType["UserContext"] = "userContext";
+})(SchemaRendererEventType || (SchemaRendererEventType = {}));
 export var JsonSchemaType;
 (function (JsonSchemaType) {
     JsonSchemaType["Array"] = "array";
@@ -13,13 +25,13 @@ export var JsonSchemaType;
     JsonSchemaType["Object"] = "object";
     JsonSchemaType["String"] = "string";
 })(JsonSchemaType || (JsonSchemaType = {}));
-export var EntityType;
-(function (EntityType) {
-    EntityType["Any"] = "any";
-    EntityType["Array"] = "array";
-    EntityType["Boolean"] = "boolean";
-    EntityType["Number"] = "number";
-    EntityType["Object"] = "object";
-    EntityType["String"] = "string";
-})(EntityType || (EntityType = {}));
+export var NodeType;
+(function (NodeType) {
+    NodeType["Any"] = "any";
+    NodeType["Array"] = "array";
+    NodeType["Boolean"] = "boolean";
+    NodeType["Number"] = "number";
+    NodeType["Object"] = "object";
+    NodeType["String"] = "string";
+})(NodeType || (NodeType = {}));
 export const EMPTY_OBJECT = {};

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

@@ -1,5 +1,8 @@
-export { Entity, type EntityProps, type EntityState } from './Entity';
+export { SchemaRendererNode, type SchemaRendererNodeProps, type SchemaRendererNodeState, getAccumulatedSchema, getRenderKit, } from './SchemaRendererNode';
 export { SchemaRenderer, type SchemaRendererProps } from './SchemaRenderer';
-export { EntityType, JsonSchemaType, SchemaRendererMode } from './constants';
+export { NodeType, JsonSchemaType, SchemaRendererEventType, SchemaRendererMode } from './constants';
 export type * from './types';
-export { schemaRendererMutators, type UseSchemaRendererParams, type UseSchemaRendererReturn, useSchemaRenderer, useSchemaRendererMutators, } from './useSchemaRenderer';
+export { SCHEMA_RENDERER_SERVICE_FIELD, type SchemaRendererState, type SchemaPatch, type SchemaPatchRemover, type UseSchemaRendererParams, useSchemaRenderer, } from './useSchemaRenderer';
+export { type UseSchemaRendererStateParams, useSchemaRendererState } from './useSchemaRendererState';
+export { useSchemaRendererTools } from './useSchemaRendererTools';
+export { createNodeParametersDefiner, defineNodeEntityConfig, defineNodeLayoutConfig, getServiceFieldName, getSchemaByPointer, } from './utils';

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

@@ -1,4 +1,7 @@
-export { Entity } from './Entity';
+export { SchemaRendererNode, getAccumulatedSchema, getRenderKit, } from './SchemaRendererNode';
 export { SchemaRenderer } from './SchemaRenderer';
-export { EntityType, JsonSchemaType, SchemaRendererMode } from './constants';
-export { schemaRendererMutators, useSchemaRenderer, useSchemaRendererMutators, } from './useSchemaRenderer';
+export { NodeType, JsonSchemaType, SchemaRendererEventType, SchemaRendererMode } from './constants';
+export { SCHEMA_RENDERER_SERVICE_FIELD, useSchemaRenderer, } from './useSchemaRenderer';
+export { useSchemaRendererState } from './useSchemaRendererState';
+export { useSchemaRendererTools } from './useSchemaRendererTools';
+export { createNodeParametersDefiner, defineNodeEntityConfig, defineNodeLayoutConfig, getServiceFieldName, getSchemaByPointer, } from './utils';

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

@@ -1,29 +1,29 @@
 import type React from 'react';
 import type { FieldRenderProps } from 'react-final-form';
+import type { SchemaRendererMode } from '../constants';
 import type { SchemaToValueType } from './helpers';
 import type { JsonSchema } from './schema';
-export interface ControlProps<Schema extends JsonSchema, ControlComponentProps extends Record<string, any> = {}, WrapperComponentProps extends Record<string, any> = {}> extends FieldRenderProps<SchemaToValueType<Schema> | null | undefined> {
-    schema: Schema;
-    controlProps: Partial<ControlComponentProps>;
-    Wrapper?: Wrapper<Schema, WrapperComponentProps>;
-    wrapperProps?: Partial<WrapperComponentProps>;
-}
-export type Control<Schema extends JsonSchema, ControlComponentProps extends Record<string, any> = {}, WrapperComponentProps extends Record<string, any> = {}> = React.ComponentType<ControlProps<Schema, ControlComponentProps, WrapperComponentProps>>;
-export interface ViewProps<Schema extends JsonSchema, ViewComponentProps extends Record<string, any> = {}, WrapperComponentProps extends Record<string, any> = {}> extends FieldRenderProps<SchemaToValueType<Schema> | null | undefined> {
+export interface NodeLayoutProps<Schema extends JsonSchema, Props extends Record<string, any> = {}> extends FieldRenderProps<SchemaToValueType<Schema> | null | undefined> {
+    children: React.ReactNode;
+    headName: string;
+    mode: SchemaRendererMode;
+    props: {
+        copy?: boolean;
+        hidden?: boolean;
+        open?: boolean;
+        required?: boolean;
+    } & Partial<Props>;
     schema: Schema;
-    viewProps: Partial<ViewComponentProps>;
-    Wrapper?: Wrapper<Schema, WrapperComponentProps>;
-    wrapperProps?: Partial<WrapperComponentProps>;
+    schemaPath: string;
 }
-export type View<Schema extends JsonSchema, ViewComponentProps extends Record<string, any> = {}, WrapperComponentProps extends Record<string, any> = {}> = React.ComponentType<ViewProps<Schema, ViewComponentProps, WrapperComponentProps>>;
-export interface WrapperProps<Schema extends JsonSchema, WrapperComponentProps extends Record<string, any> = {}> extends FieldRenderProps<SchemaToValueType<Schema> | null | undefined> {
+export type NodeLayout<Schema extends JsonSchema, Props extends Record<string, any> = {}> = React.FC<NodeLayoutProps<Schema, Props>>;
+export interface NodeEntityProps<Schema extends JsonSchema, Props extends Record<string, any> = {}, LayoutProps extends Record<string, any> = {}> extends FieldRenderProps<SchemaToValueType<Schema> | null | undefined> {
+    Layout?: NodeLayout<Schema, LayoutProps>;
+    headName: string;
+    layoutProps?: LayoutProps;
+    mode: SchemaRendererMode;
+    props: Partial<Props>;
     schema: Schema;
-    wrapperProps: {
-        open?: boolean;
-        hidden?: boolean;
-        copy?: boolean;
-        required?: boolean;
-    } & Partial<WrapperComponentProps>;
-    children: React.ReactNode;
+    schemaPath: string;
 }
-export type Wrapper<Schema extends JsonSchema, WrapperComponentProps extends Record<string, any> = {}> = React.ComponentType<WrapperProps<Schema, WrapperComponentProps>>;
+export type NodeEntity<Schema extends JsonSchema, Props extends Record<string, any> = {}, LayoutProps extends Record<string, any> = {}> = React.FC<NodeEntityProps<Schema, Props, LayoutProps>>;