extended-dynamic-forms 0.1.20 → 0.1.22

package/README.md

@@ -66,13 +66,14 @@ const uiRules: UiRule[] = [{
 
 ### 🧙‍♂️ Multi-Step Wizard Forms 
 - Automatic step detection from schema structure
-- Step-aware conditional logic
+- **Full conditional logic support** with step-aware rule processing
 - Built-in progress indicators and navigation
 - Per-step validation
+- Supports both v1 conditions (deprecated) and v2 Three Pillars architecture
 
 **Step-Aware Conditional Logic**
 
-The `WizardForm` automatically scopes conditional logic to the current step. Use v2 `UiRule`s with field prefixes:
+The `WizardForm` automatically filters and transforms conditional rules to work within the current step's context. This means you can define conditions that reference fields across different steps, and the wizard will intelligently apply only the relevant rules for the active step:
 
 ```tsx
 // Define steps with prefixed field names to avoid collisions
@@ -161,6 +162,28 @@ const uiRules: UiRule[] = [{
 </html>
 ```
 
+**Important Notes on Conditional Logic in Vanilla JS:**
+- **Only v1 conditions are supported** - The Three Pillars v2 architecture requires React hooks
+- Use the `conditionals` prop with v1 format: `{ rules: [...] }`
+- Subject to v1's O(M×N) performance for array conditionals
+- For v2 benefits, use the React-based API instead
+
+```javascript
+// Vanilla JS supports only v1 conditionals
+ExtendedDynamicForms.createForm({
+  container: '#my-form',
+  schema: schema,
+  conditionals: {
+    rules: [
+      {
+        conditions: { showField: true },
+        event: { type: 'show', params: { field: 'conditionalField' } }
+      }
+    ]
+  }
+});
+```
+
 **Perfect for:**
 - WordPress/Drupal integrations
 - Legacy applications
@@ -524,7 +547,7 @@ const migrationReport = generateMigrationReport(v1Rules, {
 
 ### Simple Wizard Form (Recommended)
 
-The `WizardForm` component automatically detects multi-step forms and handles navigation. Use it with Three Pillars v2:
+The `WizardForm` component automatically detects multi-step forms and handles navigation. It fully supports conditional logic through either v1 conditions (deprecated) or the recommended Three Pillars v2 architecture:
 
 ```tsx
 import { useState } from 'react';
@@ -532,9 +555,22 @@ import { WizardForm } from 'extended-dynamic-forms';
 import { useConditionalUi, UiRule } from 'extended-dynamic-forms/conditionals/v2';
 import schema from './schema.json';
 import baseUiSchema from './ui-schema.json';
-import uiRules from './ui-rules'; // Your v2 UI rules
 import webhooks from './webhooks.json';
 
+// Example: v2 Three Pillars approach (recommended)
+const uiRules: UiRule[] = [
+  {
+    name: 'Show tax ID in company step when listed',
+    condition: (formData) => formData.STEP_COMPANY?.isListedCompany === true,
+    effect: [{ op: 'remove', path: '/STEP_COMPANY/taxId/ui:widget' }]
+  },
+  {
+    name: 'Show shareholding percentage for directors with shares',
+    condition: (formData) => formData.STEP_DIRECTORS?.directors?.some(d => d.hasShareholding),
+    effect: [{ op: 'remove', path: '/STEP_DIRECTORS/directors/items/shareholdingPercentage/ui:widget' }]
+  }
+];
+
 function App() {
   const [formData, setFormData] = useState({});
   const conditionalUiSchema = useConditionalUi(uiRules, baseUiSchema, formData);
@@ -550,6 +586,26 @@ function App() {
     />
   );
 }
+
+// Alternative: v1 conditions approach (deprecated but still supported)
+const v1Conditions = [
+  {
+    conditions: { "STEP_COMPANY.isListedCompany": true },
+    event: { type: "show", params: { field: "STEP_COMPANY.taxId" } }
+  },
+  {
+    conditions: { "STEP_DIRECTORS.directors[*].hasShareholding": true },
+    event: { type: "require", params: { field: "STEP_DIRECTORS.directors[*].shareholdingPercentage" } }
+  }
+];
+
+// Pass v1 conditions directly to WizardForm
+<WizardForm
+  schema={schema}
+  uiSchema={uiSchema}
+  conditions={v1Conditions}  // WizardForm handles step-aware transformation
+  onSubmit={(data) => console.log('Submitted:', data.formData)}
+/>
 ```
 
 ### Basic Form with Three Pillars v2

package/dist/ExtendedForm.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ExtendedFormProps } from './types';
+
+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/arrays/ArrayFieldItemTemplate.d.ts

@@ -0,0 +1,3 @@
+import { ArrayFieldItemTemplateType } from '@rjsf/utils';
+
+export declare const ArrayFieldItemTemplate: (props: ArrayFieldItemTemplateType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/arrays/ArrayFieldTemplate.d.ts

@@ -0,0 +1,3 @@
+import { ArrayFieldTemplateProps } from '@rjsf/utils';
+
+export declare const ArrayFieldTemplate: (props: ArrayFieldTemplateProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { ArrayFieldTemplate } from './ArrayFieldTemplate';
+export { ArrayFieldItemTemplate } from './ArrayFieldItemTemplate';

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

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

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

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

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

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

package/dist/components/index.d.ts

@@ -0,0 +1,24 @@
+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>>;
+    phone: import('react').FC<import('@rjsf/utils').FieldProps<any, import('@rjsf/utils').RJSFSchema, any>>;
+    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, 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

@@ -0,0 +1,7 @@
+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/conditionals/v2/createConditionalEngineHook.d.ts

@@ -0,0 +1,3 @@
+import { EngineConfig, ConditionalEngineHook } from './types';
+
+export declare function createConditionalEngineHook<T>(config: EngineConfig<T>): ConditionalEngineHook<T>;

package/dist/conditionals/v2/engines/schemaEngineConfig.d.ts

@@ -0,0 +1,4 @@
+import { EngineConfig, SchemaEffect } from '../types';
+import { RJSFSchema } from '@rjsf/utils';
+
+export declare const schemaEngineConfig: EngineConfig<SchemaEffect[], RJSFSchema>;

package/dist/conditionals/v2/engines/uiEngineConfig.d.ts

@@ -0,0 +1,4 @@
+import { EngineConfig, UiEffect } from '../types';
+import { UiSchema } from '@rjsf/utils';
+
+export declare const uiEngineConfig: EngineConfig<UiEffect[], UiSchema>;

package/dist/conditionals/v2/engines/validationEngineConfig.d.ts

@@ -0,0 +1,13 @@
+import { EngineConfig, ValidationEffect } from '../types';
+import { ErrorSchema } from '@rjsf/utils';
+
+export interface ValidationConfig {
+    rules: ValidationEffect[];
+}
+export declare const validationEngineConfig: EngineConfig<ValidationEffect, ValidationConfig>;
+/**
+ * Creates a custom validation function compatible with RJSF
+ * @param validationConfig The validation configuration containing active rules
+ * @returns A validation function that can be passed to RJSF's customValidate prop
+ */
+export declare function createCustomValidate(validationConfig: ValidationConfig): (formData: any, errors: ErrorSchema) => ErrorSchema;

package/dist/conditionals/v2/hooks/useConditionalSchema.d.ts

@@ -0,0 +1,4 @@
+import { Rule, SchemaEffect } from '../types';
+
+export declare const useConditionalSchema: import('..').ConditionalEngineHook<SchemaEffect[]>;
+export type SchemaRule = Rule<SchemaEffect[]>;

package/dist/conditionals/v2/hooks/useConditionalUi.d.ts

@@ -0,0 +1,4 @@
+import { Rule, UiEffect } from '../types';
+
+export declare const useConditionalUi: import('..').ConditionalEngineHook<UiEffect[]>;
+export type UiRule = Rule<UiEffect[]>;

package/dist/conditionals/v2/hooks/useConditionalValidation.d.ts

@@ -0,0 +1,4 @@
+import { Rule, ValidationEffect } from '../types';
+
+export declare const useConditionalValidation: import('..').ConditionalEngineHook<ValidationEffect>;
+export type ValidationRule = Rule<ValidationEffect>;

package/dist/conditionals/v2/index.d.ts

@@ -0,0 +1,10 @@
+export { createConditionalEngineHook } from './createConditionalEngineHook';
+export type { Rule, EngineConfig, ConditionalEngineHook, UiEffect, SchemaEffect, ValidationEffect, } from './types';
+export { useConditionalUi, type UiRule } from './hooks/useConditionalUi';
+export { useConditionalSchema, type SchemaRule, } from './hooks/useConditionalSchema';
+export { useConditionalValidation, type ValidationRule, } from './hooks/useConditionalValidation';
+export { createDynamicArrayItemsUiSchema, mergeItemUiSchema, arrayItemPatterns, type ArrayItemsFunction, type ArrayItemConditionalFn, } from './utils/dynamicArrayItems';
+export { uiEngineConfig } from './engines/uiEngineConfig';
+export { schemaEngineConfig } from './engines/schemaEngineConfig';
+export { validationEngineConfig, createCustomValidate, } from './engines/validationEngineConfig';
+export * from './migration';

package/dist/conditionals/v2/migration.d.ts

@@ -0,0 +1,76 @@
+import { UiRule } from './hooks/useConditionalUi';
+import { SchemaRule } from './hooks/useConditionalSchema';
+
+interface V1Rule {
+    conditions: Record<string, any>;
+    event: {
+        type: string;
+        params?: any;
+    };
+    order?: number;
+}
+interface JsonRulesEngineRule {
+    conditions: {
+        all?: JsonRulesEngineCondition[];
+        any?: JsonRulesEngineCondition[];
+    };
+    event: {
+        type: string;
+        params?: any;
+    };
+}
+interface JsonRulesEngineCondition {
+    fact: string;
+    operator: string;
+    value: any;
+    all?: JsonRulesEngineCondition[];
+    any?: JsonRulesEngineCondition[];
+}
+export interface MigrationReport {
+    totalRules: number;
+    migratedRules: number;
+    manualReviewRequired: Array<{
+        rule: any;
+        reason: string;
+        suggestion: string;
+    }>;
+    warnings: string[];
+}
+/**
+ * Analyzes v1 rules and suggests which pillar they belong to
+ */
+export declare function analyzeRules(rules: V1Rule[]): {
+    uiRules: V1Rule[];
+    schemaRules: V1Rule[];
+    validationRules: V1Rule[];
+    unknown: V1Rule[];
+};
+/**
+ * Migrates v1 rules to v2 UI rules
+ */
+export declare function migrateV1ToUiRules(rules: V1Rule[]): {
+    rules: UiRule[];
+    report: MigrationReport;
+};
+/**
+ * Migrates v1 rules to v2 Schema rules
+ */
+export declare function migrateV1ToSchemaRules(rules: V1Rule[]): {
+    rules: SchemaRule[];
+    report: MigrationReport;
+};
+/**
+ * Migrates JSON Rules Engine format to Three Pillars format
+ */
+export declare function migrateJsonRulesEngine(rules: JsonRulesEngineRule[]): {
+    uiRules: UiRule[];
+    report: MigrationReport;
+};
+/**
+ * Generates a comprehensive migration report
+ */
+export declare function generateMigrationReport(v1Rules: V1Rule[], options?: {
+    includeExamples?: boolean;
+    outputFormat?: 'markdown' | 'json';
+}): string;
+export {};

package/dist/conditionals/v2/types.d.ts

@@ -0,0 +1,37 @@
+import { ErrorSchema } from '@rjsf/utils';
+
+export interface Rule<T> {
+    name: string;
+    condition: (formData: any) => boolean;
+    effect: T;
+    order?: number;
+}
+export interface EngineConfig<T, C = any> {
+    applyEffects: (effects: T[], baseConfig: C, formData: any) => C;
+    defaultConfig: () => C;
+}
+export type ConditionalEngineHook<T, C = any> = (rules: Rule<T>[], baseConfig: C, formData: any) => C;
+export interface UiEffect {
+    op: 'add' | 'remove' | 'replace';
+    path: string;
+    value?: any;
+}
+export interface SchemaEffect {
+    op: 'add' | 'remove' | 'replace';
+    path: string;
+    value?: any;
+}
+export interface ValidationEffect {
+    /**
+     * Name of the validation rule for debugging purposes
+     */
+    name: string;
+    /**
+     * Determines if this validation should be applied based on current form data
+     */
+    isActive: (formData: any) => boolean;
+    /**
+     * Applies validation logic and adds errors to the ErrorSchema
+     */
+    validate: (errors: ErrorSchema, formData: any) => void;
+}

package/dist/conditionals/v2/utils/dynamicArrayItems.d.ts

@@ -0,0 +1,59 @@
+import { UiSchema } from '@rjsf/utils';
+
+/**
+ * Function type for dynamic uiSchema.items in RJSF fork
+ * This enables O(n) performance for array conditionals
+ */
+export type ArrayItemsFunction = (itemData: any, index: number, formContext?: any) => UiSchema;
+/**
+ * Function type for conditional logic applied to array items
+ */
+export type ArrayItemConditionalFn = (itemData: any, index: number, formContext?: any) => Partial<UiSchema>;
+/**
+ * Creates a dynamic uiSchema.items function for array fields
+ *
+ * @param baseItemUiSchema - Base UI schema applied to all array items
+ * @param conditionalLogic - Function that returns conditional UI schema modifications
+ * @returns Function compatible with RJSF fork's dynamic uiSchema.items
+ *
+ * @example
+ * ```typescript
+ * const directorsUiSchema = {
+ *   items: createDynamicArrayItemsUiSchema(
+ *     { 'ui:order': ['name', 'hasShareholding', 'shareholdingPercentage'] },
+ *     (itemData) => {
+ *       if (!itemData?.hasShareholding) {
+ *         return { shareholdingPercentage: { 'ui:widget': 'hidden' } };
+ *       }
+ *       return {};
+ *     }
+ *   )
+ * };
+ * ```
+ */
+export declare function createDynamicArrayItemsUiSchema(baseItemUiSchema: UiSchema, conditionalLogic: ArrayItemConditionalFn): ArrayItemsFunction;
+/**
+ * Safely merges UI schemas with proper handling of nested properties
+ *
+ * @param base - Base UI schema
+ * @param overrides - Conditional UI schema overrides
+ * @returns Merged UI schema
+ */
+export declare function mergeItemUiSchema(base: UiSchema, overrides: Partial<UiSchema>): UiSchema;
+/**
+ * Helper to create common conditional patterns
+ */
+export declare const arrayItemPatterns: {
+    /**
+     * Show/hide a field based on a condition
+     */
+    hideField: (fieldName: string, condition: (itemData: any) => boolean) => ArrayItemConditionalFn;
+    /**
+     * Make a field required based on a condition
+     */
+    requireField: (fieldName: string, condition: (itemData: any) => boolean) => ArrayItemConditionalFn;
+    /**
+     * Apply styles to first/last items
+     */
+    applyIndexStyles: (totalItems: number) => ArrayItemConditionalFn;
+};

package/dist/conditionals/v2/utils/jsonPatch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple JSON Patch-like utility for applying operations to objects
+ * Supports add, remove, and replace operations with JSONPath-like syntax
+ */
+export declare function applyPatch(target: any, operations: Array<{
+    op: string;
+    path: string;
+    value?: any;
+}>): any;