@pixerate/editor 0.6.1 → 0.8.0

package/dist/index.d.cts

@@ -6,6 +6,7 @@ export { ExtractedMention, escapeHtml, extractMentionsFromDoc, getEditorMarkdown
 import { Editor, EditorOptions, Content, Extensions } from '@tiptap/core';
 export { Content, Editor, EditorOptions, Extensions } from '@tiptap/core';
 export { ASTNode, BinaryOpNode, CellCoordinate, CellData, CellDep, CellFormat, CellRange, CellRefNode, ColumnBinding, ColumnType, DataSourceBinder, DependencyGraph, EvaluationContext, FormulaEvaluator, FormulaParser, FormulaToken, FormulaTokenType, FunctionCallNode, LiteralNode, PropertyRefNode, RangeNode, RowType, SpreadsheetColumn, SpreadsheetController, SpreadsheetControllerOptions, SpreadsheetDataSource, SpreadsheetDataSourceField, SpreadsheetDocument, SpreadsheetRow, UnaryOpNode, colNameToIndex, extractCellDependencies, indexToColName, parseCellReference, parseFormula, parseRange, tokenizeFormula } from './spreadsheet/index.cjs';
+export { Command, HistoryManager, HistoryManagerOptions, HistoryState, MergedExecutionOptions, SnapshotCommandOptions, createHistoryManager } from './history/index.cjs';
 export { MarkdownOptions } from 'tiptap-markdown';
 import '@tiptap/pm/view';
 import '@tiptap/pm/model';
@@ -40,6 +41,7 @@ declare class EditorController {
     private readonly onMarkdownChange?;
     private readonly onTokensChange?;
     private readonly onSelectionChange?;
+    private baselineContent;
     constructor(options?: EditorControllerOptions);
     private enforcePlainTextClipboard;
     private handleUpdate;
@@ -51,6 +53,11 @@ declare class EditorController {
     insertText(text: string): void;
     insertTextAt(pos: number, text: string): void;
     replaceRange(from: number, to: number, text: string): void;
+    getCurrentContentString(): string;
+    isDirty(): boolean;
+    setCheckpoint(content?: string): void;
+    resetDirty(): void;
+    getBaselineContent(): string;
     destroy(): void;
 }
 /**
@@ -58,4 +65,41 @@ declare class EditorController {
  */
 declare function createEditor(options?: EditorControllerOptions): EditorController;
 
-export { EditorController, type EditorControllerOptions, Token, createEditor };
+/**
+ * Compares two values for structural equality.
+ * Handles primitives, objects, arrays, and null/undefined.
+ */
+declare function defaultIsEqual<T>(a: T, b: T): boolean;
+interface DirtyTrackerOptions<T> {
+    isEqual?: (a: T, b: T) => boolean;
+}
+/**
+ * Tracks a baseline value and determines if the current state is dirty (modified).
+ */
+declare class DirtyTracker<T = unknown> {
+    private baseline;
+    private readonly isEqual;
+    constructor(initialBaseline: T, options?: DirtyTrackerOptions<T> | ((a: T, b: T) => boolean));
+    /**
+     * Returns current baseline value.
+     */
+    getBaseline(): T;
+    /**
+     * Sets a new baseline value without triggering any dirty state.
+     */
+    setBaseline(value: T): void;
+    /**
+     * Checks whether the given value differs from the baseline.
+     */
+    isDirty(current: T): boolean;
+    /**
+     * Resets the baseline to the provided current value (or clears dirty status).
+     */
+    reset(current: T): void;
+}
+/**
+ * Creates a DirtyTracker instance.
+ */
+declare function createDirtyTracker<T>(initialBaseline: T, options?: DirtyTrackerOptions<T> | ((a: T, b: T) => boolean)): DirtyTracker<T>;
+
+export { DirtyTracker, type DirtyTrackerOptions, EditorController, type EditorControllerOptions, Token, createDirtyTracker, createEditor, defaultIsEqual };

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export { ExtractedMention, escapeHtml, extractMentionsFromDoc, getEditorMarkdown
 import { Editor, EditorOptions, Content, Extensions } from '@tiptap/core';
 export { Content, Editor, EditorOptions, Extensions } from '@tiptap/core';
 export { ASTNode, BinaryOpNode, CellCoordinate, CellData, CellDep, CellFormat, CellRange, CellRefNode, ColumnBinding, ColumnType, DataSourceBinder, DependencyGraph, EvaluationContext, FormulaEvaluator, FormulaParser, FormulaToken, FormulaTokenType, FunctionCallNode, LiteralNode, PropertyRefNode, RangeNode, RowType, SpreadsheetColumn, SpreadsheetController, SpreadsheetControllerOptions, SpreadsheetDataSource, SpreadsheetDataSourceField, SpreadsheetDocument, SpreadsheetRow, UnaryOpNode, colNameToIndex, extractCellDependencies, indexToColName, parseCellReference, parseFormula, parseRange, tokenizeFormula } from './spreadsheet/index.js';
+export { Command, HistoryManager, HistoryManagerOptions, HistoryState, MergedExecutionOptions, SnapshotCommandOptions, createHistoryManager } from './history/index.js';
 export { MarkdownOptions } from 'tiptap-markdown';
 import '@tiptap/pm/view';
 import '@tiptap/pm/model';
@@ -40,6 +41,7 @@ declare class EditorController {
     private readonly onMarkdownChange?;
     private readonly onTokensChange?;
     private readonly onSelectionChange?;
+    private baselineContent;
     constructor(options?: EditorControllerOptions);
     private enforcePlainTextClipboard;
     private handleUpdate;
@@ -51,6 +53,11 @@ declare class EditorController {
     insertText(text: string): void;
     insertTextAt(pos: number, text: string): void;
     replaceRange(from: number, to: number, text: string): void;
+    getCurrentContentString(): string;
+    isDirty(): boolean;
+    setCheckpoint(content?: string): void;
+    resetDirty(): void;
+    getBaselineContent(): string;
     destroy(): void;
 }
 /**
@@ -58,4 +65,41 @@ declare class EditorController {
  */
 declare function createEditor(options?: EditorControllerOptions): EditorController;
 
-export { EditorController, type EditorControllerOptions, Token, createEditor };
+/**
+ * Compares two values for structural equality.
+ * Handles primitives, objects, arrays, and null/undefined.
+ */
+declare function defaultIsEqual<T>(a: T, b: T): boolean;
+interface DirtyTrackerOptions<T> {
+    isEqual?: (a: T, b: T) => boolean;
+}
+/**
+ * Tracks a baseline value and determines if the current state is dirty (modified).
+ */
+declare class DirtyTracker<T = unknown> {
+    private baseline;
+    private readonly isEqual;
+    constructor(initialBaseline: T, options?: DirtyTrackerOptions<T> | ((a: T, b: T) => boolean));
+    /**
+     * Returns current baseline value.
+     */
+    getBaseline(): T;
+    /**
+     * Sets a new baseline value without triggering any dirty state.
+     */
+    setBaseline(value: T): void;
+    /**
+     * Checks whether the given value differs from the baseline.
+     */
+    isDirty(current: T): boolean;
+    /**
+     * Resets the baseline to the provided current value (or clears dirty status).
+     */
+    reset(current: T): void;
+}
+/**
+ * Creates a DirtyTracker instance.
+ */
+declare function createDirtyTracker<T>(initialBaseline: T, options?: DirtyTrackerOptions<T> | ((a: T, b: T) => boolean)): DirtyTracker<T>;
+
+export { DirtyTracker, type DirtyTrackerOptions, EditorController, type EditorControllerOptions, Token, createDirtyTracker, createEditor, defaultIsEqual };

package/dist/index.js

@@ -2358,6 +2358,7 @@ var EditorController = class {
   onMarkdownChange;
   onTokensChange;
   onSelectionChange;
+  baselineContent;
   constructor(options = {}) {
     const {
       element,
@@ -2395,6 +2396,7 @@ var EditorController = class {
     if (plainTextMode) {
       this.enforcePlainTextClipboard();
     }
+    this.baselineContent = this.getCurrentContentString();
   }
   enforcePlainTextClipboard() {
     this.editor.setOptions({
@@ -2468,6 +2470,23 @@ var EditorController = class {
   replaceRange(from, to, text) {
     this.editor.chain().focus().deleteRange({ from, to }).insertContentAt(from, text).run();
   }
+  getCurrentContentString() {
+    if (this.plainTextMode) return this.getPlainText();
+    if (this.markdownMode) return this.getMarkdown();
+    return this.editor.getHTML();
+  }
+  isDirty() {
+    return this.getCurrentContentString() !== this.baselineContent;
+  }
+  setCheckpoint(content) {
+    this.baselineContent = content !== void 0 ? content : this.getCurrentContentString();
+  }
+  resetDirty() {
+    this.setCheckpoint();
+  }
+  getBaselineContent() {
+    return this.baselineContent;
+  }
   destroy() {
     this.editor.destroy();
   }
@@ -3750,15 +3769,310 @@ var SpreadsheetController = class {
     this.onDocumentChange?.(this.document);
   }
 };
+
+// src/dirty.ts
+function defaultIsEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!defaultIsEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!defaultIsEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+var DirtyTracker = class {
+  baseline;
+  isEqual;
+  constructor(initialBaseline, options) {
+    this.baseline = initialBaseline;
+    if (typeof options === "function") {
+      this.isEqual = options;
+    } else {
+      this.isEqual = options?.isEqual ?? defaultIsEqual;
+    }
+  }
+  /**
+   * Returns current baseline value.
+   */
+  getBaseline() {
+    return this.baseline;
+  }
+  /**
+   * Sets a new baseline value without triggering any dirty state.
+   */
+  setBaseline(value) {
+    this.baseline = value;
+  }
+  /**
+   * Checks whether the given value differs from the baseline.
+   */
+  isDirty(current) {
+    return !this.isEqual(this.baseline, current);
+  }
+  /**
+   * Resets the baseline to the provided current value (or clears dirty status).
+   */
+  reset(current) {
+    this.baseline = current;
+  }
+};
+function createDirtyTracker(initialBaseline, options) {
+  return new DirtyTracker(initialBaseline, options);
+}
+
+// src/history/HistoryManager.ts
+var HistoryManager = class {
+  undoStack = [];
+  redoStack = [];
+  maxDepth;
+  isApplying = false;
+  batchDepth = 0;
+  currentBatch = null;
+  listeners = /* @__PURE__ */ new Set();
+  onStateChange;
+  cachedState;
+  constructor(options = {}) {
+    this.maxDepth = options.maxDepth ?? 50;
+    this.onStateChange = options.onStateChange;
+    this.cachedState = this.computeState();
+  }
+  computeState() {
+    const canUndo = this.undoStack.length > 0;
+    const canRedo = this.redoStack.length > 0;
+    return {
+      canUndo,
+      canRedo,
+      undoName: canUndo ? this.undoStack[this.undoStack.length - 1].name : "",
+      redoName: canRedo ? this.redoStack[this.redoStack.length - 1].name : "",
+      undoCount: this.undoStack.length,
+      redoCount: this.redoStack.length
+    };
+  }
+  /**
+   * Returns a snapshot of the current history state.
+   * Cached to maintain referential equality across renders for useSyncExternalStore.
+   */
+  getState() {
+    return this.cachedState;
+  }
+  notify() {
+    this.cachedState = this.computeState();
+    const state = this.cachedState;
+    this.onStateChange?.(state);
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (err) {
+        console.error("[HistoryManager] Error in state listener:", err);
+      }
+    });
+  }
+  /**
+   * Executes a command and pushes it onto the undo stack.
+   * Clears the redo stack.
+   */
+  execute(command) {
+    if (this.isApplying) {
+      command.execute();
+      return;
+    }
+    if (this.batchDepth > 0 && this.currentBatch) {
+      command.execute();
+      this.currentBatch.push({
+        ...command,
+        timestamp: command.timestamp ?? Date.now()
+      });
+      return;
+    }
+    command.execute();
+    this.undoStack.push({
+      ...command,
+      timestamp: command.timestamp ?? Date.now()
+    });
+    if (this.undoStack.length > this.maxDepth) {
+      this.undoStack.shift();
+    }
+    this.redoStack = [];
+    this.notify();
+  }
+  /**
+   * Executes a command, coalescing it with the previous command if they share
+   * the same `tag` and occurred within `windowMs` (default: 300ms).
+   * Useful for high-frequency interactions like slider scrubs or node drags.
+   */
+  executeMerged(command, options = {}) {
+    const windowMs = options.windowMs ?? 300;
+    const now = Date.now();
+    if (command.tag && this.undoStack.length > 0 && this.batchDepth === 0 && !this.isApplying) {
+      const top = this.undoStack[this.undoStack.length - 1];
+      const elapsed = top.timestamp ? now - top.timestamp : Infinity;
+      if (top.tag === command.tag && elapsed <= windowMs) {
+        command.execute();
+        const initialUndo = top.undo;
+        this.undoStack[this.undoStack.length - 1] = {
+          name: command.name,
+          tag: command.tag,
+          timestamp: now,
+          execute: command.execute,
+          undo: initialUndo,
+          redo: command.redo ?? command.execute
+        };
+        this.redoStack = [];
+        this.notify();
+        return;
+      }
+    }
+    this.execute({ ...command, timestamp: now });
+  }
+  /**
+   * Batches multiple commands executed within `fn` into a single atomic undo entry.
+   */
+  batch(name, fn) {
+    if (this.isApplying) {
+      fn();
+      return;
+    }
+    if (this.batchDepth > 0) {
+      fn();
+      return;
+    }
+    this.batchDepth++;
+    this.currentBatch = [];
+    try {
+      fn();
+    } finally {
+      this.batchDepth--;
+      const batchCommands = this.currentBatch;
+      this.currentBatch = null;
+      if (batchCommands && batchCommands.length > 0) {
+        const compoundCommand = {
+          name,
+          timestamp: Date.now(),
+          execute: () => {
+            for (let i = 0; i < batchCommands.length; i++) {
+              (batchCommands[i].redo ?? batchCommands[i].execute)();
+            }
+          },
+          undo: () => {
+            for (let i = batchCommands.length - 1; i >= 0; i--) {
+              batchCommands[i].undo();
+            }
+          },
+          redo: () => {
+            for (let i = 0; i < batchCommands.length; i++) {
+              (batchCommands[i].redo ?? batchCommands[i].execute)();
+            }
+          }
+        };
+        this.undoStack.push(compoundCommand);
+        if (this.undoStack.length > this.maxDepth) {
+          this.undoStack.shift();
+        }
+        this.redoStack = [];
+        this.notify();
+      }
+    }
+  }
+  /**
+   * Reverts the most recent command on the undo stack.
+   * Returns true if a command was undone, false otherwise.
+   */
+  undo() {
+    if (this.undoStack.length === 0 || this.isApplying || this.batchDepth > 0) {
+      return false;
+    }
+    this.isApplying = true;
+    try {
+      const command = this.undoStack.pop();
+      command.undo();
+      this.redoStack.push(command);
+      return true;
+    } finally {
+      this.isApplying = false;
+      this.notify();
+    }
+  }
+  /**
+   * Re-applies the most recent undone command on the redo stack.
+   * Returns true if a command was redone, false otherwise.
+   */
+  redo() {
+    if (this.redoStack.length === 0 || this.isApplying || this.batchDepth > 0) {
+      return false;
+    }
+    this.isApplying = true;
+    try {
+      const command = this.redoStack.pop();
+      (command.redo ?? command.execute)();
+      this.undoStack.push(command);
+      return true;
+    } finally {
+      this.isApplying = false;
+      this.notify();
+    }
+  }
+  /**
+   * Clears both undo and redo stacks.
+   */
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.notify();
+  }
+  /**
+   * Subscribes to history state changes.
+   * The listener is immediately invoked with the current state.
+   * Returns an unsubscribe function.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.getState());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Utility helper to create a Command from before/after state snapshots.
+   */
+  static createSnapshotCommand(options) {
+    return {
+      name: options.name,
+      tag: options.tag,
+      execute: () => options.apply(options.after),
+      undo: () => options.apply(options.before),
+      redo: () => options.apply(options.after)
+    };
+  }
+};
+function createHistoryManager(options = {}) {
+  return new HistoryManager(options);
+}
 export {
   ColorHighlighter,
   DataSourceBinder,
   DependencyGraph,
+  DirtyTracker,
   EditorController,
   FontSize,
   FormulaEvaluator,
   FormulaParser,
   GradientText,
+  HistoryManager,
   INSTRUCTION_REGEX,
   Image2 as Image,
   LoadingNode,
@@ -3771,9 +4085,12 @@ export {
   TemplateSuggestions,
   VARIABLE_REGEX,
   colNameToIndex,
+  createDirtyTracker,
   createEditor,
+  createHistoryManager,
   createMentionExtension,
   createRichTextPreset,
+  defaultIsEqual,
   escapeHtml,
   extractCellDependencies,
   extractInstructionNames,