reactaform 1.0.0

package/dist/components/fields/MultiSelection.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type OptionsField = DefinitionPropertyField & {
+    options: NonNullable<DefinitionPropertyField['options']>;
+};
+type MultiSelectionProps = BaseInputProps<string[] | null, OptionsField>;
+declare const MultiSelect: React.FC<MultiSelectionProps>;
+export default MultiSelect;

package/dist/components/fields/MultilineTextInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type TextInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const MultilineTextInput: React.FC<TextInputProps>;
+export default MultilineTextInput;

package/dist/components/fields/NumericStepperInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type NumericStepperInputProps = BaseInputProps<number, DefinitionPropertyField>;
+declare const NumericStepperInput: React.FC<NumericStepperInputProps>;
+export default NumericStepperInput;

package/dist/components/fields/PhoneInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type PhoneInputProps = BaseInputProps<string, DefinitionPropertyField>;
+export declare const PhoneInput: React.FC<PhoneInputProps>;
+export default PhoneInput;

package/dist/components/fields/RadioInput.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+export type RadioInputProps = BaseInputProps<string, DefinitionPropertyField>;
+/**
+ * RadioInput
+ *
+ * Renders radio button options for selecting a single value.
+ * - Supports horizontal and vertical layouts
+ * - Validates that the selected value is in the options list
+ * - Auto-corrects to first option if invalid value provided
+ */
+declare const RadioInput: React.FC<RadioInputProps>;
+export default RadioInput;

package/dist/components/fields/RatingInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type RatingInputProps = BaseInputProps<number, DefinitionPropertyField>;
+declare const RatingInput: React.FC<RatingInputProps>;
+export default RatingInput;

package/dist/components/fields/Separator.d.ts

@@ -0,0 +1,20 @@
+interface SeparatorProps {
+    color?: string;
+    thickness?: number;
+    margin?: string | number;
+    label?: string | null;
+    alignment?: "left" | "center" | "right";
+}
+export declare const Separator: React.FC<SeparatorProps>;
+interface FieldSeparatorProps {
+    field: {
+        color?: string;
+        thickness?: number;
+        margin?: string | number;
+        label?: string;
+        alignment?: "left" | "center" | "right";
+    };
+    t: (text: string) => string;
+}
+declare const FieldSeparator: React.FC<FieldSeparatorProps>;
+export default FieldSeparator;

package/dist/components/fields/SliderInput.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+/**
+ * SliderInput component
+ *
+ * A reusable UI component that displays a range slider with a linked numeric input.
+ * Designed for numeric fields defined in a JSON schema, this component supports:
+ * - Validation (min/max, required, and custom rules)
+ * - Real-time synchronization between slider and text input
+ * - Tooltip display on hover
+ * - Integration with ReactaForm context (for styling, translation, and validation)
+ *
+ * Props:
+ * - field: DefinitionPropertyField
+ *   - Required: min, max
+ *   - Optional: tooltip
+ * - value: current numeric value
+ * - onChange: callback triggered with new value and optional error string
+ */
+type SliderInputProps = BaseInputProps<string | number, DefinitionPropertyField>;
+declare const SliderInput: React.FC<SliderInputProps>;
+export default SliderInput;

package/dist/components/fields/SpinInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type SpinInputProps = BaseInputProps<number, DefinitionPropertyField>;
+declare const SpinInput: React.FC<SpinInputProps>;
+export default SpinInput;

package/dist/components/fields/SwitchInput.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type SwitchInputProps = BaseInputProps<boolean, DefinitionPropertyField>;
+/**
+ * SwitchInput
+ *
+ * Renders a toggle switch UI for boolean values.
+ * - Clicking anywhere on the container toggles the switch.
+ * - Visual toggle with sliding knob and background color changes.
+ * - Displays label and optional tooltip.
+ */
+export declare const SwitchInput: React.FC<SwitchInputProps>;
+export default SwitchInput;

package/dist/components/fields/TextInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type TextInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const TextInput: React.FC<TextInputProps>;
+export default TextInput;

package/dist/components/fields/TimeInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type TimeInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const TimeInput: React.FC<TimeInputProps>;
+export default TimeInput;

package/dist/components/fields/UnitValueInput.d.ts

@@ -0,0 +1,5 @@
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+type UnitValueInputProps = BaseInputProps<[string | number, string], DefinitionPropertyField>;
+declare function UnitValueInput({ field, value, onChange }: UnitValueInputProps): import("react/jsx-runtime").JSX.Element | null;
+export default UnitValueInput;

package/dist/components/fields/UrlInput.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+/**
+ * UrlInput component
+ *
+ * This component provides a controlled input field for URL values.
+ * It validates required fields, URL format, and integrates with Reacta form context.
+ *
+ * Props:
+ * - field: Field metadata (name, displayName, tooltip, validation rules).
+ * - value: Current URL string.
+ * - onChange: Callback called with (value, error).
+ *
+ * Features:
+ * - Validates using a robust URL regex and `URL` constructor fallback.
+ * - Supports tooltip, localization, and inline validation errors.
+ */
+export type UrlInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const UrlInput: React.FC<UrlInputProps>;
+export default UrlInput;

package/dist/components/renderFields.d.ts

@@ -0,0 +1,4 @@
+import type { DefinitionPropertyField, FieldValueType, ErrorType } from "../core/reactaFormTypes";
+import type { JSX } from "react/jsx-runtime";
+export declare const renderFields: (fields: DefinitionPropertyField[], valuesMap: Record<string, FieldValueType>, handleChange: (fieldName: string, value: FieldValueType, error: ErrorType) => void, visibility: Record<string, boolean>, loadedCount: number, handleError?: (fieldName: string, error: ErrorType) => void) => (JSX.Element | null)[];
+export declare const renderFieldsWithGroups: (groupState: Record<string, boolean>, fields: DefinitionPropertyField[], valuesMap: Record<string, FieldValueType>, t: (key: string) => string, handleChange: (fieldName: string, value: FieldValueType, error: ErrorType) => void, handleError: (fieldName: string, error: ErrorType) => void, visibility: Record<string, boolean>, loadedCount: number, toggleGroup: (groupName: string) => void) => JSX.Element[];

package/dist/core/fieldVisibility.d.ts

@@ -0,0 +1,25 @@
+import type { DefinitionPropertyField, FieldValueType } from "./reactaFormTypes";
+/**
+ * Initializes the visibility map for all fields by setting them to `false`.
+ */
+export declare const initializeVisibility: (fields: DefinitionPropertyField[]) => Record<string, boolean>;
+/**
+ * Creates a lookup map for faster field access during visibility calculations
+ */
+export declare const createFieldMap: (fields: DefinitionPropertyField[]) => Record<string, DefinitionPropertyField>;
+/**
+ * Updates visibility map based on current field values and parent-child relationships
+ */
+export declare const updateVisibilityMap: (fields: DefinitionPropertyField[], values: Record<string, FieldValueType>, oldVisibility: Record<string, boolean>, fieldMapRef: Record<string, DefinitionPropertyField>) => Record<string, boolean>;
+/**
+ * Updates visibility when a specific field value changes
+ */
+export declare const updateVisibilityBasedOnSelection: (visibility: Record<string, boolean>, fieldMap: Record<string, DefinitionPropertyField>, valuesMap: Record<string, FieldValueType>, fieldName: string, value: FieldValueType) => Record<string, boolean>;
+/**
+ * Checks if a field should be visible based on its parent relationships
+ */
+export declare const isFieldVisible: (fieldName: string, fieldMap: Record<string, DefinitionPropertyField>, values: Record<string, FieldValueType>) => boolean;
+/**
+ * Gets all visible fields efficiently
+ */
+export declare const getVisibleFields: (fields: DefinitionPropertyField[], values: Record<string, FieldValueType>) => DefinitionPropertyField[];

package/dist/core/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./reactaFormTypes";
+export * from "./validation";
+export * from "./submitForm";
+export * from "./fieldVisibility";
+export * from "./reactaFormModel";
+export * from "./registries";
+import * as registries from "./registries";
+import * as validation from "./validation";
+import * as submitForm from "./submitForm";
+import * as fieldVisibility from "./fieldVisibility";
+import * as reactaFormModel from "./reactaFormModel";
+declare const _default: {
+    registries: typeof registries;
+    validation: typeof validation;
+    submitForm: typeof submitForm;
+    fieldVisibility: typeof fieldVisibility;
+    reactaFormModel: typeof reactaFormModel;
+};
+export default _default;

package/dist/core/reactaFormModel.d.ts

@@ -0,0 +1,38 @@
+import type { ReactaDefinition, ReactaInstance } from "./reactaFormTypes";
+export interface LoadDefinitionOptions {
+    validateSchema?: boolean;
+}
+export interface DefinitionLoadResult {
+    success: boolean;
+    definition?: ReactaDefinition;
+    error?: string;
+}
+/**
+ * Validates that a definition object has the required structure
+ */
+export declare function validateDefinitionSchema(definition: ReactaDefinition): string | null;
+/**
+ * Load definition from a JSON string. This intentionally does not perform any file I/O.
+ */
+export declare function loadJsonDefinition(jsonData: string, options?: LoadDefinitionOptions): Promise<DefinitionLoadResult>;
+/**
+ * Create instance from definition with validation and error handling
+ */
+export declare function createInstanceFromDefinition(definition: ReactaDefinition, name: string): {
+    success: boolean;
+    instance?: ReactaInstance;
+    error?: string;
+};
+/**
+ * Load instance data with validation
+ */
+export declare function loadInstance(instanceData: string | Record<string, unknown>): {
+    success: boolean;
+    instance?: ReactaInstance;
+    error?: string;
+};
+export declare function upgradeInstanceToLatestDefinition(instance: ReactaInstance, latestDefinition: ReactaDefinition, callback?: (oldInstance: ReactaInstance, newInstance: Record<string, unknown>, latestDefinition: ReactaDefinition) => void): {
+    success: boolean;
+    upgradedInstance?: Record<string, unknown>;
+    error?: string;
+};

package/dist/core/reactaFormTypes.d.ts

@@ -0,0 +1,137 @@
+import type { ReactNode } from 'react';
+type Integer = number;
+type Float = number;
+export type FieldValueType = boolean | Integer | Float | string | Integer[] | Float[] | string[] | [number, string] | File | File[];
+export type ErrorType = string | null;
+export type ParentField = Record<string, string[] | Integer[] | boolean[]>;
+export interface DefinitionPropertyField {
+    name: string;
+    displayName: string;
+    type: string;
+    defaultValue: FieldValueType;
+    required?: boolean;
+    parents?: ParentField;
+    children?: Record<string, string[]>;
+    group?: string;
+    tooltip?: string;
+    labelLayout?: 'row' | 'column-left' | 'column-center';
+    validationHandlerName?: string;
+    dimension?: string;
+    defaultUnit?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    minInclusive?: boolean;
+    maxInclusive?: boolean;
+    step?: number;
+    minCount?: number;
+    maxCount?: number;
+    minDate?: string;
+    maxDate?: string;
+    includeSeconds?: boolean;
+    layout?: 'horizontal' | 'vertical' | 'row' | 'column';
+    alignment?: 'left' | 'center' | 'right';
+    width?: number;
+    height?: number;
+    localized?: string;
+    minHeight?: string;
+    accept?: string;
+    multiple?: boolean;
+}
+export interface ReactaDefinition {
+    name: string;
+    version: string;
+    displayName: string;
+    localization?: string;
+    properties: DefinitionPropertyField[];
+    validationHandlerName?: string;
+    submitHandlerName?: string;
+}
+export interface ReactaInstance {
+    name: string;
+    definition: string;
+    version: string;
+    values: Record<string, FieldValueType>;
+}
+export interface ReactaFormProps {
+    definitionData: string | Record<string, unknown>;
+    language?: string;
+    instance?: ReactaInstance;
+    className?: string;
+    darkMode?: boolean;
+    style?: React.CSSProperties;
+}
+export type FieldValidationHandler = (value: FieldValueType | unknown, t: (defaultText: string, ...args: unknown[]) => string) => string | undefined;
+export type FormValidationHandler = (valuesMap: Record<string, FieldValueType | unknown>, t: (key: string, ...args: unknown[]) => string) => string[] | undefined;
+export type FormSubmissionHandler = (definition: ReactaDefinition | Record<string, unknown>, instanceName: string | null, valuesMap: Record<string, FieldValueType | unknown>, t: (defaultText: string, ...args: unknown[]) => string) => string[] | undefined;
+export type InputOnChange<T> = (value: T | string, error: string | null) => void;
+export interface BaseInputProps<TValue = unknown, TField extends DefinitionPropertyField = DefinitionPropertyField> {
+    field: TField;
+    value: TValue;
+    placeholder?: string;
+    onChange?: InputOnChange<TValue>;
+    onError?: (error: string | null) => void;
+}
+export type ReactaFormContextType = {
+    definitionName: string;
+    language: string;
+    darkMode: boolean;
+    formStyle: {
+        container?: React.CSSProperties;
+        titleStyle?: React.CSSProperties;
+    };
+    fieldStyle: Record<string, unknown>;
+    t: (defaultText: string, ...args: unknown[]) => string;
+};
+export type ReactaFormProviderProps = {
+    children: ReactNode;
+    defaultDefinitionName?: string;
+    defaultStyle?: Record<string, unknown>;
+    defaultLanguage?: string;
+    defaultDarkMode?: boolean;
+    defaultLocalizeName?: string;
+    className?: string;
+};
+export type TranslationMap = Record<string, string>;
+export type TranslationCache = Map<string, TranslationMap>;
+export interface RegistryResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export interface FieldGroup {
+    name: string;
+    displayName: string;
+    description?: string;
+    collapsed?: boolean;
+    order?: number;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+export type FormEventType = 'init' | 'change' | 'validate' | 'submit' | 'reset';
+export interface FormEvent {
+    type: FormEventType;
+    timestamp: Date;
+    data?: unknown;
+}
+export interface EnhancedDefinitionPropertyField extends DefinitionPropertyField {
+    category?: string;
+    tags?: string[];
+    dependencies?: string[];
+    conditional?: {
+        field: string;
+        value: unknown;
+        operator?: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than';
+    };
+}
+export {};

package/dist/core/registries/baseRegistry.d.ts

@@ -0,0 +1,15 @@
+export declare class BaseRegistry<T> {
+    private map;
+    register(name: string, value: T): void;
+    get(name: string): T | undefined;
+    has(name: string): boolean;
+    list(): string[];
+    entries(): [string, T][];
+    values(): T[];
+    size(): number;
+    unregister(name: string): boolean;
+    clear(): void;
+    registerAll(entries: Record<string, T> | [string, T][]): void;
+    getOrDefault(name: string, defaultValue: T): T;
+}
+export default BaseRegistry;

package/dist/core/registries/componentRegistry.d.ts

@@ -0,0 +1,9 @@
+import BaseRegistry from "./baseRegistry";
+import React from "react";
+type ComponentType = React.ComponentType<any>;
+declare const registry: BaseRegistry<ComponentType>;
+export declare function registerComponent(type: string, component: ComponentType): void;
+export declare function getComponent(type: string): ComponentType | undefined;
+export declare function listComponents(): string[];
+export declare function registerBaseComponents(): void;
+export default registry;

package/dist/core/registries/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./componentRegistry";
+export * from "./submissionHandlerRegistry";
+export * from "./validationHandlerRegistry";
+export * from "./baseRegistry";
+export { default as componentRegistry } from "./componentRegistry";
+export { default as submissionRegistry } from "./submissionHandlerRegistry";
+export { default as validatorRegistry } from "./validationHandlerRegistry";

package/dist/core/registries/submissionHandlerRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { FormSubmissionHandler } from "../reactaFormTypes";
+import BaseRegistry from "./baseRegistry";
+declare const registry: BaseRegistry<FormSubmissionHandler>;
+export declare function registerSubmissionHandler(submitterName: string, fn: FormSubmissionHandler): void;
+export declare function getFormSubmissionHandler(submitterName: string): FormSubmissionHandler | undefined;
+export default registry;

package/dist/core/registries/validationHandlerRegistry.d.ts

@@ -0,0 +1,16 @@
+import type { FieldValidationHandler, FormValidationHandler } from "../reactaFormTypes";
+export declare function registerFormValidationHandler(name: string, fn: FormValidationHandler): void;
+export declare function registerFieldValidationHandler(category: string, name: string, fn: FieldValidationHandler): void;
+export declare function getFieldValidationHandler(category: string, name: string): FieldValidationHandler | null;
+export declare function getFormValidationHandler(name: string): FormValidationHandler | null;
+export declare function listFieldValidationHandlers(category?: string): string[];
+export declare function listFormValidationHandlers(): string[];
+declare const _default: {
+    registerFormValidationHandler: typeof registerFormValidationHandler;
+    registerFieldValidationHandler: typeof registerFieldValidationHandler;
+    getFieldValidationHandler: typeof getFieldValidationHandler;
+    getFormValidationHandler: typeof getFormValidationHandler;
+    listFieldValidationHandlers: typeof listFieldValidationHandlers;
+    listFormValidationHandlers: typeof listFormValidationHandlers;
+};
+export default _default;

package/dist/core/submitForm.d.ts

@@ -0,0 +1,12 @@
+import type { ReactaDefinition, FieldValueType, ReactaInstance } from "./reactaFormTypes";
+export interface SubmitResult {
+    success: boolean;
+    message: string;
+    data?: Record<string, unknown>;
+    errors?: string[];
+}
+export declare function submitForm(definition: ReactaDefinition, instance: ReactaInstance | null, valuesMap: Record<string, FieldValueType | unknown>, t: (key: string) => string, errors: Record<string, string>): SubmitResult;
+declare const _default: {
+    submitForm: typeof submitForm;
+};
+export default _default;

package/dist/core/validation.d.ts

@@ -0,0 +1,10 @@
+import type { ReactaDefinition, FieldValueType, DefinitionPropertyField } from "./reactaFormTypes";
+export declare function validateFieldValue(definitionName: string, field: Partial<DefinitionPropertyField>, value: FieldValueType | unknown, t: (key: string) => string): string | null;
+export declare function validateFormValues(definition: ReactaDefinition | null, valuesMap: Record<string, FieldValueType | unknown>, t: (key: string) => string): string[] | null;
+export declare function clearValidationCache(): void;
+declare const _default: {
+    validateFieldValue: typeof validateFieldValue;
+    validateFormValues: typeof validateFormValues;
+    clearValidationCache: typeof clearValidationCache;
+};
+export default _default;

package/dist/hooks/useDebouncedCallback.d.ts

@@ -0,0 +1,25 @@
+export type DebouncedCallback = {
+    callback: (...args: unknown[]) => void;
+    cancel: () => void;
+    flush: () => void;
+};
+/**
+ * useDebouncedCallback
+ * - callback: function to call
+ * - wait: debounce delay in ms
+ * - options.leading: if true, call on leading edge (optional)
+ *
+ * Returns { callback, cancel, flush } where callback is debounced.
+ */
+export declare function useDebouncedCallback(callback: (...args: unknown[]) => unknown, wait?: number, options?: {
+    leading?: boolean;
+}): DebouncedCallback;
+/**
+ * createDebouncedCallback - non-hook variant that returns the same API but
+ * doesn't use React hooks. Useful for creating many debounced callbacks
+ * programmatically (e.g., driven from a static schema) while handling
+ * lifecycle cleanup manually.
+ */
+export declare function createDebouncedCallback(callback: (...args: unknown[]) => unknown, wait?: number, options?: {
+    leading?: boolean;
+}): DebouncedCallback;

package/dist/hooks/useReactaFormContext.d.ts

@@ -0,0 +1,4 @@
+import type { ReactaFormContextType } from '../core/reactaFormTypes';
+export declare const ReactaFormContext: import("react").Context<ReactaFormContextType | undefined>;
+declare const useReactaFormContext: () => ReactaFormContextType;
+export default useReactaFormContext;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { default as ReactaForm } from './components/ReactaForm';
+export { default as ReactaFormRenderer } from './components/ReactaFormRenderer';
+export type { ReactaFormRendererProps } from './components/ReactaFormRenderer';
+export { ReactaFormProvider } from './components/ReactaFormProvider';
+export { default as useReactaFormContext } from './hooks/useReactaFormContext';
+export type { ReactaFormContextType, ReactaFormProviderProps, DefinitionPropertyField, ReactaDefinition, ReactaInstance, ReactaFormProps, FieldValueType, ErrorType, FieldValidationHandler, FormValidationHandler, FormSubmissionHandler, InputOnChange, BaseInputProps } from './core/reactaFormTypes';
+export { registerComponent, getComponent, } from './core/registries/componentRegistry';
+export { validateFieldValue, validateFormValues } from './core/validation';
+export { loadJsonDefinition, createInstanceFromDefinition, // Create new instance with default values
+loadInstance } from './core/reactaFormModel';
+export { registerSubmissionHandler, } from './core/registries/submissionHandlerRegistry';
+export { registerFieldValidationHandler, registerFormValidationHandler, } from './core/registries/validationHandlerRegistry';
+export { useDebouncedCallback } from './hooks/useDebouncedCallback';
+export * as Units from './utils/unitValueMapper';
+export { serializeInstance, deserializeInstance, serializeDefinition, deserializeDefinition } from './utils/definitionSerializers';