@flowdrop/flowdrop 1.5.0 → 1.7.0

package/dist/commands/index.d.ts

@@ -6,9 +6,9 @@
  *
  * @module commands
  */
-export type { AddNodeCommand, DeleteNodeCommand, RenameNodeCommand, SetConfigCommand, GetConfigCommand, ConnectCommand, DisconnectPortsCommand, DisconnectNodeCommand, ListNodesCommand, ListEdgesCommand, ListTypesCommand, InfoCommand, UndoCommand, RedoCommand, ConfigOpenCommand, SelectNodeCommand, HelpCommand, ClearCommand, SwapNodeCommand, MoveNodeCommand, AutoLayoutCommand, BeautifyLayoutCommand, CanvasFitViewCommand, CanvasZoomInCommand, CanvasZoomOutCommand, CanvasZoomToCommand, CanvasPanToCommand, CanvasResetViewCommand, Command, ParseResult, CommandErrorCode, AddNodeResultData, ListNodesResultData, ListEdgesResultData, ListTypesResultData, InfoResultData, GetConfigResultData, SetConfigResultData, HelpResultData, SwapNodeResultData, CommandResultData, CommandResultOk, CommandResultError, CommandResult, BatchResult, UIAction, CommandDispatch, CommandContext, } from "./types.js";
-export { buildTypeMap } from "./types.js";
-export { parseCommand } from "./parser.js";
-export { executeCommand, toShortId, toShortTypeId, resolveNode, COMMAND_HELP, } from "./executor.js";
-export { executeBatch } from "./batch.js";
-export { computeAutoPosition } from "./positioner.js";
+export type { AddNodeCommand, DeleteNodeCommand, RenameNodeCommand, SetConfigCommand, GetConfigCommand, ConnectCommand, DisconnectPortsCommand, DisconnectNodeCommand, ListNodesCommand, ListEdgesCommand, ListTypesCommand, InfoCommand, UndoCommand, RedoCommand, ConfigOpenCommand, SelectNodeCommand, HelpCommand, ClearCommand, SwapNodeCommand, MoveNodeCommand, AutoLayoutCommand, BeautifyLayoutCommand, CanvasFitViewCommand, CanvasZoomInCommand, CanvasZoomOutCommand, CanvasZoomToCommand, CanvasPanToCommand, CanvasResetViewCommand, Command, ParseResult, CommandErrorCode, AddNodeResultData, ListNodesResultData, ListEdgesResultData, ListTypesResultData, InfoResultData, GetConfigResultData, SetConfigResultData, HelpResultData, SwapNodeResultData, CommandResultData, CommandResultOk, CommandResultError, CommandResult, BatchResult, UIAction, CommandDispatch, CommandContext } from './types.js';
+export { buildTypeMap } from './types.js';
+export { parseCommand } from './parser.js';
+export { executeCommand, toShortId, toShortTypeId, resolveNode, COMMAND_HELP } from './executor.js';
+export { executeBatch } from './batch.js';
+export { computeAutoPosition } from './positioner.js';

package/dist/commands/index.js

@@ -6,12 +6,12 @@
  *
  * @module commands
  */
-export { buildTypeMap } from "./types.js";
+export { buildTypeMap } from './types.js';
 // Parser
-export { parseCommand } from "./parser.js";
+export { parseCommand } from './parser.js';
 // Executor
-export { executeCommand, toShortId, toShortTypeId, resolveNode, COMMAND_HELP, } from "./executor.js";
+export { executeCommand, toShortId, toShortTypeId, resolveNode, COMMAND_HELP } from './executor.js';
 // Batch executor
-export { executeBatch } from "./batch.js";
+export { executeBatch } from './batch.js';
 // Positioner
-export { computeAutoPosition } from "./positioner.js";
+export { computeAutoPosition } from './positioner.js';

package/dist/commands/parser.d.ts

@@ -6,7 +6,7 @@
  *
  * @module commands/parser
  */
-import type { ParseResult } from "./types.js";
+import type { ParseResult } from './types.js';
 /**
  * Parse a command string into a typed Command object.
  *

package/dist/commands/parser.js

@@ -17,232 +17,233 @@ const rules = [
     {
         pattern: /^add\s+(\S+)\s+at\s+(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/i,
         parse: (m) => ({
-            type: "add_node",
+            type: 'add_node',
             nodeTypeId: m[1],
-            position: parseCoords(m[2], m[3]),
-        }),
+            position: parseCoords(m[2], m[3])
+        })
     },
     // add <type>
     {
         pattern: /^add\s+(\S+)$/i,
         parse: (m) => ({
-            type: "add_node",
-            nodeTypeId: m[1],
-        }),
+            type: 'add_node',
+            nodeTypeId: m[1]
+        })
     },
     // delete <nodeId>
     {
         pattern: /^delete\s+(\S+)$/i,
         parse: (m) => ({
-            type: "delete_node",
-            nodeId: m[1],
-        }),
+            type: 'delete_node',
+            nodeId: m[1]
+        })
     },
     // rename <nodeId> <label...>
     {
         pattern: /^rename\s+(\S+)\s+(.+)$/i,
         parse: (m) => ({
-            type: "rename_node",
+            type: 'rename_node',
             nodeId: m[1],
-            label: m[2].trim(),
-        }),
+            label: m[2].trim()
+        })
     },
     // set <nodeId>:<key> """<multiline value>"""
     {
         pattern: /^set\s+(\S+?):(\S+)\s+"""([\s\S]*)"""$/,
         parse: (m) => ({
-            type: "set_config",
+            type: 'set_config',
             nodeId: m[1],
             key: m[2],
-            // trim one leading/trailing newline added by the textarea wrapper
-            value: m[3].replace(/^\n/, "").replace(/\n$/, ""),
-        }),
+            // trim one leading/trailing newline added by the textarea wrapper,
+            // then unescape \""" → """ (escape sequence for literal triple-quotes in content)
+            value: m[3].replace(/^\n|\n$/g, '').replace(/\\"""/g, '"""')
+        })
     },
     // set <nodeId>:<key> <value...>
     {
         pattern: /^set\s+(\S+?):(\S+)\s+(.+)$/i,
         parse: (m) => ({
-            type: "set_config",
+            type: 'set_config',
             nodeId: m[1],
             key: m[2],
-            value: m[3],
-        }),
+            value: m[3]
+        })
     },
     // get <nodeId>:<key>
     {
         pattern: /^get\s+(\S+?):(\S+)$/i,
         parse: (m) => ({
-            type: "get_config",
+            type: 'get_config',
             nodeId: m[1],
-            key: m[2],
-        }),
+            key: m[2]
+        })
     },
     // info <nodeId>
     {
         pattern: /^info\s+(\S+)$/i,
         parse: (m) => ({
-            type: "info",
-            nodeId: m[1],
-        }),
+            type: 'info',
+            nodeId: m[1]
+        })
     },
     // config <nodeId>
     {
         pattern: /^config\s+(\S+)$/i,
         parse: (m) => ({
-            type: "config_open",
-            nodeId: m[1],
-        }),
+            type: 'config_open',
+            nodeId: m[1]
+        })
     },
     // select <nodeId>
     {
         pattern: /^select\s+(\S+)$/i,
         parse: (m) => ({
-            type: "select_node",
-            nodeId: m[1],
-        }),
+            type: 'select_node',
+            nodeId: m[1]
+        })
     },
     // connect <nid>:<port> to <nid>:<port>
     {
         pattern: /^connect\s+(\S+?):(\S+)\s+to\s+(\S+?):(\S+)$/i,
         parse: (m) => ({
-            type: "connect",
+            type: 'connect',
             sourceNodeId: m[1],
             sourcePort: m[2],
             targetNodeId: m[3],
-            targetPort: m[4],
-        }),
+            targetPort: m[4]
+        })
     },
     // disconnect <nid>:<port> from <nid>:<port>
     {
         pattern: /^disconnect\s+(\S+?):(\S+)\s+from\s+(\S+?):(\S+)$/i,
         parse: (m) => ({
-            type: "disconnect_ports",
+            type: 'disconnect_ports',
             sourceNodeId: m[1],
             sourcePort: m[2],
             targetNodeId: m[3],
-            targetPort: m[4],
-        }),
+            targetPort: m[4]
+        })
     },
     // disconnect <nodeId> (disconnect all)
     {
         pattern: /^disconnect\s+(\S+)$/i,
         parse: (m) => ({
-            type: "disconnect_node",
-            nodeId: m[1],
-        }),
+            type: 'disconnect_node',
+            nodeId: m[1]
+        })
     },
     // list nodes
     {
         pattern: /^list\s+nodes$/i,
-        parse: () => ({ type: "list_nodes" }),
+        parse: () => ({ type: 'list_nodes' })
     },
     // list edges
     {
         pattern: /^list\s+edges$/i,
-        parse: () => ({ type: "list_edges" }),
+        parse: () => ({ type: 'list_edges' })
     },
     // list types
     {
         pattern: /^list\s+types$/i,
-        parse: () => ({ type: "list_types" }),
+        parse: () => ({ type: 'list_types' })
     },
     // undo
     {
         pattern: /^undo$/i,
-        parse: () => ({ type: "undo" }),
+        parse: () => ({ type: 'undo' })
     },
     // redo
     {
         pattern: /^redo$/i,
-        parse: () => ({ type: "redo" }),
+        parse: () => ({ type: 'redo' })
     },
     // help <command>
     {
         pattern: /^help\s+(\S+)$/i,
         parse: (m) => ({
-            type: "help",
-            command: m[1],
-        }),
+            type: 'help',
+            command: m[1]
+        })
     },
     // help
     {
         pattern: /^help$/i,
-        parse: () => ({ type: "help" }),
+        parse: () => ({ type: 'help' })
     },
     // clear
     {
         pattern: /^clear$/i,
-        parse: () => ({ type: "clear" }),
+        parse: () => ({ type: 'clear' })
     },
     // swap <nodeId> with <type> (Phase 2)
     {
         pattern: /^swap\s+(\S+)\s+with\s+(\S+)$/i,
         parse: (m) => ({
-            type: "swap_node",
+            type: 'swap_node',
             nodeId: m[1],
-            newTypeId: m[2],
-        }),
+            newTypeId: m[2]
+        })
     },
     // move <nodeId> to <x>,<y> (Phase 2)
     {
         pattern: /^move\s+(\S+)\s+to\s+(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/i,
         parse: (m) => ({
-            type: "move_node",
+            type: 'move_node',
             nodeId: m[1],
-            position: parseCoords(m[2], m[3]),
-        }),
+            position: parseCoords(m[2], m[3])
+        })
     },
     // layout auto [--direction horizontal|vertical] (Phase 2)
     {
         pattern: /^layout\s+auto\s+--direction\s+(horizontal|vertical)$/i,
         parse: (m) => ({
-            type: "auto_layout",
-            direction: m[1].toLowerCase(),
-        }),
+            type: 'auto_layout',
+            direction: m[1].toLowerCase()
+        })
     },
     // layout auto (Phase 2)
     {
         pattern: /^layout\s+auto$/i,
-        parse: () => ({ type: "auto_layout" }),
+        parse: () => ({ type: 'auto_layout' })
     },
     // layout beautify — preserve relative positions, normalize spacing
     {
         pattern: /^layout\s+beautify$/i,
-        parse: () => ({ type: "beautify_layout" }),
+        parse: () => ({ type: 'beautify_layout' })
     },
     // canvas fitview | canvas fit
     {
         pattern: /^canvas\s+fit(?:\s*view)?$/i,
-        parse: () => ({ type: "canvas_fit_view" }),
+        parse: () => ({ type: 'canvas_fit_view' })
     },
     // canvas zoom in
     {
         pattern: /^canvas\s+zoom\s+in$/i,
-        parse: () => ({ type: "canvas_zoom_in" }),
+        parse: () => ({ type: 'canvas_zoom_in' })
     },
     // canvas zoom out
     {
         pattern: /^canvas\s+zoom\s+out$/i,
-        parse: () => ({ type: "canvas_zoom_out" }),
+        parse: () => ({ type: 'canvas_zoom_out' })
     },
     // canvas zoom <level>
     {
         pattern: /^canvas\s+zoom\s+(\d+(?:\.\d+)?)$/i,
-        parse: (m) => ({ type: "canvas_zoom_to", level: Number(m[1]) }),
+        parse: (m) => ({ type: 'canvas_zoom_to', level: Number(m[1]) })
     },
     // canvas pan <x>,<y>
     {
         pattern: /^canvas\s+pan\s+(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/i,
         parse: (m) => ({
-            type: "canvas_pan_to",
-            position: parseCoords(m[1], m[2]),
-        }),
+            type: 'canvas_pan_to',
+            position: parseCoords(m[1], m[2])
+        })
     },
     // canvas reset
     {
         pattern: /^canvas\s+reset$/i,
-        parse: () => ({ type: "canvas_reset_view" }),
-    },
+        parse: () => ({ type: 'canvas_reset_view' })
+    }
 ];
 // ============================================================================
 // Public API
@@ -256,7 +257,7 @@ const rules = [
 export function parseCommand(input) {
     const trimmed = input.trim();
     if (!trimmed) {
-        return { ok: false, error: "Empty command", input };
+        return { ok: false, error: 'Empty command', input };
     }
     for (const rule of rules) {
         const match = trimmed.match(rule.pattern);
@@ -267,9 +268,25 @@ export function parseCommand(input) {
     // Extract verb for better error message
     const verb = trimmed.split(/\s+/)[0].toLowerCase();
     const knownVerbs = [
-        "add", "delete", "rename", "set", "get", "info", "config",
-        "select", "connect", "disconnect", "list", "undo", "redo",
-        "help", "clear", "swap", "move", "layout", "canvas",
+        'add',
+        'delete',
+        'rename',
+        'set',
+        'get',
+        'info',
+        'config',
+        'select',
+        'connect',
+        'disconnect',
+        'list',
+        'undo',
+        'redo',
+        'help',
+        'clear',
+        'swap',
+        'move',
+        'layout',
+        'canvas'
     ];
     if (knownVerbs.includes(verb)) {
         return { ok: false, error: `Invalid syntax for '${verb}' command`, input };

package/dist/commands/positioner.d.ts

@@ -5,7 +5,7 @@
  *
  * @module commands/positioner
  */
-import type { WorkflowNode } from "../types/index.js";
+import type { WorkflowNode } from '../types/index.js';
 /**
  * Computes an auto-position for a new node based on existing nodes.
  *
@@ -13,7 +13,7 @@ import type { WorkflowNode } from "../types/index.js";
  * - Non-empty canvas: places new node 250px to the right of the rightmost node,
  *   at the same y as the rightmost node.
  */
-export declare function computeAutoPosition(existingNodes: Pick<WorkflowNode, "position">[]): {
+export declare function computeAutoPosition(existingNodes: Pick<WorkflowNode, 'position'>[]): {
     x: number;
     y: number;
 };

package/dist/commands/positioner.js

@@ -28,6 +28,6 @@ export function computeAutoPosition(existingNodes) {
     }
     return {
         x: rightmost.position.x + HORIZONTAL_GAP,
-        y: rightmost.position.y,
+        y: rightmost.position.y
     };
 }

package/dist/commands/storeIntegration.svelte.d.ts

@@ -4,8 +4,8 @@
  * Bridges the command system to the live Svelte stores.
  * This is the only Svelte-coupled file in commands/.
  */
-import { type CommandContext, type UIAction } from "./types.js";
-import type { NodeMetadata } from "../types/index.js";
+import { type CommandContext, type UIAction } from './types.js';
+import type { NodeMetadata } from '../types/index.js';
 /**
  * Creates a CommandContext that bridges the command system to the live Svelte stores.
  *

package/dist/commands/storeIntegration.svelte.js

@@ -4,9 +4,9 @@
  * Bridges the command system to the live Svelte stores.
  * This is the only Svelte-coupled file in commands/.
  */
-import { getWorkflowStore, workflowActions, } from "../stores/workflowStore.svelte.js";
-import { historyService } from "../services/historyService.js";
-import { buildTypeMap, } from "./types.js";
+import { getWorkflowStore, workflowActions } from '../stores/workflowStore.svelte.js';
+import { historyService } from '../services/historyService.js';
+import { buildTypeMap } from './types.js';
 /**
  * Creates a CommandContext that bridges the command system to the live Svelte stores.
  *
@@ -56,12 +56,12 @@ export function createStoreCommandContext(nodeTypes, onUIAction) {
             }
         },
         emitUIAction: onUIAction,
-        swapNode: (updates) => workflowActions.swapNode(updates),
+        swapNode: (updates) => workflowActions.swapNode(updates)
     };
     return {
         getWorkflow: () => getWorkflowStore(),
         nodeTypes,
         typeMap: buildTypeMap(nodeTypes),
-        dispatch,
+        dispatch
     };
 }