@d34dman/flowdrop 0.0.14 → 0.0.16

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 {};

package/dist/services/draftStorage.js

@@ -0,0 +1,298 @@
+/**
+ * Draft Storage Service for FlowDrop
+ *
+ * Handles saving and loading workflow drafts to/from localStorage.
+ * Provides interval-based auto-save functionality.
+ *
+ * @module services/draftStorage
+ */
+/**
+ * Default storage key prefix
+ */
+const STORAGE_KEY_PREFIX = "flowdrop:draft";
+/**
+ * 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 function getDraftStorageKey(workflowId, customKey) {
+    if (customKey) {
+        return customKey;
+    }
+    if (workflowId) {
+        return `${STORAGE_KEY_PREFIX}:${workflowId}`;
+    }
+    return `${STORAGE_KEY_PREFIX}:new`;
+}
+/**
+ * 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 function saveDraft(workflow, storageKey) {
+    try {
+        const draft = {
+            workflow,
+            metadata: {
+                savedAt: new Date().toISOString(),
+                workflowId: workflow.id,
+                workflowName: workflow.name
+            }
+        };
+        localStorage.setItem(storageKey, JSON.stringify(draft));
+        return true;
+    }
+    catch (error) {
+        // localStorage might be full or disabled
+        console.warn("Failed to save draft to localStorage:", error);
+        return false;
+    }
+}
+/**
+ * Load a workflow draft from localStorage
+ *
+ * @param storageKey - The storage key to load from
+ * @returns The stored draft, or null if not found
+ */
+export function loadDraft(storageKey) {
+    try {
+        const stored = localStorage.getItem(storageKey);
+        if (!stored) {
+            return null;
+        }
+        const draft = JSON.parse(stored);
+        // Validate the draft structure
+        if (!draft.workflow || !draft.metadata) {
+            console.warn("Invalid draft structure in localStorage");
+            return null;
+        }
+        return draft;
+    }
+    catch (error) {
+        console.warn("Failed to load draft from localStorage:", error);
+        return null;
+    }
+}
+/**
+ * Delete a workflow draft from localStorage
+ *
+ * @param storageKey - The storage key to delete
+ */
+export function deleteDraft(storageKey) {
+    try {
+        localStorage.removeItem(storageKey);
+    }
+    catch (error) {
+        console.warn("Failed to delete draft from localStorage:", error);
+    }
+}
+/**
+ * Check if a draft exists for a given storage key
+ *
+ * @param storageKey - The storage key to check
+ * @returns true if a draft exists
+ */
+export function hasDraft(storageKey) {
+    try {
+        return localStorage.getItem(storageKey) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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 function getDraftMetadata(storageKey) {
+    const draft = loadDraft(storageKey);
+    return draft?.metadata ?? null;
+}
+/**
+ * Draft auto-save manager
+ *
+ * Handles interval-based auto-saving of workflow drafts.
+ * Should be instantiated per FlowDrop instance.
+ */
+export class DraftAutoSaveManager {
+    /** Interval timer ID */
+    intervalId = null;
+    /** Storage key for drafts */
+    storageKey;
+    /** Auto-save interval in milliseconds */
+    interval;
+    /** Whether auto-save is enabled */
+    enabled;
+    /** Function to get current workflow */
+    getWorkflow;
+    /** Function to check if workflow is dirty */
+    isDirty;
+    /** Last saved workflow hash (for change detection) */
+    lastSavedHash = null;
+    /**
+     * Create a new DraftAutoSaveManager
+     *
+     * @param options - Configuration options
+     */
+    constructor(options) {
+        this.storageKey = options.storageKey;
+        this.interval = options.interval;
+        this.enabled = options.enabled;
+        this.getWorkflow = options.getWorkflow;
+        this.isDirty = options.isDirty;
+    }
+    /**
+     * Start auto-save interval
+     *
+     * Will save drafts at the configured interval if there are unsaved changes.
+     */
+    start() {
+        if (!this.enabled || this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(() => {
+            this.saveIfDirty();
+        }, this.interval);
+    }
+    /**
+     * Stop auto-save interval
+     */
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    /**
+     * Save draft if there are unsaved changes
+     *
+     * @returns true if a draft was saved
+     */
+    saveIfDirty() {
+        if (!this.enabled) {
+            return false;
+        }
+        const workflow = this.getWorkflow();
+        if (!workflow) {
+            return false;
+        }
+        // Only save if dirty
+        if (!this.isDirty()) {
+            return false;
+        }
+        // Check if workflow has actually changed since last save
+        const currentHash = this.hashWorkflow(workflow);
+        if (currentHash === this.lastSavedHash) {
+            return false;
+        }
+        const saved = saveDraft(workflow, this.storageKey);
+        if (saved) {
+            this.lastSavedHash = currentHash;
+        }
+        return saved;
+    }
+    /**
+     * Force save the current workflow as a draft
+     *
+     * Saves regardless of dirty state.
+     *
+     * @returns true if saved successfully
+     */
+    forceSave() {
+        const workflow = this.getWorkflow();
+        if (!workflow) {
+            return false;
+        }
+        const saved = saveDraft(workflow, this.storageKey);
+        if (saved) {
+            this.lastSavedHash = this.hashWorkflow(workflow);
+        }
+        return saved;
+    }
+    /**
+     * Clear the draft from storage
+     */
+    clearDraft() {
+        deleteDraft(this.storageKey);
+        this.lastSavedHash = null;
+    }
+    /**
+     * Mark the current state as saved
+     *
+     * Updates the hash so the next saveIfDirty won't save unless there are new changes.
+     */
+    markAsSaved() {
+        const workflow = this.getWorkflow();
+        if (workflow) {
+            this.lastSavedHash = this.hashWorkflow(workflow);
+        }
+    }
+    /**
+     * Update the storage key
+     *
+     * Useful when the workflow ID changes (e.g., after first save).
+     *
+     * @param newKey - The new storage key
+     */
+    updateStorageKey(newKey) {
+        // If there's an existing draft with the old key, migrate it
+        const existingDraft = loadDraft(this.storageKey);
+        if (existingDraft && this.storageKey !== newKey) {
+            deleteDraft(this.storageKey);
+            saveDraft(existingDraft.workflow, newKey);
+        }
+        this.storageKey = newKey;
+    }
+    /**
+     * Simple hash function for change detection
+     *
+     * Not cryptographically secure, just for detecting changes.
+     *
+     * @param workflow - The workflow to hash
+     * @returns A simple hash string
+     */
+    hashWorkflow(workflow) {
+        // Use a simple stringification for change detection
+        // We only need nodes, edges, name, and description for change detection
+        const toHash = {
+            name: workflow.name,
+            description: workflow.description,
+            nodes: workflow.nodes.map((n) => ({
+                id: n.id,
+                position: n.position,
+                data: n.data
+            })),
+            edges: workflow.edges.map((e) => ({
+                id: e.id,
+                source: e.source,
+                target: e.target,
+                sourceHandle: e.sourceHandle,
+                targetHandle: e.targetHandle
+            }))
+        };
+        return JSON.stringify(toHash);
+    }
+    /**
+     * Check if auto-save is currently running
+     */
+    isRunning() {
+        return this.intervalId !== null;
+    }
+    /**
+     * Get the current storage key
+     */
+    getStorageKey() {
+        return this.storageKey;
+    }
+}

package/dist/stores/workflowStore.d.ts

@@ -1,9 +1,60 @@
-import type { Workflow, WorkflowNode, WorkflowEdge } from '../types';
+/**
+ * Workflow Store for FlowDrop
+ *
+ * Provides global state management for workflows with dirty state tracking.
+ *
+ * @module stores/workflowStore
+ */
+import type { Workflow, WorkflowNode, WorkflowEdge } from "../types";
+import type { WorkflowChangeType } from "../types/events.js";
+/** Global workflow state */
 export declare const workflowStore: import("svelte/store").Writable<Workflow>;
+/**
+ * Store for tracking if there are unsaved changes
+ *
+ * This is set to true whenever the workflow changes after initialization.
+ * It can be reset to false by calling markAsSaved().
+ */
+export declare const isDirtyStore: import("svelte/store").Writable<boolean>;
+/**
+ * Set the dirty state change callback
+ *
+ * @param callback - Function to call when dirty state changes
+ */
+export declare function setOnDirtyStateChange(callback: ((isDirty: boolean) => void) | null): void;
+/**
+ * Set the workflow change callback
+ *
+ * @param callback - Function to call when workflow changes
+ */
+export declare function setOnWorkflowChange(callback: ((workflow: Workflow, changeType: WorkflowChangeType) => void) | null): void;
+/**
+ * Mark the current workflow state as saved
+ *
+ * Clears the dirty state by updating the saved snapshot.
+ */
+export declare function markAsSaved(): void;
+/**
+ * Check if there are unsaved changes
+ *
+ * @returns true if there are unsaved changes
+ */
+export declare function isDirty(): boolean;
+/**
+ * Get the current workflow
+ *
+ * @returns The current workflow or null
+ */
+export declare function getWorkflow(): Workflow | null;
+/** Derived store for workflow ID */
 export declare const workflowId: import("svelte/store").Readable<string>;
+/** Derived store for workflow name */
 export declare const workflowName: import("svelte/store").Readable<string>;
+/** Derived store for workflow nodes */
 export declare const workflowNodes: import("svelte/store").Readable<WorkflowNode[]>;
+/** Derived store for workflow edges */
 export declare const workflowEdges: import("svelte/store").Readable<WorkflowEdge[]>;
+/** Derived store for workflow metadata */
 export declare const workflowMetadata: import("svelte/store").Readable<{
     version: string;
     createdAt: string;
@@ -13,19 +64,68 @@ export declare const workflowMetadata: import("svelte/store").Readable<{
     versionId?: string;
     updateNumber?: number;
 }>;
+/**
+ * Actions for updating the workflow
+ *
+ * All actions that modify the workflow will trigger dirty state updates
+ * and emit change events.
+ */
 export declare const workflowActions: {
+    /**
+     * Initialize workflow (from load or new)
+     *
+     * This sets the initial saved snapshot and clears dirty state.
+     */
     initialize: (workflow: Workflow) => void;
+    /**
+     * Update the entire workflow
+     */
     updateWorkflow: (workflow: Workflow) => void;
+    /**
+     * Update nodes
+     */
     updateNodes: (nodes: WorkflowNode[]) => void;
+    /**
+     * Update edges
+     */
     updateEdges: (edges: WorkflowEdge[]) => void;
+    /**
+     * Update workflow name
+     */
     updateName: (name: string) => void;
+    /**
+     * Add a node
+     */
     addNode: (node: WorkflowNode) => void;
+    /**
+     * Remove a node
+     */
     removeNode: (nodeId: string) => void;
+    /**
+     * Add an edge
+     */
     addEdge: (edge: WorkflowEdge) => void;
+    /**
+     * Remove an edge
+     */
     removeEdge: (edgeId: string) => void;
+    /**
+     * Update a specific node
+     */
     updateNode: (nodeId: string, updates: Partial<WorkflowNode>) => void;
+    /**
+     * Clear the workflow
+     */
     clear: () => void;
+    /**
+     * Update workflow metadata
+     */
     updateMetadata: (metadata: Partial<Workflow["metadata"]>) => void;
+    /**
+     * Batch update nodes and edges
+     *
+     * Useful for complex operations that update multiple things at once.
+     */
     batchUpdate: (updates: {
         nodes?: WorkflowNode[];
         edges?: WorkflowEdge[];
@@ -34,11 +134,13 @@ export declare const workflowActions: {
         metadata?: Partial<Workflow["metadata"]>;
     }) => void;
 };
+/** Derived store for workflow changes (useful for triggering saves) */
 export declare const workflowChanged: import("svelte/store").Readable<{
     nodes: WorkflowNode[];
     edges: WorkflowEdge[];
     name: string;
 }>;
+/** Derived store for workflow validation */
 export declare const workflowValidation: import("svelte/store").Readable<{
     hasNodes: boolean;
     hasEdges: boolean;
@@ -46,6 +148,7 @@ export declare const workflowValidation: import("svelte/store").Readable<{
     edgeCount: number;
     isValid: boolean;
 }>;
+/** Derived store for workflow metadata changes */
 export declare const workflowMetadataChanged: import("svelte/store").Readable<{
     createdAt: string;
     updatedAt: string;