test

Author: goanpeca

packages/lexical/scripts/validate-tools-sync.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */

packages/lexical/src/state/LexicalAdapter.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */

packages/lexical/src/state/LexicalState.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */

packages/lexical/src/state/index.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */

packages/lexical/src/tools/core/executor.ts

@@ -11,9 +11,7 @@
  * @module tools/core/executor
  */
 
-// NOTE: This executor is designed for notebooks, not lexical documents
-// Commenting out for now as this import doesn't exist in lexical package
-// import type { Notebook2State } from '../../components/notebook/Notebook2State';
+import type { LexicalState } from '../../state/LexicalState';
 
 /**
  * Tool executor interface - abstracts how operations are executed.
@@ -23,39 +21,36 @@ export interface ToolExecutor {
   /**
    * Execute a tool operation
    *
-   * @param operationName - Name of the operation (e.g., "insertCell", "runCell")
+   * @param operationName - Name of the operation (e.g., "insertBlock", "runBlock")
    * @param args - Operation arguments
    * @returns Result from execution
    */
   execute(operationName: string, args: unknown): Promise<unknown>;
 }
 
 /**
- * Default executor - directly calls Notebook2State store methods.
+ * Default executor - directly calls LexicalState store methods.
  * Uses 1:1 mapping between operation names and store methods with no transformation.
  *
- * NOTE: This class is designed for notebooks, not lexical documents.
- * It's kept here for reference but may need adaptation for lexical use.
- *
  * @example
  * ```typescript
- * const executor = new DefaultExecutor(notebookId, notebookStore);
- * await executor.execute("insertCell", { type: "code", source: "print('hi')" });
+ * const executor = new DefaultExecutor(lexicalId, lexicalStore);
+ * await executor.execute("insertBlock", { type: "paragraph", source: "Hello world" });
  * ```
  */
 export class DefaultExecutor implements ToolExecutor {
   constructor(
-    private notebookId: string,
-    private store: any, // Notebook2State - commented out as it doesn't exist in lexical package
+    private lexicalId: string,
+    private store: LexicalState,
   ) {}
 
   /**
-   * Execute an operation by directly calling the corresponding Notebook2State method.
+   * Execute an operation by directly calling the corresponding LexicalState method.
    *
-   * Operation names map 1:1 to Notebook2State method names (e.g., "insertCell" → store.insertCell).
-   * All args are passed directly to the store method with notebookId injected.
+   * Operation names map 1:1 to LexicalState method names (e.g., "insertBlock" → store.insertBlock).
+   * All args are passed directly to the store method with lexicalId injected.
    *
-   * @param operationName - Name of the operation (e.g., "insertCell", "runCell")
+   * @param operationName - Name of the operation (e.g., "insertBlock", "runBlock")
    * @param args - Operation arguments (passed directly to store method)
    * @returns Result from store method
    */
@@ -71,11 +66,11 @@ export class DefaultExecutor implements ToolExecutor {
       );
     }
 
-    // Inject notebookId into args and call store method
+    // Inject lexicalId into args and call store method
     const payload =
       typeof args === 'object' && args !== null
-        ? { id: this.notebookId, ...args }
-        : { id: this.notebookId };
+        ? { id: this.lexicalId, ...args }
+        : { id: this.lexicalId };
 
     return await (method as (args: unknown) => Promise<unknown>).call(
       this.store,

packages/lexical/src/tools/core/formatter.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */

packages/lexical/src/tools/core/index.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */

packages/lexical/src/tools/core/interfaces.ts

@@ -1,172 +1,24 @@
 /*
- * Copyright (c) 2021-2025 Datalayer, Inc.
+ * Copyright (c) 2021-2023 Datalayer, Inc.
  *
  * MIT License
  */
 
 /**
- * Core interfaces for platform-agnostic tool operations.
- * These interfaces enable the 3-tier architecture by abstracting
- * document access and tool execution from specific platforms.
+ * Core interfaces for Lexical tool operations.
+ * These interfaces enable platform-agnostic tool execution.
  *
  * @module tools/core/interfaces
  */
 
-import type {
-  CellData,
-  NotebookMetadata,
-  ExecutionResult,
-  RuntimeInfo,
-} from './types';
-
-// Re-export types for platform adapters
-export type { CellData, NotebookMetadata, ExecutionResult, RuntimeInfo };
-
-// Import Lexical types
 import type {
   LexicalBlock,
   LexicalMetadata,
   RegisteredNodeInfo,
 } from './types';
-export type { LexicalBlock, LexicalMetadata, RegisteredNodeInfo };
-
-/**
- * Base document handle - common operations for all document types.
- */
-export interface DocumentHandle {
-  /**
-   * Get document metadata
-   */
-  getMetadata(): Promise<NotebookMetadata | LexicalMetadata>;
-
-  /**
-   * Save the document (optional)
-   */
-  save?(): Promise<void>;
-
-  /**
-   * Close the document (optional)
-   */
-  close?(): Promise<void>;
-}
-
-/**
- * Notebook document handle - for Jupyter notebooks.
- *
- * Platform implementations:
- * - VS Code: VSCodeDocumentHandle (webview messages)
- * - SaaS: SaaSDocumentHandle (JupyterLab APIs)
- */
-export interface NotebookHandle extends DocumentHandle {
-  /**
-   * Get notebook metadata (narrowed type)
-   */
-  getMetadata(): Promise<NotebookMetadata>;
-
-  /**
-   * Get total number of cells in the notebook
-   */
-  getCellCount(): Promise<number>;
-
-  /**
-   * Get a specific cell by index
-   */
-  getCell(index: number): Promise<CellData>;
-
-  /**
-   * Get all cells from the notebook
-   */
-  getAllCells(): Promise<CellData[]>;
-
-  /**
-   * Insert a cell at the specified index
-   */
-  insertCell(index: number, cell: CellData): Promise<void>;
-
-  /**
-   * Delete a cell at the specified index
-   */
-  deleteCell(index: number): Promise<void>;
 
-  /**
-   * Update a cell's source code
-   */
-  updateCell(index: number, source: string): Promise<void>;
-
-  /**
-   * Execute a code cell
-   */
-  executeCell(index: number): Promise<ExecutionResult>;
-}
-
-/**
- * Lexical document handle - for Lexical rich text documents.
- *
- * Platform implementations:
- * - VS Code: VSCodeLexicalHandle (webview messages)
- * - SaaS: SaaSLexicalHandle (direct DOM)
- */
-export interface LexicalHandle extends DocumentHandle {
-  /**
-   * Get Lexical metadata (narrowed type)
-   */
-  getMetadata(): Promise<LexicalMetadata>;
-
-  /**
-   * Get all blocks with their block_id values
-   */
-  getBlocks(): Promise<LexicalBlock[]>;
-
-  /**
-   * Insert a block after a specific block ID
-   * @param block - Block to insert (block_id will be generated)
-   * @param afterBlockId - Block ID to insert after ('TOP', 'BOTTOM', or actual block_id)
-   */
-  insertBlock(block: LexicalBlock, afterBlockId: string): Promise<void>;
-
-  /**
-   * Insert multiple blocks sequentially
-   * @param blocks - Array of blocks to insert
-   * @param afterBlockId - Block ID to insert first block after ('TOP', 'BOTTOM', or actual block_id)
-   */
-  insertBlocks(blocks: LexicalBlock[], afterBlockId: string): Promise<void>;
-
-  /**
-   * Delete a block by its ID
-   * @param blockId - ID of the block to delete
-   */
-  deleteBlock(blockId: string): Promise<void>;
-
-  /**
-   * Update a block by its ID
-   * @param blockId - ID of the block to update
-   * @param block - New block data
-   */
-  updateBlock(blockId: string, block: LexicalBlock): Promise<void>;
-
-  /**
-   * Get registered node types from editor
-   */
-  getAvailableBlockTypes(): Promise<RegisteredNodeInfo[]>;
-}
-
-/**
- * Type guard for NotebookHandle
- */
-export function isNotebookHandle(
-  handle: DocumentHandle | undefined,
-): handle is NotebookHandle {
-  return handle !== undefined && 'getCellCount' in handle;
-}
-
-/**
- * Type guard for LexicalHandle
- */
-export function isLexicalHandle(
-  handle: DocumentHandle | undefined,
-): handle is LexicalHandle {
-  return handle !== undefined && 'getBlocks' in handle;
-}
+// Re-export types for convenience
+export type { LexicalBlock, LexicalMetadata, RegisteredNodeInfo };
 
 /**
  * Base tool execution context - common to all operations
@@ -211,21 +63,6 @@ export interface BaseExecutionContext {
   extras?: Record<string, unknown>;
 }
 
-/**
- * Notebook-specific execution context
- * Used by all notebook cell operations (insert, delete, update, execute, read)
- */
-export interface NotebookExecutionContext extends BaseExecutionContext {
-  /**
-   * Notebook ID - universal identifier for both local and remote notebooks
-   * - Local notebooks: Same as file URI (e.g., "file:///path/to/notebook.ipynb")
-   * - Remote notebooks: Datalayer document UID (e.g., "01KAJ42KE2XKM7NBNZV568KXQX")
-   *
-   * This is the same ID used by Notebook2 component: `id={documentId || notebookId}`
-   */
-  notebookId: string;
-}
-
 /**
  * Lexical-specific execution context
  * Used by all Lexical block operations (insertBlock, deleteBlock, readBlocks)
@@ -239,33 +76,6 @@ export interface LexicalExecutionContext extends BaseExecutionContext {
   lexicalId: string;
 }
 
-/**
- * Generic execution context (for operations that don't need documents)
- * Used by creation tools (createNotebook, startRuntime, etc.)
- */
-export interface ToolExecutionContext extends BaseExecutionContext {
-  /**
-   * Optional notebook ID (for notebook-specific operations)
-   * - Local notebooks: Same as file URI (e.g., "file:///path/to/notebook.ipynb")
-   * - Remote notebooks: Datalayer document UID (e.g., "01KAJ42KE2XKM7NBNZV568KXQX")
-   */
-  notebookId?: string;
-
-  /**
-   * Optional lexical document ID (for lexical-specific operations)
-   * - Local documents: Same as file URI (e.g., "file:///path/to/document.lexical")
-   * - Remote documents: Datalayer document UID (e.g., "01KAJ42KE2XKM7NBNZV568KXQX")
-   */
-  lexicalId?: string;
-
-  /**
-   * Optional generic document ID (backwards compatibility)
-   * - For notebooks: Same as notebookId
-   * - For Lexical: Same as lexicalId
-   */
-  documentId?: string;
-}
-
 /**
  * Core tool operation interface - platform agnostic.
  *
@@ -289,11 +99,11 @@ export interface ToolOperation<TParams, TResult> {
    * ToolDefinition (schema), not here. Operations are pure implementation.
    *
    * @param params - Tool-specific parameters
-   * @param context - Execution context (document, SDK, auth)
+   * @param context - Execution context (lexicalId, SDK, auth)
    * @returns Operation result
    * @throws Error if operation fails
    */
-  execute(params: TParams, context: ToolExecutionContext): Promise<TResult>;
+  execute(params: TParams, context: LexicalExecutionContext): Promise<TResult>;
 }
 
 /**