@opentiny/fluent-editor 3.20.3 → 3.21.0

package/types/fluent-editor.d.ts

@@ -0,0 +1,9 @@
+import { IEditorConfig } from './config/types';
+import { default as Quill } from 'quill';
+
+export declare class FluentEditor extends Quill {
+    isFullscreen: boolean;
+    constructor(container: HTMLElement | string, options?: IEditorConfig);
+}
+declare const _default: typeof FluentEditor;
+export default _default;

package/types/format-painter/index.d.ts

@@ -0,0 +1,15 @@
+import { default as Toolbar } from 'quill/modules/toolbar';
+
+interface FormatData {
+    formatPainter: {
+        rangeFormat: Record<string, any>;
+        isFormatterLock: boolean;
+        isFormating: boolean;
+        prepareLock: boolean;
+    };
+}
+export declare function FormatPainter(this: Toolbar & FormatData): void;
+export declare namespace FormatPainter {
+    var toolName: string;
+}
+export {};

package/types/fullscreen/handler.d.ts

@@ -0,0 +1,3 @@
+import { FluentEditorToolbar } from '../config/types';
+
+export declare function fullscreenHandler(this: FluentEditorToolbar): void;

package/types/global-link/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ON_WIKI_LINK_REMOVE = "wiki-link/remove";
+export declare const ON_DOC_LINK_REMOVE = "doc-link/remove";
+export declare const ON_WORK_ITEM_LINK_REMOVE = "work-item-link/remove";

package/types/global-link/formats/customer-widget-link.d.ts

@@ -0,0 +1,14 @@
+declare const BlockEmbed: unknown;
+declare class CustomerWidgetLink extends BlockEmbed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    static create(value: any): any;
+    static value(domNode: any): {
+        type: any;
+        id: any;
+        value: any;
+    };
+    constructor(scroll: any, domNode: any, data: any);
+}
+export default CustomerWidgetLink;

package/types/global-link/formats/doc-link.d.ts

@@ -0,0 +1,17 @@
+declare const Embed: unknown;
+declare class DocumentLink extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    docData: any;
+    scroll: any;
+    static create(value: any): any;
+    static value(domNode: any): {
+        link: any;
+        icon: any;
+        text: any;
+    };
+    constructor(scroll: any, domNode: any, data: any);
+    remove(): any;
+}
+export default DocumentLink;

package/types/global-link/formats/wiki-link.d.ts

@@ -0,0 +1,16 @@
+declare const Embed: unknown;
+declare class WikiLink extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    wikiData: any;
+    scroll: any;
+    static create(value: any): any;
+    static value(domNode: any): {
+        link: any;
+        text: any;
+    };
+    constructor(scroll: any, domNode: any, data: any);
+    remove(): any;
+}
+export default WikiLink;

package/types/global-link/formats/work-item-link.d.ts

@@ -0,0 +1,16 @@
+declare const BlockEmbed: unknown;
+declare class WorkItemLink extends BlockEmbed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    workItemData: any;
+    scroll: any;
+    static create(value: any): any;
+    static value(domNode: any): {
+        link: any;
+        data: any;
+    };
+    constructor(scroll: any, domNode: any, data: any);
+    remove(): any;
+}
+export default WorkItemLink;

package/types/global-link/global-link-panel.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '@angular/core';
+
+interface WikiLink {
+    link: string;
+    text: string;
+}
+interface DocLink {
+    link: string;
+    text: string;
+    icon: string;
+}
+export interface GlobalLinkPanel {
+    wikiLink: EventEmitter<WikiLink[]>;
+    docLink: EventEmitter<DocLink[]>;
+    workItemLink: EventEmitter<any>;
+    close?: EventEmitter<any>;
+    autoClose?: boolean;
+}
+export {};

package/types/global-link/index.d.ts

@@ -0,0 +1,18 @@
+declare const Module: unknown;
+declare class GlobalLink extends Module {
+    open: boolean;
+    wrap: any;
+    panel: any;
+    quill: any;
+    static register(): void;
+    constructor(quill: any, options: any);
+    onEditorClick(evt: any): void;
+    handleLinkClick(linkNode: any): void;
+    handleGlobalLinkButtonClick(_value: any): void;
+    triggerPanel(): void;
+    addWikiLink(wikiData: any): void;
+    addDocLink(docData: any): void;
+    addWorkItemLink(workItemData: any): void;
+    closePanel(): void;
+}
+export default GlobalLink;

package/types/global-link/utils/createTable.d.ts

@@ -0,0 +1 @@
+export declare function createTable(data: any[]): HTMLTableElement;

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import { default as FluentEditor } from './fluent-editor';
+
+export * from './config';
+export default FluentEditor;

package/types/link/formats/link.d.ts

@@ -0,0 +1,16 @@
+import { default as TypeInline } from 'quill/blots/inline';
+
+declare const Inline: typeof TypeInline;
+export default class Link extends Inline {
+    static blotName: string;
+    static tagName: string;
+    static SANITIZED_URL: string;
+    static PROTOCOL_WHITELIST: string[];
+    static className: string;
+    static autoProtocol: string;
+    static create(value: any): HTMLElement;
+    static formats(domNode: any): any;
+    static sanitize(url: any): any;
+    format(name: any, value: any): void;
+}
+export {};

package/types/link/index.d.ts

@@ -0,0 +1,6 @@
+declare const Module: typeof import('quill/core/module').default;
+declare class Link extends Module {
+    static register(): void;
+    constructor(quill: any, options: any);
+}
+export default Link;

package/types/link/modules/tooltip.d.ts

@@ -0,0 +1,32 @@
+import { BaseTooltip } from 'quill/themes/base';
+
+export default class Tooltip extends BaseTooltip {
+    static TEMPLATE: string;
+    isInputFocus: boolean;
+    isHover: boolean;
+    debouncedHideToolTip: any;
+    debouncedShowToolTip: any;
+    hide: any;
+    linkRange: any;
+    quill: any;
+    root: any;
+    restoreFocus: any;
+    textbox: any;
+    boundsContainer: any;
+    options: {
+        autoProtocol: string;
+    };
+    constructor(quill: any, bounds: any);
+    resolveOptions(): void;
+    shouldHide(): boolean;
+    hideToolTip(): void;
+    showToolTip(name: any, value: any, range: any): void;
+    handleMouseLeave(): void;
+    handleMouseEnter(event: any): void;
+    listen(): void;
+    save(): void;
+    position(reference: any): number;
+    edit(mode: string, preview: any, range: any): void;
+    show(): void;
+    addHttpProtocol(url: string): string;
+}

package/types/mention/Mention.d.ts

@@ -0,0 +1,56 @@
+import { default as Quill } from 'quill';
+
+interface MentionOption {
+    containerClass?: string;
+    dataAttributes?: string[];
+    defaultLink?: string;
+    itemActiveClass?: string;
+    itemKey: string;
+    itemClass?: string;
+    listClass?: string;
+    listHideClass?: string;
+    maxHeight?: number;
+    mentionChar?: string;
+    remove?: (data: any) => void;
+    renderMentionItem?: (data: any) => string | HTMLElement;
+    renderMentionText?: (data: any) => string | HTMLElement;
+    search?: (term: string) => Promise<any[]>;
+    searchKey: string;
+    select?: (data: any) => void;
+    target?: string;
+}
+declare class Mention {
+    private quill;
+    private readonly options;
+    private readonly mentionListEL;
+    private activeMentionIndex;
+    private latestMentionList;
+    private latestMentionCharPos;
+    private latestCaretPos;
+    private searchTerm;
+    private needInsertBr;
+    private readonly defaultOptions;
+    static register(): void;
+    constructor(quill: Quill, options: MentionOption);
+    on(eventName: any, callback: any): void;
+    getMentionItemIndex(itemEl: Element): unknown;
+    handleTextChange: (_delta: any, _oldDelta: any, source: any) => void;
+    handleMouseClick(_itemEl: HTMLLIElement, index: number): void;
+    handleMouseEnter(_itemEl: HTMLLIElement, index: number): void;
+    handleArrowUpKey: () => boolean;
+    handleArrowDownKey: () => boolean;
+    handleEnterKey: () => boolean;
+    handleEscapeKey: () => boolean;
+    getActiveMentionItem(): Element;
+    isOpen(): boolean;
+    searchMentionListByTerm(term: string): Promise<void>;
+    showMentionList(mentionList: any[]): void;
+    hideMentionList(): void;
+    setMentionListPos(): void;
+    render(mentionList: any[]): void;
+    highlightMentionItem(index: number): void;
+    scrollIntoView(node: Element): void;
+    selectMentionItem(index?: number, isClick?: boolean): void;
+    insertMentionBlot(activeMentionItem: any, isClick?: boolean): void;
+}
+export { Mention as default };

package/types/mention/MentionLink.d.ts

@@ -0,0 +1,18 @@
+declare const Embed: unknown;
+declare class MentionLink extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    scroll: any;
+    mentionData: any;
+    static create(data: any): any;
+    static value(domNode: any): {
+        char: any;
+        text: any;
+        name: any;
+    };
+    constructor(scroll: any, domNode: any, data: any);
+    value(): any;
+    remove(): any;
+}
+export { MentionLink as default };

package/types/mention/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ON_MENTION_LINK_REMOVE = "mention-link/remove";
+export declare const MENTION_CHAR = "mentionChar";
+export declare const DEFAULT_MENTION_CHAR = "@";

package/types/quick-menu/index.d.ts

@@ -0,0 +1,22 @@
+import { default as Quill } from 'quill';
+
+interface QuickMenuOptions {
+    container: string;
+    component: any;
+}
+declare class QuickMenu {
+    private quill;
+    private options;
+    private container;
+    private hostElement;
+    private quickMenu;
+    private quickMenuContainer;
+    constructor(quill: Quill, options: QuickMenuOptions);
+    handleSlashKeyDown: (_range: any, context: any) => void;
+    private isOpen;
+    hideQuickMenu: (event: any) => void;
+    handleArrowUpKey: (_range: any, _context: any) => boolean;
+    handleArrowDownKey: (_range: any, _context: any) => boolean;
+    handleEnterKey: (_range: any, _context: any) => boolean;
+}
+export default QuickMenu;

package/types/screenshot/index.d.ts

@@ -0,0 +1,20 @@
+import { default as html2canvas, Options as Html2CanvasOptions } from 'html2canvas';
+import { default as Toolbar } from 'quill/modules/toolbar';
+
+export type ScreenShotOptions = Partial<Html2CanvasOptions> & {
+    Html2Canvas: typeof html2canvas;
+    beforeCreateCanvas: () => void | Promise<void>;
+    beforeCreateImage: (canvas: HTMLCanvasElement) => HTMLCanvasElement | string | Promise<HTMLCanvasElement | string>;
+};
+interface ScreenShotOptionsInQuill {
+    quill: {
+        options: {
+            screenshot: Partial<ScreenShotOptions>;
+        };
+    };
+}
+export declare function Screenshot(this: Toolbar & ScreenShotOptionsInQuill): void;
+export declare namespace Screenshot {
+    var toolName: string;
+}
+export {};

package/types/soft-break/index.d.ts

@@ -0,0 +1,14 @@
+declare const Embed: unknown;
+declare class SoftBreak extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    domNode: any;
+    prev: any;
+    next: any;
+    remove: () => void;
+    static create(): any;
+    optimize(): void;
+    length(): number;
+}
+export default SoftBreak;

package/types/strike/index.d.ts

@@ -0,0 +1,7 @@
+declare const Inline: unknown;
+declare class StrikeBlot extends Inline {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+}
+export default StrikeBlot;

package/types/syntax/index.d.ts

@@ -0,0 +1,14 @@
+import { default as TypeSyntax } from 'quill/modules/syntax';
+
+declare const Syntax: typeof TypeSyntax;
+declare class CustomSyntax extends Syntax {
+    static DEFAULTS: {
+        hljs: any;
+        interval: number;
+        languages: {
+            key: string;
+            label: string;
+        }[];
+    };
+}
+export default CustomSyntax;

package/types/table/better-table.d.ts

@@ -0,0 +1,27 @@
+import { default as TableColumnTool } from './modules/table-column-tool';
+import { default as TableScrollBar } from './modules/table-scroll-bar';
+
+declare const Module: unknown;
+declare class BetterTable extends Module {
+    static keyboardBindings: any;
+    isComposition: boolean;
+    quill: any;
+    table: any;
+    modulesContainer: any;
+    tableSelection: any;
+    subscriber: any;
+    tableOperationMenu: any;
+    columnTool: TableColumnTool;
+    tableScrollBar: TableScrollBar;
+    static register(): void;
+    constructor(quill: any, options: any);
+    handleMouseDown(evt: any, quill: any): void;
+    handleKeyDown(evt: any, quill: any): void;
+    handleCompositionstart(quill: any): void;
+    handleCompositionend(quill: any): void;
+    getTable(range?: any): any[];
+    insertTable(rows: any, columns: any): void;
+    showTableTools(table: any, quill: any): void;
+    hideTableTools(): void;
+}
+export default BetterTable;

package/types/table/formats/header.d.ts

@@ -0,0 +1,22 @@
+declare const Block: unknown;
+declare class Header extends Block {
+    static tagName: any;
+    static blotName: string;
+    domNode: any;
+    replaceWith: any;
+    parent: any;
+    wrap: any;
+    enforceAllowedChildren: any;
+    uiNode: any;
+    children: any;
+    statics: any;
+    appendChild: any;
+    remove: any;
+    cache: Record<string, any>;
+    scroll: any;
+    static create(value: any): any;
+    static formats(domNode: any): any;
+    format(name: any, value: any): void;
+    optimize(_context: any): void;
+}
+export default Header;

package/types/table/formats/list.d.ts

@@ -0,0 +1,34 @@
+declare const Block: unknown;
+declare const Container: unknown;
+declare class ListContainer extends Container {
+    static allowedChildren: any;
+    static blotName: string;
+    static tagName: string;
+    replaceWith: any;
+    domNode: any;
+    parent: any;
+    statics: any;
+    wrap: any;
+    format(name: any, value: any): void;
+}
+declare class ListItem extends Block {
+    static blotName: string;
+    static tagName: string;
+    static requiredContainer: typeof ListContainer;
+    statics: any;
+    attachUI: any;
+    domNode: any;
+    replaceWith: any;
+    parent: any;
+    wrap: any;
+    children: any;
+    prev: any;
+    remove: () => void;
+    static create(value: any): any;
+    static formats(domNode: any): any;
+    static register(): void;
+    constructor(scroll: any, domNode: any);
+    format(name: any, value: any): void;
+    optimize(context: any): void;
+}
+export { ListContainer, ListItem as default };

package/types/table/formats/table.d.ts

@@ -0,0 +1,147 @@
+import { CELL_ATTRIBUTES, CELL_IDENTITY_KEYS } from '../table-config';
+
+declare const Block: unknown;
+declare const Container: unknown;
+declare class TableCellLine extends Block {
+    static requiredContainer: any;
+    static tagName: string;
+    static className: string;
+    static blotName: any;
+    domNode: any;
+    statics: any;
+    wrap: any;
+    parent: any;
+    static create(value: any): any;
+    static formats(domNode: any): Record<string, any>;
+    toggleAttribute(name: any, value: any): void;
+    formatChildren(name: any, value: any): void;
+    format(name: any, value: any): void;
+    optimize(context: any): void;
+    tableCell(): any;
+}
+declare class TableCell extends Container {
+    static allowedChildren: any;
+    static blotName: any;
+    static requiredContainer: any;
+    static tagName: string;
+    next: any;
+    children: any;
+    parent: any;
+    domNode: any;
+    statics: any;
+    wrap: any;
+    splitAfter: any;
+    prev: any;
+    scroll: any;
+    static create(value?: {
+        row: string;
+    }): any;
+    static formats(domNode: any): {
+        height: any;
+        row: any;
+    };
+    checkMerge(): boolean;
+    cellOffset(): any;
+    formats(): {};
+    toggleAttribute(name: any, value: any): void;
+    formatChildren(name: any, value: any): void;
+    /**
+     * this method is for TableCellLine to change cell background color
+     *  if use `format('cell-bg', value)` will loop trigger
+     *  TableCellLine.optimize -> TableCell.format -> TableCellLine.optimize ...
+     */
+    setCellBg(value?: string): void;
+    format(name: any, value: any): void;
+    optimize(context: any): void;
+    getFormat(domNode: any): Record<string, any>;
+    row(): any;
+    rowOffset(): any;
+    table(): any;
+}
+declare class TableRow extends Container {
+    static requiredContainer: any;
+    static allowedChildren: any;
+    static blotName: string;
+    static tagName: string;
+    next: any;
+    children: any;
+    domNode: any;
+    statics: any;
+    wrap: any;
+    splitAfter: any;
+    enforceAllowedChildren: any;
+    uiNode: any;
+    parent: any;
+    prev: any;
+    static create(value: any): any;
+    checkMerge(): boolean;
+    formats(): {};
+    format(key: any, value: any): void;
+    optimize(context: any): void;
+    rowOffset(): any;
+    table(): any;
+}
+declare class TableBody extends Container {
+    static requiredContainer: any;
+    static allowedChildren: any;
+    static blotName: string;
+    static tagName: string;
+}
+declare class TableCol extends Block {
+    static requiredContainer: any;
+    static blotName: string;
+    static tagName: string;
+    domNode: any;
+    static create(value: any): any;
+    static formats(domNode: any): {};
+    format(name: any, value: any): void;
+    html(): any;
+}
+declare class TableColGroup extends Container {
+    static requiredContainer: any;
+    static allowedChildren: any;
+    static blotName: string;
+    static tagName: string;
+    parent: any;
+    statics: any;
+    optimize(context: any): void;
+    findTdColspanInTbody(tbody: any, trId: any): number;
+}
+declare class TableContainer extends Container {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+    static requiredContainer: any;
+    static allowedChildren: any;
+    domNode: any;
+    parent: any;
+    children: any;
+    descendants: any;
+    scroll: any;
+    remove: any;
+    static create(): any;
+    constructor(scroll: any, domNode: any);
+    updateTableWidth(): void;
+    cells(column: any): any;
+    colGroup(): any;
+    deleteColumns(compareRect: any, delIndexes: any[], editorWrapper: any): boolean;
+    deleteRow(compareRect: any, editorWrapper: any): void;
+    tableDestroy(): void;
+    insertCell(tableRow: any, ref: any, bg?: string): void;
+    insertColumn(compareRect: any, colIndex: any, isRight: boolean, editorWrapper: any): any[];
+    insertRow(compareRect: any, isDown: any, editorWrapper: any): any[];
+    mergeCells(_compareRect: any, mergingCells: any, rowspan: any, colspan: any, _editorWrapper: any): any;
+    unmergeCells(unmergingCells: any, editorWrapper: any): void;
+    emptyCells(selectedTds: any): void;
+    rows(): any;
+}
+declare class TableViewWrapper extends Container {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    static allowedChildren: any;
+    constructor(scroll: any, domNode: any);
+}
+declare function rowId(): string;
+declare function cellId(): string;
+export { CELL_ATTRIBUTES, CELL_IDENTITY_KEYS, cellId, rowId, TableBody, TableCell, TableCellLine, TableCol, TableColGroup, TableContainer, TableRow, TableViewWrapper, };

package/types/table/modules/table-column-tool.d.ts

@@ -0,0 +1,23 @@
+export default class TableColumnTool {
+    table: any;
+    quill: any;
+    modulesContainer: any;
+    domNode: any;
+    columnCtrlPanel: HTMLDivElement;
+    leftMask: HTMLDivElement;
+    rowCtrlPanel: HTMLDivElement;
+    activeToolCell: HTMLElement;
+    oldRootScrollTop: any;
+    constructor(table: any, quill: any, dom: any);
+    handleQuillRootScroll(): void;
+    initColTool(): void;
+    createToolCell(isRow: any): HTMLDivElement;
+    updateColToolCells(): void;
+    updateRowToolCells(): void;
+    destroy(): any;
+    addRowCellSelectHandler(cell: any): void;
+    addRowCellHolderHandler(cell: any): void;
+    addColCellSelectHandler(cell: any): void;
+    addColCellHolderHandler(cell: any): void;
+    colToolCells(): unknown[];
+}

package/types/table/modules/table-operation-menu.d.ts

@@ -0,0 +1,32 @@
+export default class TableOperationMenu {
+    tableSelection: any;
+    table: any;
+    quill: any;
+    options: any;
+    menuItems: any;
+    tableColumnTool: any;
+    tableScrollBar: any;
+    boundary: any;
+    selectedTds: any;
+    destroyHandler: any;
+    columnToolCells: any;
+    colorSubTitle: any;
+    cellColors: any;
+    domNode: any;
+    constructor(params: any, quill: any, options: any);
+    mount(): void;
+    destroy(): any;
+    menuInitial({ cell, left, top }: {
+        cell: any;
+        left: any;
+        top: any;
+    }): void;
+    colorsItemCreator(colors: any): HTMLDivElement;
+    menuItemCreator({ text }: {
+        text: any;
+    }): HTMLDivElement;
+    onCopy(operation: any): void;
+    createVirtualTable(selectedTds: any, _operation: any): any;
+    setCopyRange(selectedNodes: any): void;
+    groupTableCell(selectedTds: any): any[];
+}