slate-vue3 0.0.6 → 0.0.7

package/dist/index.d.ts

@@ -268,6 +268,11 @@ export declare interface BaseText {
     text: string;
 }
 
+declare interface Batch {
+    operations: Operation[];
+    selectionBefore: Range_2 | null;
+}
+
 export declare const before: EditorInterface['before'];
 
 export declare const CAN_USE_DOM: boolean;
@@ -1420,6 +1425,87 @@ export declare const hasShadowRoot: (node: Node | null) => boolean;
 
 export declare const hasTexts: EditorInterface['hasTexts'];
 
+/**
+ * Weakmaps for attaching state to the editor.
+ */
+export declare const HISTORY: toRawWeakMap<DOMEditor, History_2>;
+
+/**
+ * `History` objects hold all of the operations that are applied to a value, so
+ * they can be undone or redone as necessary.
+ */
+declare interface History_2 {
+    redos: Batch[];
+    undos: Batch[];
+}
+
+declare const History_2: {
+    /**
+     * Check if a value is a `History` object.
+     */
+    isHistory(value: any): value is History_2;
+};
+export { History_2 as History }
+
+/**
+ * `HistoryEditor` contains helpers for history-enabled editors.
+ */
+export declare interface HistoryEditor extends BaseEditor {
+    history: History_2;
+    undo: () => void;
+    redo: () => void;
+    writeHistory: (stack: "undos" | "redos", batch: any) => void;
+}
+
+export declare const HistoryEditor: {
+    /**
+     * Check if a value is a `HistoryEditor` object.
+     */
+    isHistoryEditor(value: any): value is HistoryEditor;
+    /**
+     * Get the merge flag's current value.
+     */
+    isMerging(editor: HistoryEditor): boolean | undefined;
+    /**
+     * Get the splitting once flag's current value.
+     */
+    isSplittingOnce(editor: HistoryEditor): boolean | undefined;
+    setSplittingOnce(editor: HistoryEditor, value: boolean | undefined): void;
+    /**
+     * Get the saving flag's current value.
+     */
+    isSaving(editor: HistoryEditor): boolean | undefined;
+    /**
+     * Redo to the previous saved state.
+     */
+    redo(editor: HistoryEditor): void;
+    /**
+     * Undo to the previous saved state.
+     */
+    undo(editor: HistoryEditor): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, These operations will
+     * be merged into the previous history.
+     */
+    withMerging(editor: HistoryEditor, fn: () => void): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, ensuring that the first
+     * operation starts a new batch in the history. Subsequent operations will be
+     * merged as usual.
+     */
+    withNewBatch(editor: HistoryEditor, fn: () => void): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, without merging any of
+     * the new operations into previous save point in the history.
+     */
+    withoutMerging(editor: HistoryEditor, fn: () => void): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, without saving any of
+     * their operations into the history.
+     */
+    withoutSaving(editor: HistoryEditor, fn: () => void): void;
+};
+
 /**
  * Hotkeys.
  */
@@ -1622,6 +1708,8 @@ export declare const mergeNodes: NodeTransforms['mergeNodes'];
  */
 export declare function mergeStringDiffs(targetText: string, a: StringDiff, b: StringDiff): StringDiff | null;
 
+export declare const MERGING: toRawWeakMap<DOMEditor, boolean | undefined>;
+
 export declare const move: SelectionTransforms['move'];
 
 export declare type MoveNodeOperation = ExtendedType<'MoveNodeOperation', BaseMoveNodeOperation>;
@@ -2405,6 +2493,8 @@ export declare interface RenderPlaceholderProps {
     };
 }
 
+export declare const SAVING: toRawWeakMap<DOMEditor, boolean | undefined>;
+
 export declare type Scrubber = (key: string, value: unknown) => unknown;
 
 /**
@@ -2542,6 +2632,8 @@ export declare type SplitNodeOperation = ExtendedType<'SplitNodeOperation', Base
 
 export declare const splitNodes: NodeTransforms['splitNodes'];
 
+export declare const SPLITTING_ONCE: toRawWeakMap<DOMEditor, boolean | undefined>;
+
 export declare const start: EditorInterface['start'];
 
 export declare const string: EditorInterface['string'];
@@ -2735,6 +2827,17 @@ export declare const withDOM: <T extends BaseEditor>(editor: T, clipboardFormatK
 
 declare type WithEditorFirstArg<T extends (...args: any) => any> = (editor: Editor, ...args: Parameters<T>) => ReturnType<T>;
 
+/**
+ * The `withHistory` plugin keeps track of the operation history of a Slate
+ * editor as operations are applied to it, using undo and redo stacks.
+ *
+ * If you are using TypeScript, you must extend Slate's CustomTypes to use
+ * this plugin.
+ *
+ * See https://docs.slatejs.org/concepts/11-typescript to learn how.
+ */
+export declare const withHistory: <T extends Editor>(editor: T) => T & HistoryEditor;
+
 export declare const withoutNormalizing: EditorInterface['withoutNormalizing'];
 
 export declare const wrapNodes: NodeTransforms['wrapNodes'];

package/dist/slate-vue3.js

@@ -12365,6 +12365,205 @@ const useSelection = () => {
   }
   return selection;
 };
+const History = {
+  /**
+   * Check if a value is a `History` object.
+   */
+  isHistory(value) {
+    return isPlainObject(value) && Array.isArray(value.redos) && Array.isArray(value.undos) && (value.redos.length === 0 || Operation.isOperationList(value.redos[0].operations)) && (value.undos.length === 0 || Operation.isOperationList(value.undos[0].operations));
+  }
+};
+const HISTORY = new toRawWeakMap();
+const SAVING = new toRawWeakMap();
+const MERGING = new toRawWeakMap();
+const SPLITTING_ONCE = new toRawWeakMap();
+const HistoryEditor = {
+  /**
+   * Check if a value is a `HistoryEditor` object.
+   */
+  isHistoryEditor(value) {
+    return History.isHistory(value.history) && Editor.isEditor(value);
+  },
+  /**
+   * Get the merge flag's current value.
+   */
+  isMerging(editor) {
+    return MERGING.get(editor);
+  },
+  /**
+   * Get the splitting once flag's current value.
+   */
+  isSplittingOnce(editor) {
+    return SPLITTING_ONCE.get(editor);
+  },
+  setSplittingOnce(editor, value) {
+    SPLITTING_ONCE.set(editor, value);
+  },
+  /**
+   * Get the saving flag's current value.
+   */
+  isSaving(editor) {
+    return SAVING.get(editor);
+  },
+  /**
+   * Redo to the previous saved state.
+   */
+  redo(editor) {
+    editor.redo();
+  },
+  /**
+   * Undo to the previous saved state.
+   */
+  undo(editor) {
+    editor.undo();
+  },
+  /**
+   * Apply a series of changes inside a synchronous `fn`, These operations will
+   * be merged into the previous history.
+   */
+  withMerging(editor, fn) {
+    const prev = HistoryEditor.isMerging(editor);
+    MERGING.set(editor, true);
+    fn();
+    MERGING.set(editor, prev);
+  },
+  /**
+   * Apply a series of changes inside a synchronous `fn`, ensuring that the first
+   * operation starts a new batch in the history. Subsequent operations will be
+   * merged as usual.
+   */
+  withNewBatch(editor, fn) {
+    const prev = HistoryEditor.isMerging(editor);
+    MERGING.set(editor, true);
+    SPLITTING_ONCE.set(editor, true);
+    fn();
+    MERGING.set(editor, prev);
+    SPLITTING_ONCE.delete(editor);
+  },
+  /**
+   * Apply a series of changes inside a synchronous `fn`, without merging any of
+   * the new operations into previous save point in the history.
+   */
+  withoutMerging(editor, fn) {
+    const prev = HistoryEditor.isMerging(editor);
+    MERGING.set(editor, false);
+    fn();
+    MERGING.set(editor, prev);
+  },
+  /**
+   * Apply a series of changes inside a synchronous `fn`, without saving any of
+   * their operations into the history.
+   */
+  withoutSaving(editor, fn) {
+    const prev = HistoryEditor.isSaving(editor);
+    SAVING.set(editor, false);
+    fn();
+    SAVING.set(editor, prev);
+  }
+};
+const withHistory = (editor) => {
+  const e2 = editor;
+  const { apply: apply2 } = e2;
+  e2.history = { undos: [], redos: [] };
+  e2.redo = () => {
+    const { history } = e2;
+    const { redos } = history;
+    if (redos.length > 0) {
+      const batch2 = redos[redos.length - 1];
+      if (batch2.selectionBefore) {
+        Transforms.setSelection(e2, batch2.selectionBefore);
+      }
+      HistoryEditor.withoutSaving(e2, () => {
+        Editor.withoutNormalizing(e2, () => {
+          for (const op of batch2.operations) {
+            e2.apply(op);
+          }
+        });
+      });
+      history.redos.pop();
+      e2.writeHistory("undos", batch2);
+    }
+  };
+  e2.undo = () => {
+    const { history } = e2;
+    const { undos } = history;
+    if (undos.length > 0) {
+      const batch2 = undos[undos.length - 1];
+      HistoryEditor.withoutSaving(e2, () => {
+        Editor.withoutNormalizing(e2, () => {
+          const inverseOps = batch2.operations.map(Operation.inverse).reverse();
+          for (const op of inverseOps) {
+            e2.apply(op);
+          }
+          if (batch2.selectionBefore) {
+            Transforms.setSelection(e2, batch2.selectionBefore);
+          }
+        });
+      });
+      e2.writeHistory("redos", batch2);
+      history.undos.pop();
+    }
+  };
+  e2.apply = (op) => {
+    const { operations, history } = e2;
+    const { undos } = history;
+    const lastBatch = undos[undos.length - 1];
+    const lastOp = lastBatch && lastBatch.operations[lastBatch.operations.length - 1];
+    let save = HistoryEditor.isSaving(e2);
+    let merge = HistoryEditor.isMerging(e2);
+    if (save == null) {
+      save = shouldSave(op);
+    }
+    if (save) {
+      if (merge == null) {
+        if (lastBatch == null) {
+          merge = false;
+        } else if (operations.length !== 0) {
+          merge = true;
+        } else {
+          merge = shouldMerge(op, lastOp);
+        }
+      }
+      if (HistoryEditor.isSplittingOnce(e2)) {
+        merge = false;
+        HistoryEditor.setSplittingOnce(e2, void 0);
+      }
+      if (lastBatch && merge) {
+        lastBatch.operations.push(op);
+      } else {
+        const batch2 = {
+          operations: [op],
+          selectionBefore: e2.selection
+        };
+        e2.writeHistory("undos", batch2);
+      }
+      while (undos.length > 100) {
+        undos.shift();
+      }
+      history.redos = [];
+    }
+    apply2(op);
+  };
+  e2.writeHistory = (stack2, batch2) => {
+    e2.history[stack2].push(batch2);
+  };
+  return e2;
+};
+const shouldMerge = (op, prev) => {
+  if (prev && op.type === "insert_text" && prev.type === "insert_text" && op.offset === prev.offset + prev.text.length && Path.equals(op.path, prev.path)) {
+    return true;
+  }
+  if (prev && op.type === "remove_text" && prev.type === "remove_text" && op.offset + op.text.length === prev.offset && Path.equals(op.path, prev.path)) {
+    return true;
+  }
+  return false;
+};
+const shouldSave = (op, prev) => {
+  if (op.type === "set_selection") {
+    return false;
+  }
+  return true;
+};
 export {
   CAN_USE_DOM,
   DOMEditor,
@@ -12386,6 +12585,9 @@ export {
   Editor,
   Element,
   HAS_BEFORE_INPUT_SUPPORT,
+  HISTORY,
+  History,
+  HistoryEditor,
   Hotkeys,
   IS_ANDROID,
   IS_CHROME,
@@ -12402,6 +12604,7 @@ export {
   Key,
   Location,
   MARK_PLACEHOLDER_SYMBOL,
+  MERGING,
   NODE_TO_ELEMENT,
   NODE_TO_INDEX,
   NODE_TO_KEY,
@@ -12415,6 +12618,8 @@ export {
   PointRef,
   Range,
   RangeRef,
+  SAVING,
+  SPLITTING_ONCE,
   Scrubber,
   Slate,
   Span,
@@ -12528,6 +12733,7 @@ export {
   useSelection,
   verifyDiffState,
   withDOM,
+  withHistory,
   withoutNormalizing,
   wrapNodes
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slate-vue3",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -19,10 +19,10 @@
     "is-hotkey": "^0.2.0",
     "lodash-es": "^4.17.21",
     "scroll-into-view-if-needed": "^3.1.0",
-    "slate-history": "^0.110.3",
-    "slate-hyperscript": "^0.100.0",
-    "vue": "^3.5.13",
-    "vue-router": "^4.5.0"
+    "slate-history": "^0.110.3"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.13"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.4.0",
@@ -39,7 +39,9 @@
     "typescript": "~5.7.2",
     "vite": "^6.0.11",
     "vite-plugin-dts": "^4.5.0",
-    "vue-tsc": "^2.2.0"
+    "vue-tsc": "^2.2.0",
+    "slate-hyperscript": "^0.100.0",
+    "vue-router": "^4.5.0"
   },
   "keywords": [
     "canvas",