slate-angular 19.1.0-next.2 → 19.1.0-next.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slate-angular",
-  "version": "19.1.0-next.2",
+  "version": "19.1.0-next.4",
   "description": "Angular view layer for Slate",
   "author": "pubuzhixing <pubuzhixing@gmail.com>",
   "homepage": "https://github.com/worktile/slate-angular#readme",

package/plugins/angular-editor.d.ts

@@ -2,6 +2,7 @@ import { Editor, Node, Path, Element } from 'slate';
 import { Injector } from '@angular/core';
 import { SlateError } from '../types/error';
 import { CustomDOMEditor } from './with-dom';
+import { DOMEditor } from 'slate-dom';
 /**
  * An Angular and DOM-specific version of the `Editor` interface.
  */
@@ -49,6 +50,9 @@ export declare const AngularEditor: {
     moveBlockCardCursor(editor: AngularEditor, path: Path, options: {
         direction: "left" | "right";
     }): void;
+    focus: (editor: any, options?: {
+        retries: number;
+    }) => void;
     isNodeInEditor(editor: CustomDOMEditor, node: Node): boolean;
     isLeafInEditor(editor: CustomDOMEditor, leafNode: globalThis.Element): boolean;
     isBlockHangingRight(editor: Editor): boolean;
@@ -60,41 +64,38 @@ export declare const AngularEditor: {
     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?: {
+    blur: (editor: DOMEditor) => void;
+    deselect: (editor: DOMEditor) => void;
+    findDocumentOrShadowRoot: (editor: DOMEditor) => Document | ShadowRoot;
+    findEventRange: (editor: DOMEditor, event: any) => import("slate").Range;
+    findKey: (editor: DOMEditor, node: Node) => import("slate-dom").Key;
+    findPath: (editor: DOMEditor, node: Node) => Path;
+    getWindow: (editor: DOMEditor) => Window;
+    hasDOMNode: (editor: 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: {
+    hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is globalThis.Node;
+    hasRange: (editor: DOMEditor, range: import("slate").Range) => boolean;
+    hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
+    hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is globalThis.Node;
+    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: import("slate").Point) => import("slate-dom").DOMPoint;
+    toDOMRange: (editor: DOMEditor, range: import("slate").Range) => Range;
+    toSlateNode: (editor: DOMEditor, domNode: globalThis.Node) => Node;
+    toSlatePoint: <T extends boolean>(editor: 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: {
+    toSlateRange: <T extends boolean>(editor: DOMEditor, domRange: Range | StaticRange | Selection, options: {
         exactMatch: boolean;
         suppressThrow: T;
     }) => T extends true ? import("slate").Range | null : import("slate").Range;

package/utils/dom.d.ts

@@ -12,3 +12,7 @@ export declare const isDOMText: (value: any) => value is DOMText;
  * The domNode must be attached to the DOM.
  */
 export declare const getPlainText: (domNode: DOMNode) => string;
+/**
+ * Get the dom selection from Shadow Root if possible, otherwise from the document
+ */
+export declare const getSelection: (root: Document | ShadowRoot) => Selection | null;

package/view/render/utils.d.ts

@@ -3,7 +3,7 @@ import { ComponentRef, EmbeddedViewRef, ViewContainerRef } from '@angular/core';
 import { ViewType } from '../../types/view';
 import { SlateElementContext, SlateLeafContext, SlateTextContext, SlateViewContext } from '../context';
 import { SlateBlockCard } from '../../components/block-card/block-card.component';
-export declare function createEmbeddedViewOrComponent(viewType: ViewType, context: any, viewContext: SlateViewContext, viewContainerRef: ViewContainerRef): ComponentRef<any> | EmbeddedViewRef<any>;
+export declare function createEmbeddedViewOrComponent(viewType: ViewType, context: any, viewContext: SlateViewContext, viewContainerRef: ViewContainerRef): EmbeddedViewRef<any> | ComponentRef<any>;
 export declare function updateContext(view: EmbeddedViewRef<any> | ComponentRef<any>, newContext: SlateElementContext | SlateTextContext | SlateLeafContext, viewContext: SlateViewContext): void;
 export declare function mount(views: (EmbeddedViewRef<any> | ComponentRef<any>)[], blockCards: (ComponentRef<SlateBlockCard> | null)[] | null, outletParent: HTMLElement, outletElement: HTMLElement | null): void;
 export declare function getRootNodes(ref: EmbeddedViewRef<any> | ComponentRef<any>, blockCard?: ComponentRef<SlateBlockCard>): HTMLElement[];