treege 3.0.0-beta.45 → 3.0.0-beta.47

package/dist/editor/constants/nodeTypes.d.ts

@@ -1,6 +1,6 @@
 export declare const NODE_TYPES: {
     flow: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
-    group: import('react').MemoExoticComponent<({ data, id }: import('../features/TreegeEditor/nodes/GroupNode').GroupNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    group: () => null;
     input: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
     ui: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
 };

package/dist/editor/features/TreegeEditor/nodes/components/NodeGroupBadge.d.ts

@@ -0,0 +1,5 @@
+interface NodeGroupBadgeProps {
+    groupId?: string;
+}
+declare const NodeGroupBadge: ({ groupId }: NodeGroupBadgeProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeGroupBadge;

package/dist/editor/features/TreegeEditor/nodes/layout/NodeWrapper.d.ts

@@ -1,7 +1,6 @@
 import { PropsWithChildren } from 'react';
 interface NodeWrapperProps extends PropsWithChildren {
-    inGroup: boolean;
     isSubmit?: boolean;
 }
-declare const NodeWrapper: ({ children, inGroup, isSubmit }: NodeWrapperProps) => import("react/jsx-runtime").JSX.Element;
+declare const NodeWrapper: ({ children, isSubmit }: NodeWrapperProps) => import("react/jsx-runtime").JSX.Element;
 export default NodeWrapper;

package/dist/editor/hooks/useHistoryStore.d.ts

@@ -0,0 +1,26 @@
+import { Edge, Node } from '@xyflow/react';
+type Snapshot = {
+    nodes: Node[];
+    edges: Edge[];
+};
+type HistoryStore = {
+    past: Snapshot[];
+    future: Snapshot[];
+    pushPast: (snapshot: Snapshot) => void;
+    popPast: () => Snapshot | undefined;
+    pushFuture: (snapshot: Snapshot) => void;
+    popFuture: () => Snapshot | undefined;
+    clearFuture: () => void;
+    reset: () => void;
+};
+/**
+ * Zustand store backing the editor's undo/redo history.
+ *
+ * Holds two stacks of `{ nodes, edges }` snapshots: `past` (states to undo into) and
+ * `future` (states to redo into). Both are capped at `MAX_HISTORY` to bound memory.
+ *
+ * Consumed exclusively by `useUndoRedo` — components should not read or mutate this
+ * store directly. Call `reset()` when loading a new flow to drop stale history.
+ */
+declare const useHistoryStore: import('zustand').UseBoundStore<import('zustand').StoreApi<HistoryStore>>;
+export default useHistoryStore;

package/dist/editor/hooks/useUndoRedo.d.ts

@@ -0,0 +1,31 @@
+import { OnBeforeDelete } from '@xyflow/react';
+type UseUndoRedoOptions = {
+    enableShortcuts?: boolean;
+};
+/**
+ * Snapshot-based undo/redo for the ReactFlow editor.
+ *
+ * Maintains `past` / `future` stacks of `{ nodes, edges }` snapshots in `useHistoryStore`.
+ * Callers must invoke `takeSnapshot()` before any mutation they want to be undoable
+ * (drag start, node/edge creation, deletion, type change, …); the hook itself does
+ * not observe ReactFlow state changes.
+ *
+ * @param enableShortcuts - When true, binds Cmd/Ctrl+Z (undo) and Cmd/Ctrl+Shift+Z /
+ *   Cmd/Ctrl+Y (redo) to the window. Should be enabled in a single root component
+ *   (e.g. the editor) to avoid duplicate listeners.
+ *
+ * @returns
+ * - `takeSnapshot`: pushes the current flow onto `past` and clears `future`.
+ * - `onBeforeDelete`: adapter typed for ReactFlow's `onBeforeDelete` prop.
+ * - `undo` / `redo`: restore the previous / next snapshot.
+ * - `canUndo` / `canRedo`: booleans driven by stack length, suitable for disabling UI buttons.
+ */
+declare const useUndoRedo: ({ enableShortcuts }?: UseUndoRedoOptions) => {
+    canRedo: boolean;
+    canUndo: boolean;
+    onBeforeDelete: OnBeforeDelete;
+    redo: () => void;
+    takeSnapshot: () => void;
+    undo: () => void;
+};
+export default useUndoRedo;

package/dist/editor/utils/dagreLayout.d.ts

@@ -10,8 +10,11 @@ export interface LayoutOptions {
  * `nodes` array with updated `position` fields. Nodes not yet measured by
  * React Flow keep their current position.
  *
- * Respects group hierarchy: top-level nodes are laid out together, and
- * each group's children are laid out independently using parent-relative
+ * Groups are metadata only (rendered as colored badges on each child) and
+ * do not influence the layout. They are anchored at the origin (0, 0) and
+ * never moved, which means a child's `position` (parent-relative in React
+ * Flow) is numerically equal to its absolute canvas position — so we can
+ * lay out every non-group node in a single Dagre pass without converting
  * coordinates.
  */
 export declare const getLayoutedElements: (nodes: Node[], edges: Edge[], options?: LayoutOptions) => Node[];

package/dist/editor/utils/groupColor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic color for a group, derived from its id.
+ *
+ * Why HSL + inline style (rather than a Tailwind class):
+ * Tailwind purges classes at build time and can't synthesize `bg-{color}`
+ * from a runtime hash. Picking from a fixed palette would cap the number of
+ * distinguishable groups; HSL with a hashed hue gives effectively unlimited
+ * distinct, stable colors with no Tailwind-side configuration.
+ *
+ * Saturation/lightness are fixed (65% / 45%) so every group lands in the
+ * same readable, mid-contrast band on both light and dark themes — only the
+ * hue varies between groups.
+ */
+export declare const getGroupColor: (groupId?: string) => string;