@flowdrop/flowdrop 1.0.0

package/dist/services/autoSaveService.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Auto-save Service for FlowDrop
+ *
+ * Handles automatic saving of workflows based on user settings.
+ * Uses behaviorSettings for auto-save configuration.
+ *
+ * @module services/autoSaveService
+ */
+/**
+ * Auto-save configuration options
+ */
+interface AutoSaveOptions {
+    /**
+     * Callback function to save the workflow
+     * Should return a promise that resolves when save is complete
+     */
+    onSave: () => Promise<void>;
+    /**
+     * Optional callback for save errors
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Optional callback for successful saves
+     */
+    onSuccess?: () => void;
+}
+/**
+ * Initialize auto-save functionality based on user settings
+ *
+ * Creates an interval-based auto-save mechanism that:
+ * - Listens to behaviorSettings changes for auto-save configuration
+ * - Monitors the isDirty state to check for unsaved changes
+ * - Calls the provided save callback when dirty and auto-save is enabled
+ *
+ * @param options - Auto-save configuration options
+ * @returns Cleanup function to stop auto-save and unsubscribe from stores
+ *
+ * @example
+ * ```typescript
+ * // In App.svelte onMount
+ * const cleanupAutoSave = initAutoSave({
+ *   onSave: async () => {
+ *     await saveWorkflow();
+ *   },
+ *   onError: (error) => {
+ *     console.error("Auto-save failed:", error);
+ *   },
+ *   onSuccess: () => {
+ *     console.log("Auto-saved workflow");
+ *   }
+ * });
+ *
+ * // In onDestroy
+ * cleanupAutoSave();
+ * ```
+ */
+export declare function initAutoSave(options: AutoSaveOptions): () => void;
+/**
+ * Create an auto-save manager with more control
+ *
+ * This is a class-based alternative to initAutoSave for cases where
+ * you need more fine-grained control over the auto-save behavior.
+ */
+export declare class AutoSaveManager {
+    private intervalId;
+    private isSaving;
+    private settingsUnsubscriber;
+    private onSave;
+    private onError?;
+    private onSuccess?;
+    /**
+     * Create a new AutoSaveManager
+     *
+     * @param options - Auto-save configuration options
+     */
+    constructor(options: AutoSaveOptions);
+    /**
+     * Start the auto-save manager
+     *
+     * Listens for settings changes and starts the auto-save interval.
+     */
+    start(): void;
+    /**
+     * Stop the auto-save manager
+     *
+     * Clears the interval and unsubscribes from settings.
+     */
+    stop(): void;
+    /**
+     * Force an immediate save (if dirty)
+     *
+     * @returns Promise that resolves when save is complete
+     */
+    saveNow(): Promise<void>;
+    /**
+     * Check if auto-save is currently enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Check if auto-save is currently running
+     */
+    isRunning(): boolean;
+    /**
+     * Update the interval based on current settings
+     */
+    private updateInterval;
+    /**
+     * Perform the save operation
+     */
+    private performSave;
+}
+export {};

package/dist/services/autoSaveService.js

@@ -0,0 +1,227 @@
+/**
+ * Auto-save Service for FlowDrop
+ *
+ * Handles automatic saving of workflows based on user settings.
+ * Uses behaviorSettings for auto-save configuration.
+ *
+ * @module services/autoSaveService
+ */
+import { getBehaviorSettings, onSettingsChange } from '../stores/settingsStore.svelte.js';
+import { isDirty } from '../stores/workflowStore.svelte.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Initialize auto-save functionality based on user settings
+ *
+ * Creates an interval-based auto-save mechanism that:
+ * - Listens to behaviorSettings changes for auto-save configuration
+ * - Monitors the isDirty state to check for unsaved changes
+ * - Calls the provided save callback when dirty and auto-save is enabled
+ *
+ * @param options - Auto-save configuration options
+ * @returns Cleanup function to stop auto-save and unsubscribe from stores
+ *
+ * @example
+ * ```typescript
+ * // In App.svelte onMount
+ * const cleanupAutoSave = initAutoSave({
+ *   onSave: async () => {
+ *     await saveWorkflow();
+ *   },
+ *   onError: (error) => {
+ *     console.error("Auto-save failed:", error);
+ *   },
+ *   onSuccess: () => {
+ *     console.log("Auto-saved workflow");
+ *   }
+ * });
+ *
+ * // In onDestroy
+ * cleanupAutoSave();
+ * ```
+ */
+export function initAutoSave(options) {
+    const { onSave, onError, onSuccess } = options;
+    const state = {
+        intervalId: null,
+        isSaving: false,
+        settingsUnsubscriber: null,
+        dirtyUnsubscriber: null
+    };
+    /**
+     * Perform auto-save if conditions are met
+     */
+    async function performAutoSave() {
+        // Skip if already saving or not dirty
+        if (state.isSaving || !isDirty()) {
+            return;
+        }
+        state.isSaving = true;
+        try {
+            await onSave();
+            onSuccess?.();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.error('Auto-save failed:', err);
+            onError?.(err);
+        }
+        finally {
+            state.isSaving = false;
+        }
+    }
+    /**
+     * Start or restart the auto-save interval based on current settings
+     */
+    function updateAutoSaveInterval() {
+        // Clear existing interval
+        if (state.intervalId) {
+            clearInterval(state.intervalId);
+            state.intervalId = null;
+        }
+        const settings = getBehaviorSettings();
+        // Start new interval if auto-save is enabled
+        if (settings.autoSave) {
+            state.intervalId = setInterval(() => {
+                performAutoSave();
+            }, settings.autoSaveInterval);
+        }
+    }
+    // Listen for settings changes to react to auto-save toggle/interval changes
+    state.settingsUnsubscriber = onSettingsChange((event) => {
+        if (event.category === 'behavior') {
+            updateAutoSaveInterval();
+        }
+    });
+    // Initial setup
+    updateAutoSaveInterval();
+    /**
+     * Cleanup function to stop auto-save and unsubscribe from stores
+     */
+    return function cleanup() {
+        // Clear the interval
+        if (state.intervalId) {
+            clearInterval(state.intervalId);
+            state.intervalId = null;
+        }
+        // Unsubscribe from settings changes
+        if (state.settingsUnsubscriber) {
+            state.settingsUnsubscriber();
+            state.settingsUnsubscriber = null;
+        }
+        if (state.dirtyUnsubscriber) {
+            state.dirtyUnsubscriber();
+            state.dirtyUnsubscriber = null;
+        }
+    };
+}
+/**
+ * Create an auto-save manager with more control
+ *
+ * This is a class-based alternative to initAutoSave for cases where
+ * you need more fine-grained control over the auto-save behavior.
+ */
+export class AutoSaveManager {
+    intervalId = null;
+    isSaving = false;
+    settingsUnsubscriber = null;
+    onSave;
+    onError;
+    onSuccess;
+    /**
+     * Create a new AutoSaveManager
+     *
+     * @param options - Auto-save configuration options
+     */
+    constructor(options) {
+        this.onSave = options.onSave;
+        this.onError = options.onError;
+        this.onSuccess = options.onSuccess;
+    }
+    /**
+     * Start the auto-save manager
+     *
+     * Listens for settings changes and starts the auto-save interval.
+     */
+    start() {
+        if (this.settingsUnsubscriber) {
+            return; // Already started
+        }
+        this.settingsUnsubscriber = onSettingsChange((event) => {
+            if (event.category === 'behavior') {
+                this.updateInterval();
+            }
+        });
+        this.updateInterval();
+    }
+    /**
+     * Stop the auto-save manager
+     *
+     * Clears the interval and unsubscribes from settings.
+     */
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.settingsUnsubscriber) {
+            this.settingsUnsubscriber();
+            this.settingsUnsubscriber = null;
+        }
+    }
+    /**
+     * Force an immediate save (if dirty)
+     *
+     * @returns Promise that resolves when save is complete
+     */
+    async saveNow() {
+        await this.performSave();
+    }
+    /**
+     * Check if auto-save is currently enabled
+     */
+    isEnabled() {
+        return getBehaviorSettings().autoSave;
+    }
+    /**
+     * Check if auto-save is currently running
+     */
+    isRunning() {
+        return this.intervalId !== null;
+    }
+    /**
+     * Update the interval based on current settings
+     */
+    updateInterval() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        const settings = getBehaviorSettings();
+        if (settings.autoSave) {
+            this.intervalId = setInterval(() => {
+                this.performSave();
+            }, settings.autoSaveInterval);
+        }
+    }
+    /**
+     * Perform the save operation
+     */
+    async performSave() {
+        if (this.isSaving || !isDirty()) {
+            return;
+        }
+        this.isSaving = true;
+        try {
+            await this.onSave();
+            this.onSuccess?.();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.error('Auto-save failed:', err);
+            this.onError?.(err);
+        }
+        finally {
+            this.isSaving = false;
+        }
+    }
+}

package/dist/services/categoriesApi.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Categories API Service
+ * Handles fetching category definitions from the backend
+ */
+import type { CategoryDefinition } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+/**
+ * Fetch category definitions from API
+ */
+export declare function fetchCategories(endpointConfig: EndpointConfig): Promise<CategoryDefinition[]>;
+/**
+ * Validate category definitions structure
+ */
+export declare function validateCategories(categories: CategoryDefinition[]): boolean;

package/dist/services/categoriesApi.js

@@ -0,0 +1,49 @@
+/**
+ * Categories API Service
+ * Handles fetching category definitions from the backend
+ */
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { DEFAULT_CATEGORIES } from '../config/defaultCategories.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Fetch category definitions from API
+ */
+export async function fetchCategories(endpointConfig) {
+    try {
+        const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.categories);
+        const response = await fetch(url, {
+            headers: { 'Content-Type': 'application/json' }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const categories = data.data ?? data;
+        if (!categories || !Array.isArray(categories)) {
+            logger.warn('Invalid categories received from API, using default');
+            return DEFAULT_CATEGORIES;
+        }
+        return categories;
+    }
+    catch (error) {
+        logger.error('Error fetching categories:', error);
+        return DEFAULT_CATEGORIES;
+    }
+}
+/**
+ * Validate category definitions structure
+ */
+export function validateCategories(categories) {
+    if (!categories || !Array.isArray(categories)) {
+        return false;
+    }
+    for (const category of categories) {
+        if (!category.name || typeof category.name !== 'string') {
+            return false;
+        }
+        if (!category.label || typeof category.label !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/services/draftStorage.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Draft Storage Service for FlowDrop
+ *
+ * Handles saving and loading workflow drafts to/from localStorage.
+ * Provides interval-based auto-save functionality.
+ *
+ * @module services/draftStorage
+ */
+import type { Workflow } from '../types/index.js';
+/**
+ * Draft metadata stored alongside the workflow
+ */
+interface DraftMetadata {
+    /** Timestamp when the draft was saved */
+    savedAt: string;
+    /** Workflow ID (if available) */
+    workflowId?: string;
+    /** Workflow name */
+    workflowName?: string;
+}
+/**
+ * Complete draft data stored in localStorage
+ */
+interface StoredDraft {
+    /** The workflow data */
+    workflow: Workflow;
+    /** Draft metadata */
+    metadata: DraftMetadata;
+}
+/**
+ * Generate a storage key for a workflow
+ *
+ * If a custom key is provided, use it directly.
+ * Otherwise, generate based on workflow ID or use "new" for unsaved workflows.
+ *
+ * @param workflowId - The workflow ID (optional)
+ * @param customKey - Custom storage key provided by enterprise (optional)
+ * @returns The storage key to use
+ */
+export declare function getDraftStorageKey(workflowId?: string, customKey?: string): string;
+/**
+ * Save a workflow draft to localStorage
+ *
+ * @param workflow - The workflow to save
+ * @param storageKey - The storage key to use
+ * @returns true if saved successfully, false otherwise
+ */
+export declare function saveDraft(workflow: Workflow, storageKey: string): boolean;
+/**
+ * Load a workflow draft from localStorage
+ *
+ * @param storageKey - The storage key to load from
+ * @returns The stored draft, or null if not found
+ */
+export declare function loadDraft(storageKey: string): StoredDraft | null;
+/**
+ * Delete a workflow draft from localStorage
+ *
+ * @param storageKey - The storage key to delete
+ */
+export declare function deleteDraft(storageKey: string): void;
+/**
+ * Check if a draft exists for a given storage key
+ *
+ * @param storageKey - The storage key to check
+ * @returns true if a draft exists
+ */
+export declare function hasDraft(storageKey: string): boolean;
+/**
+ * Get draft metadata without loading the full workflow
+ *
+ * Useful for displaying draft information without parsing the entire workflow.
+ *
+ * @param storageKey - The storage key to check
+ * @returns Draft metadata, or null if not found
+ */
+export declare function getDraftMetadata(storageKey: string): DraftMetadata | null;
+/**
+ * Draft auto-save manager
+ *
+ * Handles interval-based auto-saving of workflow drafts.
+ * Should be instantiated per FlowDrop instance.
+ */
+export declare class DraftAutoSaveManager {
+    /** Interval timer ID */
+    private intervalId;
+    /** Storage key for drafts */
+    private storageKey;
+    /** Auto-save interval in milliseconds */
+    private interval;
+    /** Whether auto-save is enabled */
+    private enabled;
+    /** Function to get current workflow */
+    private getWorkflow;
+    /** Function to check if workflow is dirty */
+    private isDirty;
+    /** Last saved workflow hash (for change detection) */
+    private lastSavedHash;
+    /**
+     * Create a new DraftAutoSaveManager
+     *
+     * @param options - Configuration options
+     */
+    constructor(options: {
+        storageKey: string;
+        interval: number;
+        enabled: boolean;
+        getWorkflow: () => Workflow | null;
+        isDirty: () => boolean;
+    });
+    /**
+     * Start auto-save interval
+     *
+     * Will save drafts at the configured interval if there are unsaved changes.
+     */
+    start(): void;
+    /**
+     * Stop auto-save interval
+     */
+    stop(): void;
+    /**
+     * Save draft if there are unsaved changes
+     *
+     * @returns true if a draft was saved
+     */
+    saveIfDirty(): boolean;
+    /**
+     * Force save the current workflow as a draft
+     *
+     * Saves regardless of dirty state.
+     *
+     * @returns true if saved successfully
+     */
+    forceSave(): boolean;
+    /**
+     * Clear the draft from storage
+     */
+    clearDraft(): void;
+    /**
+     * Mark the current state as saved
+     *
+     * Updates the hash so the next saveIfDirty won't save unless there are new changes.
+     */
+    markAsSaved(): void;
+    /**
+     * Update the storage key
+     *
+     * Useful when the workflow ID changes (e.g., after first save).
+     *
+     * @param newKey - The new storage key
+     */
+    updateStorageKey(newKey: string): void;
+    /**
+     * Simple hash function for change detection
+     *
+     * Not cryptographically secure, just for detecting changes.
+     *
+     * @param workflow - The workflow to hash
+     * @returns A simple hash string
+     */
+    private hashWorkflow;
+    /**
+     * Check if auto-save is currently running
+     */
+    isRunning(): boolean;
+    /**
+     * Get the current storage key
+     */
+    getStorageKey(): string;
+}
+export {};