slate-angular 19.0.0-next.0 → 19.1.0-next.0

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "slate-angular",
-  "version": "19.0.0-next.0",
+  "version": "19.1.0-next.0",
   "description": "Angular view layer for Slate",
   "author": "pubuzhixing <pubuzhixing@gmail.com>",
   "homepage": "https://github.com/worktile/slate-angular#readme",
   "license": "MIT",
   "peerDependencies": {
-    "slate": ">=0.101.0 <=0.104.0",
-    "slate-history": "^0.100.0",
+    "slate": ">=0.112.0",
+    "slate-dom": "^0.111.0",
+    "slate-history": "^0.110.3",
     "debug": "^4.1.1",
     "direction": "^2.0.1",
     "is-hotkey": "^0.2.0",
     "scroll-into-view-if-needed": "^2.2.20"
   },
   "dependencies": {
-    "slate": ">=0.101.0 <=0.104.0",
-    "slate-history": "^0.100.0",
+    "slate": ">=0.112.0",
+    "slate-dom": ">=0.111.0",
+    "slate-history": "^0.110.3",
     "direction": "^2.0.1",
     "is-hotkey": "^0.2.0",
     "scroll-into-view-if-needed": "^3.1.0",

package/plugins/angular-editor.d.ts

@@ -1,18 +1,11 @@
-import { Node, Path, Point, Range, Element, BaseEditor } from 'slate';
-import { DOMElement, DOMNode, DOMPoint, DOMRange, DOMSelection, DOMStaticRange } from '../utils/dom';
+import { Editor, Node, Path, Element } from 'slate';
 import { Injector } from '@angular/core';
-import { NodeEntry } from 'slate';
 import { SlateError } from '../types/error';
-import { Key } from '../utils/key';
-import { OriginEvent } from '../types/clipboard';
+import { CustomDOMEditor } from './with-dom';
 /**
  * An Angular and DOM-specific version of the `Editor` interface.
  */
-export interface AngularEditor extends BaseEditor {
-    insertData: (data: DataTransfer) => void;
-    insertFragmentData: (data: DataTransfer) => Promise<boolean>;
-    insertTextData: (data: DataTransfer) => Promise<boolean>;
-    setFragmentData: (data: DataTransfer, originEvent?: OriginEvent) => void;
+export interface AngularEditor extends CustomDOMEditor {
     deleteCutData: () => void;
     onKeydown: (event: KeyboardEvent) => void;
     onClick: (event: MouseEvent) => void;
@@ -20,72 +13,14 @@ export interface AngularEditor extends BaseEditor {
     isBlockCard: (node: Node) => boolean;
     isExpanded: (node: Element) => boolean;
     onError: (errorData: SlateError) => void;
-    hasRange: (editor: AngularEditor, range: Range) => boolean;
+    customInsertFragmentData: (data: DataTransfer) => Promise<boolean>;
+    customInsertTextData: (data: DataTransfer) => Promise<boolean>;
 }
 export declare const AngularEditor: {
-    /**
-     * Return the host window of the current editor.
-     */
-    getWindow(editor: AngularEditor): Window;
-    /**
-     * Find a key for a Slate node.
-     */
-    findKey(editor: AngularEditor, node: Node): Key;
     /**
      * handle editor error.
      */
     onError(errorData: SlateError): void;
-    /**
-     * Find the path of Slate node.
-     */
-    findPath(editor: AngularEditor, node: Node): Path;
-    isNodeInEditor(editor: AngularEditor, node: Node): boolean;
-    /**
-     * Find the DOM node that implements DocumentOrShadowRoot for the editor.
-     */
-    findDocumentOrShadowRoot(editor: AngularEditor): Document | ShadowRoot;
-    /**
-     * Check if the editor is focused.
-     */
-    isFocused(editor: AngularEditor): boolean;
-    /**
-     * Check if the editor is in read-only mode.
-     */
-    isReadonly(editor: AngularEditor): boolean;
-    /**
-     * Check if the editor is hanging right.
-     */
-    isBlockHangingRight(editor: AngularEditor): boolean;
-    /**
-     * Blur the editor.
-     */
-    blur(editor: AngularEditor): void;
-    /**
-     * Focus the editor.
-     */
-    focus(editor: AngularEditor): void;
-    /**
-     * Deselect the editor.
-     */
-    deselect(editor: AngularEditor): void;
-    /**
-     * Check if a DOM node is within the editor.
-     */
-    hasDOMNode(editor: AngularEditor, target: DOMNode, options?: {
-        editable?: boolean;
-    }): boolean;
-    /**
-     * Insert data from a `DataTransfer` into the editor.
-     */
-    insertData(editor: AngularEditor, data: DataTransfer): void;
-    /**
-     * Insert fragment data from a `DataTransfer` into the editor.
-     */
-    insertFragmentData(editor: AngularEditor, data: DataTransfer): Promise<boolean>;
-    /**
-     * Insert text data from a `DataTransfer` into the editor.
-     */
-    insertTextData(editor: AngularEditor, data: DataTransfer): Promise<boolean>;
     /**
      * onKeydown hook.
      */
@@ -94,59 +29,8 @@ export declare const AngularEditor: {
      * onClick hook.
      */
     onClick(editor: AngularEditor, data: MouseEvent): void;
-    /**
-     * Sets data from the currently selected fragment on a `DataTransfer`.
-     */
-    setFragmentData(editor: AngularEditor, data: DataTransfer, originEvent?: OriginEvent): void;
     deleteCutData(editor: AngularEditor): void;
-    /**
-     * Find the native DOM element from a Slate node.
-     */
-    toDOMNode(editor: AngularEditor, node: Node): HTMLElement;
-    /**
-     * Find a native DOM selection point from a Slate point.
-     */
-    toDOMPoint(editor: AngularEditor, point: Point, options: {
-        range: Range;
-    }): DOMPoint;
-    /**
-     * Find a native DOM range from a Slate `range`.
-     */
-    toDOMRange(editor: AngularEditor, range: Range): DOMRange;
-    /**
-     * Find a Slate node from a native DOM `element`.
-     */
-    toSlateNode<T extends boolean>(editor: AngularEditor, domNode: DOMNode, options?: {
-        suppressThrow: T;
-    }): T extends true ? Node | null : Node;
-    /**
-     * Get the target range from a DOM `event`.
-     */
-    findEventRange(editor: AngularEditor, event: any): Range;
-    isLeafInEditor(editor: AngularEditor, leafNode: DOMElement, options: {
-        suppressThrow: boolean;
-    }): boolean;
-    /**
-     * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
-     */
-    toSlatePoint<T extends boolean>(editor: AngularEditor, domPoint: DOMPoint, options: {
-        exactMatch?: boolean;
-        suppressThrow: T;
-    }): T extends true ? Point | null : Point;
-    /**
-     * Find a Slate range from a DOM range or selection.
-     */
-    toSlateRange<T extends boolean>(editor: AngularEditor, domRange: DOMRange | DOMStaticRange | DOMSelection, options?: {
-        exactMatch?: boolean;
-        suppressThrow: T;
-    }): T extends true ? Range | null : Range;
     isLeafBlock(editor: AngularEditor, node: Node): boolean;
-    isBlockCardLeftCursor(editor: AngularEditor): boolean;
-    isBlockCardRightCursor(editor: AngularEditor): boolean;
-    getCardCursorNode(editor: AngularEditor, blockCardNode: Node, options: {
-        direction: "left" | "right" | "center";
-    }): ChildNode;
-    toSlateCardEntry(editor: AngularEditor, node: DOMNode): NodeEntry;
     /**
      * move native selection to card-left or card-right
      * @param editor
@@ -165,5 +49,53 @@ export declare const AngularEditor: {
     moveBlockCardCursor(editor: AngularEditor, path: Path, options: {
         direction: "left" | "right";
     }): void;
-    hasRange(editor: AngularEditor, range: Range): boolean;
+    isNodeInEditor(editor: CustomDOMEditor, node: Node): boolean;
+    isLeafInEditor(editor: CustomDOMEditor, leafNode: globalThis.Element): boolean;
+    isBlockHangingRight(editor: Editor): boolean;
+    isBlockCardLeftCursor(editor: Editor): boolean;
+    isBlockCardRightCursor(editor: Editor): boolean;
+    getCardCursorNode(editor: AngularEditor, blockCardNode: Node, options: {
+        direction: "left" | "right" | "center";
+    }): ChildNode;
+    toSlateCardEntry(editor: AngularEditor, node: globalThis.Node): import("slate").NodeEntry;
+    androidPendingDiffs: (editor: Editor) => import("slate-dom").TextDiff[] | undefined;
+    androidScheduleFlush: (editor: Editor) => void;
+    blur: (editor: import("slate-dom").DOMEditor) => void;
+    deselect: (editor: import("slate-dom").DOMEditor) => void;
+    findDocumentOrShadowRoot: (editor: import("slate-dom").DOMEditor) => Document | ShadowRoot;
+    findEventRange: (editor: import("slate-dom").DOMEditor, event: any) => import("slate").Range;
+    findKey: (editor: import("slate-dom").DOMEditor, node: Node) => import("slate-dom").Key;
+    findPath: (editor: import("slate-dom").DOMEditor, node: Node) => Path;
+    focus: (editor: import("slate-dom").DOMEditor, options?: {
+        retries: number;
+    }) => void;
+    getWindow: (editor: import("slate-dom").DOMEditor) => Window;
+    hasDOMNode: (editor: import("slate-dom").DOMEditor, target: globalThis.Node, options?: {
+        editable?: boolean;
+    }) => boolean;
+    hasEditableTarget: (editor: import("slate-dom").DOMEditor, target: EventTarget | null) => target is globalThis.Node;
+    hasRange: (editor: import("slate-dom").DOMEditor, range: import("slate").Range) => boolean;
+    hasSelectableTarget: (editor: import("slate-dom").DOMEditor, target: EventTarget | null) => boolean;
+    hasTarget: (editor: import("slate-dom").DOMEditor, target: EventTarget | null) => target is globalThis.Node;
+    insertData: (editor: import("slate-dom").DOMEditor, data: DataTransfer) => void;
+    insertFragmentData: (editor: import("slate-dom").DOMEditor, data: DataTransfer) => boolean;
+    insertTextData: (editor: import("slate-dom").DOMEditor, data: DataTransfer) => boolean;
+    isComposing: (editor: import("slate-dom").DOMEditor) => boolean;
+    isFocused: (editor: import("slate-dom").DOMEditor) => boolean;
+    isReadOnly: (editor: import("slate-dom").DOMEditor) => boolean;
+    isTargetInsideNonReadonlyVoid: (editor: import("slate-dom").DOMEditor, target: EventTarget | null) => boolean;
+    setFragmentData: (editor: import("slate-dom").DOMEditor, data: DataTransfer, originEvent?: "drag" | "copy" | "cut") => void;
+    toDOMNode: (editor: import("slate-dom").DOMEditor, node: Node) => HTMLElement;
+    toDOMPoint: (editor: import("slate-dom").DOMEditor, point: import("slate").Point) => import("slate-dom").DOMPoint;
+    toDOMRange: (editor: import("slate-dom").DOMEditor, range: import("slate").Range) => Range;
+    toSlateNode: (editor: import("slate-dom").DOMEditor, domNode: globalThis.Node) => Node;
+    toSlatePoint: <T extends boolean>(editor: import("slate-dom").DOMEditor, domPoint: import("slate-dom").DOMPoint, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+        searchDirection?: "forward" | "backward";
+    }) => T extends true ? import("slate").Point | null : import("slate").Point;
+    toSlateRange: <T extends boolean>(editor: import("slate-dom").DOMEditor, domRange: Range | StaticRange | Selection, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+    }) => T extends true ? import("slate").Range | null : import("slate").Range;
 };

package/plugins/with-dom.d.ts

@@ -0,0 +1,68 @@
+import { Editor, Node, Point, Range, NodeEntry } from 'slate';
+import { DOMEditor, DOMElement, DOMNode, DOMRange, DOMPoint, DOMSelection, DOMStaticRange } from 'slate-dom';
+import { AngularEditor } from './angular-editor';
+export interface CustomDOMEditor extends DOMEditor {
+    hasEditableTarget: (editor: CustomDOMEditor, target: EventTarget | null) => target is DOMNode;
+    hasRange: (editor: CustomDOMEditor, range: Range) => boolean;
+    hasSelectableTarget: (editor: CustomDOMEditor, target: EventTarget | null) => boolean;
+    hasTarget: (editor: CustomDOMEditor, target: EventTarget | null) => target is DOMNode;
+    insertData: (data: DataTransfer) => void;
+    insertFragmentData: (data: DataTransfer) => boolean;
+    insertTextData: (data: DataTransfer) => boolean;
+    isTargetInsideNonReadonlyVoid: (editor: CustomDOMEditor, target: EventTarget | null) => boolean;
+    setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
+}
+export declare const CustomDOMEditor: {
+    isNodeInEditor(editor: CustomDOMEditor, node: Node): boolean;
+    isLeafInEditor(editor: CustomDOMEditor, leafNode: DOMElement): boolean;
+    /**
+     * Check if the editor is hanging right.
+     */
+    isBlockHangingRight(editor: Editor): boolean;
+    isBlockCardLeftCursor(editor: Editor): boolean;
+    isBlockCardRightCursor(editor: Editor): boolean;
+    getCardCursorNode(editor: AngularEditor, blockCardNode: Node, options: {
+        direction: "left" | "right" | "center";
+    }): ChildNode;
+    toSlateCardEntry(editor: AngularEditor, node: DOMNode): NodeEntry;
+    androidPendingDiffs: (editor: Editor) => import("slate-dom").TextDiff[] | undefined;
+    androidScheduleFlush: (editor: Editor) => void;
+    blur: (editor: DOMEditor) => void;
+    deselect: (editor: DOMEditor) => void;
+    findDocumentOrShadowRoot: (editor: DOMEditor) => Document | ShadowRoot;
+    findEventRange: (editor: DOMEditor, event: any) => Range;
+    findKey: (editor: DOMEditor, node: Node) => import("slate-dom").Key;
+    findPath: (editor: DOMEditor, node: Node) => import("slate").Path;
+    focus: (editor: DOMEditor, options?: {
+        retries: number;
+    }) => void;
+    getWindow: (editor: DOMEditor) => Window;
+    hasDOMNode: (editor: DOMEditor, target: DOMNode, options?: {
+        editable?: boolean;
+    }) => boolean;
+    hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
+    hasRange: (editor: DOMEditor, range: Range) => boolean;
+    hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
+    insertData: (editor: DOMEditor, data: DataTransfer) => void;
+    insertFragmentData: (editor: DOMEditor, data: DataTransfer) => boolean;
+    insertTextData: (editor: DOMEditor, data: DataTransfer) => boolean;
+    isComposing: (editor: DOMEditor) => boolean;
+    isFocused: (editor: DOMEditor) => boolean;
+    isReadOnly: (editor: DOMEditor) => boolean;
+    isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    setFragmentData: (editor: DOMEditor, data: DataTransfer, originEvent?: "drag" | "copy" | "cut") => void;
+    toDOMNode: (editor: DOMEditor, node: Node) => HTMLElement;
+    toDOMPoint: (editor: DOMEditor, point: Point) => DOMPoint;
+    toDOMRange: (editor: DOMEditor, range: Range) => DOMRange;
+    toSlateNode: (editor: DOMEditor, domNode: DOMNode) => Node;
+    toSlatePoint: <T extends boolean>(editor: DOMEditor, domPoint: DOMPoint, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+        searchDirection?: "forward" | "backward";
+    }) => T extends true ? Point | null : Point;
+    toSlateRange: <T extends boolean>(editor: DOMEditor, domRange: DOMRange | DOMStaticRange | DOMSelection, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+    }) => T extends true ? Range | null : Range;
+};

package/public-api.d.ts

@@ -14,3 +14,4 @@ export * from './view/context';
 export * from './view/context-change';
 export * from './utils';
 export * from './types';
+export { NODE_TO_INDEX, NODE_TO_PARENT } from 'slate-dom';

package/utils/block-card.d.ts

@@ -1,4 +1,4 @@
-import { DOMNode, DOMSelection } from './dom';
+import { DOMNode, DOMSelection } from "slate-dom";
 export declare const FAKE_LEFT_BLOCK_CARD_OFFSET = -1;
 export declare const FAKE_RIGHT_BLOCK_CARD_OFFSET = -2;
 export declare function hasBlockCardWithNode(node: DOMNode): boolean;

package/utils/dom.d.ts

@@ -1,68 +1,10 @@
-/**
- * Types.
- */
-import DOMNode = globalThis.Node;
-import DOMComment = globalThis.Comment;
-import DOMElement = globalThis.Element;
-import DOMText = globalThis.Text;
-import DOMRange = globalThis.Range;
-import DOMSelection = globalThis.Selection;
-import DOMStaticRange = globalThis.StaticRange;
-export { DOMNode, DOMComment, DOMElement, DOMText, DOMRange, DOMSelection, DOMStaticRange };
-declare global {
-    interface Window {
-        Selection: (typeof Selection)['constructor'];
-        DataTransfer: (typeof DataTransfer)['constructor'];
-        Node: (typeof Node)['constructor'];
-    }
-}
-export type DOMPoint = [Node, number];
-/**
- * Returns the host window of a DOM node
- */
-export declare const getDefaultView: (value: any) => Window | null;
-/**
- * Check if a DOM node is a comment node.
- */
-export declare const isDOMComment: (value: any) => value is DOMComment;
-/**
- * Check if a DOM node is an element node.
- */
-export declare const isDOMElement: (value: any) => value is DOMElement;
-/**
- * Check if a value is a DOM node.
- */
-export declare const isDOMNode: (value: any) => value is DOMNode;
-/**
- * Check if a value is a DOM selection.
- */
-export declare const isDOMSelection: (value: any) => value is DOMSelection;
+import { DOMNode, DOMText } from 'slate-dom';
+export declare const SlateFragmentAttributeKey = "data-slate-angular-fragment";
+export declare const getSlateFragmentAttribute: (htmlData: string) => string | void;
 /**
  * Check if a DOM node is an element node.
  */
 export declare const isDOMText: (value: any) => value is DOMText;
-/**
- * Checks whether a paste event is a plaintext-only event.
- */
-export declare const isPlainTextOnlyPaste: (event: ClipboardEvent) => boolean;
-/**
- * Normalize a DOM point so that it always refers to a text node.
- */
-export declare const normalizeDOMPoint: (domPoint: DOMPoint) => DOMPoint;
-/**
- * Determines wether the active element is nested within a shadowRoot
- */
-export declare const hasShadowRoot: () => boolean;
-/**
- * Get the nearest editable child and index at `index` in a `parent`, preferring
- * `direction`.
- */
-export declare const getEditableChildAndIndex: (parent: DOMElement, index: number, direction: "forward" | "backward") => [DOMNode, number];
-/**
- * Get the nearest editable child at `index` in a `parent`, preferring
- * `direction`.
- */
-export declare const getEditableChild: (parent: DOMElement, index: number, direction: "forward" | "backward") => DOMNode;
 /**
  * Get a plaintext representation of the content of a node, accounting for block
  * elements which get a newline appended.
@@ -70,5 +12,3 @@ export declare const getEditableChild: (parent: DOMElement, index: number, direc
  * The domNode must be attached to the DOM.
  */
 export declare const getPlainText: (domNode: DOMNode) => string;
-export declare const SlateFragmentAttributeKey = "data-slate-angular-fragment";
-export declare const getSlateFragmentAttribute: (htmlData: string) => string | void;

package/utils/index.d.ts

@@ -1,9 +1,7 @@
 export * from './weak-maps';
 export * from './hotkeys';
-export * from './dom';
 export * from './view';
 export * from './environment';
-export * from './key';
 export * from './range-list';
 export * from './block-card';
 export * from './global-normalize';

package/utils/weak-maps.d.ts

@@ -1,34 +1,5 @@
-import { Node, Ancestor, Editor } from 'slate';
-import { Key } from './key';
+import { Node, Editor } from 'slate';
 import { BaseElementComponent } from '../view/base';
-/**
- * Two weak maps that allow us rebuild a path given a node. They are populated
- * at render time such that after a render occurs we can always backtrack.
- */
-export declare const EDITOR_TO_WINDOW: WeakMap<Editor, Window>;
-export declare const NODE_TO_INDEX: WeakMap<Node, number>;
-export declare const NODE_TO_PARENT: WeakMap<Node, Ancestor>;
-/**
- * Weak maps that allow us to go between Slate nodes and DOM nodes. These
- * are used to resolve DOM event-related logic into Slate actions.
- */
-export declare const EDITOR_TO_ELEMENT: WeakMap<Editor, HTMLElement>;
-export declare const EDITOR_TO_PLACEHOLDER: WeakMap<Editor, string>;
-export declare const ELEMENT_TO_NODE: WeakMap<HTMLElement, Node>;
-export declare const KEY_TO_ELEMENT: WeakMap<Key, HTMLElement>;
-export declare const NODE_TO_ELEMENT: WeakMap<Node, HTMLElement>;
-export declare const NODE_TO_KEY: WeakMap<Node, Key>;
-/**
- * Weak maps for storing editor-related state.
- */
-export declare const IS_READONLY: WeakMap<Editor, boolean>;
-export declare const IS_FOCUSED: WeakMap<Editor, boolean>;
-export declare const IS_DRAGGING: WeakMap<Editor, boolean>;
-export declare const IS_CLICKING: WeakMap<Editor, boolean>;
-/**
- * Weak map for associating the context `onChange` context with the plugin.
- */
-export declare const EDITOR_TO_ON_CHANGE: WeakMap<import("slate").BaseEditor, () => void>;
 /**
  * Symbols.
  */

package/utils/constants.d.ts

@@ -1 +0,0 @@
-export declare const TRIPLE_CLICK = 3;

package/utils/key.d.ts

@@ -1,11 +0,0 @@
-/**
- * An auto-incrementing identifier for keys.
- */
-/**
- * A class that keeps track of a key string. We use a full class here because we
- * want to be able to use them as keys in `WeakMap` objects.
- */
-export declare class Key {
-    id: string;
-    constructor();
-}

package/utils/lines.d.ts

@@ -1,14 +0,0 @@
-/**
- * Utilities for single-line deletion
- */
-import { Range } from 'slate';
-import { AngularEditor } from '../plugins/angular-editor';
-/**
- * A helper utility that returns the end portion of a `Range`
- * which is located on a single line.
- *
- * @param {Editor} editor The editor object to compare against
- * @param {Range} parentRange The parent range to compare against
- * @returns {Range} A valid portion of the parentRange which is one a single line
- */
-export declare const findCurrentLineRange: (editor: AngularEditor, parentRange: Range) => Range;