@linker-design-plus/tiny-peony 1.2.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Linker Design, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/foundation/commandExecutor/commandExecutor.d.ts

@@ -0,0 +1,9 @@
+import { IContentManager, ICursorManager } from '../../typings';
+import { ICommandExecutor } from '../../typings/status/i-command-executor';
+export declare class CommandExecutor extends ICommandExecutor {
+    contentManager: IContentManager;
+    cursorManager: ICursorManager;
+    constructor(_contentManager: IContentManager, _cursorManager: ICursorManager);
+    executeUndo(): void;
+    executeRedo(): void;
+}

package/dist/foundation/contentManager/contentManager.d.ts

@@ -0,0 +1,21 @@
+import { IContentManager, IEditorCore } from '../../typings';
+export declare class ContentManager extends IContentManager {
+    protected _editorElement: HTMLElement;
+    private _editor;
+    constructor(element: HTMLElement, editor: IEditorCore);
+    insertEmptyPara(): void;
+    calcTextCount(): number;
+    getContent(): string;
+    getHtml(): string;
+    setContent(content: string): void;
+    setHtml(content: string): void;
+    appendContent(content: string | string[], cb?: (para: HTMLElement) => void): void;
+    insert(content: string | Node): void;
+    delete(): void;
+    update(content: string | Node): void;
+    getParas(): HTMLElement[];
+    getTextContent(): string[];
+    private _insert;
+    private _delete;
+    private _update;
+}

package/dist/foundation/cursorManager/cursorManager.d.ts

@@ -0,0 +1,14 @@
+import { ICursorManager } from '../../typings';
+export declare class CursorManager extends ICursorManager {
+    private _editorElement;
+    range: Range | undefined;
+    constructor(_element: HTMLDivElement);
+    destroy(): void;
+    private _recordRange;
+    isRangeInEditor(): boolean;
+    isCaret(): boolean;
+    isRange(): boolean;
+    getRangeContent(): string;
+    toEnd(node: Node): void;
+    getRangeTop(): number;
+}

package/dist/foundation/editorManager/editor.d.ts

@@ -0,0 +1,39 @@
+import { ICommandExecutor, IContentManager, ICursorManager, IUndoManager } from '../../typings';
+import { IPlugin } from '../../typings/actions/i-plugin';
+import { IEditorCore } from '../../typings/status/i-editor-manager';
+export type PluginConstructor<T extends IPlugin = IPlugin> = new (editor: IEditorCore) => T;
+export type PluginMap<Plugins extends PluginConstructor[]> = {
+    [K in Plugins[number] as InstanceType<K>['prefix']]: InstanceType<K>;
+};
+export interface EditorCoreOptions<Plugins extends PluginConstructor<IPlugin>[]> {
+    plugins?: Plugins;
+    maxLength: number;
+    onChange?: (contentLength: number) => void;
+    onUndoChange?: (anchorContent: string) => void;
+}
+export declare const PARAGRAPH_CLS: string;
+export declare const PARAGRAPH_EMPTY: string;
+export declare class EditorCore<Plugins extends PluginConstructor[] = []> extends IEditorCore {
+    private _observer;
+    private _onchange?;
+    readonly _editorElement: HTMLElement;
+    readonly _uid: string;
+    content: IContentManager;
+    cursor: ICursorManager;
+    undo: IUndoManager;
+    command: ICommandExecutor;
+    maxLength: number;
+    plugin: PluginMap<Plugins>;
+    constructor(editorElement: HTMLDivElement, options?: EditorCoreOptions<Plugins>);
+    destroy(): void;
+    editorTop(): number;
+    editorLeft(): number;
+    appendContent(content: string | string[]): void;
+    get element(): HTMLElement;
+    private _setup;
+    private _teardown;
+    private _handleBackspace;
+    private _handlePaste;
+    private _handleBeforeInput;
+    private _handleCompositionEnd;
+}

package/dist/foundation/editorManager/maxLength.d.ts

@@ -0,0 +1,4 @@
+import { IEditorCore } from '../../typings';
+export declare const hadnleCompositionEnd: (editor: IEditorCore, event: CompositionEvent) => void;
+export declare const handleBeforeInput: (editor: IEditorCore, event: InputEvent) => void;
+export declare const calcPasteTextLength: (editor: IEditorCore, paragraphs: string[]) => string[];

package/dist/foundation/editorManager/paste.d.ts

@@ -0,0 +1,3 @@
+import { IEditorCore } from '../../typings';
+export declare const handleInsertEndPausationTag: (editor: IEditorCore, elm: HTMLElement) => void;
+export declare const handlePaste: (editor: IEditorCore, paragraphs: string[]) => void;

package/dist/foundation/undoManager/undoManager.d.ts

@@ -0,0 +1,18 @@
+import { IContentManager, IEditorCore } from '../../typings';
+import { HistoryStackItem, IUndoManager } from '../../typings/status/i-undo-manager';
+export declare class UndoManager extends IUndoManager {
+    private _editor;
+    private _onUndoChange?;
+    contentManager: IContentManager;
+    undoStack: HistoryStackItem[];
+    redoStack: HistoryStackItem[];
+    constructor(_editor: IEditorCore, _contentManager: IContentManager, _undoChange?: (anchorContent: string) => void);
+    saveState(): void;
+    undo(): void;
+    redo(): void;
+    private _calcNodePathMatches;
+    private _record;
+    private _handleInput;
+    private _handleUndoOrRedo;
+    private _restoreCursor;
+}

package/dist/index.d.ts

@@ -0,0 +1,367 @@
+import type { App } from 'vue';
+import EditorContainer from './intersection/components/editor';
+export * from './typings/index';
+declare const TinyPeony: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        preTime: {
+            type: StringConstructor;
+            default: string;
+        };
+        realTime: {
+            type: StringConstructor;
+            default: string;
+        };
+        textCount: {
+            type: NumberConstructor;
+            default: number;
+        };
+        listenAnchorId: {
+            type: NumberConstructor;
+            default: number;
+        };
+        listenMode: {
+            type: import("vue").PropType<import("./typings/shared").ListenModeEnum>;
+            default: string;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        simple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLength: {
+            type: NumberConstructor;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        class: {
+            type: (ArrayConstructor | StringConstructor)[];
+            default: () => never[];
+        };
+        contentStyle: {
+            type: import("vue").PropType<import("vue").CSSProperties>;
+            default: () => {};
+        };
+    }>> & Readonly<{
+        onChange?: ((contentLength: number) => any) | undefined;
+        "onUpdate:textCount"?: ((value: number) => any) | undefined;
+        onAnchorListen?: ((value: import("./typings/index").IAnchor, text: string) => any) | undefined;
+        onAnchorRemove?: ((value: import("./typings/index").IAnchor) => any) | undefined;
+        onAnchorListenStop?: ((value: import("./typings/index").IAnchor) => any) | undefined;
+    }>, {
+        action: import("vue").Ref<import("./intersection/hooks/use-editor").EditorAction | undefined, import("./intersection/hooks/use-editor").EditorAction | undefined>;
+        innerRender: () => import("vue/jsx-runtime").JSX.Element;
+        innerGetContent: (_options?: import("./intersection/components/editor/context").ContentOptions) => string;
+        innerSetContent: (content: string) => Promise<void>;
+        innerAppendContent: (content: string | string[]) => Promise<void>;
+        innerGetTextContent: () => string[];
+        innerInsertContent: (content: string | Node) => void;
+        innerDeleteContent: () => void;
+        innerUpdateContent: (content: string | Node) => void;
+        innerIsCaret: () => boolean;
+        innerIsRange: () => boolean;
+        innerIsSelectionInDifferentParas: () => boolean;
+        innerIsSelectionContainsTag: (type: import("./typings/shared").PluginFlag) => boolean;
+        innerGetAnchorTtsMark: (id: number, startFromCursor?: boolean) => string;
+        innerGetAnchorTtsEmotionAndRole: (id: number) => [string, string | undefined];
+        innerIsAllMarkedByAnchor: () => boolean;
+        innerAddExtraAnchors: (data: import("./typings/index").IAnchor[]) => void;
+        innerClearContent: () => void;
+        innerRenderHightlight: (matchingContent: string) => void;
+        innerUnrenderHightlight: () => void;
+    }, {}, {}, {
+        getContent(options?: import("./intersection/components/editor/context").ContentOptions): string;
+        getHtml(options: import("./intersection/components/editor/context").ContentOptions): string;
+        setContent(content: string): Promise<void>;
+        setHtml(content: string): Promise<void>;
+        appendContent(content: string | string[]): Promise<void>;
+        getTextContent(): string[];
+        insertContent(content: string | Node): void;
+        deleteContent(): void;
+        updateContent(content: string | Node): void;
+        isCaret(): boolean;
+        isRange(): boolean;
+        isSelectionInDifferentParas(): boolean;
+        isSelectionContainsTag(type: import("./typings/shared").PluginFlag): boolean;
+        getAnchorTtsMark(id: number, startFromCursor?: boolean): string;
+        getAnchorTtsEmotionAndRole(id: number): [string, string | undefined];
+        isAllMarkedByAnchor(): boolean;
+        addExtraAnchors(data: import("./typings/index").IAnchor[]): void;
+        clearContent(): void;
+        clear(): Promise<void>;
+        renderHighlight(matchingContent: string): void;
+        unrenderHighlight(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (contentLength: number) => true;
+        'update:textCount': (value: number) => true;
+        anchorListen: (value: import("./typings/index").IAnchor, text: string) => true;
+        anchorListenStop: (value: import("./typings/index").IAnchor) => true;
+        anchorRemove: (value: import("./typings/index").IAnchor) => true;
+    }, import("vue").PublicProps, {
+        class: string | unknown[];
+        disabled: boolean;
+        placeholder: string;
+        maxLength: number;
+        showWordLimit: boolean;
+        simple: boolean;
+        preTime: string;
+        realTime: string;
+        textCount: number;
+        listenAnchorId: number;
+        listenMode: import("./typings/shared").ListenModeEnum;
+        contentStyle: import("vue").CSSProperties;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        preTime: {
+            type: StringConstructor;
+            default: string;
+        };
+        realTime: {
+            type: StringConstructor;
+            default: string;
+        };
+        textCount: {
+            type: NumberConstructor;
+            default: number;
+        };
+        listenAnchorId: {
+            type: NumberConstructor;
+            default: number;
+        };
+        listenMode: {
+            type: import("vue").PropType<import("./typings/shared").ListenModeEnum>;
+            default: string;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        simple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLength: {
+            type: NumberConstructor;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        class: {
+            type: (ArrayConstructor | StringConstructor)[];
+            default: () => never[];
+        };
+        contentStyle: {
+            type: import("vue").PropType<import("vue").CSSProperties>;
+            default: () => {};
+        };
+    }>> & Readonly<{
+        onChange?: ((contentLength: number) => any) | undefined;
+        "onUpdate:textCount"?: ((value: number) => any) | undefined;
+        onAnchorListen?: ((value: import("./typings/index").IAnchor, text: string) => any) | undefined;
+        onAnchorRemove?: ((value: import("./typings/index").IAnchor) => any) | undefined;
+        onAnchorListenStop?: ((value: import("./typings/index").IAnchor) => any) | undefined;
+    }>, {
+        action: import("vue").Ref<import("./intersection/hooks/use-editor").EditorAction | undefined, import("./intersection/hooks/use-editor").EditorAction | undefined>;
+        innerRender: () => import("vue/jsx-runtime").JSX.Element;
+        innerGetContent: (_options?: import("./intersection/components/editor/context").ContentOptions) => string;
+        innerSetContent: (content: string) => Promise<void>;
+        innerAppendContent: (content: string | string[]) => Promise<void>;
+        innerGetTextContent: () => string[];
+        innerInsertContent: (content: string | Node) => void;
+        innerDeleteContent: () => void;
+        innerUpdateContent: (content: string | Node) => void;
+        innerIsCaret: () => boolean;
+        innerIsRange: () => boolean;
+        innerIsSelectionInDifferentParas: () => boolean;
+        innerIsSelectionContainsTag: (type: import("./typings/shared").PluginFlag) => boolean;
+        innerGetAnchorTtsMark: (id: number, startFromCursor?: boolean) => string;
+        innerGetAnchorTtsEmotionAndRole: (id: number) => [string, string | undefined];
+        innerIsAllMarkedByAnchor: () => boolean;
+        innerAddExtraAnchors: (data: import("./typings/index").IAnchor[]) => void;
+        innerClearContent: () => void;
+        innerRenderHightlight: (matchingContent: string) => void;
+        innerUnrenderHightlight: () => void;
+    }, {}, {}, {
+        getContent(options?: import("./intersection/components/editor/context").ContentOptions): string;
+        getHtml(options: import("./intersection/components/editor/context").ContentOptions): string;
+        setContent(content: string): Promise<void>;
+        setHtml(content: string): Promise<void>;
+        appendContent(content: string | string[]): Promise<void>;
+        getTextContent(): string[];
+        insertContent(content: string | Node): void;
+        deleteContent(): void;
+        updateContent(content: string | Node): void;
+        isCaret(): boolean;
+        isRange(): boolean;
+        isSelectionInDifferentParas(): boolean;
+        isSelectionContainsTag(type: import("./typings/shared").PluginFlag): boolean;
+        getAnchorTtsMark(id: number, startFromCursor?: boolean): string;
+        getAnchorTtsEmotionAndRole(id: number): [string, string | undefined];
+        isAllMarkedByAnchor(): boolean;
+        addExtraAnchors(data: import("./typings/index").IAnchor[]): void;
+        clearContent(): void;
+        clear(): Promise<void>;
+        renderHighlight(matchingContent: string): void;
+        unrenderHighlight(): void;
+    }, {
+        class: string | unknown[];
+        disabled: boolean;
+        placeholder: string;
+        maxLength: number;
+        showWordLimit: boolean;
+        simple: boolean;
+        preTime: string;
+        realTime: string;
+        textCount: number;
+        listenAnchorId: number;
+        listenMode: import("./typings/shared").ListenModeEnum;
+        contentStyle: import("vue").CSSProperties;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    preTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    realTime: {
+        type: StringConstructor;
+        default: string;
+    };
+    textCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    listenAnchorId: {
+        type: NumberConstructor;
+        default: number;
+    };
+    listenMode: {
+        type: import("vue").PropType<import("./typings/shared").ListenModeEnum>;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    simple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showWordLimit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: (ArrayConstructor | StringConstructor)[];
+        default: () => never[];
+    };
+    contentStyle: {
+        type: import("vue").PropType<import("vue").CSSProperties>;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onChange?: ((contentLength: number) => any) | undefined;
+    "onUpdate:textCount"?: ((value: number) => any) | undefined;
+    onAnchorListen?: ((value: import("./typings/index").IAnchor, text: string) => any) | undefined;
+    onAnchorRemove?: ((value: import("./typings/index").IAnchor) => any) | undefined;
+    onAnchorListenStop?: ((value: import("./typings/index").IAnchor) => any) | undefined;
+}>, {
+    action: import("vue").Ref<import("./intersection/hooks/use-editor").EditorAction | undefined, import("./intersection/hooks/use-editor").EditorAction | undefined>;
+    innerRender: () => import("vue/jsx-runtime").JSX.Element;
+    innerGetContent: (_options?: import("./intersection/components/editor/context").ContentOptions) => string;
+    innerSetContent: (content: string) => Promise<void>;
+    innerAppendContent: (content: string | string[]) => Promise<void>;
+    innerGetTextContent: () => string[];
+    innerInsertContent: (content: string | Node) => void;
+    innerDeleteContent: () => void;
+    innerUpdateContent: (content: string | Node) => void;
+    innerIsCaret: () => boolean;
+    innerIsRange: () => boolean;
+    innerIsSelectionInDifferentParas: () => boolean;
+    innerIsSelectionContainsTag: (type: import("./typings/shared").PluginFlag) => boolean;
+    innerGetAnchorTtsMark: (id: number, startFromCursor?: boolean) => string;
+    innerGetAnchorTtsEmotionAndRole: (id: number) => [string, string | undefined];
+    innerIsAllMarkedByAnchor: () => boolean;
+    innerAddExtraAnchors: (data: import("./typings/index").IAnchor[]) => void;
+    innerClearContent: () => void;
+    innerRenderHightlight: (matchingContent: string) => void;
+    innerUnrenderHightlight: () => void;
+}, {}, {}, {
+    getContent(options?: import("./intersection/components/editor/context").ContentOptions): string;
+    getHtml(options: import("./intersection/components/editor/context").ContentOptions): string;
+    setContent(content: string): Promise<void>;
+    setHtml(content: string): Promise<void>;
+    appendContent(content: string | string[]): Promise<void>;
+    getTextContent(): string[];
+    insertContent(content: string | Node): void;
+    deleteContent(): void;
+    updateContent(content: string | Node): void;
+    isCaret(): boolean;
+    isRange(): boolean;
+    isSelectionInDifferentParas(): boolean;
+    isSelectionContainsTag(type: import("./typings/shared").PluginFlag): boolean;
+    getAnchorTtsMark(id: number, startFromCursor?: boolean): string;
+    getAnchorTtsEmotionAndRole(id: number): [string, string | undefined];
+    isAllMarkedByAnchor(): boolean;
+    addExtraAnchors(data: import("./typings/index").IAnchor[]): void;
+    clearContent(): void;
+    clear(): Promise<void>;
+    renderHighlight(matchingContent: string): void;
+    unrenderHighlight(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (contentLength: number) => true;
+    'update:textCount': (value: number) => true;
+    anchorListen: (value: import("./typings/index").IAnchor, text: string) => true;
+    anchorListenStop: (value: import("./typings/index").IAnchor) => true;
+    anchorRemove: (value: import("./typings/index").IAnchor) => true;
+}, string, {
+    class: string | unknown[];
+    disabled: boolean;
+    placeholder: string;
+    maxLength: number;
+    showWordLimit: boolean;
+    simple: boolean;
+    preTime: string;
+    realTime: string;
+    textCount: number;
+    listenAnchorId: number;
+    listenMode: import("./typings/shared").ListenModeEnum;
+    contentStyle: import("vue").CSSProperties;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    install: (app: App, options?: Record<string, any>) => void;
+} & {
+    install: (app: App) => void;
+};
+export type TinyPeonyInstance = InstanceType<typeof EditorContainer>;
+export default TinyPeony;