extended-dynamic-forms 0.3.13 → 0.4.1

package/dist/WizardForm.d.ts

@@ -4,6 +4,18 @@ export interface WizardStep {
     id: string;
     title: string;
     description?: string;
+    hidden?: boolean;
+}
+export interface StepChangeEvent {
+    stepId: string;
+    stepIndex: number;
+    allStepsIndex: number;
+    formData: any;
+}
+export interface StepAutoAdvanceEvent {
+    fromStepId: string;
+    toStepId: string;
+    formData: any;
 }
 export interface WizardFormProps {
     schema: any;
@@ -11,7 +23,9 @@ export interface WizardFormProps {
     webhooks?: WebhookConfig[];
     formData?: any;
     onSubmit?: (data: any) => void;
-    onStepChange?: (step: number, data: any) => void;
+    onStepChange?: (stepIndex: number, data: any, stepId?: string) => void;
+    onStepChangeDetailed?: (event: StepChangeEvent) => void;
+    onStepAutoAdvance?: (event: StepAutoAdvanceEvent) => void;
     onFieldFocus?: (event: any) => void;
     onFieldBlur?: (event: any) => void;
     onFieldChange?: (event: any) => void;
@@ -28,5 +42,6 @@ export interface WizardFormProps {
     fields?: any;
     templates?: any;
     enableDynamicBinding?: boolean;
+    includeHiddenStepsInSubmit?: boolean;
 }
-export declare function WizardForm({ schema, uiSchema, webhooks, formData: initialFormData, onSubmit, onStepChange, onFieldFocus, onFieldBlur, onFieldChange, onLiveChange, showProgressBar, showStepDescription, submitButtonText, liveValidate, showErrorList, onWebhookStart, onWebhookComplete, onWebhookError, widgets, fields, templates, enableDynamicBinding, }: WizardFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function WizardForm({ schema, uiSchema, webhooks, formData: initialFormData, onSubmit, onStepChange, onFieldFocus, onFieldBlur, onFieldChange, onLiveChange, showProgressBar, showStepDescription, submitButtonText, liveValidate, showErrorList, onWebhookStart, onWebhookComplete, onWebhookError, widgets, fields, templates, enableDynamicBinding, onStepChangeDetailed, onStepAutoAdvance, includeHiddenStepsInSubmit, }: WizardFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/FieldFeedbackContext.d.ts

@@ -0,0 +1,4 @@
+export declare const FieldFeedbackContext: import('react').Context<{
+    id: string;
+    setWidgetOwnsFeedback: (owns: boolean) => void;
+} | undefined>;

package/dist/components/FieldStyleContext.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties } from 'react';
+
+export declare const FieldStyleContext: import('react').Context<{
+    id: string;
+    style: CSSProperties | undefined;
+} | undefined>;
+export declare function useFieldStyle(id: string, explicitStyle?: CSSProperties): CSSProperties | undefined;

package/dist/components/SchemaSelectionContext.d.ts

@@ -0,0 +1,20 @@
+import { ComponentType } from 'react';
+import { FieldProps, MultiSchemaFieldTemplateProps } from '@rjsf/utils';
+
+export type SchemaSelections = {
+    choices: Map<string, number>;
+    rows: Map<string, string[]>;
+    scope: string;
+    arrayScope: string;
+    baseId: string;
+};
+export declare const SchemaSelectionContext: import('react').Context<SchemaSelections | undefined>;
+export declare const createSchemaSelections: () => SchemaSelections;
+export declare const schemaSelectionKey: (selection: SchemaSelections | undefined, id: string) => string;
+export declare function arrayItemSelections(selection: SchemaSelections | undefined, id: string, itemId: string, index: number, token?: string | undefined): SchemaSelections | undefined;
+/** Respect registry and per-field template overrides through RJSF's public template resolver. */
+export declare function withArraySchemaSelections(Field: ComponentType<FieldProps>): (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+/** Seed RJSF's own matching/selection state without replaying its data-changing onOptionChange. */
+export declare function withRestoredSchemaSelection(Field: ComponentType<FieldProps>): (props: FieldProps) => import("react/jsx-runtime").JSX.Element;
+/** Observe RJSF's public template inputs, not private field state or a second branch selector. */
+export declare function withSchemaSelections(Template: ComponentType<MultiSchemaFieldTemplateProps>): (props: MultiSchemaFieldTemplateProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/URLBlurValidationContext.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { ErrorListProps, ErrorSchema, WidgetProps } from '@rjsf/utils';
+import { ExtendedFormProps } from '../types';
+
+type Metadata = Pick<WidgetProps, 'id' | 'registry'>;
+type Path = string[];
+type Settings = Pick<ExtendedFormProps, 'schema' | 'uiSchema' | 'formData' | 'liveValidate' | 'noValidate' | 'extraErrors' | 'idPrefix' | 'idSeparator' | 'transformErrors' | 'customValidate'>;
+type TimingContext = {
+    register: (metadata: Metadata) => () => void;
+    touch: (metadata: Metadata, changing: boolean) => void;
+    request: (metadata: Metadata) => void;
+    errors: (metadata: Metadata, rawErrors: string[]) => string[];
+    hiddenPaths: Path[];
+};
+export declare const URLBlurValidationContext: React.Context<TimingContext | undefined>;
+export declare function useURLBlurValidationRoot(settings: Settings): {
+    acceptChange: (data: unknown, rootErrors?: ErrorSchema) => void;
+    value: {
+        register: (metadata: Metadata) => () => void;
+        touch: (metadata: Metadata, changing: boolean) => void;
+        request: (metadata: Metadata) => void;
+        errors: (metadata: Metadata, rawErrors: string[]) => string[];
+        hiddenPaths: Path[];
+    };
+};
+export declare function useURLBlurValidation(props: WidgetProps, urlPresentation?: boolean): {
+    enabled: boolean;
+    messages: string[];
+    change: () => void;
+    blur: (changing?: boolean) => void;
+};
+export declare function URLBlurFeedback({ id, messages, hideError }: {
+    id: string;
+    messages: string[];
+    hideError?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function withURLBlurErrorList(Template: React.ComponentType<ErrorListProps>): (props: ErrorListProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,28 @@
+import { FieldProps } from '@rjsf/utils';
+
+type Path = (string | number)[];
+export type TextChangeScope = {
+    parent?: TextChangeScope;
+    key: string | number;
+    name: string;
+    index?: number;
+    live: boolean;
+    widgets: Set<object>;
+    children: Set<TextChangeScope>;
+};
+export type TextChangeCalls = {
+    current?: TextChangeScope;
+};
+export declare const TextChangeContext: import('react').Context<{
+    scope: TextChangeScope;
+    onChange: FieldProps["onChange"];
+} | undefined>;
+/** Public callbacks, not DOM ids or answer equality, identify same-field delegation. */
+export declare function useTextChangeScope(props: FieldProps, item?: boolean): TextChangeScope;
+/** Presence belongs to this committed field scope, never a form-wide widget-id set. */
+export declare function useTextChangeRegistration(name: string, emptyValue: unknown): void;
+/** The actual originating leaf must match the complete public path to this boundary. */
+export declare function textChangeTargets(origin: TextChangeScope | undefined, boundary: TextChangeScope, path: Path): boolean;
+/** Preserve origin only during matching synchronous public callback forwarding. */
+export declare function useTextChangeCallback(onChange: FieldProps['onChange'], scope: TextChangeScope, calls: TextChangeCalls): (newValue: any, path?: (number | string)[], es?: import('@rjsf/utils').ErrorSchema<any> | undefined, id?: string) => void;
+export {};

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

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

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

@@ -1,3 +1,5 @@
-import { EngineConfig, ConditionalEngineHook } from './types';
+import { Rule, EngineConfig, ConditionalEngineHook } from './types';
 
+export declare function stripConditionalMetadata(value: unknown): unknown;
+export declare function evaluateConditionalRules<T, C>(config: EngineConfig<T, C>, rules: Rule<T>[], baseConfig: C, formData: unknown): C;
 export declare function createConditionalEngineHook<T>(config: EngineConfig<T>): ConditionalEngineHook<T>;

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

@@ -1,9 +1,10 @@
 export { createConditionalEngineHook } from './createConditionalEngineHook';
-export type { Rule, EngineConfig, ConditionalEngineHook, UiEffect, SchemaEffect, ValidationEffect, JsonLogicRule, } from './types';
+export type { Rule, EngineConfig, ConditionalEngineHook, UiEffect, SchemaEffect, ValidationEffect, JsonLogicRule, StepEffect, StepRule, } 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, normalizeUiSchemaDynamicItems, compileDynamicItems, type ArrayItemsFunction, type ArrayItemConditionalFn, type DynamicItemsConfig, type DynamicItemsRule, } from './utils/dynamicArrayItems';
+export { sanitizeStepRules, evaluateStepRules, type SanitizedStepRule, type StepRuleSanitizerOptions, type StepVisibilityResult, } from './utils/stepRules';
 export { uiEngineConfig } from './engines/uiEngineConfig';
 export { schemaEngineConfig } from './engines/schemaEngineConfig';
 export { validationEngineConfig, createCustomValidate, } from './engines/validationEngineConfig';

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

@@ -45,3 +45,16 @@ export interface ValidationEffect {
      */
     validate: (errors: ErrorSchema, formData: any) => void;
 }
+export type StepEffect = 'skip';
+export interface StepRule extends Omit<Rule<StepEffect>, 'condition' | 'effect'> {
+    /**
+     * JsonLogic rule determining whether the step should be skipped.
+     * Functions are not supported to keep configurations serializable.
+     */
+    condition: JsonLogicRule;
+    /**
+     * Currently only `skip` is supported. The field is optional to keep
+     * authoring friction low – when omitted we treat the rule as `skip`.
+     */
+    effect?: StepEffect;
+}

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

@@ -0,0 +1,35 @@
+import { StepEffect, StepRule } from '../types';
+
+export type SanitizedStepRule = Omit<StepRule, 'effect'> & {
+    effect: StepEffect;
+};
+export interface StepRuleSanitizerOptions {
+    /**
+     * Human-readable location for logging warnings.
+     */
+    context?: string;
+    /**
+     * When provided we attempt to pick rules addressed to this step id from
+     * mapping objects (`{ [stepId]: StepRule[] }`).
+     */
+    stepId?: string;
+    /**
+     * Allow objects that map `stepId -> StepRule[]`.
+     */
+    allowMap?: boolean;
+}
+export interface StepRuleEvaluationDebug {
+    name: string;
+    result?: boolean;
+    error?: Error;
+}
+export interface StepVisibilityResult {
+    visible: boolean;
+    triggeredRuleName?: string;
+    triggeredRule?: SanitizedStepRule;
+    evaluations?: StepRuleEvaluationDebug[];
+}
+export declare const sanitizeStepRules: (raw: unknown, options?: StepRuleSanitizerOptions) => SanitizedStepRule[];
+export declare const evaluateStepRules: (rules: SanitizedStepRule[], formData: any, options?: {
+    debug?: boolean;
+}) => StepVisibilityResult;

package/dist/events/FormEventContext.d.ts

@@ -7,14 +7,17 @@ export interface FormEventContextType {
     formData?: any;
     bindingData?: any;
     formContext?: any;
+    noValidate?: boolean;
 }
 declare const FormEventContext: React.Context<FormEventContextType | null>;
+export declare const SubmitLifecycleOwnerContext: React.Context<"form" | "parent">;
 export { FormEventContext, FormEventManager };
 export interface FormEventProviderProps {
     eventHub: FormEventHub;
     formData?: any;
     bindingData?: any;
     formContext?: any;
+    noValidate?: boolean;
     children: ReactNode;
 }
 export declare const FormEventProvider: React.FC<FormEventProviderProps>;