extended-dynamic-forms 0.1.14 → 0.1.17

package/dist/ExtendedForm.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { ExtendedFormProps } from './types';
 
-export declare const ExtendedForm: React.FC<ExtendedFormProps>;
+export declare const ExtendedForm: React.ForwardRefExoticComponent<Omit<ExtendedFormProps, "ref"> & React.RefAttributes<any>>;

package/dist/WizardForm.d.ts

@@ -0,0 +1,26 @@
+import { WebhookConfig } from './types';
+
+export interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+}
+export interface WizardFormProps {
+    schema: any;
+    uiSchema: any;
+    conditions?: any[];
+    webhooks?: WebhookConfig[];
+    formData?: any;
+    onSubmit?: (data: any) => void;
+    onStepChange?: (step: number, data: any) => void;
+    onFieldFocus?: (event: any) => void;
+    onFieldBlur?: (event: any) => void;
+    onFieldChange?: (event: any) => void;
+    showProgressBar?: boolean;
+    showStepDescription?: boolean;
+    submitButtonText?: string;
+    liveValidate?: boolean;
+    showErrorList?: boolean;
+}
+export declare function WizardForm({ schema, uiSchema, conditions, // JSON Rules Engine format conditions
+webhooks, formData: initialFormData, onSubmit, onStepChange, onFieldFocus, onFieldBlur, onFieldChange, showProgressBar, showStepDescription, submitButtonText, liveValidate, showErrorList, }: WizardFormProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,4 +1,3 @@
-import { default as React } from 'react';
 import { FieldProps } from '@rjsf/utils';
 
 export declare const AddressField: React.FC<FieldProps>;

package/dist/components/index.d.ts

@@ -2,6 +2,9 @@ import { AddressField } from './fields/AddressField';
 import { PhoneField } from './fields/PhoneField';
 import { CurrencyField } from './fields/CurrencyField';
 import { ArrayFieldTemplate, ArrayFieldItemTemplate } from './arrays';
+import { WizardObjectFieldTemplate, WizardSectionTemplate } from '../layouts/wizard';
+import { SubmitButton } from './templates/SubmitButton';
+import { FieldTemplate } from './templates/FieldTemplate';
 
 export declare const customFields: {
     address: import('react').FC<import('@rjsf/utils').FieldProps<any, import('@rjsf/utils').RJSFSchema, any>>;
@@ -9,7 +12,13 @@ export declare const customFields: {
     currency: import('react').FC<import('@rjsf/utils').FieldProps<any, import('@rjsf/utils').RJSFSchema, any>>;
 };
 export declare const customTemplates: {
+    FieldTemplate: import('react').FC<import('@rjsf/utils').FieldTemplateProps>;
     ArrayFieldTemplate: (props: import('@rjsf/utils').ArrayFieldTemplateProps) => import("react/jsx-runtime").JSX.Element;
     ArrayFieldItemTemplate: (props: import('@rjsf/utils').ArrayFieldItemTemplateType) => import("react/jsx-runtime").JSX.Element;
+    WizardObjectFieldTemplate: import('react').FC<import('@rjsf/utils').ObjectFieldTemplateProps>;
+    WizardSectionTemplate: import('react').FC<import('../layouts/wizard/WizardSectionTemplate').WizardSectionTemplateProps>;
+    ButtonTemplates: {
+        SubmitButton: import('react').FC<import('@rjsf/utils').SubmitButtonProps>;
+    };
 };
-export { AddressField, PhoneField, CurrencyField, ArrayFieldTemplate, ArrayFieldItemTemplate, };
+export { AddressField, PhoneField, CurrencyField, FieldTemplate, ArrayFieldTemplate, ArrayFieldItemTemplate, WizardObjectFieldTemplate, WizardSectionTemplate, SubmitButton, };

package/dist/components/templates/FieldTemplate.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { FieldTemplateProps } from '@rjsf/utils';
+
+export declare const FieldTemplate: React.FC<FieldTemplateProps>;

package/dist/components/templates/SubmitButton.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { SubmitButtonProps } from '@rjsf/utils';
+
+export declare const SubmitButton: React.FC<SubmitButtonProps>;

package/dist/components/templates/index.d.ts

@@ -0,0 +1,2 @@
+export { FieldTemplate } from './FieldTemplate';
+export { SubmitButton } from './SubmitButton';

package/dist/conditionals/ConditionalActions.d.ts

@@ -0,0 +1,13 @@
+import { ConditionalAction, ConditionalActions } from '../types';
+
+declare const remove: ConditionalAction;
+declare const require: ConditionalAction;
+declare const uiAppend: ConditionalAction;
+declare const uiOverride: ConditionalAction;
+declare const uiReplace: ConditionalAction;
+declare const enable: ConditionalAction;
+declare const disable: ConditionalAction;
+declare const optional: ConditionalAction;
+declare const show: ConditionalAction;
+export declare const defaultActions: ConditionalActions;
+export { remove, require, uiAppend, uiOverride, uiReplace, enable, disable, optional, show, };

package/dist/conditionals/ConditionalContext.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { ConditionalRule, ConditionalConfig, ConditionalState } from '../types';
+import { DynamicArrayConditionalEngine } from './DynamicArrayConditionalEngine';
+
+interface ConditionalContextType {
+    state: ConditionalState;
+    processor: DynamicArrayConditionalEngine | null;
+    processConditionals: (formData: any) => Promise<void>;
+    updateRules: (rules: ConditionalRule[]) => void;
+    addAction: (actionType: string, actionFunction: any) => void;
+    removeAction: (actionType: string) => void;
+    getAvailableActions: () => string[];
+}
+export interface ConditionalProviderProps {
+    children: React.ReactNode;
+    schema: RJSFSchema;
+    uiSchema?: UiSchema;
+    config?: ConditionalConfig;
+    onSchemaChange?: (schemas: {
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+    }) => void;
+}
+export declare const ConditionalProvider: React.FC<ConditionalProviderProps>;
+export declare const useConditionals: () => ConditionalContextType;
+export declare const useConditionalSchema: () => {
+    schema: RJSFSchema;
+    uiSchema: UiSchema;
+    isProcessing: boolean;
+};
+export {};

package/dist/conditionals/DynamicArrayConditionalEngine.d.ts

@@ -0,0 +1,77 @@
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { ConditionalRule, ConditionalEvent, ConditionalActions, ConditionalEngineInstance } from '../types';
+
+export declare class DynamicArrayConditionalEngine implements ConditionalEngineInstance {
+    private originalRules;
+    private engine;
+    private expandedRules;
+    constructor(rules: ConditionalRule[], schema: RJSFSchema, uiSchema?: UiSchema, extraActions?: ConditionalActions);
+    /**
+     * Expand array patterns like directors[*] based on actual form data
+     */
+    expandArrayPatterns(rules: ConditionalRule[], formData: any): ConditionalRule[];
+    /**
+     * Check if a rule contains array patterns like [*]
+     */
+    private hasArrayPatterns;
+    /**
+     * Expand a single rule that contains array patterns
+     */
+    private expandSingleRule;
+    /**
+     * Find all array patterns like "directors[*]" in a rule
+     */
+    private findArrayPatterns;
+    /**
+     * Expand a rule for a specific array index
+     */
+    private expandRuleForIndex;
+    /**
+     * Get nested value from object using dot notation
+     */
+    private getNestedValue;
+    /**
+     * Pre-process uiSchema to ensure array items have proper template structure
+     */
+    private preprocessUiSchemaForArrays;
+    /**
+     * Main processing method - implement ConditionalEngineInstance interface
+     */
+    processFormData(formData: any): Promise<{
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+        formData: any;
+    }>;
+    /**
+     * Get the original unexpanded rules
+     */
+    getOriginalRules(): ConditionalRule[];
+    /**
+     * Get the current expanded rules
+     */
+    getCurrentRules(): ConditionalRule[];
+    /**
+     * Manually set rules (useful for testing)
+     */
+    setRules(rules: ConditionalRule[]): void;
+    /**
+     * Add a rule to the engine (implement ConditionalEngineInstance interface)
+     */
+    addRule(rule: ConditionalRule): void;
+    /**
+     * Run the conditional engine and return events (implement ConditionalEngineInstance interface)
+     */
+    run(formData: any): Promise<ConditionalEvent[]>;
+    /**
+     * Add an action to the engine (for ConditionalContext compatibility)
+     */
+    addAction(actionType: string, actionFunction: any): void;
+    /**
+     * Remove an action from the engine (for ConditionalContext compatibility)
+     */
+    removeAction(actionType: string): void;
+    /**
+     * Get available actions (for ConditionalContext compatibility)
+     */
+    getAvailableActions(): string[];
+}

package/dist/conditionals/SimpleConditionalEngine.d.ts

@@ -0,0 +1,41 @@
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { ConditionalRule, ConditionalEvent, ConditionalActions, ConditionalEngineInstance } from '../types';
+
+export declare class SimpleConditionalEngine implements ConditionalEngineInstance {
+    private rules;
+    private actions;
+    private originalSchema;
+    private originalUiSchema;
+    constructor(rules: ConditionalRule[], schema: RJSFSchema, uiSchema?: UiSchema, extraActions?: ConditionalActions);
+    /**
+     * Get nested value from object using dot notation with array index support
+     */
+    private getNestedValue;
+    /**
+     * Evaluate a single condition against form data
+     */
+    private evaluateCondition;
+    /**
+     * Evaluate field-level condition
+     */
+    private evaluateFieldCondition;
+    addRule(rule: ConditionalRule): void;
+    run(formData: any): Promise<ConditionalEvent[]>;
+    processEvents(events: ConditionalEvent[], schema: RJSFSchema, uiSchema: UiSchema, formData: any): {
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+    };
+    processFormData(formData: any): Promise<{
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+        formData: any;
+    }>;
+    runAndProcess(formData: any, schema: RJSFSchema, uiSchema: UiSchema): Promise<{
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+        events: ConditionalEvent[];
+    }>;
+    getAvailableActions(): string[];
+    addAction(actionType: string, actionFunction: any): void;
+    removeAction(actionType: string): void;
+}

package/dist/conditionals/SmartJsonRulesTransformer.d.ts

@@ -0,0 +1,10 @@
+import { ConditionalRule } from '../types';
+
+/**
+ * Smart transformation of JSON Rules Engine rules to internal format
+ *
+ * Handles show/hide pairs intelligently by converting them to single remove rules
+ * Also handles rules that are already in internal format
+ */
+export declare function smartTransformJsonRulesEngine(rules: any[]): ConditionalRule[];
+export { smartTransformJsonRulesEngine as transformJsonRulesEngine };

package/dist/conditionals/index.d.ts

@@ -1,4 +1,7 @@
-export { ConditionalForm } from './ConditionalForm';
-export * from './types';
-export * from './utils';
-export * from './initialStateUtils';
+export { SimpleConditionalEngine as ConditionalProcessor } from './SimpleConditionalEngine';
+export { SimpleConditionalEngine } from './SimpleConditionalEngine';
+export { DynamicArrayConditionalEngine } from './DynamicArrayConditionalEngine';
+export { defaultActions, remove, require, uiAppend, uiOverride, uiReplace, enable, disable, optional, show, } from './ConditionalActions';
+export { smartTransformJsonRulesEngine as transformJsonRulesEngine } from './SmartJsonRulesTransformer';
+export { smartTransformJsonRulesEngine } from './SmartJsonRulesTransformer';
+export { default as Engine } from 'json-rules-engine-simplified';

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
 export { FormEventManager } from './FormEventManager';
 export { FormEventHub } from './FormEventHub';
-export { FormEventProvider, useFormEventHub, useFieldEventHandlers } from './FormEventContext';
-export type { FormEventHandlers, FieldEventHandlers, FormFieldEvent, WebhookConfig } from '../types';
+export { FormEventProvider, useFormEventHub, useFieldEventHandlers, } from './FormEventContext';
+export type { FormEventHandlers, FieldEventHandlers, FormFieldEvent, WebhookConfig, } from '../types';

package/dist/index.d.ts

@@ -3,13 +3,12 @@ export * from './components';
 export * from './widgets';
 export * from './layouts';
 export * from './events';
+export * from './conditionals';
 export * from './types';
 export * from './utils';
-export * from './lib/utils';
 export type { FormProps, IChangeEvent } from '@rjsf/core';
-export type { RJSFSchema, UiSchema, WidgetProps, FieldProps, ArrayFieldTemplateProps, ObjectFieldTemplateProps, FieldTemplateProps, ErrorSchema, RJSFValidationError } from '@rjsf/utils';
+export type { RJSFSchema, UiSchema, WidgetProps, FieldProps, ArrayFieldTemplateProps, ObjectFieldTemplateProps, FieldTemplateProps, ErrorSchema, RJSFValidationError, } from '@rjsf/utils';
 export { default as validator } from '@rjsf/validator-ajv8';
-export { generateTheme } from '@rjsf/shadcn';
 export { ExtendedForm } from './ExtendedForm';
-export { ConditionalForm } from './conditionals';
-export type { ConditionalFormProps, ConditionalRule, FieldCondition, ConditionalState } from './conditionals/types';
+export { WizardForm } from './WizardForm';
+export type { WizardFormProps, WizardStep } from './WizardForm';