@worktile/theia 19.1.6 → 19.2.0-next.0

package/interfaces/editor.d.ts

@@ -26,62 +26,66 @@ export interface TheEditor extends AngularEditor, HistoryEditor {
     isVisible: (element: Element) => boolean;
 }
 export declare const TheEditor: {
-    getWindow(editor: AngularEditor): Window;
-    findKey(editor: AngularEditor, node: Node): import("slate-angular").Key;
     onError(errorData: import("slate-angular").SlateError): void;
-    findPath(editor: AngularEditor, node: Node): Path;
-    isNodeInEditor(editor: AngularEditor, node: Node): boolean;
-    findDocumentOrShadowRoot(editor: AngularEditor): Document | ShadowRoot;
-    isFocused(editor: AngularEditor): boolean;
-    isReadonly(editor: AngularEditor): boolean;
-    isBlockHangingRight(editor: AngularEditor): boolean;
-    blur(editor: AngularEditor): void;
-    focus(editor: AngularEditor): void;
-    deselect(editor: AngularEditor): void;
-    hasDOMNode(editor: AngularEditor, target: globalThis.Node, options?: {
-        editable?: boolean;
-    }): boolean;
-    insertData(editor: AngularEditor, data: DataTransfer): void;
-    insertFragmentData(editor: AngularEditor, data: DataTransfer): Promise<boolean>;
-    insertTextData(editor: AngularEditor, data: DataTransfer): Promise<boolean>;
     onKeydown(editor: AngularEditor, data: KeyboardEvent): void;
     onClick(editor: AngularEditor, data: MouseEvent): void;
-    setFragmentData(editor: AngularEditor, data: DataTransfer, originEvent?: import("slate-angular").OriginEvent): void;
     deleteCutData(editor: AngularEditor): void;
-    toDOMNode(editor: AngularEditor, node: Node): HTMLElement;
-    toDOMPoint(editor: AngularEditor, point: Point, options: {
-        range: Range;
-    }): import("slate-angular").DOMPoint;
-    toDOMRange(editor: AngularEditor, range: Range): globalThis.Range;
-    toSlateNode<T extends boolean>(editor: AngularEditor, domNode: globalThis.Node, options?: {
-        suppressThrow: T;
-    }): T extends true ? Node | null : Node;
-    findEventRange(editor: AngularEditor, event: any): Range;
-    isLeafInEditor(editor: AngularEditor, leafNode: globalThis.Element, options: {
-        suppressThrow: boolean;
-    }): boolean;
-    toSlatePoint<T extends boolean>(editor: AngularEditor, domPoint: import("slate-angular").DOMPoint, options: {
-        exactMatch?: boolean;
-        suppressThrow: T;
-    }): T extends true ? Point | null : Point;
-    toSlateRange<T extends boolean>(editor: AngularEditor, domRange: globalThis.Range | StaticRange | Selection, 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: globalThis.Node): NodeEntry;
     moveBlockCard(editor: AngularEditor, blockCardNode: Node, options: {
         direction: "left" | "right";
     }): void;
     moveBlockCardCursor(editor: AngularEditor, path: Path, options: {
         direction: "left" | "right";
     }): void;
-    hasRange(editor: AngularEditor, range: Range): boolean;
+    isNodeInEditor(editor: import("slate-angular/plugins/with-dom").CustomDOMEditor, node: Node): boolean;
+    isLeafInEditor(editor: import("slate-angular/plugins/with-dom").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) => globalThis.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: globalThis.Range | StaticRange | Selection, options: {
+        exactMatch: boolean;
+        suppressThrow: T;
+    }) => T extends true ? import("slate").Range | null : import("slate").Range;
 };
 export declare enum TheDataMode {
     json = "json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worktile/theia",
-  "version": "19.1.6",
+  "version": "19.2.0-next.0",
   "description": "theia editor",
   "author": "YanDong <nanianqiumo@foxmail.com>",
   "homepage": "https://github.com/atinc/theia#readme",

package/utils/dom.d.ts

@@ -1,5 +1,5 @@
 import { Element } from 'slate';
-import { DOMElement } from 'slate-angular';
+import { DOMElement } from 'slate-dom';
 /** Converts CSS pixel values to numbers, eg "123px" to 123. Returns NaN for non pixel values. */
 export declare function coercePixelsFromCssValue(cssValue: string): number;
 export declare function getElementWidth(element: HTMLElement): number;