extended-dynamic-forms 0.1.21 → 0.1.23

package/README.md

@@ -1,5 +1,25 @@
 # Extended Dynamic Forms
 
+## 🚨 BREAKING CHANGE: v0.2.0 - JsonLogic Only Conditions
+
+> **⚠️ IMPORTANT**: Starting with v0.2.0, Extended Dynamic Forms **ONLY** supports JsonLogic for conditional logic. Function-based conditions are no longer supported. This is a breaking change that improves security, performance, and maintainability.
+>
+> **Migration Required**: If you are using function-based conditions like `condition: (formData) => ...`, you must migrate to JsonLogic format: `condition: { "==": [{ "var": "fieldName" }, "value"] }`
+
+## ⚠️ Project Status: Active Development & Documentation Refinement
+
+**Important Notice**: This project is currently undergoing significant documentation updates to better reflect the actual implementation. Some features described in this README may not be fully implemented or may differ from the documentation. We are actively working to align the documentation with the codebase.
+
+**Known Issues**:
+- The project currently uses local file dependencies that require a specific directory structure to build
+- The project requires RJSF packages from a sibling directory (../react-jsonschema-form/)
+- Some playground demos use deprecated v1 conditional patterns (01-simple-conditionals.demo.tsx)
+- Array drag-and-drop functionality mentioned in documentation is not implemented
+- Test coverage is limited for UI components and event systems
+- Several documented features have incomplete implementations
+- Significant dead code: 76% of utility functions are unused (13 out of 17 functions)
+- JSON Patch implementation in v2 doesn't fully comply with RFC 6902 (no move/copy/test operations)
+
 **A revolutionary extension library for [React JSON Schema Form (RJSF)](https://github.com/rjsf-team/react-jsonschema-form)** that transforms schema-driven forms into sophisticated, enterprise-ready applications with O(N) performance and professional UI components.
 
 Built on top of the excellent RJSF v6 foundation, this library introduces the **Three Pillars v2 Architecture** for conditional logic, multi-step wizard orchestration, central event systems with webhook integration, and a comprehensive suite of 25+ Ant Design components. 
@@ -35,32 +55,31 @@ This library transforms RJSF from a simple form generator into a complete enterp
 
 ## Core Features
 
-### 🚀 Three Pillars v2 Architecture (Recommended)
-- **UI Logic Pillar**: Control form appearance with JSON Patch operations
-- **Schema Logic Pillar**: Modify data structure when truly needed
-- **Validation Logic Pillar**: Dynamic validation rules without schema changes
+### 🚀 Three Pillars v2 Architecture with JsonLogic
+- **UI Logic Pillar**: Control form appearance with JsonLogic conditions and JSON Patch operations
+- **Schema Logic Pillar**: Modify data structure with JsonLogic rules when truly needed
+- **Validation Logic Pillar**: Dynamic validation rules with JsonLogic conditions
 - **O(N) Performance**: Superior array handling vs v1's O(M×N)
+- **JsonLogic-Only**: Secure, data-driven conditions without code execution
 - **React Hooks**: Modern, declarative API with `useConditionalUi`, `useConditionalSchema`, `useConditionalValidation`
 
-### 🎯 Declarative Conditional Logic
-- Define complex form behavior without code
+### 🎯 Declarative Conditional Logic with JsonLogic
+- Define complex form behavior with secure JsonLogic rules
 - Dynamic array support with per-item evaluation
-- Compatible with `json-rules-engine` format
-- Built-in migration utilities from v1 to v2
-
-For example, you can integrate existing business logic:
+- No code execution - all conditions are data-driven
+- Type-safe with comprehensive TypeScript support
 
 ```tsx
-import { engine } from './rules-engine'; // Your configured json-rules-engine instance
+import { UiRule, JsonLogicRule } from 'extended-dynamic-forms/conditionals/v2';
 
 const uiRules: UiRule[] = [{
-  name: 'Apply business logic for premium users',
-  // The condition can be a promise-based async function
-  condition: async (formData) => {
-    const { events } = await engine.run(formData);
-    return events.some(event => event.type === 'show-premium-feature');
-  },
-  effect: [...]
+  name: 'Show premium features for premium users',
+  condition: {
+    "==": [{ "var": "accountType" }, "premium"]
+  } as JsonLogicRule,
+  effect: [
+    { op: 'remove', path: '/premiumFeatures/ui:widget' }
+  ]
 }];
 ```
 
@@ -92,10 +111,12 @@ const schema = {
   }
 };
 
-// Use v2 UiRules to handle step-aware conditionals
+// Use v2 UiRules with JsonLogic to handle step-aware conditionals
 const uiRules: UiRule[] = [{
   name: 'Show SSN only for US Citizens in Personal step',
-  condition: (formData) => !formData.STEP_PERSONAL?.isUSCitizen,
+  condition: {
+    "!": { "var": "STEP_PERSONAL.isUSCitizen" }
+  } as JsonLogicRule,
   effect: [
     { op: 'add', path: '/STEP_PERSONAL/properties/ssn/ui:widget', value: 'hidden' }
   ]
@@ -125,8 +146,8 @@ const uiRules: UiRule[] = [{
 - **TypeScript**: Full type safety and IntelliSense with comprehensive interface definitions
 - **Performance**: Optimized re-renders and memoization with intelligent caching
 - **Extensible**: Add custom widgets, fields, and actions with clean APIs
-- **Well-Tested**: Extensive test suite covering all major features and edge cases
-- **Developer Experience**: Interactive playground with dozens of real-world demos
+- **Test Coverage**: Focused on conditional logic and wizard forms (UI components have limited coverage)
+- **Developer Experience**: Interactive playground with real-world demos (note: some deprecated)
 
 ### 🌐 Standalone JavaScript Support
 
@@ -163,10 +184,10 @@ const uiRules: UiRule[] = [{
 ```
 
 **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: [...] }`
+- **JsonLogic is NOT supported in vanilla JS** - The JsonLogic runtime requires React hooks
+- Only v1 conditions are supported with the `conditionals` prop
 - Subject to v1's O(M×N) performance for array conditionals
-- For v2 benefits, use the React-based API instead
+- For JsonLogic and v2 benefits, you must use the React-based API
 
 ```javascript
 // Vanilla JS supports only v1 conditionals
@@ -199,6 +220,11 @@ Special thanks to the RJSF team and contributors for creating such a flexible an
 
 ## Installation
 
+> ⚠️ **Important Note**: This library currently uses local file dependencies for RJSF packages (pointing to `../react-jsonschema-form/`). This means:
+> - The library cannot be installed directly from npm without modifications
+> - You need the RJSF source code in a sibling directory for development
+> - Consider using a monorepo structure or git submodules for proper dependency management
+
 ### React Projects
 
 ```bash
@@ -222,7 +248,7 @@ pnpm add extended-dynamic-forms
 
 ### Peer Dependencies
 
-**Current Version**: `0.1.19` - Optimized for **RJSF v6** with Three Pillars v2 architecture.
+**Current Version**: `0.2.0` - Built for **RJSF v6** with Three Pillars v2 architecture (JsonLogic-only).
 
 ```json
 {
@@ -289,31 +315,35 @@ function App() {
 }
 ```
 
-## Three Pillars v2 Architecture (Recommended Approach)
+## Three Pillars v2 Architecture with JsonLogic (Required Approach)
 
-> ⚠️ **IMPORTANT**: The v1 conditional system is deprecated. We strongly recommend using the Three Pillars v2 architecture for all new implementations.
+> ⚠️ **BREAKING CHANGE**: As of v0.2.0, the Three Pillars v2 system ONLY supports JsonLogic conditions. Function-based conditions are no longer supported for security and maintainability reasons.
 
-The Three Pillars v2 system provides superior performance, cleaner separation of concerns, and better maintainability. It consists of three independent pillars:
+The Three Pillars v2 system with JsonLogic provides superior performance, cleaner separation of concerns, and better security. It consists of three independent pillars:
 
 ### 1. UI Logic Pillar (`useConditionalUi`)
 
-Controls form appearance using JSON Patch operations:
+Controls form appearance using JSON Patch operations with JsonLogic conditions:
 
 ```tsx
 // Note: v2 conditionals require deep import for optimal tree-shaking
-import { useConditionalUi, UiRule } from 'extended-dynamic-forms/conditionals/v2';
+import { useConditionalUi, UiRule, JsonLogicRule } from 'extended-dynamic-forms/conditionals/v2';
 
-// Define UI rules with JSON Patch operations
+// Define UI rules with JsonLogic conditions and JSON Patch operations
 const uiRules: UiRule[] = [
   {
     name: 'Show shipping address when required',
-    condition: (formData) => formData.requiresShipping === true,
+    condition: {
+      "==": [{ "var": "requiresShipping" }, true]
+    } as JsonLogicRule,
     effect: [{ op: 'remove', path: '/shippingAddress/ui:widget' }],
     order: 1
   },
   {
     name: 'Dynamic country fields',
-    condition: (formData) => formData.shippingAddress?.country === 'USA',
+    condition: {
+      "==": [{ "var": "shippingAddress.country" }, "USA"]
+    } as JsonLogicRule,
     effect: [
       { op: 'remove', path: '/shippingAddress/state/ui:widget' },
       { op: 'add', path: '/shippingAddress/province/ui:widget', value: 'hidden' }
@@ -353,12 +383,14 @@ function MyForm() {
 Modifies JSON Schema structure (use sparingly - prefer UI or Validation pillars):
 
 ```tsx
-import { useConditionalSchema, SchemaRule } from 'extended-dynamic-forms/conditionals/v2';
+import { useConditionalSchema, SchemaRule, JsonLogicRule } from 'extended-dynamic-forms/conditionals/v2';
 
 const schemaRules: SchemaRule[] = [
   {
     name: 'Add premium fields',
-    condition: (formData) => formData.accountType === 'premium',
+    condition: {
+      "==": [{ "var": "accountType" }, "premium"]
+    } as JsonLogicRule,
     effect: [
       { 
         op: 'add', 
@@ -383,12 +415,14 @@ Adds conditional validation without modifying schema:
 
 ```tsx
 import { useMemo } from 'react';
-import { useConditionalValidation, ValidationRule, createCustomValidate } from 'extended-dynamic-forms/conditionals/v2';
+import { useConditionalValidation, ValidationRule, JsonLogicRule, createCustomValidate } from 'extended-dynamic-forms/conditionals/v2';
 
 const validationRules: ValidationRule[] = [
   {
     name: 'Require consent for minors',
-    condition: (formData) => formData.age < 18,
+    condition: {
+      "<": [{ "var": "age" }, 18]
+    } as JsonLogicRule,
     effect: {
       type: 'validation',
       validate: (errors, formData) => {
@@ -436,6 +470,8 @@ One of the most significant breakthroughs in v2 is the `createDynamicArrayItemsU
 - **No Rule Explosion**: Unlike v1's wildcard expansion, no rules are multiplied by array size
 - **React-Optimized**: Leverages React's rendering cycle for optimal performance
 
+> **Note**: `createDynamicArrayItemsUiSchema` still supports function-based conditions as it evaluates per-item during render. This is not a security risk as the functions are defined in your code, not from user input.
+
 ```tsx
 import { createDynamicArrayItemsUiSchema } from 'extended-dynamic-forms/conditionals/v2';
 
@@ -521,26 +557,31 @@ function MyForm() {
 }
 ```
 
-### Migration from v1 to v2
+### JsonLogic Conditions (Required)
+
+As of v0.2.0, v2 ONLY supports JsonLogic conditions for security and maintainability:
 
 ```tsx
-import { 
-  migrateV1ToUiRules, 
-  generateMigrationReport,
-  analyzeRules 
-} from 'extended-dynamic-forms/conditionals/v2';
-
-// Analyze existing rules
-const analysis = analyzeRules(v1Rules);
-
-// Auto-migrate UI rules
-const { rules: migratedRules, report } = migrateV1ToUiRules(v1Rules);
-
-// Generate detailed migration report
-const migrationReport = generateMigrationReport(v1Rules, {
-  includeExamples: true,
-  outputFormat: 'markdown'
-});
+import { JsonLogicRule, UiRule } from 'extended-dynamic-forms/conditionals/v2';
+
+// JsonLogic rule examples
+const simpleRule: UiRule = {
+  name: 'Show field B when A is true',
+  condition: { "==": [{ "var": "fieldA" }, true] } as JsonLogicRule,
+  effect: [{ op: 'remove', path: '/fieldB/ui:widget' }]
+};
+
+const complexRule: UiRule = {
+  name: 'Complex business logic',
+  condition: {
+    "and": [
+      { "==": [{ "var": "accountType" }, "premium"] },
+      { ">": [{ "var": "revenue" }, 100000] },
+      { "in": [{ "var": "country" }, ["USA", "Canada", "UK"]] }
+    ]
+  } as JsonLogicRule,
+  effect: [{ op: 'remove', path: '/advancedFeatures/ui:widget' }]
+};
 ```
 
 ## Quick Start
@@ -557,16 +598,23 @@ import schema from './schema.json';
 import baseUiSchema from './ui-schema.json';
 import webhooks from './webhooks.json';
 
-// Example: v2 Three Pillars approach (recommended)
+// Example: v2 Three Pillars approach with JsonLogic (required)
 const uiRules: UiRule[] = [
   {
     name: 'Show tax ID in company step when listed',
-    condition: (formData) => formData.STEP_COMPANY?.isListedCompany === true,
+    condition: {
+      "==": [{ "var": "STEP_COMPANY.isListedCompany" }, true]
+    } as JsonLogicRule,
     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),
+    condition: {
+      "some": [
+        { "var": "STEP_DIRECTORS.directors" },
+        { "var": "hasShareholding" }
+      ]
+    } as JsonLogicRule,
     effect: [{ op: 'remove', path: '/STEP_DIRECTORS/directors/items/shareholdingPercentage/ui:widget' }]
   }
 ];
@@ -595,7 +643,7 @@ const v1Conditions = [
   },
   {
     conditions: { "STEP_DIRECTORS.directors[*].hasShareholding": true },
-    event: { type: "require", params: { field: "STEP_DIRECTORS.directors[*].shareholdingPercentage" } }
+    event: { type: "show", params: { field: "STEP_DIRECTORS.directors[*].shareholdingPercentage" } }
   }
 ];
 
@@ -612,7 +660,7 @@ const v1Conditions = [
 
 ```tsx
 import { ExtendedForm } from 'extended-dynamic-forms';
-import { useConditionalUi, UiRule } from 'extended-dynamic-forms/conditionals/v2';
+import { useConditionalUi, UiRule, JsonLogicRule } from 'extended-dynamic-forms/conditionals/v2';
 
 const schema = {
   type: 'object',
@@ -628,11 +676,13 @@ const baseUiSchema = {
   school: { 'ui:widget': 'text' }
 };
 
-// Define UI rules outside component
+// Define UI rules outside component with JsonLogic
 const uiRules: UiRule[] = [
   {
     name: 'Show student fields when student',
-    condition: (formData) => !formData.isStudent,
+    condition: {
+      "!": { "var": "isStudent" }
+    } as JsonLogicRule,
     effect: [
       { op: 'add', path: '/studentId/ui:widget', value: 'hidden' },
       { op: 'add', path: '/school/ui:widget', value: 'hidden' }
@@ -715,6 +765,14 @@ All standard RJSF widgets are enhanced with:
 - **Error States**: Proper error indication and messaging
 - **Accessibility**: Enhanced ARIA support
 
+### Array Templates
+
+The library provides Ant Design Card-based array templates for better visual organization:
+- **ArrayFieldTemplate**: Card container with proper spacing and visual hierarchy
+- **ArrayFieldItemTemplate**: Individual array items with integrated add/remove buttons
+- **Visual Design**: Clean card-based layout for array management
+- **Note**: Drag-and-drop reordering is not currently implemented
+
 ## Central Event Orchestration System
 
 ### Field-Level Event Handling
@@ -1004,7 +1062,7 @@ Extended Dynamic Forms uses a layered architecture that cleanly extends RJSF:
 | **Array Conditionals** | ❌ None | ✅ Per-Item O(N) Performance |
 | **TypeScript** | Partial | ✅ Comprehensive Type Definitions |
 | **Standalone JS** | ❌ React Only | ✅ Complete UMD Bundle |
-| **Testing** | Basic | ✅ Extensive Test Coverage |
+| **Testing** | Basic | ⚠️ Focused on Conditionals/Wizards |
 | **Performance** | Standard | ✅ Optimized with Caching |
 | **Validation** | Basic | ✅ Dynamic + Custom Rules |
 | **Developer Tools** | Limited | ✅ Interactive Playground |
@@ -1013,11 +1071,15 @@ Extended Dynamic Forms uses a layered architecture that cleanly extends RJSF:
 
 ### 🚀 Quick Start
 
+> **Development Setup Note**: Due to local file dependencies, you need:
+> 1. Clone RJSF repository in a sibling directory: `../react-jsonschema-form/`
+> 2. Ensure the RJSF packages are built and available
+
 ```bash
-# Clone and setup
+# Clone and setup (requires specific directory structure)
 git clone https://github.com/user/extended-dynamic-forms.git
 cd extended-dynamic-forms
-npm install
+npm install  # Note: Will fail without ../react-jsonschema-form/ directory
 
 # Start development with playground
 npm run dev                    # Launches interactive playground
@@ -1045,11 +1107,11 @@ npm run serve:examples     # Serve vanilla JS examples
 
 ### 🧪 Testing
 
-**Test Coverage**: Extensive test suite with focus on:
-- **Conditional Logic**: Comprehensive coverage for v1 and v2 systems
+**Test Coverage**: Test suite focuses primarily on:
+- **Conditional Logic**: Comprehensive coverage for v1 and v2 systems (16+ test files)
 - **Wizard Forms**: Step navigation and validation
 - **Performance**: Array conditional optimization
-- **Integration**: Component interaction testing
+- **Note**: Limited coverage for UI components, event system, and utility functions
 
 ```bash
 npm run test              # Run complete test suite
@@ -1077,7 +1139,7 @@ src/
 ├── events/                  # Central event orchestration
 ├── widgets/                 # Enhanced component suite
 ├── components/              # Field and template components
-└── utils/                   # Form manipulation utilities
+└── utils/                   # Utilities (Note: 76% are unused)
 ```
 
 ## Examples & Demos
@@ -1095,6 +1157,8 @@ npm run playground
 
 ### 📚 Demo Categories
 
+> **Note**: Some playground demos may be outdated. The v1 conditional demo (`/playground/src/demos/conditionals/01-deprecated-v1-conditions.demo.tsx`) is deprecated and should not be used as a reference for new implementations.
+
 #### **Three Pillars v2 Demonstrations**
 - **Global UI Rules**: Dynamic show/hide with JSON Patch operations
 - **Dynamic Array Items**: Per-item conditional logic with O(N) performance

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,25 @@
+import { WebhookConfig } from './types';
+
+export interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+}
+export interface WizardFormProps {
+    schema: any;
+    uiSchema: 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;
+    onLiveChange?: (completeFlatData: any) => void;
+    showProgressBar?: boolean;
+    showStepDescription?: boolean;
+    submitButtonText?: string;
+    liveValidate?: boolean;
+    showErrorList?: boolean;
+}
+export declare function WizardForm({ schema, uiSchema, webhooks, formData: initialFormData, onSubmit, onStepChange, onFieldFocus, onFieldBlur, onFieldChange, onLiveChange, 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/index.d.ts

@@ -0,0 +1 @@
+export * from './v2';

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/effects/customHandlers.d.ts

@@ -0,0 +1,35 @@
+import { RJSFSchema } from '@rjsf/utils';
+
+export interface JsonPatchOperation {
+    op: 'add' | 'remove' | 'replace';
+    path: string;
+    value?: any;
+}
+export interface CustomSchemaOperation {
+    op: 'require' | 'optional';
+    path: string;
+    field: string;
+}
+export type SchemaEffect = JsonPatchOperation | CustomSchemaOperation;
+/**
+ * Apply a series of effects (JSON Patch or custom) to a schema
+ */
+export declare function applySchemaEffects(schema: RJSFSchema, effects: SchemaEffect[]): RJSFSchema;
+/**
+ * Helper to extract parent path from a field path
+ * e.g., "/properties/address/properties/street" -> "/properties/address"
+ */
+export declare function fieldPathToParentPath(fieldPath: string): string;
+/**
+ * Helper to extract field name from a path
+ * e.g., "/properties/address/properties/street" -> "street"
+ */
+export declare function extractFieldName(fieldPath: string): string;
+/**
+ * Create a require effect
+ */
+export declare function createRequireEffect(parentPath: string, fieldName: string): CustomSchemaOperation;
+/**
+ * Create an optional effect
+ */
+export declare function createOptionalEffect(parentPath: string, fieldName: string): CustomSchemaOperation;

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,9 @@
+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';