@opentiny/fluent-editor 3.20.2 → 3.20.4-alpha.0

package/types/custom-image/Options.d.ts

@@ -0,0 +1,36 @@
+export interface OverlayOptions {
+    className: string;
+    style: Record<string, string>;
+}
+export interface ResizeOptions {
+    handleClassName: string;
+    handleStyle: Record<string, string>;
+}
+export interface AlignOptions {
+    attribute: string;
+    aligner: {
+        applyStyle: boolean;
+    };
+    icons: {
+        left: string;
+        center: string;
+        right: string;
+    };
+    toolbar: {
+        allowDeselect: boolean;
+        mainClassName: string;
+        mainStyle: any;
+        buttonClassName: string;
+        addButtonSelectStyle: boolean;
+        buttonStyle: any;
+        svgStyle: any;
+    };
+}
+export interface Options {
+    specs: any;
+    overlay: OverlayOptions;
+    align: AlignOptions;
+    resize: ResizeOptions;
+}
+declare const DefaultOptions: Options;
+export default DefaultOptions;

package/types/custom-image/actions/Action.d.ts

@@ -0,0 +1,7 @@
+export default class Action {
+    formatter: any;
+    constructor(formatter: any);
+    onCreate(): void;
+    onDestroy(): void;
+    onUpdate(): void;
+}

package/types/custom-image/actions/CustomResizeAction.d.ts

@@ -0,0 +1,24 @@
+import { default as Action } from './Action';
+
+export default class CustomResizeAction extends Action {
+    topLeftHandle: HTMLElement;
+    topRightHandle: HTMLElement;
+    bottomRightHandle: HTMLElement;
+    bottomLeftHandle: HTMLElement;
+    dragHandle: HTMLElement;
+    dragStartX: number;
+    preDragWidth: number;
+    targetRatio: number;
+    maxWidth: number;
+    minWidth: number;
+    constructor(formatter: any);
+    onCreate(): void;
+    onDestroy(): void;
+    createHandle(position: string, cursor: string): HTMLElement;
+    repositionHandles(handleStyle: any): void;
+    setCursor(value: string): void;
+    onMouseDown: (event: MouseEvent) => void;
+    findTd: (node: HTMLElement, level: number) => any;
+    onDrag: (event: MouseEvent) => void;
+    onMouseUp: () => void;
+}

package/types/custom-image/actions/DeleteAction.d.ts

@@ -0,0 +1,7 @@
+import { default as Action } from './Action';
+
+export default class DeleteAction extends Action {
+    onCreate(): void;
+    onDestroy(): void;
+    onKeyUp: (event: any) => void;
+}

package/types/custom-image/image.d.ts

@@ -0,0 +1,28 @@
+declare const Embed: unknown;
+declare const Inline: unknown;
+declare class CustomImage extends Embed {
+    static ID_SEED: number;
+    static blotName: string;
+    static tagName: string;
+    domNode: any;
+    parent: any;
+    scroll: any;
+    next: any;
+    static create(value: any): any;
+    static formats(domNode: any): {};
+    static match(url: any): boolean;
+    static register(): void;
+    static sanitize(url: any): any;
+    static value(domNode: any): any;
+    format(name: any, value: any): void;
+    unWrap(): void;
+    wrap(name: any, value: any): any;
+}
+declare class CustomImageContainer extends Inline {
+    static tagName: string;
+    static className: string;
+    static blotName: string;
+    static allowedChildren: typeof CustomImage[];
+    constructor(scroll: any, domNode: any);
+}
+export { CustomImage as default, CustomImageContainer as ImageContainerBlot };

package/types/custom-image/specs/BlotSpec.d.ts

@@ -0,0 +1,13 @@
+import { default as ResizeAction } from '../actions/CustomResizeAction';
+import { default as DeleteAction } from '../actions/DeleteAction';
+
+export default class BlotSpec {
+    formatter: any;
+    constructor(formatter: any);
+    init(): void;
+    getActions(): (typeof ResizeAction | typeof DeleteAction)[];
+    getTargetElement(): any;
+    getOverlayElement(): any;
+    setSelection(): void;
+    onHide(): void;
+}

package/types/custom-image/specs/CustomImageSpec.d.ts

@@ -0,0 +1,21 @@
+import { default as CustomResizeAction } from '../actions/CustomResizeAction';
+import { default as DeleteAction } from '../actions/DeleteAction';
+import { default as ImageSpec } from './ImageSpec';
+
+export declare class CustomImageSpec extends ImageSpec {
+    formatter: any;
+    editorElem: HTMLElement | undefined;
+    observer: any;
+    oldRootScrollTop: any;
+    constructor(formatter: any);
+    handleQuillRootScroll(): void;
+    init(): void;
+    getActions(): (typeof CustomResizeAction | typeof DeleteAction)[];
+    imageMouseOver(event: any): void;
+    imageMouseout: (event: any) => void;
+    addImagePreviewOverlay(event: any): void;
+    removeImagePreviewOverlay(): void;
+    onHide(): void;
+    resetOverlayMarginTop(): void;
+    onClick: (event: MouseEvent) => void;
+}

package/types/custom-image/specs/ImageSpec.d.ts

@@ -0,0 +1,10 @@
+import { default as BlotSpec } from './BlotSpec';
+
+export default class ImageSpec extends BlotSpec {
+    img: any;
+    constructor(formatter: any);
+    init(): void;
+    getTargetElement(): any;
+    onHide(): void;
+    onClick: (event: MouseEvent) => void;
+}

package/types/custom-uploader.d.ts

@@ -0,0 +1,30 @@
+import { Range } from 'quill/core/quill';
+
+interface InsertFileData {
+    code: number;
+    message?: string;
+    data: {
+        title: string;
+        size: number;
+        src: string;
+    };
+}
+declare const Uploader: unknown;
+declare class CustomUploader extends Uploader {
+    quill: any;
+    options: any;
+    upload(range: any, files: any, isFile?: any): void;
+    isAllowedFileType: (accept: Array<string> | string, file: File) => boolean;
+    handleUploadFile(range: any, files: any, _hasRejectedFile: any): void;
+    insertFileToEditor(range: Range, file: File, { code, message, data }: InsertFileData): void;
+    insertImageToEditor(range: any, { code, message, data }: {
+        code: any;
+        message: any;
+        data: any;
+    }): void;
+    handleUploadImage(range: any, { file, files }: {
+        file: any;
+        files: any;
+    }, hasRejectedImage: any): void;
+}
+export default CustomUploader;

package/types/emoji/emoji-list/index.d.ts

@@ -0,0 +1 @@
+export { peopleEmoji } from './people';

package/types/emoji/emoji-list/people.d.ts

@@ -0,0 +1 @@
+export declare const peopleEmoji: any[];

package/types/emoji/emoji-list.d.ts

@@ -0,0 +1,2 @@
+declare const emojiList: any[];
+export default emojiList;

package/types/emoji/emoji-map.d.ts

@@ -0,0 +1,2 @@
+declare const emojiMap: {};
+export default emojiMap;

package/types/emoji/formats/emoji-blot.d.ts

@@ -0,0 +1,13 @@
+declare const Embed: unknown;
+declare class EmojiBlot extends Embed {
+    static emojiClass: string;
+    static emojiPrefix: any;
+    static tagName: string;
+    static blotName: string;
+    static className: string;
+    static create(value: any): any;
+    static value(node: any): any;
+    static buildSpan(value: any, node: any): void;
+    static parseUnicode(string: any): any;
+}
+export default EmojiBlot;

package/types/emoji/index.d.ts

@@ -0,0 +1,10 @@
+import { default as EmojiBlot } from './formats/emoji-blot';
+import { default as ShortNameEmoji } from './modules/emoji';
+import { default as ToolbarEmoji } from './modules/toolbar-emoji';
+
+declare const _default: {
+    EmojiBlot: typeof EmojiBlot;
+    ShortNameEmoji: typeof ShortNameEmoji;
+    ToolbarEmoji: typeof ToolbarEmoji;
+};
+export default _default;

package/types/emoji/modules/emoji.d.ts

@@ -0,0 +1,38 @@
+declare const Module: unknown;
+declare class ShortNameEmoji extends Module {
+    static DEFAULTS: {
+        emojiList: any[];
+        fuse: {
+            shouldSort: boolean;
+            threshold: number;
+            location: number;
+            distance: number;
+            maxPatternLength: number;
+            minMatchCharLength: number;
+            keys: string[];
+        };
+    };
+    emojiList: any;
+    quill: any;
+    fuse: any;
+    onOpen: any;
+    onClose: any;
+    container: HTMLUListElement;
+    onSelectionChange: any;
+    onTextChange: any;
+    open: boolean;
+    atIndex: any;
+    focusedButton: any;
+    isWhiteSpace: (ch: any) => boolean;
+    query: any;
+    buttons: any;
+    options: any;
+    constructor(quill: any, options: any);
+    triggerPicker(range: any, _context: any): boolean;
+    handleArrow(): boolean;
+    update(event: any): void;
+    maybeUnfocus(): void;
+    renderCompletions(emojis: any, evt: any): void;
+    close(value: any, trailingDelete?: number): void;
+}
+export default ShortNameEmoji;

package/types/emoji/modules/toolbar-emoji.d.ts

@@ -0,0 +1,8 @@
+declare const Module: unknown;
+declare class ToolbarEmoji extends Module {
+    quill: any;
+    toolbar: any;
+    constructor(quill: any, options: any);
+    checkPalatteExist(): void;
+}
+export default ToolbarEmoji;

package/types/emoji/utils.d.ts

@@ -0,0 +1 @@
+export declare function createEmoji(emojiArr: any): any[];

package/types/file/formats/file.d.ts

@@ -0,0 +1,15 @@
+declare const Embed: unknown;
+declare class File extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    static PROTOCOL_WHITELIST: string[];
+    statics: any;
+    domNode: any;
+    static create(value: any): any;
+    static value(domNode: any): any;
+    static formats(domNode: any): any;
+    static getFormats(domNode: any): any;
+    static sanitize(url: any): any;
+}
+export default File;

package/types/file/index.d.ts

@@ -0,0 +1,11 @@
+import { default as FileBar } from './modules/file-bar';
+
+declare const Module: unknown;
+declare class FileModule extends Module {
+    quill: any;
+    fileBar: FileBar;
+    static register(): void;
+    constructor(quill: any, options: any);
+    clickEvent(event: any): void;
+}
+export default FileModule;

package/types/file/modules/file-bar.d.ts

@@ -0,0 +1,14 @@
+export default class FileBar {
+    quill: any;
+    file: any;
+    domNode: HTMLElement;
+    fileRange: any;
+    template: string;
+    constructor(quill: any, target: any);
+    createFileBar(): void;
+    destroy(): void;
+    operateFile(event: any, operate: any): void;
+    setPosition(): void;
+    css(domNode: any, rules: any): void;
+    formatDate(timestamp: any): string;
+}

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 {};