@react-typed-forms/schemas 13.3.0 → 13.4.0

package/lib/renderers.d.ts

@@ -1,6 +1,6 @@
 import { ReactElement, ReactNode } from "react";
 import { ActionRendererProps, AdornmentProps, AdornmentRenderer, ArrayRendererProps, ControlLayoutProps, DataRendererProps, DisplayRendererProps, FormRenderer, GroupRendererProps, LabelRendererProps, LabelType, RenderedControl, VisibilityRendererProps } from "./controlRender";
-import { AccordionAdornment, ControlAdornment, IconAdornment, SetFieldAdornment } from "./types";
+import { AccordionAdornment, ControlAdornment, IconAdornment, SetFieldAdornment } from "./controlDefinition";
 export interface DefaultRenderers {
     data: DataRendererRegistration;
     label: LabelRendererRegistration;

package/lib/schemaBuilder.d.ts

@@ -1,4 +1,4 @@
-import { CompoundField, FieldOption, FieldType, SchemaField, SchemaMap } from "./types";
+import { CompoundField, FieldOption, FieldType, SchemaField, SchemaMap } from "./schemaField";
 export type AllowedSchema<T> = T extends string ? SchemaField & {
     type: FieldType.String | FieldType.Date | FieldType.DateTime | FieldType.Time;
 } : T extends number ? SchemaField & {

package/lib/schemaField.d.ts

@@ -0,0 +1,230 @@
+import { SchemaValidator } from "./schemaValidator";
+import { Control } from "@react-typed-forms/core";
+/**
+ * Represents a schema field with various properties.
+ */
+export interface SchemaField {
+    /** The type of the field. */
+    type: string;
+    /** The name of the field. */
+    field: string;
+    /** The display name of the field, optional. */
+    displayName?: string | null;
+    /** Tags associated with the field, optional. */
+    tags?: string[] | null;
+    /** Indicates if the field is a system field, optional. */
+    system?: boolean | null;
+    /** Indicates if the field is a collection, optional. */
+    collection?: boolean | null;
+    /** Specifies the types for which the field is applicable, optional. */
+    onlyForTypes?: string[] | null;
+    /** Indicates if the field is required, optional. */
+    required?: boolean | null;
+    /** Indicates if the field is not nullable, optional. */
+    notNullable?: boolean | null;
+    /** The default value of the field, optional. */
+    defaultValue?: any;
+    /** Indicates if the field is a type field, optional. */
+    isTypeField?: boolean | null;
+    /** Indicates if the field is searchable, optional. */
+    searchable?: boolean | null;
+    /** Options for the field, optional. */
+    options?: FieldOption[] | null;
+    /** Validators for the field, optional. */
+    validators?: SchemaValidator[] | null;
+}
+/**
+ * Represents a map of schema fields.
+ * The key is a string representing the schema name.
+ * The value is an array of SchemaField objects.
+ */
+export type SchemaMap = Record<string, SchemaField[]>;
+/**
+ * Enum representing the various field types.
+ */
+export declare enum FieldType {
+    String = "String",
+    Bool = "Bool",
+    Int = "Int",
+    Date = "Date",
+    DateTime = "DateTime",
+    Time = "Time",
+    Double = "Double",
+    EntityRef = "EntityRef",
+    Compound = "Compound",
+    AutoId = "AutoId",
+    Image = "Image",
+    Any = "Any"
+}
+/**
+ * Represents a field that references an entity.
+ */
+export interface EntityRefField extends SchemaField {
+    /** The type of the field, which is EntityRef. */
+    type: FieldType.EntityRef;
+    /** The type of the referenced entity. */
+    entityRefType: string;
+    /** The parent field of the entity reference. */
+    parentField: string;
+}
+/**
+ * Represents an option for a field.
+ */
+export interface FieldOption {
+    /** The name of the option. */
+    name: string;
+    /** The value of the option. */
+    value: any;
+    /** The description of the option, optional. */
+    description?: string | null;
+    /** The group of the option, optional. */
+    group?: string | null;
+    /** Indicates if the option is disabled, optional. */
+    disabled?: boolean | null;
+}
+/**
+ * Represents a compound field that contains child fields.
+ */
+export interface CompoundField extends SchemaField {
+    /** The type of the field, which is Compound. */
+    type: FieldType.Compound;
+    /** The child fields of the compound field. */
+    children: SchemaField[];
+    /** Indicates if the children are tree-structured, optional. */
+    treeChildren?: boolean;
+    /** The schema reference for the compound field, optional. */
+    schemaRef?: string;
+}
+/**
+ * Enum representing the various validation message types.
+ */
+export declare enum ValidationMessageType {
+    NotEmpty = "NotEmpty",
+    MinLength = "MinLength",
+    MaxLength = "MaxLength",
+    NotAfterDate = "NotAfterDate",
+    NotBeforeDate = "NotBeforeDate"
+}
+/**
+ * Interface for schema-related operations.
+ */
+export interface SchemaInterface {
+    /**
+     * Checks if the value of a field is empty.
+     * @param field The schema field.
+     * @param value The value to check.
+     * @returns True if the value is empty, false otherwise.
+     */
+    isEmptyValue(field: SchemaField, value: any): boolean;
+    /**
+     * Gets the text representation of a field's value.
+     * @param field The schema field.
+     * @param value The value to convert.
+     * @param element Indicates if the value is an element, optional.
+     * @returns The text representation of the value.
+     */
+    textValue(field: SchemaField, value: any, element?: boolean): string | undefined;
+    /**
+     * Gets the length of a control's value.
+     * @param field The schema field.
+     * @param control The control to check.
+     * @returns The length of the control's value.
+     */
+    controlLength(field: SchemaField, control: Control<any>): number;
+    /**
+     * Gets the length of a field's value.
+     * @param field The schema field.
+     * @param value The value to check.
+     * @returns The length of the value.
+     */
+    valueLength(field: SchemaField, value: any): number;
+    /**
+     * Gets the data options for a schema data node.
+     * @param node The schema data node.
+     * @returns The data options.
+     */
+    getDataOptions(node: SchemaDataNode): FieldOption[] | null | undefined;
+    /**
+     * Gets the node options for a schema node.
+     * @param node The schema node.
+     * @returns The node options.
+     */
+    getNodeOptions(node: SchemaNode): FieldOption[] | null | undefined;
+    /**
+     * Gets the options for a schema field.
+     * @param field The schema field.
+     * @returns The field options.
+     */
+    getOptions(field: SchemaField): FieldOption[] | undefined | null;
+    /**
+     * Gets the filter options for a schema data node and field.
+     * @param array The schema data node.
+     * @param field The schema node.
+     * @returns The filter options.
+     */
+    getFilterOptions(array: SchemaDataNode, field: SchemaNode): FieldOption[] | undefined | null;
+    /**
+     * Parses a string value to milliseconds.
+     * @param field The schema field.
+     * @param v The string value to parse.
+     * @returns The parsed value in milliseconds.
+     */
+    parseToMillis(field: SchemaField, v: string): number;
+    /**
+     * Gets the validation message text for a field.
+     * @param field The schema field.
+     * @param messageType The type of validation message.
+     * @param actual The actual value.
+     * @param expected The expected value.
+     * @returns The validation message text.
+     */
+    validationMessageText(field: SchemaField, messageType: ValidationMessageType, actual: any, expected: any): string;
+    /**
+     * Compares two values of a field.
+     * @param field The schema field.
+     * @param v1 The first value.
+     * @param v2 The second value.
+     * @returns The comparison result.
+     */
+    compareValue(field: SchemaField, v1: unknown, v2: unknown): number;
+    /**
+     * Gets the search text for a field's value.
+     * @param field The schema field.
+     * @param value The value to search.
+     * @returns The search text.
+     */
+    searchText(field: SchemaField, value: any): string;
+}
+export interface SchemaTreeLookup<A = string> {
+    getSchema(schemaId: A): SchemaNode | undefined;
+}
+export interface SchemaNode extends SchemaTreeLookup {
+    field: SchemaField;
+    getChildNode(field: string): SchemaNode | undefined;
+    getChildNodes(withParent?: SchemaNode): SchemaNode[];
+    parent?: SchemaNode;
+}
+export interface SchemaDataNode {
+    schema: SchemaNode;
+    elementIndex?: number;
+    control?: Control<unknown>;
+    parent?: SchemaDataNode;
+    getChild(node: SchemaNode): SchemaDataNode;
+    getChildElement(index: number): SchemaDataNode;
+}
+export declare function findField(fields: SchemaField[], field: string): SchemaField | undefined;
+export declare function isScalarField(sf: SchemaField): sf is SchemaField;
+export declare function isCompoundField(sf: SchemaField): sf is CompoundField;
+export declare function createSchemaLookup<A extends Record<string, SchemaField[]>>(schemaMap: A): SchemaTreeLookup<keyof A>;
+export declare function makeSchemaDataNode(schema: SchemaNode, control?: Control<unknown>, parent?: SchemaDataNode, elementIndex?: number): SchemaDataNode;
+export declare function schemaDataForFieldRef(fieldRef: string | undefined, schema: SchemaDataNode): SchemaDataNode;
+export declare function schemaForFieldRef(fieldRef: string | undefined, schema: SchemaNode): SchemaNode;
+export declare function traverseSchemaPath<A>(fieldPath: string[], schema: SchemaNode, acc: A, next: (acc: A, node: SchemaNode) => A): A;
+export declare function traverseData(fieldPath: string[], root: SchemaNode, data: {
+    [k: string]: any;
+}): unknown;
+export declare function schemaDataForFieldPath(fieldPath: string[], schema: SchemaDataNode): SchemaDataNode;
+export declare function schemaForFieldPath(fieldPath: string[], schema: SchemaNode): SchemaNode;
+export declare function rootSchemaNode(fields: SchemaField[], lookup?: SchemaTreeLookup): SchemaNode;
+export declare function getSchemaNodePath(node: SchemaNode): string[];
+export declare function isCompoundNode(node: SchemaNode): boolean;

package/lib/schemaValidator.d.ts

@@ -0,0 +1,27 @@
+export declare enum ValidatorType {
+    Jsonata = "Jsonata",
+    Date = "Date",
+    Length = "Length"
+}
+export interface SchemaValidator {
+    type: string;
+}
+export interface JsonataValidator extends SchemaValidator {
+    type: ValidatorType.Jsonata;
+    expression: string;
+}
+export interface LengthValidator extends SchemaValidator {
+    type: ValidatorType.Length;
+    min?: number | null;
+    max?: number | null;
+}
+export declare enum DateComparison {
+    NotBefore = "NotBefore",
+    NotAfter = "NotAfter"
+}
+export interface DateValidator extends SchemaValidator {
+    type: ValidatorType.Date;
+    comparison: DateComparison;
+    fixedDate?: string | null;
+    daysFromCurrent?: number | null;
+}

package/lib/util.d.ts

@@ -1,74 +1,266 @@
-import { CompoundField, ControlActionHandler, ControlDefinition, DataControlDefinition, DisplayOnlyRenderOptions, FieldOption, GroupRenderOptions, SchemaField, SchemaInterface } from "./types";
+import { ControlActionHandler, ControlDefinition, DataControlDefinition, DisplayOnlyRenderOptions, GroupRenderOptions } from "./controlDefinition";
 import { MutableRefObject } from "react";
-import { SchemaDataNode } from "./treeNodes";
+import { CompoundField, FieldOption, SchemaField, SchemaNode } from "./schemaField";
+/**
+ * Interface representing the classes for a control.
+ */
 export interface ControlClasses {
     styleClass?: string;
     layoutClass?: string;
     labelClass?: string;
 }
+/**
+ * Type representing a JSON path, which can be a string or a number.
+ */
 export type JsonPath = string | number;
-export interface FormContextData {
-    option?: FieldOption;
-    optionSelected?: boolean;
-}
-export interface ControlDataContext {
-    schemaInterface: SchemaInterface;
-    dataNode: SchemaDataNode | undefined;
-    parentNode: SchemaDataNode;
-    formData: FormContextData;
-}
+/**
+ * Applies default values to the given record based on the provided schema fields.
+ * @param v - The record to apply default values to.
+ * @param fields - The schema fields to use for applying default values.
+ * @param doneSet - A set to keep track of processed records.
+ * @returns The record with default values applied.
+ */
 export declare function applyDefaultValues(v: Record<string, any> | undefined, fields: SchemaField[], doneSet?: Set<Record<string, any>>): any;
+/**
+ * Applies default values to a specific field based on the provided schema field.
+ * @param v - The value to apply default values to.
+ * @param field - The schema field to use for applying default values.
+ * @param parent - The parent schema fields.
+ * @param notElement - Flag indicating if the field is not an element.
+ * @param doneSet - A set to keep track of processed records.
+ * @returns The value with default values applied.
+ */
 export declare function applyDefaultForField(v: any, field: SchemaField, parent: SchemaField[], notElement?: boolean, doneSet?: Set<Record<string, any>>): any;
+/**
+ * Returns the default values for the provided schema fields.
+ * @param fields - The schema fields to get default values for.
+ * @returns The default values for the schema fields.
+ */
 export declare function defaultValueForFields(fields: SchemaField[]): any;
+/**
+ * Returns the default value for a specific schema field.
+ * @param sf - The schema field to get the default value for.
+ * @param required - Flag indicating if the field is required.
+ * @param forceNotNull - Flag indicating if the field should not be null.
+ * @returns The default value for the schema field.
+ */
 export declare function defaultValueForField(sf: SchemaField, required?: boolean | null, forceNotNull?: boolean): any;
+/**
+ * Returns the element value for a specific schema field.
+ * @param sf - The schema field to get the element value for.
+ * @returns The element value for the schema field.
+ */
 export declare function elementValueForField(sf: SchemaField): any;
+/**
+ * Finds a scalar field in the provided schema fields.
+ * @param fields - The schema fields to search in.
+ * @param field - The field name to search for.
+ * @returns The found scalar field, or undefined if not found.
+ */
 export declare function findScalarField(fields: SchemaField[], field: string): SchemaField | undefined;
+/**
+ * Finds a compound field in the provided schema fields.
+ * @param fields - The schema fields to search in.
+ * @param field - The field name to search for.
+ * @returns The found compound field, or undefined if not found.
+ */
 export declare function findCompoundField(fields: SchemaField[], field: string): CompoundField | undefined;
+/**
+ * Checks if a field has a specific tag.
+ * @param field - The field to check.
+ * @param tag - The tag to check for.
+ * @returns True if the field has the tag, false otherwise.
+ */
 export declare function fieldHasTag(field: SchemaField, tag: string): boolean;
+/**
+ * Returns the display name for a specific field.
+ * @param field - The field to get the display name for.
+ * @returns The display name for the field.
+ */
 export declare function fieldDisplayName(field: SchemaField): string;
+/**
+ * Checks if an object has options.
+ * @param o - The object to check.
+ * @returns True if the object has options, false otherwise.
+ */
 export declare function hasOptions(o: {
     options: FieldOption[] | undefined | null;
 }): boolean;
+/**
+ * Returns the default control definition for a specific schema field.
+ * @param sf - The schema field to get the default control definition for.
+ * @returns The default control definition for the schema field.
+ */
 export declare function defaultControlForField(sf: SchemaField): DataControlDefinition;
-export declare function findControlsForCompound(compound: CompoundField, definition: ControlDefinition): ControlDefinition[];
+export declare function findControlsForCompound(compound: SchemaNode, definition: ControlDefinition): ControlDefinition[];
+/**
+ * Interface representing a control group lookup.
+ */
 export interface ControlGroupLookup {
     groups: ControlDefinition[];
     children: Record<string, ControlGroupLookup>;
 }
-export declare function findCompoundGroups(fields: SchemaField[], controls: ControlDefinition[]): Record<string, ControlGroupLookup>;
-export declare function existsInGroups(field: SchemaField, lookup: ControlGroupLookup): [SchemaField, ControlGroupLookup][];
+/**
+ * Finds compound groups in the provided schema fields and control definitions.
+ * @param fields - The schema fields to search in.
+ * @param controls - The control definitions to search in.
+ * @returns A record of found compound groups.
+ */
+export declare function findCompoundGroups(fields: SchemaNode[], controls: ControlDefinition[]): Record<string, ControlGroupLookup>;
+/**
+ * Checks if a field exists in the provided control group lookup.
+ * @param field - The field to check.
+ * @param lookup - The control group lookup to check in.
+ * @returns An array of tuples containing the field and the control group lookup.
+ */
+export declare function existsInGroups(field: SchemaNode, lookup: ControlGroupLookup): [SchemaNode, ControlGroupLookup][];
+/**
+ * Finds non-data groups in the provided control definitions.
+ * @param controls - The control definitions to search in.
+ * @returns An array of found non-data groups.
+ */
 export declare function findNonDataGroups(controls: ControlDefinition[]): ControlDefinition[];
+/**
+ * Adds missing controls to the provided control definitions based on the schema fields.
+ * @param fields - The schema fields to use for adding missing controls.
+ * @param controls - The control definitions to add missing controls to.
+ * @returns The control definitions with missing controls added.
+ */
 export declare function addMissingControls(fields: SchemaField[], controls: ControlDefinition[]): ControlDefinition[];
+/**
+ * Adds missing controls to the provided control definitions based on the schema fields.
+ * @param schema - The root schema node to use for adding missing controls.
+ * @param controls - The control definitions to add missing controls to.
+ * @returns The control definitions with missing controls added.
+ */
+export declare function addMissingControlsForSchema(schema: SchemaNode, controls: ControlDefinition[]): ControlDefinition[];
+/**
+ * Custom hook to use an updated reference.
+ * @param a - The value to create a reference for.
+ * @returns A mutable reference object.
+ */
 export declare function useUpdatedRef<A>(a: A): MutableRefObject<A>;
+/**
+ * Checks if a control definition is readonly.
+ * @param c - The control definition to check.
+ * @returns True if the control definition is readonly, false otherwise.
+ */
 export declare function isControlReadonly(c: ControlDefinition): boolean;
+/**
+ * Checks if a control definition is disabled.
+ * @param c - The control definition to check.
+ * @returns True if the control definition is disabled, false otherwise.
+ */
 export declare function isControlDisabled(c: ControlDefinition): boolean;
+/**
+ * Returns the display-only render options for a control definition.
+ * @param d - The control definition to get the display-only render options for.
+ * @returns The display-only render options, or undefined if not applicable.
+ */
 export declare function getDisplayOnlyOptions(d: ControlDefinition): DisplayOnlyRenderOptions | undefined;
+/**
+ * Cleans data for a schema based on the provided schema fields.
+ * @param v - The data to clean.
+ * @param fields - The schema fields to use for cleaning the data.
+ * @param removeIfDefault - Flag indicating if default values should be removed.
+ * @returns The cleaned data.
+ */
 export declare function cleanDataForSchema(v: {
     [k: string]: any;
 } | undefined, fields: SchemaField[], removeIfDefault?: boolean): any;
+/**
+ * Returns all referenced classes for a control definition.
+ * @param c - The control definition to get the referenced classes for.
+ * @param collectExtra - Optional function to collect extra classes.
+ * @returns An array of referenced classes.
+ */
 export declare function getAllReferencedClasses(c: ControlDefinition, collectExtra?: (c: ControlDefinition) => (string | undefined | null)[]): string[];
+/**
+ * Converts a JSON path array to a string.
+ * @param jsonPath - The JSON path array to convert.
+ * @param customIndex - Optional function to customize the index format.
+ * @returns The JSON path string.
+ */
 export declare function jsonPathString(jsonPath: JsonPath[], customIndex?: (n: number) => string): string;
+/**
+ * Finds a child control definition within a parent control definition.
+ * @param parent - The parent control definition.
+ * @param childPath - The path to the child control definition, either as a single index or an array of indices.
+ * @returns The found child control definition.
+ */
 export declare function findChildDefinition(parent: ControlDefinition, childPath: number | number[]): ControlDefinition;
+/**
+ * Returns the override class name if the class name starts with "@ ".
+ * Otherwise, returns the original class name.
+ * @param className - The class name to check and potentially modify.
+ * @returns The override class name or the original class name.
+ */
 export declare function getOverrideClass(className?: string | null): string | null | undefined;
+/**
+ * Returns the appropriate class name for a renderer.
+ * If the global class name starts with "@ ", it overrides the control class name.
+ * Otherwise, it combines the control class name and the global class name.
+ *
+ * @param controlClass - The class name for the control.
+ * @param globalClass - The global class name.
+ * @returns The appropriate class name for the renderer.
+ */
 export declare function rendererClass(controlClass?: string | null, globalClass?: string | null): string | undefined;
-export type HookDep = string | number | undefined | null;
-export interface DynamicHookGenerator<A, P> {
-    deps: HookDep;
-    state: any;
-    runHook(ctx: P, state: any): A;
-}
-export declare function makeHook<A, P, S = undefined>(runHook: (ctx: P, state: S) => A, state: S, deps?: HookDep): DynamicHookGenerator<A, P>;
-export type DynamicHookValue<A> = A extends DynamicHookGenerator<infer V, any> ? V : never;
-export declare function makeHookDepString<A>(deps: A[], asHookDep: (a: A) => HookDep): string;
-export declare function useDynamicHooks<P, Hooks extends Record<string, DynamicHookGenerator<any, P>>>(hooks: Hooks): (p: P) => {
-    [K in keyof Hooks]: DynamicHookValue<Hooks[K]>;
-};
-export declare function toDepString(x: any): string;
+/**
+ * Applies length restrictions to a value.
+ * @template Min - The type of the minimum value.
+ * @template Max - The type of the maximum value.
+ * @param {number} length - The length to check.
+ * @param {number | null | undefined} min - The minimum length.
+ * @param {number | null | undefined} max - The maximum length.
+ * @param {Min} minValue - The value to return if the length is greater than the minimum.
+ * @param {Max} maxValue - The value to return if the length is less than the maximum.
+ * @returns {[Min | undefined, Max | undefined]} - An array containing the minimum and maximum values if the length restrictions are met.
+ */
 export declare function applyLengthRestrictions<Min, Max>(length: number, min: number | null | undefined, max: number | null | undefined, minValue: Min, maxValue: Max): [Min | undefined, Max | undefined];
+/**
+ * Finds the path to a field in the schema fields.
+ * @param {SchemaField[]} fields - The schema fields to search in.
+ * @param {string | undefined} fieldPath - The path to the field.
+ * @returns {SchemaField[] | undefined} - An array of schema fields representing the path, or undefined if not found.
+ */
 export declare function findFieldPath(fields: SchemaField[], fieldPath: string | undefined): SchemaField[] | undefined;
+/**
+ * Merges two objects.
+ * @template A - The type of the objects to merge.
+ * @param {A} o1 - The first object.
+ * @param {A} o2 - The second object.
+ * @param {(k: keyof NonNullable<A>, v1: unknown, v2: unknown) => unknown} [doMerge] - Optional function to merge values.
+ * @returns {A} - The merged object.
+ */
 export declare function mergeObjects<A extends Record<string, any> | undefined>(o1: A, o2: A, doMerge?: (k: keyof NonNullable<A>, v1: unknown, v2: unknown) => unknown): A;
+/**
+ * Coerces a value to a string.
+ * @param {unknown} v - The value to coerce.
+ * @returns {string} - The coerced string.
+ */
 export declare function coerceToString(v: unknown): string;
+/**
+ * Returns the group renderer options for a control definition.
+ * @param {ControlDefinition} def - The control definition to get the group renderer options for.
+ * @returns {GroupRenderOptions | undefined} - The group renderer options, or undefined if not applicable.
+ */
 export declare function getGroupRendererOptions(def: ControlDefinition): GroupRenderOptions | undefined;
+/**
+ * Returns the group class overrides for a control definition.
+ * @param {ControlDefinition} def - The control definition to get the group class overrides for.
+ * @returns {ControlClasses} - The group class overrides.
+ */
 export declare function getGroupClassOverrides(def: ControlDefinition): ControlClasses;
+/**
+ * Checks if a control definition is display-only.
+ * @param {ControlDefinition} def - The control definition to check.
+ * @returns {boolean} - True if the control definition is display-only, false otherwise.
+ */
 export declare function isControlDisplayOnly(def: ControlDefinition): boolean;
+/**
+ * Combines multiple action handlers into a single handler.
+ * @param {...(ControlActionHandler | undefined)[]} handlers - The action handlers to combine.
+ * @returns {ControlActionHandler} - The combined action handler.
+ */
 export declare function actionHandlers(...handlers: (ControlActionHandler | undefined)[]): ControlActionHandler;

package/lib/validators.d.ts

@@ -1,6 +1,7 @@
-import { ControlDefinition, DataControlDefinition, DateValidator, JsonataValidator, LengthValidator, SchemaField, SchemaValidator } from "./types";
+import { ControlDefinition, DataControlDefinition, ControlDataContext } from "./controlDefinition";
 import { Control } from "@react-typed-forms/core";
-import { ControlDataContext } from "./util";
+import { DateValidator, JsonataValidator, LengthValidator, SchemaValidator } from "./schemaValidator";
+import { SchemaField } from "./schemaField";
 interface ValidationHookContext {
     hiddenControl: Control<boolean | null | undefined>;
     dataContext: ControlDataContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-typed-forms/schemas",
-  "version": "13.3.0",
+  "version": "13.4.0",
   "description": "",
   "type": "module",
   "main": "lib/index.cjs",

package/lib/treeNodes.d.ts

@@ -1,53 +0,0 @@
-import { Control } from "@react-typed-forms/core";
-import { ControlDefinition, SchemaField, DataControlDefinition } from "./types";
-export interface FormNode {
-    definition: ControlDefinition;
-    getChildNodes(): FormNode[];
-    parent?: FormNode;
-}
-export interface FormTreeLookup<A = string> {
-    getForm(formId: A): FormTreeNode | undefined;
-}
-export interface FormTreeNode extends FormTreeLookup {
-    rootNode: FormNode;
-}
-export interface SchemaTreeLookup<A = string> {
-    getSchema(schemaId: A): SchemaNode | undefined;
-}
-export interface SchemaNode extends SchemaTreeLookup {
-    field: SchemaField;
-    getChildNode(field: string): SchemaNode | undefined;
-    getChildNodes(): SchemaNode[];
-    parent?: SchemaNode;
-}
-export interface SchemaDataNode {
-    schema: SchemaNode;
-    elementIndex?: number;
-    control?: Control<unknown>;
-    parent?: SchemaDataNode;
-    getChild(node: SchemaNode): SchemaDataNode;
-    getChildElement(index: number): SchemaDataNode;
-}
-export declare function createSchemaLookup<A extends Record<string, SchemaField[]>>(schemaMap: A): SchemaTreeLookup<keyof A>;
-export declare function createFormLookup<A extends Record<string, ControlDefinition[]>>(formMap: A): FormTreeLookup<keyof A>;
-export declare function makeSchemaDataNode(schema: SchemaNode, control?: Control<unknown>, parent?: SchemaDataNode, elementIndex?: number): SchemaDataNode;
-export declare function fieldPathForDefinition(c: ControlDefinition): string[] | undefined;
-export declare function lookupDataNode(c: ControlDefinition, parentNode: SchemaDataNode): SchemaDataNode | undefined;
-export declare function schemaDataForFieldRef(fieldRef: string | undefined, schema: SchemaDataNode): SchemaDataNode;
-export declare function schemaForFieldRef(fieldRef: string | undefined, schema: SchemaNode): SchemaNode;
-export declare function traverseSchemaPath<A>(fieldPath: string[], schema: SchemaNode, acc: A, next: (acc: A, node: SchemaNode) => A): A;
-export declare function traverseData(fieldPath: string[], root: SchemaNode, data: {
-    [k: string]: any;
-}): unknown;
-export declare function schemaDataForFieldPath(fieldPath: string[], schema: SchemaDataNode): SchemaDataNode;
-export declare function schemaForFieldPath(fieldPath: string[], schema: SchemaNode): SchemaNode;
-export declare function traverseParents<A, B extends {
-    parent?: B | undefined;
-}>(current: B | undefined, get: (b: B) => A, until?: (b: B) => boolean): A[];
-export declare function getRootDataNode(dataNode: SchemaDataNode): SchemaDataNode;
-export declare function getJsonPath(dataNode: SchemaDataNode): (string | number)[];
-export declare function getSchemaPath(schemaNode: SchemaNode): SchemaField[];
-export declare function getSchemaFieldList(schema: SchemaNode): SchemaField[];
-export declare function rootSchemaNode(fields: SchemaField[], lookup?: SchemaTreeLookup): SchemaNode;
-export declare function visitControlDataArray<A>(controls: ControlDefinition[] | undefined | null, context: SchemaDataNode, cb: (definition: DataControlDefinition, node: SchemaDataNode) => A | undefined): A | undefined;
-export declare function visitControlData<A>(definition: ControlDefinition, ctx: SchemaDataNode, cb: (definition: DataControlDefinition, field: SchemaDataNode) => A | undefined): A | undefined;