@ones-editor/editor 2.1.7-beta.14 → 2.1.7-beta.16

package/@ones-editor/core/src/core/command-providers/block-attributes.d.ts

@@ -4,8 +4,10 @@ export default class BlockAttributesHandler implements OnesEditorCustom {
     private editor;
     private textBlockAttributes;
     private activeBlockAttributes;
+    private lastRange;
     constructor(editor: OnesEditor);
     clear: () => void;
+    handleSelectionChanged: () => void;
     destroy(): void;
     getEmptyBlockTextAttributes(blockId: string): DocBlockTextAttributes | undefined;
     setActiveBlockAttributes: (attributes: CommandParams) => void;

package/@ones-editor/core/src/core/editor/editor-dom/editor-dom.d.ts

@@ -7,5 +7,6 @@ export declare function isBlockPositionVisible(editor: OnesEditor, pos: SimpleBl
 export declare function scrollIntoView(editor: OnesEditor, target: HTMLElement, options?: {
     animation?: boolean;
     verticalOffset?: number;
+    elementToScroll?: HTMLElement;
 }): void;
 export declare function editorScrollIntoView(editor: OnesEditor): void;

package/@ones-editor/core/src/core/editor/index.d.ts

@@ -1,3 +1,3 @@
 export * from './editor';
 export * from './actions';
-export { scrollIntoView } from './editor-dom';
+export { scrollIntoView, editorScrollIntoView } from './editor-dom';

package/@ones-editor/core/src/core/types.d.ts

@@ -356,6 +356,8 @@ export interface OnesEditorUndoAction {
     redo: (editor: OnesEditor) => boolean;
     combinable: (other: OnesEditorUndoAction) => boolean;
     combine: (other: OnesEditorUndoAction) => void;
+    getTimeStamp: () => number;
+    getBatchActionId?: () => string | undefined;
 }
 export interface OnesEditorUndoManager {
     reset: () => void;
@@ -642,6 +644,7 @@ export type PasteOptions = {
 };
 export interface OnesEditorInput {
     readonly inputElement: HTMLTextAreaElement;
+    getInput: () => HTMLTextAreaElement;
     destroy: () => void;
     focus: () => void;
     handleDocumentSelectionChange: () => void;
@@ -718,6 +721,7 @@ export type CommandParams = {
     [index: string]: unknown;
 } & {
     source?: string[];
+    isFilter?: boolean;
 };
 export type CommandResult = {
     [index: string]: unknown;
@@ -727,12 +731,12 @@ export interface OnesEditorCommandProvider {
     groupIndex?: number;
     getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
     getInsertCommands?: (editor: OnesEditor, containerId: string) => CommandItem[];
-    executeInsertCommand?: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+    executeInsertCommand?: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItemWithSource, params: CommandParams, result?: CommandResult) => boolean;
     executeRangeCommand?: (editor: OnesEditor, range: SelectionRange, command: CommandItemWithSource, params: CommandParams, result?: CommandResult) => boolean;
-    executeCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+    executeCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams, result?: CommandResult) => boolean;
     filterCommands?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, commands: CommandItemWithSource[]) => CommandItemWithSource[] | undefined;
-    beforeExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams) => boolean | undefined;
-    afterExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result: CommandResult) => void;
+    beforeExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => boolean | undefined;
+    afterExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams, result: CommandResult) => void;
 }
 export interface CommandItemWithSource extends CommandItem {
     source: string;
@@ -767,3 +771,9 @@ export interface OnesEditorBlockHook {
     writable?: (editor: OnesEditor, blockElement: BlockElement | BlockElement[]) => boolean | undefined;
     commands?: (editor: OnesEditor, blockElement: BlockElement, child: TextBlockContentChild | null) => BlockCommands | undefined;
 }
+export interface MobileClient {
+    getViewPortHeight: () => number;
+    getOffsetHeight: () => number;
+    virtualViewportHeight: number;
+    virtualViewportOffsetTop: number;
+}

package/@ones-editor/core/src/core/undo-manager/actions/action.d.ts

@@ -4,11 +4,15 @@ export default class Action implements OnesEditorUndoAction {
     protected containerId: string;
     beforeRange: OnesEditorDocRange;
     afterRange: OnesEditorDocRange;
-    constructor(editor: OnesEditor, containerId: string, afterRange: OnesEditorDocRange);
+    batchActionId?: string;
+    ts: number;
+    constructor(editor: OnesEditor, containerId: string, afterRange: OnesEditorDocRange, batchActionId?: string);
+    getTimeStamp(): number;
     undo(editor: OnesEditor): boolean;
     redo(editor: OnesEditor): boolean;
     combinable(other: OnesEditorUndoAction): boolean;
     combine(other: OnesEditorUndoAction): void;
+    getBatchActionId(): string | undefined;
     setAfterRange(range: OnesEditorDocRange): void;
     hasDocContainerId(editor: OnesEditor, id: string): boolean;
     findDocBlockById(editor: OnesEditor, id: string): DocBlock | undefined;

package/@ones-editor/core/src/core/undo-manager/actions/block-action.d.ts

@@ -7,4 +7,5 @@ export default class BlockAction extends Action {
     constructor(editor: OnesEditor, containerId: string, blockIndex: number, data: DocBlock, afterRange: OnesEditorDocRange);
     deleteBlock(editor: OnesEditor, newRange: OnesEditorDocRange): boolean;
     insertBlock(editor: OnesEditor, newRange: OnesEditorDocRange): boolean;
+    getBatchActionId(): string | undefined;
 }

package/@ones-editor/core/src/core/undo-manager/actions/update-block-data-action.d.ts

@@ -9,4 +9,5 @@ export default class UpdateBlockDataAction extends Action {
     undo(editor: OnesEditor): boolean;
     redo(editor: OnesEditor): boolean;
     private static toAttributes;
+    getBatchActionId(): string | undefined;
 }

package/@ones-editor/core/src/utils/animate-scroll.d.ts

@@ -10,6 +10,7 @@ export interface IUserOptions {
     verticalOffset?: number;
     disableHorizontal?: boolean;
     disableVertical?: boolean;
+    getClientHeight?: () => number;
 }
 export interface IOptions {
     cancelOnUserAction: boolean;
@@ -22,6 +23,7 @@ export interface IOptions {
     verticalOffset: number;
     disableHorizontal?: boolean;
     disableVertical?: boolean;
+    getClientHeight?: () => number;
 }
 declare function animateScrollTo(y: number, userOptions?: IUserOptions): Promise<boolean>;
 declare function animateScrollTo(coords: TCoords, userOptions?: IUserOptions): Promise<boolean>;

package/@ones-editor/core/src/utils/dom.d.ts

@@ -1,4 +1,4 @@
-import type { CSSStyles } from '../core/types';
+import type { CSSStyles, OnesEditor } from '../core/types';
 export declare function addClass(dom: Element, ...className: Array<string>): void;
 export declare function hasClass(dom: Node | null, className: string): boolean;
 export declare function removeClass(dom: Element, ...className: Array<string>): void;
@@ -37,7 +37,7 @@ export declare function bindKeyDownEvent(input: HTMLInputElement | HTMLTextAreaE
 export declare function getElementFromPoint(x: number, y: number, options?: {
     noFilter: boolean;
 }): Element;
-export declare function ensureIsMobileEvent(events: MouseEvent | TouchEvent): events is TouchEvent;
 export declare function createMouseEventFromTouchEvent(event: TouchEvent, type: 'mousedown' | 'mousemove' | 'mouseup' | 'click'): MouseEvent;
-export declare function bindTouchEnd(elem: HTMLElement | Document, callback: (e: any) => void): void;
+export declare function ensureIsMobileEvent(events: MouseEvent | TouchEvent): events is TouchEvent;
+export declare function bindDbClick(editor: OnesEditor, elem: HTMLElement, handler: (event: MouseEvent) => void): () => void;
 export {};

package/@ones-editor/image-embed/src/image-object.d.ts

@@ -42,4 +42,5 @@ export declare class ImageObject implements ImageObjectBase {
     private setData;
     static create(editor: OnesEditor, blockData: DocEmbedBlock): ImageObject;
     static getImageObject(editor: OnesEditor, block: BlockElement | string): ImageObject;
+    static findImageObject(editor: OnesEditor, block: BlockElement | string): ImageObject | null;
 }

package/@ones-editor/mention/src/mention.d.ts

@@ -1,24 +1,31 @@
 /// <reference types="lodash" />
 import { CommandItem, OnesEditor, OnesEditorCustom } from '../../../@ones-editor/core';
-import { AutoSuggestAnchor, OnesEditorAutoSuggest } from '../../../@ones-editor/ui-base';
+import { AutoSuggestAnchor, EditorInput, OnesEditorAutoSuggest } from '../../../@ones-editor/ui-base';
 import { MentionOptions } from './types';
+interface MobileWrap {
+    wrapper: HTMLElement;
+    input: EditorInput;
+    content: HTMLElement;
+}
 export default class OnesEditorMention implements OnesEditorCustom {
     private editor;
     private options;
     suggest: OnesEditorAutoSuggest;
-    private mobileWrap;
+    private mobileWrap?;
     private items;
     constructor(editor: OnesEditor, options: MentionOptions);
     createMobileHeader: () => HTMLDivElement | undefined;
     onClose: () => void;
     destroy(): void;
     onShow: (suggest: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean;
+    onShown: (bar: OnesEditorAutoSuggest) => void;
     handleClickItem: (item: CommandItem) => void;
     handleMobileWrapClick: (e: Event) => void;
     onClickItem: (menu: OnesEditorAutoSuggest, item: CommandItem, anchor: AutoSuggestAnchor) => void;
     createItemElement: (item: CommandItem, find: string) => HTMLElement;
     createMobileItems: (content: HTMLElement, items: CommandItem[], find: string) => void;
     onInputChanged: import("lodash").DebouncedFunc<(content: HTMLElement, e: Event) => void>;
+    createMobileWrap: () => MobileWrap;
     createMobileCommandItem: (items: CommandItem[]) => {
         id: string;
         name: string;
@@ -27,3 +34,4 @@ export default class OnesEditorMention implements OnesEditorCustom {
     _queryItems: (text: string) => Promise<CommandItem[]>;
     queryItems: (menu: OnesEditorAutoSuggest, text: string) => Promise<CommandItem[]>;
 }
+export {};

package/@ones-editor/mobile-helper/src/cursor-toolbar.d.ts

@@ -1,4 +1,4 @@
-import { type CommandItem, type OnesEditor } from '../../../@ones-editor/core';
+import { CommandItem, OnesEditor } from '../../../@ones-editor/core';
 export declare class CursorToolbarHandler {
     private editor;
     private toolbar;

package/@ones-editor/mobile-helper/src/fixed-toolbar/index.d.ts

@@ -5,18 +5,14 @@ export declare class MobileCommandHandler {
     private editor;
     private commandBar;
     private observer;
+    private timer;
+    private mobileClient?;
     constructor(editor: OnesEditor);
-    destroy(): void;
-    private showKeyboard;
-    private initViewportHeight;
-    private get isKeyboardShow();
-    private get virtualViewportHeight();
-    private get clientHeight();
-    private get virtualViewportOffsetTop();
-    private get window();
-    private setDebugInfo;
     private toggleDelay;
-    toggle: import("lodash").DebouncedFunc<() => void>;
+    private preHeight;
+    layoutBar: import("lodash").DebouncedFunc<() => void>;
+    handScroll: import("lodash").DebouncedFunc<() => void>;
+    destroy(): void;
     handleFocusIn: () => void;
     handleFocusOut: () => void;
 }

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/insert-menu.d.ts

@@ -1,15 +1,13 @@
-import { BlockElement, CommandItem, CommandParams, ContainerElement, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
 import { ProxyProvider } from '../../../../../@ones-editor/ui';
-export default class InsertMenuProvider extends ProxyProvider {
+export default class MobileInsertMenuProvider extends ProxyProvider {
     private editor;
     id: string;
     get whiteList(): string[];
     providers: OnesEditorCommandProvider[];
     constructor(editor: OnesEditor);
-    getNextBlock(container: ContainerElement, block: BlockElement): number;
     getInsertCommands: () => CommandItem[];
-    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
     executeInsertCommand: () => boolean;
-    getNextBlockIndex: (container: ContainerElement, block: BlockElement) => number;
-    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => boolean;
 }

package/@ones-editor/mobile-helper/src/fixed-toolbar/toolbar-handler.d.ts

@@ -5,6 +5,9 @@ export declare class MobileToolbarHandler {
     private fixedProviders;
     bar: HTMLElement;
     constructor(editor: OnesEditor, parent: HTMLElement);
+    private subBar;
+    private handleSubBarShown;
+    layoutSubBar(): void;
     private handleSelectionChange;
     handleClick: (_: any, item: CommandItem) => void;
     destroy(): void;

package/@ones-editor/mobile-helper/src/index.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="lodash" />
 import { OnesEditor, OnesEditorCustom } from '../../../@ones-editor/core';
 import { MobileCommandHandler } from './fixed-toolbar';
-import './mobile-helper-styles.scss';
 import './locale';
+import './mobile-helper-styles.scss';
 export { MobileCommandHandler };
 export declare class OnesEditorMobileHelper implements OnesEditorCustom {
     private editor;
@@ -18,5 +18,6 @@ export declare class OnesEditorMobileHelper implements OnesEditorCustom {
     handleLongPress: (event: TouchEvent) => boolean;
     handleTouchMove: (event: TouchEvent) => void;
     handleTouchStart: (event: TouchEvent) => void;
+    debounceShowCursorToolbar: import("lodash").DebouncedFunc<() => void>;
     handleTouchEnd: (event: TouchEvent) => void;
 }

package/@ones-editor/scroll-container/src/utils.d.ts

@@ -1,5 +1,5 @@
 import { ContainerElement, ScrollAreaElement, ScrollContainerElement, ScrollCore } from './common-types';
-export declare function getContainerOption(scrollCore: ScrollCore, container: ContainerElement): import("./types").ScrollContainerOptions | undefined;
+export declare function getContainerOption(scrollCore: ScrollCore, container: ContainerElement): import("@ones-editor/editor").ScrollContainerOptions | undefined;
 export declare function getScrollContainer(scrollChild: HTMLElement): ScrollContainerElement;
 export declare function getContainerScrollArea(scrollContainer: ScrollContainerElement): ScrollAreaElement;
 export declare function getContainer(scrollChild: HTMLElement): ContainerElement;

package/@ones-editor/table-block/src/index.d.ts

@@ -1,12 +1,9 @@
 import TableBlock, { includeBigTable } from './table-block';
-import { TableBlockCommandProvider, deleteColumns, deleteRows, setStripeStyle, setColTitle, setRowTitle, insertColumn, insertRow } from './commands';
+import { TableBlockCommandProvider } from './commands';
 import './locale';
 import './table-style.scss';
 import TableShortcuts from './table-block/table-shortcuts';
-import { createEntireRowAndColumnRange, getAbstractTableSelectionRange } from './table-block/cell-menu/table-cell-dom';
-import MobileTableCommandProvider from './commands/table-command-provider';
+import MobileTableCommandProvider from './commands/mobile-command-provider';
 export * from './types';
 export { MobileTableCommandProvider, TableBlock, TableBlockCommandProvider, TableShortcuts, includeBigTable };
-export { deleteColumns, deleteRows, setStripeStyle, setColTitle, setRowTitle, insertColumn, insertRow, };
-export { createEntireRowAndColumnRange, getAbstractTableSelectionRange };
 export type { CreateTableData } from './table-block/table-creator';

package/@ones-editor/text-commands/src/index.d.ts

@@ -1,3 +1,2 @@
 import { HideTooltipShortcuts } from './shortcut-handler';
-import './locale';
 export { HideTooltipShortcuts };