reactaform 1.4.4 → 1.8.0

package/dist/core/pluginRegistry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Enhanced Plugin Registry for ReactaForm
+ * Tracks installed plugins, components, validators, submission handlers
+ * Handles conflicts with customizable strategy
+ */
+import type { FieldValidationHandler, FormValidationHandler, FormSubmissionHandler } from './reactaFormTypes';
+/** Conflict resolution strategies */
+export type ConflictResolution = 'error' | 'warn' | 'override' | 'skip';
+/** Plugin registration options */
+export interface PluginRegistrationOptions {
+    conflictResolution?: ConflictResolution;
+    onConflict?: (conflict: PluginConflict) => boolean;
+}
+/** Plugin conflict information */
+export interface PluginConflict {
+    type: 'component' | 'fieldValidator' | 'formValidator' | 'submissionHandler' | 'plugin';
+    name: string;
+    existingPlugin: string;
+    newPlugin: string;
+}
+/** ReactaForm plugin definition */
+export interface ReactaFormPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    components?: Record<string, React.ComponentType<unknown>>;
+    fieldValidators?: Record<string, Record<string, FieldValidationHandler>>;
+    formValidators?: Record<string, FormValidationHandler>;
+    submissionHandlers?: Record<string, FormSubmissionHandler>;
+    setup?: () => void;
+    cleanup?: () => void;
+}
+/** Register a plugin */
+export declare function registerPlugin(plugin: ReactaFormPlugin, options?: PluginRegistrationOptions): void;
+/** Unregister plugin */
+export declare function unregisterPlugin(pluginName: string, removeRegistrations?: boolean): boolean;
+/** Get a plugin by name */
+export declare function getPlugin(pluginName: string): ReactaFormPlugin | undefined;
+/** Get all installed plugins */
+export declare function getAllPlugins(): ReactaFormPlugin[];
+/** Check if plugin is registered */
+export declare function hasPlugin(pluginName: string): boolean;
+/** Helper to register multiple components at once */
+export declare function registerComponents(components: Record<string, React.ComponentType<unknown>>): void;

package/dist/core/reactaFormModel.d.ts

@@ -0,0 +1,31 @@
+import type { ReactaDefinition, ReactaInstance } from "./reactaFormTypes";
+export interface LoadDefinitionOptions {
+    validateSchema?: boolean;
+}
+export interface DefinitionLoadResult {
+    success: boolean;
+    definition?: ReactaDefinition;
+    error?: string;
+}
+export interface InstanceLoadResult {
+    success: boolean;
+    instance?: ReactaInstance;
+    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): InstanceLoadResult;
+/**
+ * Load instance data with validation
+ */
+export declare function loadInstance(instanceData: string | Record<string, unknown>): InstanceLoadResult;
+export declare function upgradeInstanceToLatestDefinition(oldInstance: ReactaInstance, latestDefinition: ReactaDefinition, callback?: (oldInstance: ReactaInstance, newInstance: Record<string, unknown>, latestDefinition: ReactaDefinition) => void): InstanceLoadResult;

package/dist/core/reactaFormTypes.d.ts

@@ -0,0 +1,141 @@
+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 type ValidationHandlerName = string | [string] | [string, string];
+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?: ValidationHandlerName;
+    dimension?: string;
+    defaultUnit?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    patternErrorMessage?: 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;
+    allowRelative?: 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;
+    theme?: string;
+    style?: React.CSSProperties;
+}
+export type TranslationFunction = (text: string, ...args: unknown[]) => string;
+export type FieldValidationHandler = (fieldName: string, value: FieldValueType | unknown, t: TranslationFunction) => string | undefined;
+export type FormValidationHandler = (valuesMap: Record<string, FieldValueType | unknown>, t: TranslationFunction) => string[] | undefined | Promise<string[] | undefined>;
+export type FormSubmissionHandler = (definition: ReactaDefinition | Record<string, unknown>, instanceName: string | null, valuesMap: Record<string, FieldValueType | unknown>, t: TranslationFunction) => string[] | undefined | Promise<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;
+    theme: string;
+    formStyle: {
+        container?: React.CSSProperties;
+        titleStyle?: React.CSSProperties;
+    };
+    fieldStyle: Record<string, unknown>;
+    t: TranslationFunction;
+};
+export type ReactaFormProviderProps = {
+    children: ReactNode;
+    definitionName?: string;
+    defaultStyle?: Record<string, unknown>;
+    defaultLanguage?: string;
+    defaultTheme?: string;
+    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/submissionHandlerRegistry.d.ts

@@ -0,0 +1,7 @@
+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 declare function getSubmissionHandler(submitterName: string): FormSubmissionHandler | undefined;
+export default registry;

package/dist/core/submitForm.d.ts

@@ -0,0 +1,9 @@
+import type { ReactaDefinition, FieldValueType, ReactaInstance, TranslationFunction } 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: TranslationFunction, errors: Record<string, string>): Promise<SubmitResult>;
+export default submitForm;

package/dist/hooks/useDebouncedCallback.d.ts

@@ -0,0 +1,27 @@
+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;
+    trailing?: 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;
+    trailing?: boolean;
+}): DebouncedCallback;

package/dist/hooks/useDropdownPosition.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function useDropdownPosition(controlRef: React.RefObject<HTMLElement | null>, open: boolean, baseWidth?: number, maxHeight?: number): {
+    left: number;
+    top: number;
+    width: number;
+} | null;

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/hooks/useUncontrolledValidatedInput.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export type UseUncontrolledValidatedInputProps = {
+    value?: string;
+    onChange?: (value: string, error: string | null) => void;
+    onError?: (error: string | null) => void;
+    validate: (value: string) => string | null;
+};
+/**
+ * Handles:
+ * - Uncontrolled input
+ * - Validation
+ * - Error sync
+ */
+export declare function useUncontrolledValidatedInput<T extends HTMLInputElement | HTMLTextAreaElement = HTMLInputElement>({ value, onChange, onError, validate, }: UseUncontrolledValidatedInputProps): {
+    inputRef: React.MutableRefObject<T | null>;
+    error: string | null;
+    handleChange: (e: React.ChangeEvent<T>) => void;
+};

package/dist/hooks/useUnitValueField.d.ts

@@ -0,0 +1,13 @@
+import type { DefinitionPropertyField } from "../core/reactaFormTypes";
+export declare function useUnitValueField(definitionName: string, field: DefinitionPropertyField, value: [string | number, string], unitFactors: {
+    default: string;
+    labels: Record<string, string>;
+    reverseLabels?: Record<string, string>;
+}, t: (key: string) => string, onChange?: (v: [string, string], err: string | null) => void, onError?: (err: string | null) => void): {
+    value: string;
+    unit: string;
+    error: string | null;
+    setValue: (v: string) => void;
+    setUnit: (u: string) => void;
+    setBoth: (v: string, u: string) => void;
+};

package/dist/index.d.ts

@@ -7,17 +7,20 @@ export { default as useReactaFormContext } from './hooks/useReactaFormContext';
 export { StandardFieldLayout } from './components/LayoutComponents';
 export { CSS_CLASSES, combineClasses } from './utils/cssClasses';
 export type { ReactaFormContextType, ReactaFormProviderProps, DefinitionPropertyField, ReactaDefinition, ReactaInstance, ReactaFormProps, FieldValueType, ErrorType, FieldValidationHandler, FormValidationHandler, FormSubmissionHandler, InputOnChange, BaseInputProps, TranslationFunction, } from './core/reactaFormTypes';
-export { registerComponent, getComponent, } from './core/registries/componentRegistry';
-export { validateFieldValue } from './core/validation';
-export { registerPlugin, unregisterPlugin, getPlugin, getAllPlugins, hasPlugin, registerComponents, } from './core/registries/pluginRegistry';
-export type { ReactaFormPlugin, ConflictResolution, PluginRegistrationOptions, PluginConflict, } from './core/registries/pluginRegistry';
+export { registerComponent, getComponent, } from './core/componentRegistry';
+export { validateFieldValue, // Deprecated, use validateFieldWithHandler instead
+validateFieldWithHandler } from './validation/validation';
+import './validation';
+export { registerPlugin, unregisterPlugin, getPlugin, getAllPlugins, hasPlugin, registerComponents, } from './core/pluginRegistry';
+export type { ReactaFormPlugin, ConflictResolution, PluginRegistrationOptions, PluginConflict, } from './core/pluginRegistry';
 export type { LoadDefinitionOptions, DefinitionLoadResult, InstanceLoadResult, } from './core/reactaFormModel';
 export { loadJsonDefinition, createInstanceFromDefinition, // Create new instance with default values
 loadInstance, // Load existing instance (valuesMap)
 upgradeInstanceToLatestDefinition } from './core/reactaFormModel';
-export { registerSubmissionHandler, } from './core/registries/submissionHandlerRegistry';
-export { registerFieldValidationHandler, registerFormValidationHandler, } from './core/registries/validationHandlerRegistry';
+export { registerSubmissionHandler, } from './core/submissionHandlerRegistry';
+export { registerFieldValidationHandler, registerFormValidationHandler, } from './validation/validationHandlerRegistry';
 export type { DebouncedCallback } from './hooks/useDebouncedCallback';
 export { useDebouncedCallback } from './hooks/useDebouncedCallback';
 export * as Units from './utils/unitValueMapper';
+export { isDarkTheme } from './utils/themeUtils';
 export { serializeInstance, deserializeInstance, serializeDefinition, deserializeDefinition } from './utils/definitionSerializers';