@digiform/builder 0.1.7 → 0.2.1

package/features/template-system/utils/templateGovernance.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Template Governance Configuration
+ *
+ * This file allows developers to easily configure which templates should be editable
+ * and which should be read-only (locked) during development.
+ */
+export interface TemplateGovernanceRule {
+    /** Template ID or pattern to match */
+    templateId: string | RegExp;
+    /** Whether this template should be locked (read-only) */
+    isLocked: boolean;
+    /** Reason for locking the template */
+    lockReason?: string;
+    /** Description of the governance rule */
+    description?: string;
+}
+/**
+ * Template Governance Rules
+ *
+ * Add rules here to control which templates can be edited.
+ * Rules are evaluated in order, first match wins.
+ */
+export declare const TEMPLATE_GOVERNANCE_RULES: TemplateGovernanceRule[];
+/**
+ * Development Mode Configuration
+ *
+ * Set this to true during development to make all templates editable
+ * regardless of the governance rules above.
+ */
+export declare const DEVELOPMENT_MODE: boolean;
+/**
+ * Check if a template should be locked based on governance rules
+ */
+export declare function isTemplateLocked(templateId: string): {
+    isLocked: boolean;
+    lockReason?: string;
+};
+/**
+ * Get human-readable governance information for a template
+ */
+export declare function getTemplateGovernanceInfo(templateId: string): {
+    isLocked: boolean;
+    lockReason?: string;
+    description?: string;
+    matchedRule?: TemplateGovernanceRule;
+};
+/**
+ * Override governance for specific template (useful for testing)
+ */
+export declare function overrideTemplateGovernance(templateId: string, isLocked: boolean, lockReason?: string): void;
+/**
+ * Clear all governance overrides (useful for testing cleanup)
+ */
+export declare function clearGovernanceOverrides(): void;

package/features/template-system/utils/templateLoader.d.ts

@@ -0,0 +1,25 @@
+import { FormStepConfig, FormTemplate, StepNavigation, TemplateStepConfig } from '../../../../../core/src/index.ts';
+/**
+ * Loads a template by ID, handling both generic and team templates
+ */
+export declare function loadTemplate(templateId: string): Promise<FormTemplate>;
+/**
+ * Resolves a template step reference to a full FormStepConfig
+ */
+export declare function resolveTemplateStep(templateStep: TemplateStepConfig, defaultNavigation?: StepNavigation, stepIndex?: number): Promise<FormStepConfig>;
+/**
+ * Gets template metadata without loading the full template
+ */
+export declare function getTemplateMetadata(templateId: string): Promise<import('../../../../../core/src/index.ts').TemplateMetadata>;
+/**
+ * Lists available templates from both generic and team sources
+ */
+export declare function getAvailableTemplates(): Promise<string[]>;
+/**
+ * Lists available generic templates only (for backward compatibility)
+ */
+export declare function getAvailableGenericTemplates(): string[];
+/**
+ * Clears the template cache (useful for development/testing)
+ */
+export declare function clearTemplateCache(): void;

package/features/template-system/utils/templateMetadataOperations.d.ts

@@ -0,0 +1,40 @@
+import { FileStorageResult, Template, TemplateCategory, TemplateMetadata, TemplateStorageConfig } from '../../../utils/fileStorage';
+/**
+ * Interface for template metadata updates
+ */
+export interface TemplateMetadataUpdate {
+    name?: string;
+    description?: string;
+    tags?: string[];
+}
+/**
+ * Interface for metadata validation result
+ */
+export interface MetadataValidationResult {
+    isValid: boolean;
+    errors: string[];
+}
+/**
+ * Update template metadata
+ */
+export declare function updateTemplateMetadata(templateId: string, category: TemplateCategory, updates: TemplateMetadataUpdate, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<Template>>;
+/**
+ * Validate template metadata
+ */
+export declare function validateTemplateMetadata(metadata: Partial<TemplateMetadata>): MetadataValidationResult;
+/**
+ * Create a template for duplication with new ID and metadata
+ */
+export declare function createTemplateForDuplication<T extends Template>(sourceTemplate: T, newName: string): T;
+/**
+ * Generate a unique template name to avoid conflicts
+ */
+export declare function generateUniqueTemplateName(baseName: string, category: TemplateCategory, storageConfig: TemplateStorageConfig): Promise<string>;
+/**
+ * Check if a template name is unique within a category
+ */
+export declare function isTemplateNameUnique(name: string, category: TemplateCategory, storageConfig: TemplateStorageConfig, excludeTemplateId?: string): Promise<boolean>;
+/**
+ * Increment template usage count
+ */
+export declare function incrementTemplateUsage(templateId: string, category: TemplateCategory, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<void>>;

package/features/template-system/utils/templateUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Loader-specific template functions for form-builder-component
+ *
+ * This file only contains functions that depend on the local templateLoader.
+ * All other template utilities should be imported directly from @libs/shared/utils
+ */
+export declare const getAvailableGenericTemplatesSync: () => string[];
+export declare const getTemplateInfo: (templateId: string) => Promise<any>;
+export declare const validateTemplateReferences: (config: import('../../../../../core/src/index.ts').FormWizardConfig) => Promise<{
+    isValid: boolean;
+    errors: string[];
+}>;

package/features/trigger-action-system/components/ActionConfigurationSheet/ActionConfigurationSheet.d.ts

@@ -0,0 +1,9 @@
+import { ActionTrigger, FormAction } from '../../../../../../core/src/index.ts';
+interface ActionConfigurationSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    creatingActionTrigger?: ActionTrigger | null;
+    onActionCreate?: (actionData: Omit<FormAction, "id" | "order">) => void;
+}
+declare const ActionConfigurationSheet: import('react').NamedExoticComponent<ActionConfigurationSheetProps>;
+export { ActionConfigurationSheet };

package/features/trigger-action-system/components/ActionEditor/ActionEditor.d.ts

@@ -0,0 +1,15 @@
+import { FormAction } from '../../../../../../core/src/index.ts';
+interface ActionEditorProps {
+    action: FormAction;
+    availableSteps: Array<{
+        id: string;
+        title: string;
+    }>;
+    onUpdate: (updates: Partial<FormAction>) => void;
+    onSave: () => void;
+    onDelete: () => void;
+    onCancel: () => void;
+    isCreating?: boolean;
+}
+declare const ActionEditor: import('react').NamedExoticComponent<ActionEditorProps>;
+export { ActionEditor };

package/features/trigger-action-system/components/ActionsList/ActionsList.d.ts

@@ -0,0 +1,8 @@
+import { ActionTrigger, FormAction } from '../../../../../../core/src/index.ts';
+interface ActionsListProps {
+    onStepLoadActions: FormAction[];
+    onStepFinishActions: FormAction[];
+    onActionAdd: (trigger: ActionTrigger) => void;
+}
+declare const ActionsList: import('react').NamedExoticComponent<ActionsListProps>;
+export { ActionsList };

package/features/trigger-action-system/components/ComponentTriggerActionEditor/ComponentTriggerActionEditor.d.ts

@@ -0,0 +1,8 @@
+import { ComponentTrigger } from '../../../../../../core/src/index.ts';
+interface ComponentTriggerActionEditorProps {
+    triggers?: ComponentTrigger[];
+    onTriggersUpdate: (triggers: ComponentTrigger[]) => void;
+    className?: string;
+}
+declare const ComponentTriggerActionEditor: React.FC<ComponentTriggerActionEditorProps>;
+export default ComponentTriggerActionEditor;

package/features/trigger-action-system/components/TriggerContextSelector/TriggerContextSelector.d.ts

@@ -0,0 +1,9 @@
+import { TriggerContextConfig } from '../../../../../../core/src/index.ts';
+interface TriggerContextSelectorProps {
+    contexts?: TriggerContextConfig[];
+    onContextsUpdate: (contexts: TriggerContextConfig[]) => void;
+    className?: string;
+}
+declare const TriggerContextSelector: React.FC<TriggerContextSelectorProps>;
+export { TriggerContextSelector };
+export default TriggerContextSelector;

package/features/trigger-action-system/index.d.ts

@@ -0,0 +1,5 @@
+export * from './components/ActionConfigurationSheet/ActionConfigurationSheet';
+export * from './components/ActionEditor/ActionEditor';
+export * from './components/ActionsList/ActionsList';
+export { default as ComponentTriggerActionEditor } from './components/ComponentTriggerActionEditor/ComponentTriggerActionEditor';
+export * from './components/TriggerContextSelector/TriggerContextSelector';

package/features/visual-mapping/components/ApiCallEditor/ApiCallEditor.d.ts

@@ -0,0 +1,15 @@
+import { ApiCallConfig } from '../../../../../../core/src/index.ts';
+interface ApiCallEditorProps {
+    config: ApiCallConfig;
+    onUpdate: (config: ApiCallConfig) => void;
+    onSave?: () => void;
+    isCreating?: boolean;
+    errors?: Record<string, string>;
+    stepId?: string;
+    actionId?: string;
+}
+export interface ApiCallEditorRef {
+    getCurrentConfig: () => ApiCallConfig;
+}
+declare const ApiCallEditor: import('react').MemoExoticComponent<import('react').ForwardRefExoticComponent<ApiCallEditorProps & import('react').RefAttributes<ApiCallEditorRef>>>;
+export { ApiCallEditor };

package/features/visual-mapping/components/ApiResponsePreview/ApiResponsePreview.d.ts

@@ -0,0 +1,8 @@
+import { ApiCallConfig, ApiResponseData } from '../../../../../../core/src/index.ts';
+interface ApiResponsePreviewProps {
+    config: ApiCallConfig;
+    onResponseData: (data: ApiResponseData) => void;
+    className?: string;
+}
+export declare const ApiResponsePreview: import('react').NamedExoticComponent<ApiResponsePreviewProps>;
+export {};

package/features/visual-mapping/components/ApiStructureTree/ApiStructureTree.d.ts

@@ -0,0 +1,10 @@
+import { ApiFieldNode, VisualMapping } from '../../../../../../core/src/index.ts';
+interface ApiStructureTreeProps {
+    nodes: ApiFieldNode[];
+    onNodeSelect: (nodeId: string | null) => void;
+    selectedNodeId: string | null;
+    visualMappings: VisualMapping[];
+    onToggleExpand?: (nodeId: string) => void;
+}
+export declare const ApiStructureTree: import('react').NamedExoticComponent<ApiStructureTreeProps>;
+export {};

package/features/visual-mapping/components/CompactApiTestButton/CompactApiTestButton.d.ts

@@ -0,0 +1,11 @@
+import { ApiCallConfig, ApiResponseData } from '../../../../../../core/src/index.ts';
+interface CompactApiTestButtonProps {
+    config: ApiCallConfig;
+    onResponseData: (data: ApiResponseData) => void;
+    apiResponseData?: ApiResponseData | null;
+}
+export declare const CompactApiTestButton: {
+    ({ config, onResponseData, apiResponseData, }: CompactApiTestButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/features/visual-mapping/components/ConnectionCircle/ConnectionCircle.d.ts

@@ -0,0 +1,8 @@
+export declare const ConnectionCircle: ({ type, isMapped, isCompatibleTarget, compatibilityLevel, isSelected, }: {
+    type: string;
+    isMapped: boolean;
+    isCompatibleTarget?: boolean;
+    compatibilityLevel?: string;
+    isSelected: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ConnectionCircle;

package/features/visual-mapping/components/ConnectionLines/ConnectionLines.d.ts

@@ -0,0 +1,8 @@
+import { VisualMapping } from '../../../../../../core/src/index.ts';
+interface ConnectionLinesProps {
+    visualMappings: VisualMapping[];
+    containerRef: React.RefObject<HTMLDivElement>;
+}
+export declare const findFormElementByPath: (container: HTMLElement, formPath: string) => HTMLElement | null;
+declare const ConnectionLines: import('react').NamedExoticComponent<ConnectionLinesProps>;
+export { ConnectionLines };

package/features/visual-mapping/components/CurrentMappingsDisplay/CurrentMappingsDisplay.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Displays the current visual API mappings with remove functionality.
+ * Follows Single Responsibility Principle by handling only the display of existing mappings.
+ */
+export declare const CurrentMappingsDisplay: () => import("react/jsx-runtime").JSX.Element | null;

package/features/visual-mapping/components/EmptyFormFieldsMessage/EmptyFormFieldsMessage.d.ts

@@ -0,0 +1 @@
+export declare const EmptyFormFieldsMessage: () => import("react/jsx-runtime").JSX.Element;

package/features/visual-mapping/components/FormFieldItem/FormFieldItem.d.ts

@@ -0,0 +1,9 @@
+import { FormFieldNode } from '../../../../../../core/src/index.ts';
+interface FormFieldItemProps {
+    field: FormFieldNode;
+    onSelect: (fieldPath: string) => void;
+    isSelected: boolean;
+    isMapped: boolean;
+}
+export declare const FormFieldItem: import('react').NamedExoticComponent<FormFieldItemProps>;
+export default FormFieldItem;

package/features/visual-mapping/components/FormFieldsList/FormFieldsList.d.ts

@@ -0,0 +1,9 @@
+import { FormFieldNode, VisualMapping } from '../../../../../../core/src/index.ts';
+interface FormFieldsListProps {
+    fields: FormFieldNode[];
+    onFieldSelect: (fieldPath: string | null) => void;
+    selectedFieldPath: string | null;
+    visualMappings: VisualMapping[];
+}
+export declare const FormFieldsList: import('react').NamedExoticComponent<FormFieldsListProps>;
+export {};

package/features/visual-mapping/components/KeyValueEditor/KeyValueEditor.d.ts

@@ -0,0 +1,39 @@
+export interface KeyValueItem {
+    id: string;
+    key: string;
+    value: string;
+}
+export interface SelectOption {
+    value: string;
+    label: string;
+}
+export interface SelectFieldConfig {
+    placeholder?: string;
+    options: SelectOption[];
+    getValue: (item: KeyValueItem) => string;
+    onChange: (id: string, value: string) => void;
+    className?: string;
+}
+export interface FieldSelectorConfig {
+    currentStepId: string;
+    onSelectField: (fieldId: string, selectedField: {
+        path: string;
+        label: string;
+    }) => void;
+    targetField?: "key" | "value";
+}
+interface KeyValueEditorProps {
+    items: KeyValueItem[];
+    onChange: (id: string, updates: Partial<KeyValueItem>) => void;
+    onRemove: (id: string) => void;
+    keyPlaceholder?: string;
+    valuePlaceholder?: string;
+    selectConfig?: SelectFieldConfig;
+    fieldSelectorConfig?: FieldSelectorConfig;
+    showFieldSelector?: boolean;
+    showFieldSelectorOnKey?: boolean;
+    showFieldSelectorOnValue?: boolean;
+    showRemoveCondition?: (item: KeyValueItem) => boolean;
+}
+declare const KeyValueEditor: import('react').NamedExoticComponent<KeyValueEditorProps>;
+export default KeyValueEditor;

package/features/visual-mapping/components/MappingActionsDropdownMenu/MappingActionsDropdownMenu.d.ts

@@ -0,0 +1,9 @@
+interface MappingActionsDropdownMenuProps {
+    onRefresh?: () => void;
+    onClearSaved?: () => void;
+    onClearAll?: () => void;
+    showClearSaved?: boolean;
+    showClearAll?: boolean;
+}
+export declare function MappingActionsDropdownMenu({ onRefresh, onClearSaved, onClearAll, showClearSaved, showClearAll, }: MappingActionsDropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/features/visual-mapping/components/MappingConnections/MappingConnections.d.ts

@@ -0,0 +1,10 @@
+import { VisualMapping } from '../../../../../../core/src/index.ts';
+import { RefObject } from 'react';
+interface MappingConnectionsProps {
+    mappings: VisualMapping[];
+    containerRef: RefObject<HTMLDivElement>;
+    leftPanelRef: RefObject<HTMLDivElement>;
+    rightPanelRef: RefObject<HTMLDivElement>;
+}
+export declare const MappingConnections: import('react').NamedExoticComponent<MappingConnectionsProps>;
+export {};

package/features/visual-mapping/components/RequestBodyEditor/RequestBodyEditor.d.ts

@@ -0,0 +1,10 @@
+import { ApiCallConfig } from '../../../../../../core/src/index.ts';
+interface RequestBodyEditorProps {
+    apiCall: ApiCallConfig;
+    onUpdate?: (updates: Partial<ApiCallConfig>) => void;
+}
+export interface RequestBodyEditorRef {
+    getCurrentConfig: () => Partial<ApiCallConfig>;
+}
+declare const RequestBodyEditor: import('react').ForwardRefExoticComponent<RequestBodyEditorProps & import('react').RefAttributes<RequestBodyEditorRef>>;
+export default RequestBodyEditor;

package/features/visual-mapping/components/SearchBar/SearchBar.d.ts

@@ -0,0 +1,25 @@
+interface SearchBarProps {
+    isOpen: boolean;
+    searchTerm: string;
+    onToggle: () => void;
+    onSearchChange: (term: string) => void;
+    onClear: () => void;
+    placeholder?: string;
+    className?: string;
+}
+export declare const SearchToggleButton: import('react').NamedExoticComponent<{
+    isOpen: boolean;
+    onToggle: () => void;
+    className?: string;
+}>;
+export declare const SearchInputBar: import('react').NamedExoticComponent<{
+    isOpen: boolean;
+    searchTerm: string;
+    onSearchChange: (term: string) => void;
+    onClear: () => void;
+    onToggle: () => void;
+    placeholder?: string;
+    className?: string;
+}>;
+export declare const SearchBar: import('react').NamedExoticComponent<SearchBarProps>;
+export {};

package/features/visual-mapping/components/VisualApiMappingInterface/VisualApiMappingInterface.d.ts

@@ -0,0 +1,9 @@
+import { ApiCallConfig } from '../../../../../../core/src/index.ts';
+interface VisualApiMappingInterfaceProps {
+    config: ApiCallConfig;
+    onUpdate: (config: ApiCallConfig) => void;
+    className?: string;
+}
+export type DataTypeKey = "string" | "number" | "boolean" | "array" | "object" | "null" | "undefined";
+export declare const VisualApiMappingInterface: import('react').NamedExoticComponent<VisualApiMappingInterfaceProps>;
+export {};

package/features/visual-mapping/components/index.d.ts

@@ -0,0 +1,2 @@
+export { ApiStructureTree } from './ApiStructureTree/ApiStructureTree';
+export { FormFieldsList } from './FormFieldsList/FormFieldsList';

package/features/visual-mapping/components/typeCompatibility.d.ts

@@ -0,0 +1,4 @@
+export declare const checkTypeCompatibility: (apiType: string, formType: string) => boolean;
+export declare const getCompatibilityLevel: (apiType: string, formType: string) => "perfect" | "compatible" | "warning" | "error";
+export declare const getCompatibilityMessage: (apiType: string, formType: string) => string;
+export declare const getCompatibilityColor: (apiType: string, formType: string) => string;

package/features/visual-mapping/components/utils/getFormFieldDataType.d.ts

@@ -0,0 +1,2 @@
+import { DataTypeKey } from '../VisualApiMappingInterface/VisualApiMappingInterface';
+export declare const getFormFieldDataType: (fieldType: string) => DataTypeKey;

package/features/visual-mapping/index.d.ts

@@ -0,0 +1,18 @@
+export * from './components/ApiCallEditor/ApiCallEditor';
+export * from './components/ApiResponsePreview/ApiResponsePreview';
+export * from './components/ApiStructureTree/ApiStructureTree';
+export * from './components/CompactApiTestButton/CompactApiTestButton';
+export * from './components/ConnectionCircle/ConnectionCircle';
+export * from './components/ConnectionLines/ConnectionLines';
+export * from './components/CurrentMappingsDisplay/CurrentMappingsDisplay';
+export * from './components/EmptyFormFieldsMessage/EmptyFormFieldsMessage';
+export * from './components/FormFieldItem/FormFieldItem';
+export * from './components/FormFieldsList/FormFieldsList';
+export * from './components/MappingActionsDropdownMenu/MappingActionsDropdownMenu';
+export * from './components/MappingConnections/MappingConnections';
+export * from './components/RequestBodyEditor/RequestBodyEditor';
+export * from './components/SearchBar/SearchBar';
+export * from './components/typeCompatibility';
+export * from './components/utils/getFormFieldDataType';
+export * from './components/VisualApiMappingInterface/VisualApiMappingInterface';
+export * from './utils/apiBodyUtils';

package/features/visual-mapping/utils/apiBodyUtils.d.ts

@@ -0,0 +1 @@
+export { compileApiRequestBody, getValueFromFormData, interpolateTemplate, interpolateObjectTemplate, setNestedValue, getAvailableFormFields, } from '../../../../../core/src/index.ts';

package/index.d.ts

@@ -0,0 +1,35 @@
+export { isFormFieldComponent } from './component-registry/components';
+export type { ComponentValue } from '../../ui/src/index.ts';
+export { renderComponent } from '../../ui/src/index.ts';
+export { DEFAULT_FORM_CONFIG, type FormConfig, type FormStorageConfig, useFormConfiguration, } from './config';
+export { FlowBuilderErrorBoundary } from './error-boundaries';
+export * from './features/condition-editor';
+export * from './features/dialog-system';
+export * from './features/form-builder';
+export * from './features/form-management';
+/** @deprecated Use ProjectsView, FormsView, FormBuilderView with NavigationProvider instead */
+export type { FormExplorerProps } from './features/form-management/components/FormExplorer/FormExplorer';
+/** @deprecated Use ProjectsView, FormsView, FormBuilderView with NavigationProvider instead */
+export { FormExplorer } from './features/form-management/components/FormExplorer/FormExplorer';
+export type { 
+/** @deprecated Use FormBuilderView directly - FormBuilderPage requires react-router-dom */
+FormBuilderPageProps, 
+/** @deprecated Use FormsView directly - FormsPage requires react-router-dom */
+FormsPageProps, ProjectsPageProps, } from './features/form-management/components/pages';
+export { 
+/** @deprecated Use FormBuilderView directly - FormBuilderPage requires react-router-dom */
+FormBuilderPage, 
+/** @deprecated Use FormsView directly - FormsPage requires react-router-dom */
+FormsPage, ProjectsPage, } from './features/form-management/components/pages';
+export * from './features/property-editors';
+export * from './features/template-system';
+export { TemplateStorageService } from './features/template-system/services/TemplateStorageService';
+export * from './features/trigger-action-system';
+export * from './features/visual-mapping';
+export * from './providers';
+export type { CreateFormRequest, CreateProjectRequest, FileStorageError, FormBuilderSettings, FormFile, FormMetadata, FormStorageProvider, GenericTemplate, PersonalTemplate, SharedTemplate, StorageResult, TeamTemplate, TemplateCategory, TemplateCategoryInfo, TemplateDirectory, TemplateFile, TemplateStorageConfig, } from './storage/types';
+export type { ComponentConfig, FormSectionConfig, FormStepConfig, FormWizardConfig, StepNavigation, StepNavigationItem, StepTemplate, TemplateHistoryEntry, } from './store';
+export { useCanUndo, useCurrentSection, useFormBuilderActions, useFormBuilderStore, useFormConfig, useFormSteps, useHasUnsavedChanges, useIsSaving, useLastSavedAt, useSaveError, useSelectedSectionId, useSelectedStepId, } from './store';
+export * from './utils';
+export { getDatabaseConfig, resolveConfigVariables, } from './utils/configReader';
+export { type FormOperationsConfig, formatProjectName, getStorageProvider, loadFormConfigFromExplorer, registerStorageStrategy, type StorageStrategy, } from './utils/formsExplorer';

package/integrations/NextJSIntegration.d.ts

@@ -0,0 +1,23 @@
+import { FormManagerProps } from '../features/form-management/components/FormManager/FormManager';
+export interface NextJSFormManagerProps {
+    className?: string;
+    style?: React.CSSProperties;
+    initialView?: FormManagerProps["initialView"];
+    config?: FormManagerProps["config"];
+    previewUrl?: FormManagerProps["previewUrl"];
+    getPreviewUrl?: FormManagerProps["getPreviewUrl"];
+    showPreview?: FormManagerProps["showPreview"];
+    project?: string;
+    wizardId?: string;
+}
+/**
+ * FormManager with Next.js App Router integration
+ * Use this when you're using Next.js 13+ App Router
+ */
+export declare const NextJSFormManager: React.FC<NextJSFormManagerProps>;
+/**
+ * FormManager with Next.js Pages Router integration
+ * Use this when you're using Next.js Pages Router (legacy)
+ */
+export declare const NextJSPagesFormManager: React.FC<NextJSFormManagerProps>;
+export default NextJSFormManager;

package/integrations/ReactRouterIntegration.d.ts

@@ -0,0 +1,16 @@
+import { FormManagerProps } from '../features/form-management/components/FormManager/FormManager';
+export interface ReactRouterFormManagerProps {
+    className?: string;
+    style?: React.CSSProperties;
+    initialView?: FormManagerProps["initialView"];
+    config?: FormManagerProps["config"];
+    previewUrl?: FormManagerProps["previewUrl"];
+    getPreviewUrl?: FormManagerProps["getPreviewUrl"];
+    showPreview?: FormManagerProps["showPreview"];
+}
+/**
+ * FormManager with React Router integration
+ * Use this when you're using react-router-dom
+ */
+export declare const ReactRouterFormManager: React.FC<ReactRouterFormManagerProps>;
+export default ReactRouterFormManager;

package/integrations/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Framework integrations for FormManager
+ *
+ * These integrations provide seamless compatibility with different React frameworks
+ * while maintaining the core FormManager's framework-agnostic design.
+ */
+export type { FormManagerProps, RouterIntegration, } from '../features/form-management/components/FormManager/FormManager';
+export { default as FormManager } from '../features/form-management/components/FormManager/FormManager';
+export type { NextJSFormManagerProps } from './NextJSIntegration';
+export { NextJSFormManager, NextJSPagesFormManager } from './NextJSIntegration';
+export type { ReactRouterFormManagerProps } from './ReactRouterIntegration';
+export { ReactRouterFormManager } from './ReactRouterIntegration';

package/integrations/react-router/FormBuilderPage/FormBuilderPage.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { FormConfig } from '../../../config/types';
+export interface FormBuilderPageProps {
+    /**
+     * Optional form configuration
+     */
+    config?: FormConfig;
+    /**
+     * Optional CSS class name
+     */
+    className?: string;
+    /**
+     * Optional inline styles
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * Standalone FormBuilderPage component for user-defined routing
+ * Shows the form builder for a specific form
+ *
+ * @deprecated Use FormBuilderView directly with your framework's param reading
+ */
+export declare const FormBuilderPage: React.FC<FormBuilderPageProps>;

package/integrations/react-router/FormsPage.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+export interface FormsPageProps {
+    /**
+     * Optional CSS class name
+     */
+    className?: string;
+    /**
+     * Optional inline styles
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * Standalone FormsPage component for user-defined routing
+ * Shows forms within a specific project
+ *
+ * @deprecated Use FormsView directly with your framework's param reading
+ */
+export declare const FormsPage: React.FC<FormsPageProps>;

package/integrations/react-router/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * React Router integrations for form management
+ *
+ * @deprecated Use standalone view components with NavigationProvider instead
+ */
+export type { ReactRouterFormManagerProps } from '../ReactRouterIntegration';
+export { ReactRouterFormManager } from '../ReactRouterIntegration';
+export type { FormBuilderPageProps } from './FormBuilderPage/FormBuilderPage';
+export { FormBuilderPage } from './FormBuilderPage/FormBuilderPage';
+export type { FormsPageProps } from './FormsPage';
+export { FormsPage } from './FormsPage';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digiform/builder",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "description": "React form builder for creating and managing configurable multi-step forms",
   "author": "VladAfanasev",
   "license": "MIT",

package/providers/FormSaveContext.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { FormSaveProvider } from './FormSaveProvider';
+interface FormSaveProviderProps {
+    provider?: FormSaveProvider;
+    children: ReactNode;
+}
+/**
+ * Form save provider component
+ * Wrap your app with this to configure the save functionality
+ */
+export declare const FormSaveProviderComponent: ({ provider, children, }: FormSaveProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to get the current form save provider
+ */
+export declare const useFormSaveProvider: () => FormSaveProvider;
+/**
+ * Hook to check if a save provider is configured
+ */
+export declare const useHasFormSaveProvider: () => boolean;
+export {};