react-reason-editor-sidebar 0.1.0

package/dist/features/ai-rewrite/AIRewriteSuggestion.d.ts

@@ -0,0 +1,27 @@
+import { RewriteMode } from './rewriteModes';
+/** Props for the {@link AIRewriteSuggestion} component. */
+interface AIRewriteSuggestionProps {
+    /** The original selected text before rewriting. */
+    originalText: string;
+    /** The AI-generated replacement text. */
+    suggestedText: string;
+    /** Called when the user accepts the suggestion. */
+    onApprove: () => void;
+    /** Called when the user rejects the suggestion. */
+    onReject: () => void;
+    /** Optional callback to regenerate with a different rewrite mode. */
+    onRegenerate?: (mode: RewriteMode) => void;
+    /** Whether to show a spinner instead of the suggestion panel. */
+    isLoading?: boolean;
+    /** ID of the currently selected rewrite mode, used to highlight the active badge. */
+    currentMode?: string;
+}
+/**
+ * Renders an AI suggestion card.
+ *
+ * Shows a spinner while `isLoading` is `true`. Once a suggestion is available
+ * it displays the original text (struck-through), the suggested replacement,
+ * mode-selection badges, and approve/reject action buttons.
+ */
+export declare const AIRewriteSuggestion: ({ originalText, suggestedText, onApprove, onReject, onRegenerate, isLoading, currentMode, }: AIRewriteSuggestionProps) => import("react").JSX.Element;
+export {};

package/dist/features/ai-rewrite/rewriteModes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module rewriteModes
+ * @description Defines and persists the list of AI rewrite modes available
+ * in the editor. Modes are stored in `localStorage` so users can customise
+ * them without losing changes on refresh.
+ */
+/** A single AI rewrite mode configuration. */
+export interface RewriteMode {
+    /** Unique identifier used to reference the mode programmatically. */
+    id: string;
+    /** Human-readable label shown in the UI badges. */
+    name: string;
+    /** System prompt prepended to the selected text when calling the AI API. */
+    prompt: string;
+    /** Tailwind colour key used to style the mode badge (e.g. `'blue'`). */
+    color?: string;
+}
+/** Built-in rewrite modes shipped with the application. */
+export declare const DEFAULT_REWRITE_MODES: RewriteMode[];
+/**
+ * Returns the current list of rewrite modes. Reads from `localStorage` when
+ * a saved list exists, otherwise falls back to {@link DEFAULT_REWRITE_MODES}.
+ *
+ * @returns Array of rewrite mode objects.
+ */
+export declare const getRewriteModes: () => RewriteMode[];
+/**
+ * Persists a rewrite mode list to `localStorage`.
+ *
+ * @param modes - The array of modes to store.
+ */
+export declare const saveRewriteModes: (modes: RewriteMode[]) => void;
+/**
+ * Resets rewrite modes to {@link DEFAULT_REWRITE_MODES} by overwriting the
+ * stored list in `localStorage`.
+ */
+export declare const resetRewriteModes: () => void;

package/dist/file-tree/FileTreeContextMenu.d.ts

@@ -0,0 +1,18 @@
+interface FileTreeContextMenuProps {
+    children: React.ReactNode;
+    itemId: string;
+    isFolder: boolean;
+    hasCopiedItem: boolean;
+    onAddChild?: (itemId: string) => void;
+    onAddChildFolder?: (itemId: string) => void;
+    onAddSibling?: (itemId: string) => void;
+    onAddSiblingFolder?: (itemId: string) => void;
+    onRename?: (itemId: string) => void;
+    onDuplicate?: (itemId: string) => void;
+    onCopy?: (itemId: string) => void;
+    onPaste?: (targetId: string | null) => void;
+    onDelete?: (itemId: string) => void;
+    onManageTags?: (itemId: string) => void;
+}
+export declare const FileTreeContextMenu: ({ children, itemId, isFolder, hasCopiedItem, onAddChild, onAddChildFolder, onAddSibling, onAddSiblingFolder, onRename, onDuplicate, onCopy, onPaste, onDelete, onManageTags, }: FileTreeContextMenuProps) => import("react").JSX.Element;
+export {};

package/dist/file-tree/documentUtils.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @module documentUtils
+ * @description Utility functions for document tree operations: building
+ * flat lists from nested trees, collecting descendant IDs, and resolving
+ * drop positions for drag-and-drop reordering.
+ */
+import type { Document } from "../documents/DocumentTree";
+/**
+ * Utility functions for document tree operations
+ */
+/**
+ * Generate a unique ID for a new document
+ */
+export declare function generateDocumentId(): string;
+/**
+ * Find a document by ID in the tree
+ */
+export declare function findDocumentById(documents: Document[], id: string): Document | null;
+/**
+ * Find the parent document of a given document ID
+ */
+export declare function findParentDocument(documents: Document[], id: string): Document | null;
+/**
+ * Get all siblings of a document (including itself)
+ */
+export declare function getSiblings(documents: Document[], id: string): Document[];
+/**
+ * Create a new document with default values
+ */
+export declare function createDocument(parentId: string | null, isFolder?: boolean): Document;
+/**
+ * Deep clone a document (for duplication)
+ * Generates new IDs for the cloned document and all children
+ */
+export declare function cloneDocument(doc: Document, newParentId?: string | null): Document;
+/**
+ * Flatten a document tree into a flat array
+ */
+export declare function flattenDocuments(documents: Document[]): Document[];
+/**
+ * Build a tree structure from flat documents array
+ */
+export declare function buildDocumentTree(documents: Document[]): Document[];
+/**
+ * Update a document in the tree
+ */
+export declare function updateDocument(documents: Document[], id: string, updates: Partial<Document>): Document[];
+/**
+ * Delete a document from the tree
+ */
+export declare function deleteDocument(documents: Document[], id: string): Document[];
+/**
+ * Add a document to the tree
+ */
+export declare function addDocument(documents: Document[], newDoc: Document, parentId: string | null): Document[];
+/**
+ * Move a document to a new position in the tree
+ */
+export declare function moveDocument(documents: Document[], draggedId: string, targetId: string | null, position: "before" | "after" | "child"): Document[];
+/**
+ * Check if a document is an ancestor of another document
+ */
+export declare function isAncestor(documents: Document[], ancestorId: string, descendantId: string): boolean;

package/dist/file-tree/expandLevels.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module file-tree/expandLevels
+ * @description Pure helpers behind the file tree's "expand one level at a
+ * time" cycle: which folders live at each nesting depth, how deep the tree
+ * is currently expanded, and which level a click should move to next.
+ */
+/** Minimal shape the level math needs from a tree item. */
+export interface FolderLikeItem {
+    children?: string[];
+    isFolder: boolean;
+}
+export type FolderItems = Record<string, FolderLikeItem>;
+/** Folder ids grouped by nesting depth (index 0 = top-level folders). */
+export declare function getFolderIdsByLevel(items: FolderItems, rootId: string): string[][];
+/** Deepest folder nesting level in the tree (0 = no folders at all). */
+export declare function getMaxFolderLevel(items: FolderItems, rootId: string): number;
+/** Folder ids reachable within `level` levels of nesting (1 = top-level folders). */
+export declare function getFolderIdsUpToLevel(items: FolderItems, rootId: string, level: number): string[];
+/**
+ * Infers the deepest folder level that is currently fully expanded: the
+ * largest depth `L` such that every folder at depth <= L is expanded.
+ * Returns 0 when any top-level folder is collapsed.
+ */
+export declare function getExpandedLevel(items: FolderItems, rootId: string, expandedItems: readonly string[]): number;
+/**
+ * The level one click of the expand/collapse toggle should move to: one
+ * level deeper each time, wrapping back to fully collapsed once the
+ * deepest level is showing.
+ */
+export declare function nextExpandLevel(currentLevel: number, maxLevel: number): number;
+/** Tooltip text describing what the next click of the toggle will do. */
+export declare function expandToggleLabelFor(currentLevel: number, maxLevel: number): string;

package/dist/file-tree/filetree.d.ts

@@ -0,0 +1,66 @@
+import type { Document } from "../documents/DocumentTree";
+export type DocumentTreeHandle = {
+    collapseAll: () => void;
+    edit: (nodeId: string) => void;
+    expandAll: () => void;
+    expandToLevel: (level: number) => void;
+    /** Deepest folder level currently fully expanded (0 = fully collapsed). */
+    getExpandLevel: () => number;
+    /** Deepest folder nesting level in the tree (0 = no folders at all). */
+    getMaxExpandLevel: () => number;
+};
+interface FileTreeProps {
+    activeId: string | null;
+    documents: Document[];
+    onMove: (draggedId: string, targetId: string | null, position: "before" | "after" | "child") => void;
+    onRename?: (id: string, newTitle: string) => void;
+    onSelect: (id: string) => void;
+    onDelete?: (id: string) => void;
+    onDuplicate?: (id: string) => void;
+    onAddChild?: (parentId: string) => void;
+    onAddChildFolder?: (parentId: string) => void;
+    onAddSibling?: (itemId: string) => void;
+    onAddSiblingFolder?: (itemId: string) => void;
+    onCopy?: (id: string) => void;
+    onPaste?: (targetId: string | null) => void;
+    onNewFile?: (parentId: string | null) => void;
+    onNewFolder?: (parentId: string | null) => void;
+    onManageTags?: (id: string) => void;
+    /**
+     * Reports the tree's live expansion depth so the toolbar's expand/collapse
+     * toggle can label its next step. Fires on mount, whenever the expanded
+     * depth or the tree's own depth changes, and with zeroes on unmount.
+     */
+    onExpandStateChange?: (state: {
+        level: number;
+        maxLevel: number;
+    }) => void;
+    /**
+     * Hands the tree's current expanded-folder set to the host whenever it
+     * changes, so the host can persist it. Without this, a stepped
+     * expand/collapse lives only in the tree's local state and the next
+     * document change (e.g. a rename) resets the tree back to the persisted
+     * `isExpanded` flags, throwing the cycle away.
+     */
+    onExpandedFoldersChange?: (folderIds: string[]) => void;
+}
+type DropPlacement = {
+    targetId: string | null;
+    position: "before" | "after" | "child";
+};
+/**
+ * Turns a headless-tree reorder target into the sibling-relative move the
+ * `onMove` callback speaks.
+ *
+ * `insertionIndex` is the drop slot counted against the parent's children
+ * *after* the dragged nodes have been lifted out of them, so the anchor has to
+ * be looked up in that same lifted-out list — using the raw `childIndex`
+ * against it lands a downward drag one slot too far, which reads as the node
+ * refusing to move where it was dropped.
+ *
+ * Exported for tests.
+ */
+export declare function resolveDropPlacement(parentChildren: string[], draggedIds: string[], insertionIndex: number, parentId: string | null): DropPlacement;
+declare const FileTree: import("react").ForwardRefExoticComponent<FileTreeProps & import("react").RefAttributes<DocumentTreeHandle>>;
+export { FileTree };
+export default FileTree;

package/dist/file-tree/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module filetree
+ * @description File tree components, hooks, and utilities for managing document hierarchy
+ */
+export { default as FileTree } from "./filetree";
+export { FileTreeContextMenu } from "./FileTreeContextMenu";
+export { useFileTreeOperations } from "./useFileTreeOperations";
+export * from "./expandLevels";
+export * from "./documentUtils";

package/dist/file-tree/useFileTreeOperations.d.ts

@@ -0,0 +1,27 @@
+import type { Document } from "../documents/DocumentTree";
+/**
+ * Hook that provides all file tree context menu operations
+ * Manages state and handlers for copy/paste, rename, delete, etc.
+ */
+export declare function useFileTreeOperations(documents: Document[], onDocumentUpdate: (id: string, updates: Partial<Document>) => void, onDocumentCreate: (parentId: string | null, isFolder: boolean) => void, onDocumentDelete: (id: string) => void, onDocumentDuplicate: (id: string) => void): {
+    copiedNodeId: string | null;
+    editingNodeId: string | null;
+    deleteConfirmId: string | null;
+    handleAddChild: (parentId: string) => void;
+    handleAddChildFolder: (parentId: string) => void;
+    handleAddSibling: (itemId: string) => void;
+    handleAddSiblingFolder: (itemId: string) => void;
+    handleRename: (id: string, newTitle: string) => void;
+    handleStartEdit: (id: string) => void;
+    handleCancelEdit: () => void;
+    handleDuplicate: (id: string) => void;
+    handleCopy: (id: string) => void;
+    handlePaste: (_targetId: string | null) => void;
+    handleDeleteRequest: (id: string) => void;
+    handleDeleteConfirm: () => void;
+    handleDeleteCancel: () => void;
+    handleManageTags: (id: string) => void;
+    findDocument: (id: string) => Document | null;
+    findParent: (id: string) => Document | null;
+    getSiblings: (id: string) => Document[];
+};

package/dist/fileSourceUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const getSourceIcon: (type: string) => import("react").JSX.Element;
+export declare const getSourceTypeLabel: (type: string) => string;