@digiform/builder 0.1.7 → 0.2.4

package/features/template-system/components/TemplateContextMenu/TemplateContextMenu.d.ts

@@ -0,0 +1,12 @@
+import { Template } from '../../../../utils/fileStorage';
+import { default as React } from 'react';
+interface TemplateContextMenuProps {
+    template: Template;
+    currentUser: string;
+    onPreview?: () => void;
+    onEdit?: () => void;
+    onDuplicate?: () => void;
+    onDelete?: () => void;
+}
+export declare const TemplateContextMenu: React.FC<TemplateContextMenuProps>;
+export {};

package/features/template-system/hooks/useTemplateGovernance.d.ts

@@ -0,0 +1,46 @@
+import { FormStepConfig, TemplateStepConfig } from '../../../../../core/src/index.ts';
+/**
+ * Hook to get template governance information for a step
+ *
+ * Returns comprehensive information about template permissions, display properties,
+ * and lock status for use in UI components.
+ */
+export declare function useTemplateGovernance(step: FormStepConfig | TemplateStepConfig | null, templateOrigin?: {
+    templateId: string;
+    stepIndex?: number;
+}): {
+    isLocked: boolean;
+    isGeneric: boolean;
+    isTeam: boolean;
+    isRegularStep: boolean;
+    permissions: import('../utils/templateConfig').TemplatePermissions;
+    display: import('../utils/templateConfig').TemplateDisplayConfig;
+    lockMessage: string;
+};
+/**
+ * Hook to check if a specific action is allowed for a step
+ */
+export declare function useTemplatePermission(step: FormStepConfig | TemplateStepConfig | null, permission: keyof ReturnType<typeof useTemplateGovernance>["permissions"], templateOrigin?: {
+    templateId: string;
+    stepIndex?: number;
+}): boolean;
+/**
+ * Hook to get the lock status and message for a property
+ */
+export declare function usePropertyLock(step: FormStepConfig | TemplateStepConfig | null, propertyName: string, templateOrigin?: {
+    templateId: string;
+    stepIndex?: number;
+}): {
+    isLocked: boolean;
+    lockMessage: string;
+};
+/**
+ * Hook specifically for component property locks
+ */
+export declare function useComponentPropertyLock(step: FormStepConfig | TemplateStepConfig | null, templateOrigin?: {
+    templateId: string;
+    stepIndex?: number;
+}): {
+    isLocked: boolean;
+    lockMessage: string;
+};

package/features/template-system/hooks/useTemplatePermissions.d.ts

@@ -0,0 +1,104 @@
+import { FormStepConfig, TemplateStepConfig } from '../../../../../core/src/index.ts';
+import { TemplatePermissions } from '../utils/templateConfig';
+/**
+ * Hook to get template permissions and validation for a step
+ */
+export declare function useTemplatePermissions(step: FormStepConfig | TemplateStepConfig | null): {
+    permissions: TemplatePermissions;
+    isLocked: boolean;
+    canEdit: boolean;
+    templateInfo: null;
+    validateAction: () => {
+        allowed: boolean;
+    };
+    isActionAllowed: () => true;
+} | {
+    permissions: TemplatePermissions;
+    isLocked: boolean;
+    canEdit: boolean;
+    templateInfo: {
+        type: import('../utils/templateConfig').TemplateType;
+        permissions: TemplatePermissions;
+        display: import('../utils/templateConfig').TemplateDisplayConfig;
+        rules: {
+            lockMessage: string;
+            supportsMultipleSteps: boolean;
+            defaultNavigation: {
+                next: {
+                    label: string;
+                    enabled: boolean;
+                };
+                previous: {
+                    label: string;
+                    enabled: boolean;
+                };
+            };
+        };
+        isLocked: boolean;
+        canEdit: boolean;
+        isGeneric: boolean;
+        isTeam: boolean;
+        isRegularStep: boolean;
+    };
+    validateAction: (action: keyof TemplatePermissions) => {
+        allowed: boolean;
+        message?: string;
+    };
+    isActionAllowed: (action: keyof TemplatePermissions) => boolean;
+};
+/**
+ * Hook to get template permissions for the currently selected step
+ */
+export declare function useCurrentStepTemplatePermissions(): {
+    permissions: TemplatePermissions;
+    isLocked: boolean;
+    canEdit: boolean;
+    templateInfo: null;
+    validateAction: () => {
+        allowed: boolean;
+    };
+    isActionAllowed: () => true;
+} | {
+    permissions: TemplatePermissions;
+    isLocked: boolean;
+    canEdit: boolean;
+    templateInfo: {
+        type: import('../utils/templateConfig').TemplateType;
+        permissions: TemplatePermissions;
+        display: import('../utils/templateConfig').TemplateDisplayConfig;
+        rules: {
+            lockMessage: string;
+            supportsMultipleSteps: boolean;
+            defaultNavigation: {
+                next: {
+                    label: string;
+                    enabled: boolean;
+                };
+                previous: {
+                    label: string;
+                    enabled: boolean;
+                };
+            };
+        };
+        isLocked: boolean;
+        canEdit: boolean;
+        isGeneric: boolean;
+        isTeam: boolean;
+        isRegularStep: boolean;
+    };
+    validateAction: (action: keyof TemplatePermissions) => {
+        allowed: boolean;
+        message?: string;
+    };
+    isActionAllowed: (action: keyof TemplatePermissions) => boolean;
+};
+/**
+ * Hook to check if a specific action is allowed for the current step
+ */
+export declare function useIsActionAllowed(action: keyof TemplatePermissions): boolean;
+/**
+ * Hook to validate an action for the current step and get appropriate error message
+ */
+export declare function useValidateAction(action: keyof TemplatePermissions): {
+    allowed: boolean;
+};

package/features/template-system/hooks/useTemplateStepTitle.d.ts

@@ -0,0 +1,5 @@
+import { TemplateStepConfig } from '../../../../../core/src/index.ts';
+/**
+ * Hook to resolve template step titles
+ */
+export declare const useTemplateStepTitle: (step: TemplateStepConfig) => string;

package/features/template-system/index.d.ts

@@ -0,0 +1,17 @@
+export * from './components/CreateTemplateDialog/CreateTemplateDialog';
+export * from './components/DeleteTemplateDialog/DeleteTemplateDialog';
+export * from './components/DuplicateTemplateDialog/DuplicateTemplateDialog';
+export * from './components/EditTemplateDialog/EditTemplateDialog';
+export * from './components/EnhancedTemplateBrowser/EnhancedTemplateBrowser';
+export * from './components/TemplateContextMenu/TemplateContextMenu';
+export * from './hooks/useTemplateGovernance';
+export * from './hooks/useTemplatePermissions';
+export * from './hooks/useTemplateStepTitle';
+export * from './services/TemplateStorageService';
+export * from './utils/templateApplication';
+export * from './utils/templateCategories';
+export * from './utils/templateConfig';
+export * from './utils/templateDeletion';
+export * from './utils/templateDuplication';
+export * from './utils/templateGovernance';
+export * from './utils/templateMetadataOperations';

package/features/template-system/services/TemplateStorageService.d.ts

@@ -0,0 +1,52 @@
+import { FileStorageResult, Template, TemplateCategory, TemplateStorageConfig } from '../../../utils/fileStorage';
+/**
+ * Template storage service using File System Access API
+ * Falls back to download/upload for browsers without support
+ */
+export declare class TemplateStorageService {
+    private storageConfig;
+    /**
+     * Initialize the service with storage configuration
+     */
+    initialize(storageConfig: TemplateStorageConfig): Promise<void>;
+    /**
+     * Save a template to storage
+     */
+    saveTemplate(template: Template): Promise<FileStorageResult<string>>;
+    private saveWithDirectFilesystem;
+    /**
+     * Load a template from storage
+     */
+    loadTemplate(templateId: string, category: TemplateCategory): Promise<FileStorageResult<Template>>;
+    private loadWithFetch;
+    /**
+     * List templates in a category
+     */
+    listTemplates(category: TemplateCategory): Promise<FileStorageResult<Template[]>>;
+    private listWithFetch;
+    /**
+     * Delete a template
+     */
+    deleteTemplate(templateId: string, category: TemplateCategory): Promise<FileStorageResult<void>>;
+    /**
+     * Get template directory path for a category
+     */
+    private getTemplateDirectory;
+    /**
+     * Check if the service is properly configured and ready to use
+     */
+    isReady(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): TemplateStorageConfig | null;
+    /**
+     * Update template metadata
+     */
+    updateTemplateMetadata(templateId: string, category: TemplateCategory, updates: Partial<Template["metadata"]>): Promise<FileStorageResult<Template>>;
+    /**
+     * Duplicate a template with new ID
+     */
+    duplicateTemplate(sourceTemplateId: string, sourceCategory: TemplateCategory, newMetadata: Partial<Template["metadata"]>, targetCategory?: TemplateCategory): Promise<FileStorageResult<string>>;
+}
+export declare const templateStorageService: TemplateStorageService;

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

@@ -0,0 +1,75 @@
+import { Template } from '../../../utils/fileStorage';
+import { FormStepConfig, FormTemplate } from '../../../../../core/src/index.ts';
+/**
+ * Minimal interface representing what applyCustomTemplate actually reads from a template.
+ * stepsData is typed as unknown so callers with Omit<FormStepConfig, "navigation">[] or
+ * FormStepConfig[] can pass their template objects without unsafe casts.
+ * The function accesses individual step fields and fills in missing properties (e.g. navigation).
+ */
+export interface TemplateWithStepsData {
+    stepsData: unknown;
+}
+/**
+ * Interface for template application result
+ */
+export interface TemplateApplicationResult {
+    success: boolean;
+    stepConfig?: FormStepConfig;
+    conflicts?: TemplateConflict[];
+    error?: string;
+}
+/**
+ * Interface for multi-step template application result
+ */
+export interface StepTemplateApplicationResult {
+    success: boolean;
+    stepConfigs?: FormStepConfig[];
+    conflicts?: TemplateConflict[];
+    error?: string;
+}
+/**
+ * Interface for template conflicts that need user resolution
+ */
+export interface TemplateConflict {
+    type: "duplicate_id" | "naming_conflict" | "validation_conflict";
+    field: string;
+    message: string;
+    suggestions: string[];
+}
+/**
+ * Interface for template application options
+ */
+export interface TemplateApplicationOptions {
+    /** Whether to automatically resolve ID conflicts */
+    autoResolveIds?: boolean;
+    /** Whether to preserve existing field names */
+    preserveFieldNames?: boolean;
+    /** Custom field name mappings */
+    fieldMappings?: Record<string, string>;
+    /** Step title override */
+    stepTitle?: string;
+    /** Whether to validate the template before application */
+    validateTemplate?: boolean;
+}
+/**
+ * Apply a built-in template to create a new step configuration
+ */
+export declare function applyBuiltinTemplate(templateKey: string, options?: TemplateApplicationOptions): TemplateApplicationResult;
+/**
+ * Apply a multi-step template to create multiple step configurations
+ */
+export declare function applyStepTemplate(template: FormTemplate, options?: TemplateApplicationOptions): StepTemplateApplicationResult;
+/**
+ * Apply a custom template to create a new step configuration.
+ * Accepts any object with a stepsData property — both Template (from file storage)
+ * and CompatibleTemplateConfig (from formBuilderStore) satisfy this interface.
+ */
+export declare function applyCustomTemplate(template: Template | TemplateWithStepsData, options?: TemplateApplicationOptions): TemplateApplicationResult;
+/**
+ * Get template preview data for built-in templates
+ */
+export declare function getTemplatePreview(templateKey: string): {
+    sectionCount: number;
+    componentCount: number;
+    description: string;
+} | null;

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

@@ -0,0 +1,105 @@
+import { FileStorageResult, Template, TemplateCategory, TemplateStorageConfig } from '../../../utils/fileStorage';
+/**
+ * Interface for category display information
+ */
+export interface CategoryDisplayInfo {
+    displayName: string;
+    description: string;
+    icon: string;
+    permissions: {
+        canCreate: boolean;
+        canEdit: boolean;
+        canDelete: boolean;
+    };
+}
+/**
+ * Interface for category statistics
+ */
+export interface CategoryStatistics {
+    templateCount: number;
+    totalUsage: number;
+    lastModified: number | null;
+    recentlyAdded: number;
+    error?: string;
+}
+/**
+ * Interface for category access validation result
+ */
+export interface CategoryAccessResult {
+    hasAccess: boolean;
+    permissions: {
+        canView: boolean;
+        canCreate: boolean;
+        canEdit: boolean;
+        canDelete: boolean;
+        canShare: boolean;
+        canManage: boolean;
+    };
+    reason?: string;
+}
+/**
+ * Get available template categories based on storage configuration
+ */
+export declare function getAvailableCategories(storageConfig: TemplateStorageConfig): TemplateCategory[];
+/**
+ * Get display information for a category
+ */
+export declare function getCategoryDisplayInfo(category: TemplateCategory): CategoryDisplayInfo;
+/**
+ * Get statistics for all categories
+ */
+export declare function getCategoryStatistics(storageConfig: TemplateStorageConfig): Promise<FileStorageResult<Record<TemplateCategory, CategoryStatistics>>>;
+/**
+ * Validate category access for a user
+ */
+export declare function validateCategoryAccess(category: TemplateCategory, currentUser: string, storageConfig: TemplateStorageConfig): CategoryAccessResult;
+/**
+ * Get permissions for a user in a specific category
+ */
+export declare function getCategoryPermissions(category: TemplateCategory, currentUser: string): {
+    canView: boolean;
+    canCreate: boolean;
+    canEdit: boolean;
+    canDelete: boolean;
+    canShare: boolean;
+    canManage: boolean;
+};
+/**
+ * Get templates for a specific category
+ */
+export declare function getTemplatesByCategory(category: TemplateCategory, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<Template[]>>;
+/**
+ * Get category usage analytics
+ */
+export declare function getCategoryUsageAnalytics(category: TemplateCategory, storageConfig: TemplateStorageConfig, days?: number): Promise<FileStorageResult<{
+    totalTemplates: number;
+    totalUsage: number;
+    averageUsage: number;
+    mostUsedTemplates: Array<{
+        name: string;
+        usageCount: number;
+    }>;
+    leastUsedTemplates: Array<{
+        name: string;
+        usageCount: number;
+    }>;
+    recentActivity: Array<{
+        date: string;
+        templateName: string;
+        action: "created" | "modified";
+    }>;
+}>>;
+/**
+ * Get templates by tag across all categories
+ */
+export declare function getTemplatesByTag(tag: string, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<Array<Template & {
+    category: TemplateCategory;
+}>>>;
+/**
+ * Get all unique tags across categories
+ */
+export declare function getAllTemplateTags(storageConfig: TemplateStorageConfig): Promise<FileStorageResult<Array<{
+    tag: string;
+    count: number;
+    categories: TemplateCategory[];
+}>>>;

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

@@ -0,0 +1,148 @@
+import { FormStepConfig, TemplateStepConfig } from '../../../../../core/src/index.ts';
+export type TemplateType = "generic" | "team" | null;
+/**
+ * Template permissions configuration
+ */
+export interface TemplatePermissions {
+    /** Can add new components to sections */
+    canAddComponents: boolean;
+    /** Can remove existing components */
+    canRemoveComponents: boolean;
+    /** Can edit component properties */
+    canEditComponentProperties: boolean;
+    /** Can add new sections */
+    canAddSections: boolean;
+    /** Can remove existing sections */
+    canRemoveSections: boolean;
+    /** Can edit section properties */
+    canEditSectionProperties: boolean;
+    /** Can edit step title */
+    canEditStepTitle: boolean;
+    /** Can edit navigation settings */
+    canEditNavigation: boolean;
+    /** Can add/edit actions */
+    canEditActions: boolean;
+    /** Can duplicate the step */
+    canDuplicate: boolean;
+    /** Can delete the step */
+    canDelete: boolean;
+}
+/**
+ * Template display configuration
+ */
+export interface TemplateDisplayConfig {
+    /** Template type for UI display */
+    type: TemplateType;
+    /** Whether template is readonly */
+    isReadonly: boolean;
+    /** Whether to show lock icon */
+    showLockIcon: boolean;
+    /** CSS classes for theme styling */
+    themeClass: string;
+    /** Icon color classes */
+    iconColor: string;
+    /** Tooltip text for locked templates */
+    lockTooltip?: string;
+    /** Badge text for template type */
+    badgeText?: string;
+}
+/**
+ * Complete template configuration
+ */
+export interface TemplateConfig {
+    permissions: TemplatePermissions;
+    display: TemplateDisplayConfig;
+    rules: {
+        /** Message shown when user tries to edit locked content */
+        lockMessage: string;
+        /** Whether this template type supports multiple steps */
+        supportsMultipleSteps: boolean;
+        /** Default navigation behavior */
+        defaultNavigation: {
+            next: {
+                label: string;
+                enabled: boolean;
+            };
+            previous: {
+                label: string;
+                enabled: boolean;
+            };
+        };
+    };
+}
+/**
+ * Gets the complete template configuration for a given template ID or step
+ */
+export declare function getTemplateConfig(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): TemplateConfig;
+/**
+ * Gets template permissions for a given template ID or step
+ */
+export declare function getTemplatePermissions(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): TemplatePermissions;
+/**
+ * Gets template display configuration for a given template ID or step
+ */
+export declare function getTemplateDisplayConfig(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): TemplateDisplayConfig;
+/**
+ * Checks if a specific action is allowed for a template or step
+ */
+export declare function isActionAllowed(templateIdOrStep: string | FormStepConfig | TemplateStepConfig, action: keyof TemplatePermissions): boolean;
+/**
+ * Checks if a step is locked for editing
+ */
+export declare function isStepLocked(step: FormStepConfig | TemplateStepConfig, templateOrigin?: {
+    templateId: string;
+    stepIndex?: number;
+}): boolean;
+/**
+ * Gets the lock message for a template
+ */
+export declare function getLockMessage(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): string;
+/**
+ * Validates if a template action should be blocked and returns appropriate message
+ */
+export declare function validateTemplateAction(templateIdOrStep: string | FormStepConfig | TemplateStepConfig, action: keyof TemplatePermissions): {
+    allowed: boolean;
+    message?: string;
+};
+/**
+ * Gets template type from various input formats
+ */
+export declare function getTemplateTypeFromInput(input: string | FormStepConfig | TemplateStepConfig): TemplateType;
+/**
+ * Utility to check if input represents a generic template
+ */
+export declare function isGenericTemplateInput(input: string | FormStepConfig | TemplateStepConfig): boolean;
+/**
+ * Utility to check if input represents a team template
+ */
+export declare function isTeamTemplateInput(input: string | FormStepConfig | TemplateStepConfig): boolean;
+/**
+ * Creates a comprehensive template info object for UI components
+ */
+export declare function getTemplateInfo(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): {
+    type: TemplateType;
+    permissions: TemplatePermissions;
+    display: TemplateDisplayConfig;
+    rules: {
+        /** Message shown when user tries to edit locked content */
+        lockMessage: string;
+        /** Whether this template type supports multiple steps */
+        supportsMultipleSteps: boolean;
+        /** Default navigation behavior */
+        defaultNavigation: {
+            next: {
+                label: string;
+                enabled: boolean;
+            };
+            previous: {
+                label: string;
+                enabled: boolean;
+            };
+        };
+    };
+    isLocked: boolean;
+    canEdit: boolean;
+    isGeneric: boolean;
+    isTeam: boolean;
+    isRegularStep: boolean;
+};

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

@@ -0,0 +1,44 @@
+import { FileStorageResult, Template, TemplateCategory } from '../../../utils/fileStorage';
+/**
+ * Interface for deletion permission check result
+ */
+export interface DeletionPermissionResult {
+    canDelete: boolean;
+    reason?: string;
+}
+/**
+ * Interface for deletion validation result
+ */
+export interface DeletionValidationResult {
+    canDelete: boolean;
+    template?: Template;
+    warnings: string[];
+    errors: string[];
+}
+/**
+ * Interface for bulk deletion result
+ */
+export interface BulkDeletionResult {
+    deletedCount: number;
+    failedCount: number;
+    failures: Array<{
+        templateId: string;
+        error: string;
+    }>;
+}
+/**
+ * Check if a template can be deleted by a specific user
+ */
+export declare function canDeleteTemplate(template: Template, currentUser: string): DeletionPermissionResult;
+/**
+ * Delete a template with validation
+ */
+export declare function deleteTemplateWithValidation(templateId: string, category: TemplateCategory, currentUser: string): Promise<FileStorageResult<void>>;
+/**
+ * Delete multiple templates
+ */
+export declare function deleteMultipleTemplates(templateIds: string[], category: TemplateCategory, currentUser: string): Promise<FileStorageResult<BulkDeletionResult>>;
+/**
+ * Validate template deletion and provide warnings
+ */
+export declare function validateTemplateDeletion(templateId: string, category: TemplateCategory, currentUser: string): Promise<DeletionValidationResult>;

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

@@ -0,0 +1,65 @@
+import { FileStorageResult, Template, TemplateCategory, TemplateStorageConfig } from '../../../utils/fileStorage';
+import { FormStepConfig } from '../../../../../core/src/index.ts';
+/**
+ * Interface for duplication request
+ */
+export interface DuplicationRequest {
+    name: string;
+    description?: string;
+    tags?: string[];
+}
+/**
+ * Interface for duplication validation result
+ */
+export interface DuplicationValidationResult {
+    isValid: boolean;
+    errors: string[];
+    sourceTemplate?: Template;
+}
+/**
+ * Interface for duplication result
+ */
+export interface DuplicationResult {
+    templateId: string;
+    filePath: string;
+}
+/**
+ * Duplicate a template
+ */
+export declare function duplicateTemplate(sourceTemplateId: string, sourceCategory: TemplateCategory, duplicateInfo: DuplicationRequest, targetCategory: TemplateCategory, currentUser: string, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<DuplicationResult>>;
+/**
+ * Validate a duplication request
+ */
+export declare function validateDuplicationRequest(sourceTemplateId: string, sourceCategory: TemplateCategory, newName: string, targetCategory: TemplateCategory, _currentUser: string, storageConfig: TemplateStorageConfig): Promise<DuplicationValidationResult>;
+/**
+ * Create a duplicate template with new IDs
+ */
+export declare function createDuplicateWithNewIds(sourceTemplate: Template, duplicateInfo: DuplicationRequest, targetCategory: TemplateCategory, currentUser: string): Template;
+/**
+ * Generate unique IDs for all components in step data
+ */
+export declare function generateUniqueComponentIds(stepData: FormStepConfig): FormStepConfig;
+/**
+ * Duplicate multiple templates
+ */
+export declare function duplicateMultipleTemplates(templates: Array<{
+    sourceTemplateId: string;
+    sourceCategory: TemplateCategory;
+    duplicateInfo: DuplicationRequest;
+}>, targetCategory: TemplateCategory, currentUser: string, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<Array<{
+    templateId: string;
+    name: string;
+    success: boolean;
+    error?: string;
+}>>>;
+/**
+ * Create a template copy with auto-generated name
+ */
+export declare function quickDuplicateTemplate(sourceTemplateId: string, sourceCategory: TemplateCategory, targetCategory: TemplateCategory, currentUser: string, storageConfig: TemplateStorageConfig): Promise<FileStorageResult<DuplicationResult>>;
+/**
+ * Validate that duplication preserves template structure
+ */
+export declare function validateDuplicateStructure(original: FormStepConfig, duplicate: FormStepConfig): {
+    isValid: boolean;
+    errors: string[];
+};