@worktile/theia 1.2.6 → 1.2.10

package/queries/index.d.ts

@@ -1,73 +1,55 @@
-export declare const TheQueries: {
-    getLastNode: (editor: import("@worktile/theia").TheEditor, level: number) => import("slate").NodeEntry<import("slate").Node>;
-    getAnchorBlockEntry: (editor: import("@worktile/theia").TheEditor, at?: import("slate").Path | import("slate").BasePoint) => import("slate").NodeEntry<import("@worktile/theia").CustomElement>;
-    getAboveByType: (editor: import("@worktile/theia").TheEditor, types: string | string[], options?: Omit<import("@worktile/theia").EditorAboveOptions<import("slate").Ancestor>, "match">) => import("slate").NodeEntry<import("slate").Ancestor>;
-    getNodes: (editor: import("@worktile/theia").TheEditor, options?: import("@worktile/theia").EditorNodesOptions & import("../transforms/un-hang-range").UnhangRangeOptions) => Generator<import("slate").NodeEntry<import("slate").Node>, void, undefined>;
-    getNodesByType: (editor: import("@worktile/theia").TheEditor, types: string | string[], options?: Omit<import("@worktile/theia").EditorNodesOptions, "match">) => Generator<import("slate").NodeEntry<import("slate").Node>, void, undefined>;
-    getBlockAbove: (editor: import("@worktile/theia").TheEditor, options?: Omit<import("@worktile/theia").EditorAboveOptions<import("slate").Ancestor>, "match">) => import("slate").NodeEntry<import("slate").Ancestor>;
-    getPreviousPath: (path: import("slate").Path) => import("slate").Path;
-    getNode: (editor: import("@worktile/theia").TheEditor, path: import("slate").Path) => import("slate").Node;
-    getParent: (editor: import("@worktile/theia").TheEditor, at: import("slate").Location, options?: import("@worktile/theia").EditorParentOptions) => import("slate").NodeEntry<import("slate").Ancestor>;
-    getLastChild: (nodeEntry: import("slate").NodeEntry<import("slate").Ancestor>) => import("slate").NodeEntry<import("slate").Descendant>;
-    getLastChildPath: (nodeEntry: import("slate").NodeEntry<import("slate").Ancestor>) => import("slate").Path;
-    getNextSiblingNodes: (ancestorEntry: import("slate").NodeEntry<import("slate").Ancestor>, path: import("slate").Path) => import("slate").Descendant[];
-    getAbove: <T = import("slate").Ancestor>(editor: import("@worktile/theia").TheEditor, options?: import("@worktile/theia").EditorAboveOptions<T>) => import("slate").NodeEntry<import("slate").Ancestor>;
-    getChildren: (nodeEntry: import("slate").NodeEntry<import("slate").Node>) => import("slate").NodeEntry<import("slate").Node>[];
-    getPointBefore: (editor: import("@worktile/theia").TheEditor, at: import("slate").Location, options?: import("./get-point-before").PointBeforeOptions) => any;
-    getSelectionNodesByType: (editor: import("@worktile/theia").TheEditor, fragmentData: import("slate").Descendant[], types?: import("@worktile/theia").ElementKinds[]) => import("slate").Node;
-    getText: (editor: import("@worktile/theia").TheEditor, at?: import("slate").Location) => string;
-    getPointFromLocation: (editor: import("@worktile/theia").TheEditor, { at, focus }?: {
-        at?: import("slate").Location;
-        focus?: boolean;
-    }) => import("slate").BasePoint;
-    getRangeFromBlockStart: (editor: import("@worktile/theia").TheEditor, options?: Omit<import("@worktile/theia").EditorAboveOptions<import("slate").Ancestor>, "match">) => false | {
-        anchor: import("slate").BasePoint;
-        focus: import("slate").BasePoint;
-    };
-    getRangeBefore: (editor: import("@worktile/theia").TheEditor, at: import("slate").Location, options?: import("./get-point-before").PointBeforeOptions) => import("slate").BaseRange;
-    getBlockCardCenterCursor: (editor: import("@worktile/theia").TheEditor) => import("slate").BasePoint;
-    getBlockCardAbove: (editor: import("@worktile/theia").TheEditor, options?: Omit<import("@worktile/theia").EditorAboveOptions<import("slate").Ancestor>, "match">) => import("slate").NodeEntry<import("slate").Ancestor>;
-    getPlainText: (editor: import("@worktile/theia").TheEditor, format?: string) => string;
-    getSelectionMarks: (editor: import("@worktile/theia").TheEditor) => {
-        bold?: any;
-        italic?: any;
-        underlined?: any;
-        strike?: any;
-        color?: any;
-        "background-color"?: any;
-        "code-line"?: any;
-    };
-    getContainerBlocks: (editor: import("@worktile/theia").TheEditor) => import("@worktile/theia").ElementKinds[];
-    isAncestor: (node: import("slate").Node) => node is import("slate").Ancestor;
-    isCollapsed: (range?: import("slate").BaseRange) => boolean;
-    isEmptyParagraph: (editor: import("@worktile/theia").TheEditor, at?: import("slate").Path | import("slate").BasePoint) => boolean;
-    isParagraph: (editor: import("@worktile/theia").TheEditor) => boolean;
-    isBlockActive: (editor: import("@worktile/theia").TheEditor, format: import("@worktile/theia").BlockElementKinds) => boolean;
-    isIncludeTypes: (editor: import("@worktile/theia").TheEditor, types: import("@worktile/theia").ElementKinds[]) => boolean;
-    isAncestorEmpty: (editor: import("@worktile/theia").TheEditor, node: import("slate").Ancestor) => boolean;
-    isBlockAboveEmpty: (editor: import("@worktile/theia").TheEditor) => boolean;
-    isNodeTypeIn: (editor: import("@worktile/theia").TheEditor, types: string | string[], options?: Omit<import("@worktile/theia").EditorNodesOptions, "match">) => boolean;
-    isFirstChild: (path: import("slate").Path) => boolean;
-    isPointAtRoot: (point: import("slate").BasePoint) => boolean;
-    isRangeAtRoot: (range: import("slate").BaseRange) => boolean;
-    isBlockTextEmptyAfterSelection: (editor: import("@worktile/theia").TheEditor) => boolean;
-    isStart: (editor: import("@worktile/theia").TheEditor, point: import("slate").BasePoint, at: import("slate").Location) => boolean;
-    isRangeAcrossBlocks: (editor: import("@worktile/theia").TheEditor, { at, ...options }?: Omit<import("@worktile/theia").EditorAboveOptions<import("slate").Ancestor>, "match" | "at"> & {
-        at?: import("slate").BaseRange;
-    }) => boolean;
-    isDescendant: (node: any) => node is import("slate").Descendant;
-    isNodeType: (entry?: import("slate").NodeEntry<import("slate").Node>, { filter, allow, exclude }?: import("@worktile/theia").QueryOptions) => boolean;
-    isAcrossBlocks: (editor: import("@worktile/theia").TheEditor, fragment: import("@worktile/theia").CustomElement[]) => boolean;
-    isBlockCardCursor: (editor: import("@worktile/theia").TheEditor) => boolean;
-    isEmptyContent: (children: import("slate").Descendant[]) => boolean;
-    isEmptyParagraphByPath: (editor: import("@worktile/theia").TheEditor, at: import("slate").Path) => boolean;
-    isContainer: (editor: import("@worktile/theia").TheEditor, value: import("@worktile/theia").CustomElement) => boolean;
-    anchorBlock: (editor: import("@worktile/theia").TheEditor) => import("@worktile/theia").CustomElement;
-    anchorBlockEntry: (editor: import("@worktile/theia").TheEditor, at?: import("slate").Path | import("slate").BasePoint) => import("slate").NodeEntry<import("@worktile/theia").CustomElement>;
-    anchorInlineEntry: (editor: import("@worktile/theia").TheEditor) => import("slate").NodeEntry<import("@worktile/theia").CustomElement>;
-    anchorInline: (editor: import("@worktile/theia").TheEditor) => import("@worktile/theia").CustomElement;
-    findPath: (editor: import("slate-angular").AngularEditor, node: import("slate").Node) => import("slate").Path;
-    findNode: <T_1 extends import("slate").Node = import("slate").Node>(editor: import("@worktile/theia").TheEditor, options: import("./find-node").FindNodeOptions<T_1>) => import("slate").NodeEntry<T_1>;
-    findDescendant: <T_2 extends import("slate").Node = import("slate").Node>(editor: import("@worktile/theia").TheEditor, options: import("./find-node").FindNodeOptions<T_2>) => import("slate").NodeEntry<T_2>;
-    someNode: <T_3 extends import("slate").Node = import("slate").Node>(editor: import("@worktile/theia").TheEditor, options: import("./find-node").FindNodeOptions<T_3>) => boolean;
-};
+import { getLastNode } from './get-last-node';
+import { isAncestor } from './is-ancestor';
+import { isCollapsed } from './is-collapsed';
+import { getAnchorBlockEntry } from './get-anchor-block-entry';
+import { isEmptyParagraph } from './is-empty-paragraph';
+import { isParagraph } from './is-paragraph';
+import { isBlockActive } from './is-block-active';
+import { isIncludeTypes } from './is-include-types';
+import { getAboveByType } from './get-above-by-type';
+import { anchorBlockEntry } from './anchor-block-entry';
+import { getNodesByType } from './get-nodes-by-type';
+import { getNodes } from './get-nodes';
+import { anchorBlock } from './anchor-block';
+import { getBlockAbove } from './get-block-above';
+import { isAncestorEmpty } from './is-ancestor-empty';
+import { isBlockAboveEmpty } from './is-block-above-empty';
+import { isNodeTypeIn } from './is-node-type-in';
+import { isFirstChild } from './is-first-child';
+import { getPreviousPath } from './get-previous-path';
+import { getNode } from './get-node';
+import { getParent } from './get-parent';
+import { findPath } from './find-path';
+import { findNode } from './find-node';
+import { findDescendant } from './find-descendant';
+import { getLastChildPath, getLastChild } from './get-last-child-path';
+import { isPointAtRoot } from './is-point-at-root';
+import { isRangeAtRoot } from './is-range-at-root';
+import { getNextSiblingNodes } from './get-next-sibling-nodes';
+import { isBlockTextEmptyAfterSelection } from './is-block-text-empty-after-selection';
+import { getAbove } from './get-above';
+import { isStart } from './is-start';
+import { isRangeAcrossBlocks } from './is-range-across-blocks';
+import { someNode } from './some-node';
+import { getChildren } from './get-children';
+import { isDescendant } from './is-descendant';
+import { isNodeType } from './is-node-type';
+import { anchorInlineEntry } from './anchor-inline-entry';
+import { anchorInline } from './anchor-inline';
+import { getPointBefore } from './get-point-before';
+import { getSelectionNodesByType } from './get-selection-nodes-by-type';
+import { isAcrossBlocks } from './is-across-blocks';
+import { getText } from './get-text';
+import { getPointFromLocation } from './get-point-from-location';
+import { getRangeFromBlockStart } from './get-rang-from-block-start';
+import { getRangeBefore } from './get-range-before';
+import { isBlockCardCursor } from './is-block-card-cursor';
+import { getBlockCardCenterCursor } from './get-block-card-cursor';
+import { isEmptyContent } from './is-empty-content';
+import { getBlockCardAbove } from './get-block-card-above';
+import { getPlainText } from './get-plain-text';
+import { isEmptyParagraphByPath } from './is-empty-paragraph-by-path';
+import { getSelectionMarks } from './get-selection-marks';
+import { isContainer } from './is-container-type';
+import { getContainerBlocks } from './get-container-blocks';
+export { getLastNode, getAnchorBlockEntry, getAboveByType, getNodes, getNodesByType, getBlockAbove, getPreviousPath, getNode, getParent, getLastChild, getLastChildPath, getNextSiblingNodes, getAbove, getChildren, getPointBefore, getSelectionNodesByType, getText, getPointFromLocation, getRangeFromBlockStart, getRangeBefore, getBlockCardCenterCursor, getBlockCardAbove, getPlainText, getSelectionMarks, getContainerBlocks, isAncestor, isCollapsed, isEmptyParagraph, isParagraph, isBlockActive, isIncludeTypes, isAncestorEmpty, isBlockAboveEmpty, isNodeTypeIn, isFirstChild, isPointAtRoot, isRangeAtRoot, isBlockTextEmptyAfterSelection, isStart, isRangeAcrossBlocks, isDescendant, isNodeType, isAcrossBlocks, isBlockCardCursor, isEmptyContent, isEmptyParagraphByPath, isContainer, anchorBlock, anchorBlockEntry, anchorInlineEntry, anchorInline, findPath, findNode, findDescendant, someNode };

package/queries/is-block-active.d.ts

@@ -1,3 +1,3 @@
 import { Editor } from 'slate';
-import { BlockElementKinds } from '../interfaces';
-export declare const isBlockActive: (editor: Editor, format: BlockElementKinds) => boolean;
+import { CustomElementKinds } from '../custom-types';
+export declare const isBlockActive: (editor: Editor, format: CustomElementKinds) => boolean;

package/queries/is-include-types.d.ts

@@ -1,3 +1,3 @@
 import { Editor } from 'slate';
-import { ElementKinds } from '../constants';
-export declare const isIncludeTypes: (editor: Editor, types: ElementKinds[]) => boolean;
+import { CustomElementKinds } from '../custom-types';
+export declare const isIncludeTypes: (editor: Editor, types: CustomElementKinds[]) => boolean;

package/services/context.service.d.ts

@@ -16,6 +16,10 @@ interface PaintFormatStatus {
 export declare class TheContextService {
     private ngZone;
     private options;
+    fileList: {
+        url: string;
+        file: File;
+    }[];
     paintFormatStatus: PaintFormatStatus;
     onMouseUp$: Observable<MouseEvent>;
     onMouseMove$: Observable<MouseEvent>;
@@ -23,6 +27,11 @@ export declare class TheContextService {
     constructor(ngZone: NgZone);
     initialize(options: TheContextOptions): void;
     getOptions(): TheContextOptions;
+    setUploadFileList(file: {
+        url: string;
+        file: File;
+    }): void;
+    removeUploadImage(file: File): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TheContextService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TheContextService>;
 }

package/services/toolbar.service.d.ts

@@ -1,7 +1,7 @@
 import { ToolbarKey, ToolbarItem, ToolbarDefinition, ToolbarEntity, ToolbarInitOption } from '../interfaces';
 import * as i0 from "@angular/core";
 export declare class TheToolbarService {
-    initialize(toolbarItems: ToolbarItem[], global?: string[], inline?: string[], block?: string[]): ToolbarInitOption;
+    initialize(toolbarItems: ToolbarItem[], global?: string[], inline?: string[], quick?: string[]): ToolbarInitOption;
     nextToolbarEntity(toolbarDefinition: ToolbarDefinition, toolbarItems: Map<string, ToolbarItem>): ToolbarEntity;
     getToolbarItemByKeys(keys: ToolbarKey[], toolbarItems: Map<string, ToolbarItem>): ToolbarItem[];
     static ɵfac: i0.ɵɵFactoryDeclaration<TheToolbarService, never>;

package/styles/editor.scss

@@ -12,12 +12,17 @@ $thy-icon-nav-link-margin-right: 5px;
 
         .the-editable-container {
             padding: 0;
-            overflow-y: auto;
-            overflow-x: hidden;
-        }
-        .slate-editable-container {
-            min-height: initial;
-            padding: 0;
+
+            &.max-height {
+                padding: 0;
+                overflow-y: auto;
+                overflow-x: hidden;
+            }
+
+            .the-editor-typo {
+                min-height: initial;
+                padding: 0;
+            }
         }
 
         .the-hr {
@@ -36,11 +41,25 @@ $thy-icon-nav-link-margin-right: 5px;
         }
     }
 
+    .the-editor-disabled {
+        .the-check-item {
+            input[type='checkbox'] {
+                cursor: auto;
+            }
+            input[type='checkbox']:not(:checked):hover {
+                border-color: $gray-300;
+            }
+        }
+    }
+
     .the-editable-container {
         position: relative;
-        padding: 23px 0;
-        margin-top: -23px;
-        overflow-y: scroll;
+
+        &.max-height {
+            padding: 41px 0;
+            margin-top: -41px;
+            overflow-y: scroll;
+        }
     }
 
     // list style
@@ -109,12 +128,19 @@ $thy-icon-nav-link-margin-right: 5px;
     }
 }
 
-nav-split-line {
-    width: 1px;
-    height: 1rem;
-    margin-top: 0.45rem;
-    margin-right: 5px;
-    background: $gray-300;
+.the-nav-split-line {
+    &.horizontal {
+        margin: 5px 20px;
+        display: block;
+        border-top: 1px solid $gray-200;
+    }
+    &.vertical {
+        width: 1px;
+        height: 1rem;
+        margin-top: 0.45rem;
+        margin-right: 5px;
+        background: $gray-300;
+    }
 }
 
 @mixin controlSelected {

package/styles/index.scss

@@ -6,7 +6,6 @@
 @import '../components/toolbar-dropdown/toolbar-dropdown.component.scss';
 @import '../components/toolbar-group/toolbar-group.component.scss';
 @import '../components/toolbar/toolbar.component.scss';
-@import '../components/placeholder/placeholder.component.scss';
 @import '../components/color-select/color-select.component.scss';
 @import '../plugins/code/code.component.scss';
 @import '../plugins/link/link.component.scss';
@@ -14,4 +13,8 @@
 @import '../plugins/table/components/table.component.scss';
 @import '../components/table-select/table-select.component.scss';
 @import '../components/conversion-hint/conversion-hint.component.scss';
-@import '../plugins/vertical-align/vertical-align.scss'
+@import '../plugins/vertical-align/vertical-align.scss';
+@import '../components/inline-toolbar/inline-toolbar.component.scss';
+@import '../plugins/quick-insert/components/quick-insert.component.scss';
+@import '../plugins/quick-insert/components/quick-toolbar/quick-toolbar.component.scss';
+@import '../plugins/placeholder/placeholder.component.scss';

package/styles/typo.scss

@@ -1,3 +1,5 @@
+@use 'sass:math';
+
 $default-text-space: 10px; // text white space 18(distance between paragrahp) - 8(block margin)
 
 $headline-one-size: 28px;
@@ -121,7 +123,7 @@ $selection-background: rgba($color: $primary, $alpha: 0.3);
     .slate-element-code,
     .slate-element-image,
     .slate-element-block-quote {
-        padding: $default-text-space/2 0px;
+        padding: math.div($default-text-space, 2) 0;
     }
     .slate-element-image {
         .image-content {
@@ -133,7 +135,7 @@ $selection-background: rgba($color: $primary, $alpha: 0.3);
     .slate-block-card {
         .card-left,
         .card-right {
-            bottom: $default-text-space/2;
+            bottom: math.div($default-text-space, 2);
             line-height: 17px; // cursor default height
         }
         &.slate-block-card-table {

package/transforms/handle-continual-delete-backward.d.ts

@@ -0,0 +1,3 @@
+import { CustomElementKinds } from '../custom-types';
+import { Editor, Element, NodeEntry } from 'slate';
+export declare function handleContinualDeleteBackward(editor: Editor, aboveResult: NodeEntry<Element>, type: CustomElementKinds): boolean;

package/transforms/handle-continual-insert-break.d.ts

@@ -0,0 +1,3 @@
+import { CustomElementKinds } from '../custom-types';
+import { Editor, Element } from 'slate';
+export declare function handleContinualInsertBreak(editor: Editor, lowestBlock: Element, type: CustomElementKinds): boolean;

package/transforms/index.d.ts

@@ -1,27 +1,20 @@
-export declare const TheTransforms: {
-    setMarks: (editor: import("@worktile/theia").TheEditor, marks: {
-        bold?: any;
-        italic?: any;
-        underlined?: any;
-        strike?: any;
-        color?: any;
-        "background-color"?: any;
-        "code-line"?: any;
-    }, at?: import("slate").Path | import("slate").BaseRange | import("slate").BasePoint) => void;
-    clearMarks: (editor: import("@worktile/theia").TheEditor) => void;
-    insertElement: (editor: import("@worktile/theia").TheEditor, element: import("@worktile/theia").CustomElement) => void;
-    insertElementNext: (editor: import("@worktile/theia").TheEditor, node: import("@worktile/theia").CustomElement) => void;
-    insertParagraph: (editor: import("@worktile/theia").TheEditor, at: import("slate").Location) => void;
-    setNode: (editor: import("@worktile/theia").TheEditor, props: Partial<import("@worktile/theia").CustomElement>, origin: import("@worktile/theia").CustomElement) => void;
-    unwrapNodesByType: (editor: import("@worktile/theia").TheEditor, types: string | string[], options?: Omit<import("@worktile/theia").WrapOptions, "match">) => void;
-    onKeyDownResetBlockType: ({ rules }: import("../interfaces/reset-block-type-plugin-options").ResetBlockTypePluginOptions) => (event: KeyboardEvent, editor: import("@worktile/theia").TheEditor) => boolean;
-    moveChildren: (editor: import("@worktile/theia").TheEditor, { at, to, match, start }: import("./move-children").MoveChildrenOptions) => number;
-    applyDeepToNodes: ({ node, source, apply, query }: import("./apply-deep-to-nodes").ApplyDeepToNodesOptions) => void;
-    mergeDeepToNodes: (options: Omit<import("./apply-deep-to-nodes").ApplyDeepToNodesOptions, "apply">) => void;
-    unWrap: (editor: import("@worktile/theia").TheEditor, kind: import("@worktile/theia").BlockElementKinds) => void;
-    splitNode: (editor: import("@worktile/theia").TheEditor, indivisibleTypes: import("@worktile/theia").ElementKinds[]) => import("slate").Path;
-    deleteElement: (editor: import("@worktile/theia").TheEditor, element: import("@worktile/theia").CustomElement) => void;
-    setEndSelection: (editor: import("@worktile/theia").TheEditor) => void;
-    insertTheElements: (editor: import("@worktile/theia").TheEditor, nodes: import("@worktile/theia").CustomElement[]) => void;
-    closeConversionHint: (editor: import("@worktile/theia").TheEditor) => void;
-};
+import { setMarks } from './set-marks';
+import { clearMarks } from './clear-marks';
+import { insertElement } from './insert-element';
+import { insertElementNext } from './insert-element-next';
+import { setNode } from './set-node';
+import { unwrapNodesByType } from './unwrap-nodes-by-type';
+import { onKeyDownResetBlockType } from './on-keydown-reset-block-type';
+import { moveChildren } from './move-children';
+import { insertParagraph } from './insert-paragraph';
+import { applyDeepToNodes } from './apply-deep-to-nodes';
+import { mergeDeepToNodes } from './merge-deep-to-nodes';
+import { unWrap } from './un-wrap';
+import { splitNode } from './split-node';
+import { deleteElement } from './delete-element';
+import { setEndSelection } from './set-end-selection';
+import { insertTheElements } from './insert-elements';
+import { closeConversionHint } from './close-conversion-hint';
+import { handleContinualDeleteBackward } from './handle-continual-delete-backward';
+import { handleContinualInsertBreak } from './handle-continual-insert-break';
+export { setMarks, clearMarks, insertElement, insertElementNext, insertParagraph, setNode, unwrapNodesByType, onKeyDownResetBlockType, moveChildren, applyDeepToNodes, mergeDeepToNodes, unWrap, splitNode, deleteElement, setEndSelection, insertTheElements, closeConversionHint, handleContinualDeleteBackward, handleContinualInsertBreak };

package/transforms/split-node.d.ts

@@ -1,3 +1,3 @@
 import { Path, Editor } from 'slate';
-import { ElementKinds } from '../constants/node-types';
-export declare const splitNode: (editor: Editor, indivisibleTypes: ElementKinds[]) => Path;
+import { CustomElementKinds } from '../custom-types';
+export declare const splitNode: (editor: Editor, indivisibleTypes: CustomElementKinds[]) => Path;

package/transforms/un-wrap.d.ts

@@ -1,3 +1,3 @@
 import { Editor } from 'slate';
-import { BlockElementKinds, InlineElementKinds } from '../interfaces';
-export declare const unWrap: (editor: Editor, kind: BlockElementKinds | InlineElementKinds) => void;
+import { CustomElementKinds } from '../custom-types';
+export declare const unWrap: (editor: Editor, kind: CustomElementKinds) => void;

package/utils/is-clean-empty-paragraph.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from 'slate';
+/**
+ * whether the current node is a clean paragraph
+ * @param editor
+ * @param text
+ * @returns boolean
+ */
+export declare const isCleanEmptyParagraph: (editor: Editor) => boolean;

package/utils/weak-maps.d.ts

@@ -2,3 +2,4 @@ import { ThyPopoverRef } from 'ngx-tethys/popover';
 import { Editor } from 'slate';
 export declare const THE_EDITOR_UUID: WeakMap<import("@worktile/theia").TheEditor, string>;
 export declare const THE_EDITOR_CONVERSION_HINT_REF: WeakMap<Editor, ThyPopoverRef<any>>;
+export declare const THE_EDITOR_QUICK_TOOLBAR_REF: WeakMap<Editor, ThyPopoverRef<any>>;

package/esm2015/components/placeholder/placeholder.component.js

@@ -1,88 +0,0 @@
-import { Component, Input, HostListener } from '@angular/core';
-import { Range, Editor, Node, Text, Element } from 'slate';
-import { AngularEditor } from 'slate-angular';
-import { TheQueries } from '../../queries';
-import { ElementKinds } from '../../constants/node-types';
-import * as i0 from "@angular/core";
-export class ThePlaceholderComponent {
-    constructor(renderer, elementRef) {
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-        this.isHide = true;
-    }
-    get selection() {
-        return this.editor.selection;
-    }
-    handleCompositionStart() {
-        this.hide();
-    }
-    handleCompositionEnd(event) {
-        if (!event.data) {
-            this.checkStatus();
-        }
-    }
-    checkStatus(value) {
-        const { editor } = this;
-        const children = value ? value : editor.children;
-        // empty content and no selection processing
-        if (this.autoFocus && !this.selection && TheQueries.isEmptyContent(children)) {
-            this.updatePosition(30, 51);
-            this.isHide = false;
-            return;
-        }
-        if (AngularEditor.isFocused(editor) && this.selection && Range.isCollapsed(this.selection)) {
-            const block = Node.ancestor(editor, [this.selection.anchor.path[0]]);
-            const textIndent = 'textIndent';
-            const align = 'align';
-            const hasTextIndent = block[textIndent];
-            const hasAlign = block[align];
-            if (Node.string(block) === '' &&
-                Element.isElement(block) &&
-                block.type === ElementKinds.paragraph &&
-                block.children.length === 1 &&
-                Text.isText(block.children[0]) &&
-                !Editor.isVoid(editor, block) &&
-                !hasTextIndent &&
-                !hasAlign) {
-                const rootNode = AngularEditor.toDOMNode(this.editor, block);
-                this.updatePosition(rootNode.offsetLeft, rootNode.offsetTop);
-                return;
-            }
-        }
-        this.hide();
-    }
-    updatePosition(left, top) {
-        this.isHide = false;
-        this.renderer.setStyle(this.elementRef.nativeElement, 'top', `${top}px`);
-        this.renderer.setStyle(this.elementRef.nativeElement, 'left', `${left}px`);
-    }
-    hide() {
-        this.isHide = true;
-    }
-}
-ThePlaceholderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ThePlaceholderComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
-ThePlaceholderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: ThePlaceholderComponent, selector: "div[thePlaceholder]", inputs: { editor: "editor", autoFocus: "autoFocus", placeholder: "placeholder" }, host: { listeners: { "document:compositionstart": "handleCompositionStart()", "document:compositionend": "handleCompositionEnd($event)" }, properties: { "class.hide": "isHide" }, classAttribute: "the-placeholder" }, ngImport: i0, template: `{{ placeholder }}`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ThePlaceholderComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'div[thePlaceholder]',
-                    template: `{{ placeholder }}`,
-                    host: {
-                        class: 'the-placeholder',
-                        '[class.hide]': 'isHide'
-                    }
-                }]
-        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { editor: [{
-                type: Input
-            }], autoFocus: [{
-                type: Input
-            }], placeholder: [{
-                type: Input
-            }], handleCompositionStart: [{
-                type: HostListener,
-                args: ['document:compositionstart']
-            }], handleCompositionEnd: [{
-                type: HostListener,
-                args: ['document:compositionend', ['$event']]
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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