@ones-editor/editor 0.0.1

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

@@ -0,0 +1,13 @@
+import { OnesEditorDocRange } from '../../doc/doc';
+import { OnesEditor, OnesEditorUndoAction } from '../../types';
+export default class Action implements OnesEditorUndoAction {
+    protected containerId: string;
+    beforeRange: OnesEditorDocRange;
+    afterRange: OnesEditorDocRange;
+    constructor(editor: OnesEditor, containerId: string, afterRange: OnesEditorDocRange);
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+    combinable(other: OnesEditorUndoAction): boolean;
+    combine(other: OnesEditorUndoAction): void;
+    setAfterRange(range: OnesEditorDocRange): void;
+}

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

@@ -0,0 +1,2 @@
+import { OnesEditorUndoAction } from '../../types';
+export default function addActions(actions: OnesEditorUndoAction[], action: OnesEditorUndoAction): void;

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

@@ -0,0 +1,10 @@
+import { DocBlock, OnesEditorDocRange } from '../../doc';
+import { OnesEditor } from '../../types';
+import Action from './action';
+export default class BlockAction extends Action {
+    blockData: DocBlock;
+    blockIndex: number;
+    constructor(editor: OnesEditor, containerId: string, blockIndex: number, data: DocBlock, afterRange: OnesEditorDocRange);
+    deleteBlock(editor: OnesEditor, newRange: OnesEditorDocRange): boolean;
+    insertBlock(editor: OnesEditor, newRange: OnesEditorDocRange): boolean;
+}

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

@@ -0,0 +1,9 @@
+import { DocBlock } from '../../doc';
+import { OnesEditor } from '../../types';
+import Action from './action';
+export default class ChildContainerAction extends Action {
+    private blocks;
+    constructor(editor: OnesEditor, containerId: string, blocks: DocBlock[]);
+    deleteChildContainer(editor: OnesEditor): boolean;
+    insertChildContainer(editor: OnesEditor): boolean;
+}

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

@@ -0,0 +1,6 @@
+import { OnesEditor } from '../../types';
+import BlockAction from './block-action';
+export default class DeleteBlockAction extends BlockAction {
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+}

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

@@ -0,0 +1,6 @@
+import { OnesEditor } from '../../types';
+import ChildContainerAction from './child-container-action';
+export default class DeleteChildContainerAction extends ChildContainerAction {
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+}

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

@@ -0,0 +1,11 @@
+import { OnesEditorDocRange } from '../../doc';
+import { OnesEditor, OnesEditorUndoAction } from '../../types';
+import Action from './action';
+export default class GroupAction extends Action {
+    actions: OnesEditorUndoAction[];
+    constructor(editor: OnesEditor);
+    addAction(action: OnesEditorUndoAction): void;
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+    setAfterRange(range: OnesEditorDocRange): void;
+}

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

@@ -0,0 +1,3 @@
+import { OnesEditor } from '../../types';
+export declare function editorUndo(editor: OnesEditor): boolean;
+export declare function editorRedo(editor: OnesEditor): boolean;

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

@@ -0,0 +1,6 @@
+import { OnesEditor } from '../../types';
+import BlockAction from './block-action';
+export default class InsertBlockAction extends BlockAction {
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+}

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

@@ -0,0 +1,6 @@
+import { OnesEditor } from '../../types';
+import ChildContainerAction from './child-container-action';
+export default class InsertChildContainerAction extends ChildContainerAction {
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+}

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

@@ -0,0 +1,12 @@
+import { DocBlock, OnesEditorDocRange } from '../../doc';
+import { OnesEditor } from '../../types';
+import Action from './action';
+export default class UpdateBlockDataAction extends Action {
+    beforeBlockData: DocBlock;
+    afterBlockData: DocBlock;
+    blockId: string;
+    constructor(editor: OnesEditor, containerId: string, blockId: string, oldData: DocBlock, newData: DocBlock, newRange: OnesEditorDocRange);
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+    private static toAttributes;
+}

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

@@ -0,0 +1,21 @@
+import { DocBlockText, OnesEditorDocRange } from '../../doc';
+import { OnesEditor, OnesEditorUndoAction } from '../../types';
+import Action from './action';
+export default class UpdateBlockTextAction extends Action {
+    beforeRichTextData: DocBlockText;
+    afterRichTextData: DocBlockText;
+    blockId: string;
+    type: {
+        textType: string;
+        begin: boolean;
+    };
+    constructor(editor: OnesEditor, container: string, blockId: string, oldData: DocBlockText, newData: DocBlockText, newRange: OnesEditorDocRange);
+    static calType(oldData: DocBlockText, newData: DocBlockText): {
+        textType: string;
+        begin: boolean;
+    };
+    undo(editor: OnesEditor): boolean;
+    redo(editor: OnesEditor): boolean;
+    combinable(other: OnesEditorUndoAction): boolean;
+    combine(other: OnesEditorUndoAction): void;
+}

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

@@ -0,0 +1,2 @@
+import UndoManager from './undo-manager';
+export { UndoManager };

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

@@ -0,0 +1,33 @@
+import { DocBlock, DocBlockText, OnesEditorDocRange } from '../doc';
+import { EditorDocLocalActionCallbacks, OnesEditor, OnesEditorUndoAction, OnesEditorUndoManager } from '../types';
+import Action from './actions/action';
+declare class UndoManager implements OnesEditorUndoManager, EditorDocLocalActionCallbacks {
+    editor: OnesEditor;
+    private actions;
+    private undoCursor;
+    private currentGroup;
+    private groupCounter;
+    private undoRedoing;
+    constructor(editor: OnesEditor);
+    reset(): void;
+    prepareSaveUndoState(): void;
+    addAction(action: OnesEditorUndoAction): void;
+    private beginGroup;
+    private endGroup;
+    hasGroup(): boolean;
+    runInGroup<T>(action: () => T): T;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    lastAction(): Action;
+    undoTo(action: OnesEditorUndoAction | null): boolean;
+    onBeforeUpdateBlockText(containerId: string, blockId: string, oldText: DocBlockText, newText: DocBlockText, newRange: OnesEditorDocRange): void;
+    onBeforeUpdateBlockData(containerId: string, blockId: string, oldData: DocBlock, newData: DocBlock, newRange: OnesEditorDocRange): void;
+    onBeforeInsertBlock(containerId: string, blockIndex: number, blockData: DocBlock, newRange: OnesEditorDocRange): void;
+    onBeforeDeleteBlock(containerId: string, blockIndex: number, blockData: DocBlock, newRange: OnesEditorDocRange): void;
+    onBeforeInsertChildContainer(containerId: string, blocks: DocBlock[]): void;
+    onBeforeDeleteChildContainer(containerId: string, blocks: DocBlock[]): void;
+    private handleSelectionChange;
+}
+export default UndoManager;

package/@ones-editor/core/src/helper/block-helper.d.ts

@@ -0,0 +1,2 @@
+import { BlockElement } from '../core';
+export declare function isRootBlock(block: BlockElement): boolean;

package/@ones-editor/core/src/helper/hovering-block.d.ts

@@ -0,0 +1,30 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { TextBlockContentChild } from '../core/blocks/text-blocks/base/child';
+import { BlockElement, OnesEditor, OnesEditorCustom } from '../core/types';
+export interface OnesEditorHoveringBlockEvents {
+    change: (block: BlockElement | null, old: BlockElement | null, event: MouseEvent) => void;
+    childChange: (block: BlockElement | null, child: TextBlockContentChild | null, old: TextBlockContentChild | null, event: MouseEvent) => void;
+}
+export interface OnesEditorHoveringBlockFilter extends OnesEditorCustom {
+    isInBlock: (block: BlockElement, event: MouseEvent) => boolean;
+}
+export interface OnesEditorHoveringBlockFinder extends OnesEditorCustom {
+    findTargetBlock: (editor: OnesEditor, event: MouseEvent) => BlockElement | null;
+}
+export default class OnesEditorHoveringBlock extends TypedEmitter<OnesEditorHoveringBlockEvents> {
+    private editor;
+    private hoveringBlock;
+    private hoveringTextChild;
+    private filters;
+    private finders;
+    constructor(editor: OnesEditor);
+    destroy(): void;
+    addFilter(filter: OnesEditorHoveringBlockFilter): void;
+    addFinder(finder: OnesEditorHoveringBlockFinder): void;
+    hoveringBlockId(): string;
+    private findBlockByFinders;
+    private handleDocumentMouseMove;
+    private setHoveringBlock;
+    static get(editor: OnesEditor): OnesEditorHoveringBlock;
+    private getParentTextContentChild;
+}

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

@@ -0,0 +1,5 @@
+import OnesEditorHoveringBlock from './hovering-block';
+import type { OnesEditorHoveringBlockFilter, OnesEditorHoveringBlockFinder } from './hovering-block';
+export { OnesEditorHoveringBlock, OnesEditorHoveringBlockFilter, OnesEditorHoveringBlockFinder };
+export * from './block-helper';
+export * from './run-once';

package/@ones-editor/core/src/helper/run-once.d.ts

@@ -0,0 +1,4 @@
+import { OnesEditor } from '../core';
+export type EditorRunOnceCleanupAction = () => void;
+export type EditorRunOnceAction = () => EditorRunOnceCleanupAction | undefined | void;
+export declare function editorRunOnce(editor: OnesEditor, id: string, action: EditorRunOnceAction): void;

package/@ones-editor/core/src/i18n/en-us.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    name: string;
+    date: {
+        dateFromFuture: string;
+        dateJustNow: string;
+        dateYesterday: string;
+        dateMinutesAgo: string;
+        date1HourAgo: string;
+        dateHoursAgo: string;
+        dateDaysAgo: string;
+        dateWeeksAgo: string;
+    };
+    common: {
+        cancel: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,3 @@
+export declare function setLang(lang?: string | null | undefined): void;
+export declare function mergeLang(l: any): void;
+export declare function t(key: string, args?: Record<string, string>): string;

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

@@ -0,0 +1,2 @@
+import * as i18n from './i18n';
+export default i18n;

package/@ones-editor/core/src/i18n/zh-cn.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    name: string;
+    date: {
+        dateFromFuture: string;
+        dateJustNow: string;
+        dateYesterday: string;
+        dateMinutesAgo: string;
+        date1HourAgo: string;
+        dateHoursAgo: string;
+        dateDaysAgo: string;
+        dateWeeksAgo: string;
+    };
+    common: {
+        cancel: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,8 @@
+import i18n from './i18n';
+import './style.scss';
+export * from './core';
+export * from './local-doc';
+export * from './utils';
+export * from './users';
+export * from './helper';
+export { i18n };

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

@@ -0,0 +1,27 @@
+import { DocBlock, DocBlockDelta, DocBlockText, DocBlockTextActions, DocObject, OnesEditorDoc, OnesEditorDocCallbacks, OnesEditorUser, UploadResourceOptions, UploadResourceResult } from '../core/doc';
+import { EventCallbacks } from '../utils';
+import { RemoteUsers } from '../users';
+export declare class LocalDoc extends EventCallbacks<OnesEditorDocCallbacks> implements OnesEditorDoc {
+    doc: DocObject;
+    constructor(doc?: DocObject);
+    beginBatchUpdate(): number;
+    endBatchUpdate(): number;
+    toJSON(): DocObject;
+    getContainerBlocks(containerId: string): DocBlock[];
+    getBlockData(containerId: string, blockIndex: number): DocBlock;
+    localUpdateBlockText(containerId: string, blockIndex: number, actions: DocBlockTextActions): DocBlockText;
+    localUpdateBlockData(containerId: string, blockIndex: number, delta: DocBlockDelta): DocBlock;
+    localInsertBlock(containerId: string, blockIndex: number, data: DocBlock): DocBlock;
+    localDeleteBlock(containerId: string, blockIndex: number): DocBlock;
+    localInsertChildContainer(containerId: string, blocks: DocBlock[]): void;
+    localDeleteChildContainers(containerIds: string[]): void;
+    uploadResource(file: File, options?: UploadResourceOptions): Promise<UploadResourceResult>;
+    addResources(resourceIds: string[]): Promise<string[]>;
+    buildResourceUrl(src: string): string;
+    request<T>(url: string, opt?: any): Promise<T>;
+    broadcastMessage(data: unknown): void;
+    getUser(): OnesEditorUser;
+    getRemoteUsers(): RemoteUsers;
+    setDoc(doc: DocObject): void;
+    destroy(): void;
+}

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

@@ -0,0 +1 @@
+import './style.css';

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

@@ -0,0 +1,25 @@
+import Delta from 'quill-delta';
+import Op from 'quill-delta/dist/Op';
+declare const _default: {
+    type: {
+        name: string;
+        uri: string;
+        create(initial: Op[]): Delta;
+        apply(snapshot: Op[], delta: Op[]): Op[];
+        compose(delta1: Op[], delta2: Op[]): Op[];
+        diff(delta1: Op[], delta2: Op[]): Op[];
+        transform(delta1: Op[], delta2: Op[], side: 'left' | 'right'): Op[];
+        transformCursor(cursor: number, delta: Delta, isOwnOp: boolean): number;
+        normalize(delta: Delta): Delta;
+        serialize(delta: Delta): Op[];
+        deserialize(ops: Op[]): Op[];
+        transformPresence(range: {
+            index: number;
+            length: number;
+        }, op: Op[], isOwnOp: boolean): {
+            index: number;
+            length: number;
+        } | null;
+    };
+};
+export default _default;

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

@@ -0,0 +1,2 @@
+import RemoteUsers from './remote-users';
+export { RemoteUsers };

package/@ones-editor/core/src/users/remote-users.d.ts

@@ -0,0 +1,21 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { DocBlock, DocBlockTextActions, OnesEditorClientSelection, OnesEditorRemoteUsers, OnesEditorUser, RemoteUsersEvents } from '../core/doc';
+declare class RemoteUsers extends TypedEmitter<RemoteUsersEvents> implements OnesEditorRemoteUsers {
+    private users;
+    private cursors;
+    private addingUser;
+    private colors;
+    constructor(colors?: string[]);
+    setCursor(message: OnesEditorClientSelection): void;
+    addUsers(users: OnesEditorUser[]): void;
+    addUser(user: OnesEditorUser): void;
+    findUser(userId: string): OnesEditorUser | null;
+    removeUser(clientId: string): void;
+    updateUsers(users: OnesEditorUser[]): void;
+    getSimpleCursors(blockId: string): Map<number, OnesEditorClientSelection[]>;
+    getCursors(blockId: string): OnesEditorClientSelection[];
+    onUpdateBlockText(blockData: DocBlock, actions: DocBlockTextActions, local: boolean): void;
+    getFixedUserColor(userId: string, type: 'flag' | 'selection'): string;
+    destroy(): void;
+}
+export default RemoteUsers;

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

@@ -0,0 +1,2 @@
+import type { OnesEditor, SimpleSelectionRange } from '../core/types';
+export declare function allSelected(editor: OnesEditor, range: SimpleSelectionRange): boolean;

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

@@ -0,0 +1,25 @@
+export type TCoords = [number | null | undefined, number | null | undefined];
+export interface IUserOptions {
+    cancelOnUserAction?: boolean;
+    easing?: (t: number) => number;
+    elementToScroll?: Element | Window;
+    horizontalOffset?: number;
+    maxDuration?: number;
+    minDuration?: number;
+    speed?: number;
+    verticalOffset?: number;
+}
+export interface IOptions {
+    cancelOnUserAction: boolean;
+    easing: (t: number) => number;
+    elementToScroll: Element | Window | null;
+    horizontalOffset: number;
+    maxDuration: number;
+    minDuration: number;
+    speed: number;
+    verticalOffset: number;
+}
+declare function animateScrollTo(y: number, userOptions?: IUserOptions): Promise<boolean>;
+declare function animateScrollTo(coords: TCoords, userOptions?: IUserOptions): Promise<boolean>;
+declare function animateScrollTo(scrollToElement: Element, userOptions?: IUserOptions): Promise<boolean>;
+export default animateScrollTo;

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

@@ -0,0 +1,14 @@
+import { Logger } from './logger';
+declare global {
+    interface Error {
+        lineNumber?: number;
+        columnNumber?: number;
+        fileName?: string;
+        code?: number | string;
+    }
+}
+export declare class AssertError extends Error {
+    constructor(message: string);
+}
+declare function assert(logger: Logger, cond: unknown, message: string): asserts cond;
+export { assert, };

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

@@ -0,0 +1,35 @@
+export type Direction = 'right' | 'left' | 'top' | 'bottom';
+export type CancelContinuousScroll = () => void;
+export type ContinuousScrollOptions = {
+    direction: Direction;
+    step: number;
+};
+export type ScrollDomInfo = {
+    bottom: number;
+    right: number;
+    left: number;
+    top: number;
+};
+export interface AutoScrollOptions {
+    scrollElement: HTMLElement;
+    trackMouseEvent?: 'mousemove' | 'drag';
+    step?: number;
+    edge: {
+        [k in Direction]?: number;
+    };
+    onDirectionChange?: (direction: Direction) => void;
+}
+export declare function scrollable(scrollElement: HTMLElement, direction: Direction): boolean;
+export declare function continuousScroll(scrollElement: HTMLElement, { direction, step }: ContinuousScrollOptions): CancelContinuousScroll | null;
+export declare class AutoScroll {
+    private cancelScroll;
+    private options;
+    private scrollDomInfo;
+    private scrolling;
+    constructor(options: AutoScrollOptions);
+    private getScrollDomInfo;
+    private getScrollingDirection;
+    private handleMouseMove;
+    active(): void;
+    inactive(): void;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * A mutex lock for coordination across async functions
+ */
+declare class AwaitLock {
+    private _acquired;
+    private _waitingResolvers;
+    constructor();
+    /**
+     * Acquires the lock, waiting if necessary for it to become free if it is already locked. The
+     * returned promise is fulfilled once the lock is acquired.
+     *
+     * After acquiring the lock, you **must** call `release` when you are done with it.
+     */
+    acquireAsync(timeout?: number): Promise<unknown>;
+    /**
+     * Acquires the lock if it is free and otherwise returns immediately without waiting. Returns
+     * `true` if the lock was free and is now acquired, and `false` otherwise,
+     */
+    tryAcquire(): boolean;
+    /**
+     * Releases the lock and gives it to the next waiting acquirer, if there is one. Each acquirer
+     * must release the lock exactly once.
+     */
+    release(): void;
+    acquired(): boolean;
+    debug(): {
+        waitingCount: number;
+    };
+}
+export default AwaitLock;

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

@@ -0,0 +1,7 @@
+export default class EventCallbacks<T> {
+    private _callbacks;
+    get callbacks(): T[];
+    registerCallback(callback: T): void;
+    unregisterCallback(callback: T): void;
+    clearCallbacks(): void;
+}

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

@@ -0,0 +1,5 @@
+export declare function isNumber(str: string): boolean;
+export declare function isLetter(str: string): boolean;
+export declare function isSpace(str: string): boolean;
+export declare function isCJK(str: string): boolean;
+export declare function trimChar(s: string, char: string): string;

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

@@ -0,0 +1,16 @@
+export declare function isSafari(): boolean;
+export declare function isFirefox(): boolean;
+declare const clientType: {
+    isAndroid: boolean;
+    isIOS: boolean;
+    isIPad: boolean;
+    isIPhone: boolean;
+    isLinux: boolean;
+    isMac: boolean;
+    isMobile: boolean;
+    isWindows: boolean;
+    isIe: boolean;
+    isSafari: boolean;
+    isMobileSafari: boolean;
+};
+export { clientType };

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

@@ -0,0 +1,8 @@
+export declare function setClipboardDataByEvent(items: {
+    type: string;
+    data: string;
+}[], event: ClipboardEvent): Promise<boolean>;
+export declare function setClipboardData(items: {
+    type: string;
+    data: string | Blob;
+}[]): Promise<boolean>;

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

@@ -0,0 +1,2 @@
+export declare function stringToDataUrl(data: string, type: string): Promise<string>;
+export declare function fileToDataUrl(file: File): Promise<string>;

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

@@ -0,0 +1,9 @@
+export declare function daysAfter(date: Date, days: number): Date;
+export declare function addMonths(date: Date, m: number): Date;
+export declare function addDays(date: Date, days: number): Date;
+export declare function isSameDay(date1: Date, date2: Date): boolean;
+export declare function isToday(date: Date): boolean;
+export declare function isYesterday(date: Date): boolean;
+export declare function diffDays(firstDate: Date, secondDate: Date): number;
+export declare function formatDate(date: Date, format?: string): string;
+export declare function fromNowString(date: Date, format?: string): string;

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

@@ -0,0 +1,3 @@
+export declare function getScrollContainer(element: HTMLElement): HTMLElement;
+export declare function disablePageScroll(id: string): void;
+export declare function enablePageScroll(id: string): void;

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

@@ -0,0 +1,29 @@
+import type { CSSStyles } 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;
+type Dataset = Record<string, string | number>;
+export declare function createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, classes: string[], parent: HTMLElement | DocumentFragment | null, innerTextOrDataset?: string | Dataset): HTMLElementTagNameMap[K];
+export declare function createIconButton(svg: string, classes: string[], parent: HTMLElement | null): HTMLButtonElement;
+export declare function createImage(src: string, classes: string[], parent: HTMLElement | DocumentFragment | null): HTMLImageElement;
+export declare function createRange(node: Node, offset: number): Range;
+export declare function createExpandedRange(startNode: Node, startOffset: number, endNode: Node, endOffset: number): Range;
+export declare function getFirstClientRect(elem: Element): DOMRect;
+export declare function getLastClientRect(elem: Element): DOMRect;
+export declare function getDistanceSquare(rect: DOMRect, x: number, y: number): number;
+export declare function textNodeOffsetFromPoint(node: Text, x: number, y: number): number;
+export declare function compareElement(elem1: Element, elem2: Element): number;
+export declare function getHorizontalPadding(elem: Element): number;
+export declare function isNodeRemoved(elem: Element): boolean;
+export declare function isChildNode(parent: Node, child: Node): boolean;
+export declare function loadJs(url: string, id: string, callback: (error?: Error) => void): void;
+export declare function loadJsPromise(url: string, id: string): Promise<void>;
+export declare function setDataset(el: HTMLElement, dataset: Record<string, string | number>): void;
+export declare function setAttributes(el: HTMLElement, attributes: Record<string, string>): void;
+export declare function setStyles(el: HTMLElement, styles: CSSStyles): void;
+export declare function getElementOffset(el: Element): {
+    top: number;
+    left: number;
+};
+export declare function findTarget(event: Event, cssSelector: string): Element | null;
+export {};

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

@@ -0,0 +1,41 @@
+export type DragStartHandler<T> = (drag: DragDrop<T>, event: MouseEvent, elem: HTMLElement) => void;
+export type DraggingHandler<T> = (drag: DragDrop<T>, event: MouseEvent, elem: HTMLElement, deltaX: number, deltaY: number) => void;
+export type DragEndHandler<T> = (drag: DragDrop<T>, event: MouseEvent, elem: HTMLElement, deltaX: number, deltaY: number) => void;
+export interface DragDropOptions<T> {
+    elem: HTMLElement;
+    onDragStart: DragStartHandler<T>;
+    onDragging: DraggingHandler<T>;
+    onDragEnd: DragEndHandler<T>;
+    data: T;
+    minThreshold?: number;
+    cursor?: string;
+    mouseDownEvent?: MouseEvent;
+}
+export declare const MIN_DISTANCE_THRESHOLD = 3;
+export declare class DragDrop<T> {
+    private options;
+    constructor(options: DragDropOptions<T>);
+    private dragStarted;
+    private mouseDownEvent;
+    private _dragOffsetX;
+    private _dragOffsetY;
+    get data(): T;
+    get dragOffsetX(): number;
+    get dragOffsetY(): number;
+    get dragOffset(): {
+        x: number;
+        y: number;
+    };
+    private trackEvents;
+    private untrackEvents;
+    private bindEvents;
+    private unbindEvents;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private onDragStart;
+    private onDragging;
+    private onDragEnd;
+    destroy(): void;
+}
+export declare function registerDragDrop<T>(options: DragDropOptions<T>): DragDrop<T>;

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

@@ -0,0 +1,7 @@
+interface SelectFileOptions {
+    multiple?: boolean;
+}
+export declare function selectFile<T extends SelectFileOptions = SelectFileOptions>(accept: string, options?: T): Promise<T extends {
+    multiple: true;
+} ? File[] : File>;
+export {};

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

@@ -0,0 +1,2 @@
+export declare function htmlToFragment(html: string): DocumentFragment;
+export declare function fragmentToHtml(fragment: DocumentFragment): string;

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

@@ -0,0 +1,2 @@
+declare const genId: () => string;
+export default genId;

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

@@ -0,0 +1 @@
+export declare function escapeSpace(text: string): string;

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

@@ -0,0 +1 @@
+export declare function escapeHtmlText(dangerousString: string): string;