@signalsafe/tree-spec-editor-react 0.1.1 → 0.1.3

package/dist/hooks/useEditorAutosave.js

@@ -0,0 +1,37 @@
+import { useEffect, useRef } from 'react';
+import { compileTreeSpec } from '@signalsafe/tree-spec';
+import { AUTOSAVE_STATUS } from '@signalsafe/tree-spec-editor-core';
+export function useEditorAutosave(options) {
+    const { enableAutosave, autosaveDebounceMs, entityId, tree, isPublished, saving, publishing, autosaveStatus, setAutosaveStatus, lastSavedKeyRef, saveDraftRef, } = options;
+    const autosaveTimerRef = useRef(null);
+    useEffect(() => {
+        if (!enableAutosave)
+            return;
+        if (!entityId || !tree)
+            return;
+        if (isPublished)
+            return;
+        if (saving || publishing)
+            return;
+        const compiled = compileTreeSpec(tree);
+        const key = JSON.stringify(compiled);
+        if (key === lastSavedKeyRef.current) {
+            if (autosaveStatus !== AUTOSAVE_STATUS.SAVED)
+                setAutosaveStatus(AUTOSAVE_STATUS.IDLE);
+            return;
+        }
+        setAutosaveStatus(AUTOSAVE_STATUS.DIRTY);
+        autosaveTimerRef.current = globalThis.setTimeout(() => {
+            void saveDraftRef.current?.();
+        }, autosaveDebounceMs);
+        return () => {
+            if (autosaveTimerRef.current) {
+                globalThis.clearTimeout(autosaveTimerRef.current);
+                autosaveTimerRef.current = null;
+            }
+        };
+        // NOTE: autosaveStatus is intentionally NOT in deps. The dirty/idle
+        // bookkeeping above flips status, and re-running the effect on every
+        // status change would reset the debounce timer.
+    }, [tree, entityId, isPublished, saving, publishing, autosaveDebounceMs, enableAutosave]);
+}

package/dist/hooks/useEditorHistory.d.ts

@@ -0,0 +1,16 @@
+import { type EditorTree, type GraphSelection } from '@signalsafe/tree-spec-editor-core';
+export type UseEditorHistoryResult = {
+    tree: EditorTree | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    hasCopiedNode: boolean;
+    commitTree: (next: EditorTree | null) => void;
+    replaceTreeWithoutHistory: (next: EditorTree | null) => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    copySelectedNode: (selection: GraphSelection) => boolean;
+    pasteCopiedNode: (setSelection: (next: GraphSelection) => void, setFocusNodeId: (id: string | null) => void) => boolean;
+    duplicateNodeById: (nodeId: string, setSelection: (next: GraphSelection) => void, setFocusNodeId: (id: string | null) => void) => string | undefined;
+};
+export declare function useEditorHistory(isPublished: boolean): UseEditorHistoryResult;
+//# sourceMappingURL=useEditorHistory.d.ts.map

package/dist/hooks/useEditorHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorHistory.d.ts","sourceRoot":"","sources":["../../src/hooks/useEditorHistory.ts"],"names":[],"mappings":"AAEA,OAAO,EAaH,KAAK,UAAU,EACf,KAAK,cAAc,EACtB,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,sBAAsB,GAAG;IACjC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAAC;IAC9C,yBAAyB,EAAE,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAAC;IAC7D,IAAI,EAAE,MAAM,OAAO,CAAC;IACpB,IAAI,EAAE,MAAM,OAAO,CAAC;IACpB,gBAAgB,EAAE,CAAC,SAAS,EAAE,cAAc,KAAK,OAAO,CAAC;IACrD,eAAe,EAAE,CACjB,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,EAC5C,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,KAC1C,OAAO,CAAC;IACb,iBAAiB,EAAE,CACf,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,EAC5C,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,KAC1C,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,OAAO,GAAG,sBAAsB,CAsH7E"}

package/dist/hooks/useEditorHistory.js

@@ -0,0 +1,103 @@
+import { useCallback, useRef, useState } from 'react';
+import { canRedoEditorHistory, canUndoEditorHistory, clearEditorHistory, createEditorHistoryStack, duplicateNode, editorTreesEqual, END_NODE_ID, GRAPH_SELECTION_KIND, popEditorRedo, popEditorUndo, pushEditorHistory, } from '@signalsafe/tree-spec-editor-core';
+export function useEditorHistory(isPublished) {
+    const [tree, setTree] = useState(null);
+    const historyRef = useRef(createEditorHistoryStack());
+    const copiedNodeIdRef = useRef(null);
+    const [canUndo, setCanUndo] = useState(false);
+    const [canRedo, setCanRedo] = useState(false);
+    const [hasCopiedNode, setHasCopiedNode] = useState(false);
+    const syncHistoryMeta = useCallback(() => {
+        const stack = historyRef.current;
+        setCanUndo(canUndoEditorHistory(stack));
+        setCanRedo(canRedoEditorHistory(stack));
+    }, []);
+    const resetEditorHistory = useCallback(() => {
+        clearEditorHistory(historyRef.current);
+        copiedNodeIdRef.current = null;
+        setHasCopiedNode(false);
+        syncHistoryMeta();
+    }, [syncHistoryMeta]);
+    const commitTree = useCallback((next) => {
+        setTree((prev) => {
+            if (prev && next && !editorTreesEqual(prev, next)) {
+                pushEditorHistory(historyRef.current, prev);
+            }
+            return next;
+        });
+        queueMicrotask(syncHistoryMeta);
+    }, [syncHistoryMeta]);
+    const replaceTreeWithoutHistory = useCallback((next) => {
+        resetEditorHistory();
+        setTree(next);
+    }, [resetEditorHistory]);
+    const undo = useCallback(() => {
+        if (!tree || isPublished)
+            return false;
+        const result = popEditorUndo(historyRef.current, tree);
+        if (!result)
+            return false;
+        historyRef.current.future.unshift(result.currentSnapshot);
+        setTree(result.nextTree);
+        queueMicrotask(syncHistoryMeta);
+        return true;
+    }, [tree, isPublished, syncHistoryMeta]);
+    const redo = useCallback(() => {
+        if (!tree || isPublished)
+            return false;
+        const result = popEditorRedo(historyRef.current, tree);
+        if (!result)
+            return false;
+        historyRef.current.past.push(result.currentSnapshot);
+        setTree(result.nextTree);
+        queueMicrotask(syncHistoryMeta);
+        return true;
+    }, [tree, isPublished, syncHistoryMeta]);
+    const copySelectedNode = useCallback((selection) => {
+        if (selection.kind !== GRAPH_SELECTION_KIND.NODE || !selection.id)
+            return false;
+        if (selection.id === END_NODE_ID)
+            return false;
+        copiedNodeIdRef.current = selection.id;
+        setHasCopiedNode(true);
+        return true;
+    }, []);
+    const pasteCopiedNode = useCallback((setSelection, setFocusNodeId) => {
+        if (!tree || isPublished)
+            return false;
+        const sourceId = copiedNodeIdRef.current;
+        if (!sourceId)
+            return false;
+        const duplicated = duplicateNode(tree, sourceId);
+        if (!duplicated)
+            return false;
+        commitTree(duplicated.nextTree);
+        setSelection({ kind: GRAPH_SELECTION_KIND.NODE, id: duplicated.nextNodeId });
+        setFocusNodeId(duplicated.nextNodeId);
+        return true;
+    }, [tree, isPublished, commitTree]);
+    const duplicateNodeById = useCallback((nodeId, setSelection, setFocusNodeId) => {
+        if (!tree || isPublished)
+            return undefined;
+        const duplicated = duplicateNode(tree, nodeId);
+        if (!duplicated)
+            return undefined;
+        commitTree(duplicated.nextTree);
+        setSelection({ kind: GRAPH_SELECTION_KIND.NODE, id: duplicated.nextNodeId });
+        setFocusNodeId(duplicated.nextNodeId);
+        return duplicated.nextNodeId;
+    }, [tree, isPublished, commitTree]);
+    return {
+        tree,
+        canUndo,
+        canRedo,
+        hasCopiedNode,
+        commitTree,
+        replaceTreeWithoutHistory,
+        undo,
+        redo,
+        copySelectedNode,
+        pasteCopiedNode,
+        duplicateNodeById,
+    };
+}

package/dist/hooks/useEditorSelection.d.ts

@@ -0,0 +1,22 @@
+import { type EditorNode, type EditorTransition, type EditorTree, type GraphSelection } from '@signalsafe/tree-spec-editor-core';
+export type UseEditorSelectionResult = {
+    selection: GraphSelection;
+    focusNodeId: string | null;
+    focusChoiceId: string | null;
+    fitViewNonce: number;
+    selectedNode: EditorNode | null;
+    selectedEdge: EditorTransition | null;
+    inspectorNode: EditorNode | null;
+    selectChoice: (nodeId: string, choiceId: string) => void;
+    applySelection: (next: GraphSelection) => void;
+    setFocusNodeId: (id: string | null) => void;
+    setFocusChoiceId: (id: string | null) => void;
+    triggerResetView: () => void;
+    selectIssue: (issue: {
+        node_id?: string;
+        choice_id?: string;
+    }) => void;
+    setSelection: (next: GraphSelection) => void;
+};
+export declare function useEditorSelection(tree: EditorTree | null): UseEditorSelectionResult;
+//# sourceMappingURL=useEditorSelection.d.ts.map

package/dist/hooks/useEditorSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorSelection.d.ts","sourceRoot":"","sources":["../../src/hooks/useEditorSelection.ts"],"names":[],"mappings":"AAEA,OAAO,EAIH,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,cAAc,EACtB,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,wBAAwB,GAAG;IACnC,SAAS,EAAE,cAAc,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACtC,aAAa,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,cAAc,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IAC/C,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC5C,gBAAgB,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC9C,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,WAAW,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACvE,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;CAChD,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,wBAAwB,CA4EpF"}

package/dist/hooks/useEditorSelection.js

@@ -0,0 +1,75 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { END_NODE_ID, GRAPH_SELECTION_KIND, resolveGraphSelectionFocus, } from '@signalsafe/tree-spec-editor-core';
+export function useEditorSelection(tree) {
+    const [selection, setSelection] = useState({ kind: null, id: null });
+    const [focusNodeId, setFocusNodeId] = useState(null);
+    const [focusChoiceId, setFocusChoiceId] = useState(null);
+    const [fitViewNonce, setFitViewNonce] = useState(0);
+    const selectChoice = useCallback((nodeId, choiceId) => {
+        setSelection({ kind: GRAPH_SELECTION_KIND.NODE, id: nodeId });
+        setFocusChoiceId(choiceId);
+        setFocusNodeId(nodeId);
+    }, []);
+    const applySelection = useCallback((next) => {
+        setSelection(next);
+        if (next.kind === GRAPH_SELECTION_KIND.EDGE && next.id && tree) {
+            if (!tree.transitions.some((t) => t.id === next.id))
+                return;
+        }
+        const { focusNodeId: nextFocusNodeId, focusChoiceId: nextFocusChoiceId } = resolveGraphSelectionFocus(next, tree);
+        setFocusNodeId(nextFocusNodeId);
+        setFocusChoiceId(nextFocusChoiceId);
+    }, [tree]);
+    const selectedNode = useMemo(() => {
+        if (!tree || selection.kind !== GRAPH_SELECTION_KIND.NODE || !selection.id)
+            return null;
+        if (selection.id === END_NODE_ID)
+            return null;
+        return tree.nodes[selection.id] ?? null;
+    }, [tree, selection]);
+    const selectedEdge = useMemo(() => {
+        if (!tree || selection.kind !== GRAPH_SELECTION_KIND.EDGE || !selection.id)
+            return null;
+        return tree.transitions.find((t) => t.id === selection.id) ?? null;
+    }, [tree, selection]);
+    const inspectorNode = useMemo(() => {
+        if (selectedNode)
+            return selectedNode;
+        if (selectedEdge)
+            return tree?.nodes[selectedEdge.fromNodeId] ?? null;
+        return null;
+    }, [selectedNode, selectedEdge, tree]);
+    const triggerResetView = useCallback(() => setFitViewNonce((n) => n + 1), []);
+    const selectIssue = useCallback((issue) => {
+        if (!issue.node_id)
+            return;
+        setSelection({ kind: GRAPH_SELECTION_KIND.NODE, id: issue.node_id });
+        setFocusNodeId(issue.node_id);
+        setFocusChoiceId(issue.choice_id ?? null);
+        setFitViewNonce((n) => n + 1);
+    }, []);
+    useEffect(() => {
+        if (!inspectorNode || !focusChoiceId)
+            return;
+        if (typeof document === 'undefined')
+            return;
+        const el = document.getElementById(`choice-editor-${inspectorNode.id}-${focusChoiceId}`);
+        el?.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
+    }, [inspectorNode, focusChoiceId]);
+    return {
+        selection,
+        focusNodeId,
+        focusChoiceId,
+        fitViewNonce,
+        selectedNode,
+        selectedEdge,
+        inspectorNode,
+        selectChoice,
+        applySelection,
+        setFocusNodeId,
+        setFocusChoiceId,
+        triggerResetView,
+        selectIssue,
+        setSelection,
+    };
+}

package/dist/hooks/useGraphConnect.d.ts

@@ -0,0 +1,22 @@
+import { type MutableRefObject } from 'react';
+import type { Connection, Edge } from 'reactflow';
+import { type EditorTree, type GraphSelection } from '@signalsafe/tree-spec-editor-core';
+export type UseGraphConnectOptions = {
+    treeRef: MutableRefObject<EditorTree>;
+    onChange: (next: EditorTree) => void;
+    onSelect?: (sel: GraphSelection) => void;
+    readOnly: boolean;
+};
+export type UseGraphConnectResult = {
+    onConnect: (conn: Connection) => void;
+    onConnectStart: (_event: unknown, params: {
+        nodeId: string | null;
+        handleId: string | null;
+    }) => void;
+    onConnectEnd: (event: MouseEvent | TouchEvent) => void;
+    onReconnect: (oldEdge: Edge, newConnection: Connection) => void;
+    onEdgesDelete: (deleted: Edge[]) => void;
+    isValidConnection: (conn: Connection) => boolean;
+};
+export declare function useGraphConnect(options: UseGraphConnectOptions): UseGraphConnectResult;
+//# sourceMappingURL=useGraphConnect.d.ts.map

package/dist/hooks/useGraphConnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGraphConnect.d.ts","sourceRoot":"","sources":["../../src/hooks/useGraphConnect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGlD,OAAO,EAMH,KAAK,UAAU,EACf,KAAK,cAAc,EACtB,MAAM,mCAAmC,CAAC;AAI3C,MAAM,MAAM,sBAAsB,GAAG;IACjC,OAAO,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACtC,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACrC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAC;IACzC,QAAQ,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAChC,SAAS,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,cAAc,EAAE,CACZ,MAAM,EAAE,OAAO,EACf,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,KACzD,IAAI,CAAC;IACV,YAAY,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,KAAK,IAAI,CAAC;IACvD,WAAW,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC;IAChE,aAAa,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;IACzC,iBAAiB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC;CACpD,CAAC;AAEF,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,CAmGtF"}

package/dist/hooks/useGraphConnect.js

@@ -0,0 +1,75 @@
+import { useCallback, useRef } from 'react';
+import { useReactFlow } from 'reactflow';
+import { GRAPH_SELECTION_KIND, applyEditorConnect, applyEditorConnectOnDrop, applyEditorReconnect, isValidEditorConnection, } from '@signalsafe/tree-spec-editor-core';
+import { isReactFlowPaneTarget } from '../canvas/typeGuards.js';
+export function useGraphConnect(options) {
+    const { treeRef, onChange, onSelect, readOnly } = options;
+    const rf = useReactFlow();
+    const connectCompletedRef = useRef(false);
+    const pendingConnectRef = useRef(null);
+    const onConnect = useCallback((conn) => {
+        connectCompletedRef.current = true;
+        const nextTree = applyEditorConnect(treeRef.current, conn);
+        if (!nextTree)
+            return;
+        onChange(nextTree);
+    }, [onChange, treeRef]);
+    const onConnectStart = useCallback((_event, params) => {
+        connectCompletedRef.current = false;
+        if (!params.nodeId || !params.handleId) {
+            pendingConnectRef.current = null;
+            return;
+        }
+        pendingConnectRef.current = {
+            source: params.nodeId,
+            sourceHandle: params.handleId,
+        };
+    }, []);
+    const onConnectEnd = useCallback((event) => {
+        if (readOnly || connectCompletedRef.current) {
+            pendingConnectRef.current = null;
+            return;
+        }
+        const pending = pendingConnectRef.current;
+        pendingConnectRef.current = null;
+        if (!pending)
+            return;
+        if (!isReactFlowPaneTarget(event.target)) {
+            return;
+        }
+        const clientX = 'clientX' in event ? event.clientX : event.changedTouches?.[0]?.clientX;
+        const clientY = 'clientY' in event ? event.clientY : event.changedTouches?.[0]?.clientY;
+        if (clientX == null || clientY == null)
+            return;
+        const dropPosition = rf.screenToFlowPosition({ x: clientX, y: clientY });
+        const result = applyEditorConnectOnDrop(treeRef.current, pending.source, pending.sourceHandle, dropPosition);
+        if (!result)
+            return;
+        onChange(result.nextTree);
+        onSelect?.({ kind: GRAPH_SELECTION_KIND.NODE, id: result.nextNodeId });
+    }, [onChange, onSelect, readOnly, rf, treeRef]);
+    const isValidConnection = useCallback((conn) => isValidEditorConnection(treeRef.current, conn), [treeRef]);
+    const onReconnect = useCallback((oldEdge, newConnection) => {
+        const nextTree = applyEditorReconnect(treeRef.current, oldEdge, newConnection);
+        if (!nextTree)
+            return;
+        onChange(nextTree);
+    }, [onChange, treeRef]);
+    const onEdgesDelete = useCallback((deleted) => {
+        const deletedIds = new Set(deleted.map((edge) => String(edge.id)));
+        if (deletedIds.size === 0)
+            return;
+        onChange({
+            ...treeRef.current,
+            transitions: treeRef.current.transitions.filter((t) => !deletedIds.has(t.id)),
+        });
+    }, [onChange, treeRef]);
+    return {
+        onConnect,
+        onConnectStart,
+        onConnectEnd,
+        onReconnect,
+        onEdgesDelete,
+        isValidConnection,
+    };
+}

package/dist/hooks/useTreeSpecEditor.d.ts

@@ -1,18 +1,10 @@
-import type { UseTreeSpecEditorOptions, UseTreeSpecEditorResult } from './types';
+import type { UseTreeSpecEditorOptions, UseTreeSpecEditorResult } from './types.js';
 /**
  * Headless React hook that owns the full stateful behavior of the SignalSafe
  * TreeSpec graph editor — loading, autosave, validation, publish, snapshots,
  * audit, clone-to-draft, selection, focus + fit-view, node/choice operations,
  * and keyboard shortcuts. Consumers compose their own UI (toolbar, panels,
  * modals, layout) on top of the returned state + actions.
- *
- * Boundary commitments:
- * - **No router**: routing is host-injected via `onPreview` / `onCloneNavigate`.
- * - **No UI library**: returns data only; never renders JSX.
- * - **No simulator runtime**: hosts inject `computeRuntimeIssues` if needed.
- *
- * See {@link UseTreeSpecEditorOptions} for full option documentation and
- * {@link UseTreeSpecEditorResult} for the returned shape.
  */
 export declare function useTreeSpecEditor(options: UseTreeSpecEditorOptions): UseTreeSpecEditorResult;
 //# sourceMappingURL=useTreeSpecEditor.d.ts.map

package/dist/hooks/useTreeSpecEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTreeSpecEditor.d.ts","sourceRoot":"","sources":["../../src/hooks/useTreeSpecEditor.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAIR,wBAAwB,EACxB,uBAAuB,EAE1B,MAAM,SAAS,CAAC;AAajB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,CAmrB5F"}
+{"version":3,"file":"useTreeSpecEditor.d.ts","sourceRoot":"","sources":["../../src/hooks/useTreeSpecEditor.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAER,wBAAwB,EACxB,uBAAuB,EAE1B,MAAM,SAAS,CAAC;AAcjB;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,CA6f5F"}