@naersen/tts-rich-text 0.1.0

package/dist/components/tts-rich-text/editor/useEditorToolbar.d.ts

@@ -0,0 +1,33 @@
+import { ComputedRef } from 'vue';
+import { ToolConfig } from './config';
+import { RichTextEditor } from './useRichTextEditor';
+type ToolbarTool = (typeof ToolConfig)[keyof typeof ToolConfig];
+export type ToolbarItem = {
+    tool: ToolbarTool;
+    disabled?: () => boolean;
+    onClick?: () => void;
+};
+type UseEditorToolbarOptions = {
+    editorContext: RichTextEditor;
+    openModal: {
+        pinyin: (text: string) => void;
+        replace: (text: string) => void;
+        formula: (text: string) => void;
+        aiRewrite: () => void;
+        upload: () => void;
+    };
+};
+export declare const useEditorToolbar: ({ editorContext, openModal }: UseEditorToolbarOptions) => {
+    toolList: ComputedRef<ToolbarItem[]>;
+    languageOptions: ComputedRef<readonly import('../../..').LanguageOption[]>;
+    numberToTextList: ComputedRef<{
+        label: string;
+        value: string;
+    }[]>;
+    isToolDisabled: (toolItem: ToolbarItem) => boolean;
+    insertCustomStop: (time: number) => void;
+    setLanguage: (code: string) => boolean;
+    replaceText: (text: string) => void;
+    markPinyin: (text: string) => void;
+};
+export {};

package/dist/components/tts-rich-text/editor/useOverflowToolbar.d.ts

@@ -0,0 +1,13 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+type UseOverflowToolbarOptions<T> = {
+    list: MaybeRefOrGetter<readonly T[]>;
+    toolbarRef: Ref<HTMLElement | undefined>;
+    measureRef: Ref<HTMLElement | undefined>;
+    itemSelector?: string;
+    gap?: number;
+};
+export declare const useOverflowToolbar: <T>({ list, toolbarRef, measureRef, itemSelector, gap }: UseOverflowToolbarOptions<T>) => {
+    visibleList: import('vue').ComputedRef<T[]>;
+    hiddenList: import('vue').ComputedRef<T[]>;
+};
+export {};

package/dist/components/tts-rich-text/editor/useRichTextEditor.d.ts

@@ -0,0 +1,91 @@
+import { Ref } from 'vue';
+import { Editor, JSONContent } from '@tiptap/core';
+import { NotificationType, TtsEditorFeatures, TtsRichTextServices } from '../../../type';
+import { CustomTagType, DriveModeEnum } from './config';
+export interface UseRichTextEditorOptions {
+    content?: JSONContent;
+    textLimitLength?: number;
+    getGenerateAudioParams?: () => {
+        /**
+         * 音调，范围 0-100，默认 50。
+         */
+        pitch?: number;
+        /**
+         * 语速，范围 0-100，默认 50。
+         */
+        speed?: number;
+        /**
+         * 选中的音色 ID（对应 t_voice_timbre.id）
+         */
+        timberId?: string;
+        /**
+         * 音量，范围 0-100，默认 50。
+         */
+        volume?: number;
+    };
+    voiceVersion?: Ref<number>;
+    placeholder?: string;
+    editable?: Ref<boolean>;
+    services?: Ref<TtsRichTextServices>;
+    features?: Ref<TtsEditorFeatures>;
+    onCreate?: (editor: Editor) => void;
+    onUpdate?: (content: JSONContent, editor: Editor) => void;
+}
+export declare function useRichTextEditor(options?: UseRichTextEditorOptions): {
+    editor: import('vue').ShallowRef<import('@tiptap/vue-3').Editor | undefined, import('@tiptap/vue-3').Editor | undefined>;
+    driveMode: Ref<DriveModeEnum, DriveModeEnum>;
+    insertToken: (data: {
+        categ: CustomTagType;
+        payload: Record<string, any>;
+    }) => void;
+    insertWrappedToken: (data: {
+        categ: CustomTagType;
+        payload: Record<string, any>;
+    }) => void;
+    clearContent: () => void;
+    getSelectedText: () => string;
+    getSelectedJson: () => JSONContent | null;
+    selectedText: Ref<string, string>;
+    hasSelectedText: import('vue').ComputedRef<boolean>;
+    isSelectedPureNumber: import('vue').ComputedRef<boolean>;
+    textLimitLength: number;
+    getGenerateAudioParams: () => {
+        /**
+         * 音调，范围 0-100，默认 50。
+         */
+        pitch?: number;
+        /**
+         * 语速，范围 0-100，默认 50。
+         */
+        speed?: number;
+        /**
+         * 选中的音色 ID（对应 t_voice_timbre.id）
+         */
+        timberId?: string;
+        /**
+         * 音量，范围 0-100，默认 50。
+         */
+        volume?: number;
+    };
+    services: Ref<TtsRichTextServices, TtsRichTextServices>;
+    features: Ref<TtsEditorFeatures, TtsEditorFeatures>;
+    notify: (type: NotificationType, message: string) => void;
+    getReferencedVirtualElement: () => {
+        getBoundingClientRect(): {
+            x: number;
+            y: number;
+            left: number;
+            top: number;
+            right: number;
+            bottom: number;
+            width: number;
+            height: number;
+        };
+    } | null;
+    replaceContentWithText: (text: string) => void;
+    textLength: import('vue').ComputedRef<number>;
+    voiceVersion: Ref<number, number>;
+};
+export type RichTextEditor = ReturnType<typeof useRichTextEditor>;
+export declare const useEditorProvider: (context: RichTextEditor) => void;
+export declare const useEditorContext: () => RichTextEditor;

package/dist/components/tts-rich-text/editor/useSSETool.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { TtsServiceContext } from '../../../type';
+type ScrollTarget = Ref<HTMLElement | null | undefined> | (() => HTMLElement | null | undefined);
+type StreamRunner = (data: Record<string, unknown>, context: TtsServiceContext) => Promise<string | void>;
+interface UseSseToolOptions {
+    runner?: StreamRunner;
+    onChange?: (text: string) => void;
+    scrollTarget?: ScrollTarget;
+}
+export declare const useSSETool: (options: UseSseToolOptions) => {
+    exec: (data?: Record<string, unknown>) => Promise<void>;
+    result: Ref<string, string>;
+    loading: Ref<boolean, boolean>;
+    abort: () => void;
+};
+export {};

package/dist/components/tts-rich-text/editor/useTestAudioTool.d.ts

@@ -0,0 +1,4 @@
+import { TtsPreviewRequest } from '../../../type';
+export declare const useTestAudioTool: () => {
+    testAudio: (data: TtsPreviewRequest) => Promise<string | null>;
+};

package/dist/components/tts-rich-text/editor/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './split-sentence';
+export * from './transform-data';
+export * from './number-to-text';

package/dist/components/tts-rich-text/editor/utils/number-to-text.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 数字转文字工具类
+ */
+/**
+ * 基数读法：逐字转换
+ * 示例: 123 -> "一二三"
+ * @param numStr 数字字符串
+ */
+export declare function toCardinal(numStr: string): string;
+/**
+ * 电话号读法：逐位用电话专用读音
+ * 示例: 13800138000 -> "幺三八洞洞幺三八洞洞洞"
+ * @param numStr 数字字符串
+ */
+export declare function toPhoneReading(numStr: string): string;
+/**
+ * 位数读法 / 口语读法：按中文习惯读取
+ * 示例: 123 -> "一百二十三", 10000 -> "一万"
+ * @param numStr 数字字符串
+ */
+export declare function toPositional(numStr: string): string;
+/**
+ * 口语读法：目前逻辑与位数读法一致
+ * 如果需要区分（例如口语中更倾向于省略某些“零”），可以在此处修改逻辑
+ * @param numStr 数字字符串
+ */
+export declare function toColloquial(numStr: string): string;
+export declare const NumberToTextTools: {
+    label: string;
+    func: typeof toCardinal;
+}[];

package/dist/components/tts-rich-text/editor/utils/sanitize-pasted-text.d.ts

@@ -0,0 +1,2 @@
+export declare const sanitizePastedText: (text: string) => string;
+export declare const sanitizePastedHtml: (html: string) => string;

package/dist/components/tts-rich-text/editor/utils/split-sentence.d.ts

@@ -0,0 +1,7 @@
+export interface SentenceSplitOptions {
+    minSegmentLength?: number;
+    maxSegmentLength?: number;
+    rebalanceRatio?: number;
+}
+export declare const getVisualLength: (text: string) => number;
+export declare const splitTextToSentences: (text: string, options?: SentenceSplitOptions) => string[];

package/dist/components/tts-rich-text/editor/utils/transform-data.d.ts

@@ -0,0 +1,24 @@
+import { JSONContent } from '@tiptap/core';
+import { CustomTagType } from '../config';
+interface SentenceResult {
+    text: string;
+    protectedRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+    playments: Array<{
+        action: string;
+        model: string;
+        payload: string;
+        position: number;
+        text: string;
+        actionCode: CustomTagType;
+    }>;
+}
+export interface TtsInputData {
+    sentences: string[];
+    playments: SentenceResult['playments'][];
+}
+export declare const transformParagraph: (paragraphNode: JSONContent) => SentenceResult;
+export declare const convertToTtsFormat: (data: JSONContent) => TtsInputData;
+export {};

package/dist/components/tts-rich-text/hooks/useGlobalAudioControl.d.ts

@@ -0,0 +1,4 @@
+export declare const globalAudioControlKey: unique symbol;
+export declare const useGlobalAudioControl: (options: {
+    on: () => void;
+}) => import('@vueuse/core').UseEventBusReturn<unknown, any>;

package/dist/components/tts-rich-text/hooks/useSynthesizeAudioTool.d.ts

@@ -0,0 +1,248 @@
+import { Ref } from 'vue';
+import { TtsPreviewRequest } from '../../../type';
+export declare const useSynthesizeAudioTool: (audioRef?: Ref<HTMLAudioElement | undefined>) => {
+    execute: (data: TtsPreviewRequest) => Promise<unknown>;
+    loading: Ref<boolean, boolean>;
+    abort: () => void;
+    resume: () => Promise<void>;
+    stop: () => void;
+    playing: import('vue').WritableComputedRef<boolean, boolean>;
+    mediaControls: {
+        playing: import('vue').WritableComputedRef<boolean, boolean>;
+        currentTime: import('vue').WritableComputedRef<number, number>;
+        duration: import('vue').ComputedRef<number>;
+        waiting: Ref<boolean, boolean>;
+        seeking: Ref<boolean, boolean>;
+        ended: Ref<boolean, boolean>;
+        stalled: Ref<boolean, boolean>;
+        buffered: Ref<[number, number][], [number, number][]>;
+        rate: Ref<number, number>;
+        volume: Ref<number, number>;
+        muted: Ref<boolean, boolean>;
+        tracks: Ref<{
+            id: number;
+            label: string;
+            language: string;
+            mode: TextTrackMode;
+            kind: TextTrackKind;
+            inBandMetadataTrackDispatchType: string;
+            cues: {
+                [x: number]: {
+                    endTime: number;
+                    id: string;
+                    onenter: ((this: TextTrackCue, ev: Event) => any) | null;
+                    onexit: ((this: TextTrackCue, ev: Event) => any) | null;
+                    pauseOnExit: boolean;
+                    startTime: number;
+                    readonly track: {
+                        readonly activeCues: any | null;
+                        readonly cues: any | null;
+                        readonly id: string;
+                        readonly inBandMetadataTrackDispatchType: string;
+                        readonly kind: TextTrackKind;
+                        readonly label: string;
+                        readonly language: string;
+                        mode: TextTrackMode;
+                        oncuechange: ((this: TextTrack, ev: Event) => any) | null;
+                        addCue: (cue: TextTrackCue) => void;
+                        removeCue: (cue: TextTrackCue) => void;
+                        addEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                        };
+                        removeEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                        };
+                        dispatchEvent: {
+                            (event: Event): boolean;
+                            (event: Event): boolean;
+                        };
+                    } | null;
+                    addEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                    };
+                    removeEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                };
+                readonly length: number;
+                getCueById: (id: string) => TextTrackCue | null;
+                [Symbol.iterator]: () => ArrayIterator<TextTrackCue>;
+            } | null;
+            activeCues: {
+                [x: number]: {
+                    endTime: number;
+                    id: string;
+                    onenter: ((this: TextTrackCue, ev: Event) => any) | null;
+                    onexit: ((this: TextTrackCue, ev: Event) => any) | null;
+                    pauseOnExit: boolean;
+                    startTime: number;
+                    readonly track: {
+                        readonly activeCues: any | null;
+                        readonly cues: any | null;
+                        readonly id: string;
+                        readonly inBandMetadataTrackDispatchType: string;
+                        readonly kind: TextTrackKind;
+                        readonly label: string;
+                        readonly language: string;
+                        mode: TextTrackMode;
+                        oncuechange: ((this: TextTrack, ev: Event) => any) | null;
+                        addCue: (cue: TextTrackCue) => void;
+                        removeCue: (cue: TextTrackCue) => void;
+                        addEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                        };
+                        removeEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                        };
+                        dispatchEvent: {
+                            (event: Event): boolean;
+                            (event: Event): boolean;
+                        };
+                    } | null;
+                    addEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                    };
+                    removeEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                };
+                readonly length: number;
+                getCueById: (id: string) => TextTrackCue | null;
+                [Symbol.iterator]: () => ArrayIterator<TextTrackCue>;
+            } | null;
+        }[], import('@vueuse/core').UseMediaTextTrack[] | {
+            id: number;
+            label: string;
+            language: string;
+            mode: TextTrackMode;
+            kind: TextTrackKind;
+            inBandMetadataTrackDispatchType: string;
+            cues: {
+                [x: number]: {
+                    endTime: number;
+                    id: string;
+                    onenter: ((this: TextTrackCue, ev: Event) => any) | null;
+                    onexit: ((this: TextTrackCue, ev: Event) => any) | null;
+                    pauseOnExit: boolean;
+                    startTime: number;
+                    readonly track: {
+                        readonly activeCues: any | null;
+                        readonly cues: any | null;
+                        readonly id: string;
+                        readonly inBandMetadataTrackDispatchType: string;
+                        readonly kind: TextTrackKind;
+                        readonly label: string;
+                        readonly language: string;
+                        mode: TextTrackMode;
+                        oncuechange: ((this: TextTrack, ev: Event) => any) | null;
+                        addCue: (cue: TextTrackCue) => void;
+                        removeCue: (cue: TextTrackCue) => void;
+                        addEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                        };
+                        removeEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                        };
+                        dispatchEvent: {
+                            (event: Event): boolean;
+                            (event: Event): boolean;
+                        };
+                    } | null;
+                    addEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                    };
+                    removeEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                };
+                readonly length: number;
+                getCueById: (id: string) => TextTrackCue | null;
+                [Symbol.iterator]: () => ArrayIterator<TextTrackCue>;
+            } | null;
+            activeCues: {
+                [x: number]: {
+                    endTime: number;
+                    id: string;
+                    onenter: ((this: TextTrackCue, ev: Event) => any) | null;
+                    onexit: ((this: TextTrackCue, ev: Event) => any) | null;
+                    pauseOnExit: boolean;
+                    startTime: number;
+                    readonly track: {
+                        readonly activeCues: any | null;
+                        readonly cues: any | null;
+                        readonly id: string;
+                        readonly inBandMetadataTrackDispatchType: string;
+                        readonly kind: TextTrackKind;
+                        readonly label: string;
+                        readonly language: string;
+                        mode: TextTrackMode;
+                        oncuechange: ((this: TextTrack, ev: Event) => any) | null;
+                        addCue: (cue: TextTrackCue) => void;
+                        removeCue: (cue: TextTrackCue) => void;
+                        addEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                        };
+                        removeEventListener: {
+                            <K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                        };
+                        dispatchEvent: {
+                            (event: Event): boolean;
+                            (event: Event): boolean;
+                        };
+                    } | null;
+                    addEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                    };
+                    removeEventListener: {
+                        <K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                };
+                readonly length: number;
+                getCueById: (id: string) => TextTrackCue | null;
+                [Symbol.iterator]: () => ArrayIterator<TextTrackCue>;
+            } | null;
+        }[]>;
+        selectedTrack: Ref<number, number>;
+        enableTrack: (track: number | import('@vueuse/core').UseMediaTextTrack, disableTracks?: boolean) => void;
+        disableTrack: (track?: number | import('@vueuse/core').UseMediaTextTrack) => void;
+        supportsPictureInPicture: boolean | undefined;
+        togglePictureInPicture: () => Promise<unknown>;
+        isPictureInPicture: Ref<boolean, boolean>;
+        onSourceError: import('@vueuse/core').EventHookOn<Event>;
+        onPlaybackError: import('@vueuse/core').EventHookOn<Event>;
+    };
+    shouldAutoPlay: import('vue').ComputedRef<boolean>;
+    hasAudio: import('vue').ComputedRef<boolean>;
+};

package/dist/components/tts-rich-text/hooks/useVoiceChangeConfirm.d.ts

@@ -0,0 +1,6 @@
+import { RichTextEditor } from '../editor';
+export declare const useVoiceChangeConfirm: (options: {
+    richTextEditor: RichTextEditor;
+}) => {
+    handleChangeVoice: (currentModel: number, nextModel: number) => Promise<boolean>;
+};

package/dist/components/tts-rich-text/index.d.ts

@@ -0,0 +1,9 @@
+export { default as TtsAiRewriteModal } from './components/ai-rewrite-modal.vue';
+export { default as TtsEditorFooter } from './components/editor-footer.vue';
+export { default as TtsEditorToolbar } from './components/editor-toolbar.vue';
+export { default as TtsFormulaModal } from './components/formula-modal.vue';
+export { default as TtsMarkPinyinModal } from './components/mark-pinyin-modal.vue';
+export { default as TtsReplaceTextModal } from './components/replace-text-modal.vue';
+export { default as TtsSelectionMenu } from './components/selection-menu.vue';
+export { default as TtsTagNodeView } from './components/tag-node-view.vue';
+export { default as TtsUploadModal } from './components/upload-modal.vue';

package/dist/components/tts-rich-text-editor/index.d.ts

@@ -0,0 +1 @@
+export { default } from './index.vue';

package/dist/components/tts-rich-text-editor/index.vue.d.ts

@@ -0,0 +1,57 @@
+import { TtsEditorFeatures, TtsRichTextEditorProps, TtsRichTextServices } from '../../type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'toolbar-before'?(_: {
+            editor: import('@tiptap/vue-3').Editor | undefined;
+        }): any;
+        'toolbar-after'?(_: {
+            editor: import('@tiptap/vue-3').Editor | undefined;
+        }): any;
+        'editor-after'?(_: {
+            editor: import('@tiptap/vue-3').Editor | undefined;
+        }): any;
+        'footer-before'?(_: {
+            editor: import('@tiptap/vue-3').Editor | undefined;
+            textLength: number;
+        }): any;
+        'footer-after'?(_: {
+            editor: import('@tiptap/vue-3').Editor | undefined;
+            textLength: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TtsRichTextEditorProps, {
+    clear: () => void;
+    focus: () => void;
+    getJson: () => import('@tiptap/core').JSONContent;
+    getTtsData: () => import('../../type').TtsInputData;
+    replaceText: (text: string) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: import('@tiptap/core').JSONContent) => any;
+    change: (value: import('@tiptap/core').JSONContent) => any;
+    ready: (editor: import('@tiptap/core').Editor) => any;
+}, string, import('vue').PublicProps, Readonly<TtsRichTextEditorProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('@tiptap/core').JSONContent) => any) | undefined;
+    onChange?: ((value: import('@tiptap/core').JSONContent) => any) | undefined;
+    onReady?: ((editor: import('@tiptap/core').Editor) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    modelValue: import('@tiptap/core').JSONContent;
+    voiceVersion: number;
+    services: TtsRichTextServices;
+    features: TtsEditorFeatures;
+    textLimit: number;
+    showFullscreen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/config.d.ts

@@ -0,0 +1,67 @@
+import { JSONContent } from '@tiptap/core';
+import { LanguageOption, ResolvedTtsEditorFeatures, TtsEditorFeatures, TtsToolType } from '../type';
+export declare const DeleteMode: {
+    readonly DELETE_NODE: "deleteNode";
+    readonly CONVERT_TO_TEXT: "convertToText";
+};
+export type DeleteMode = (typeof DeleteMode)[keyof typeof DeleteMode];
+export declare const ToolConfig: {
+    readonly stop: {
+        readonly label: "停顿";
+        readonly type: "stop";
+        readonly deleteMode: "deleteNode";
+    };
+    readonly customStop: {
+        readonly label: "长停顿";
+        readonly type: "customStop";
+        readonly deleteMode: "deleteNode";
+    };
+    readonly continue: {
+        readonly label: "连续";
+        readonly type: "continue";
+        readonly deleteMode: "convertToText";
+    };
+    readonly pinyin: {
+        readonly label: "拼音标注";
+        readonly type: "pinyin";
+        readonly deleteMode: "convertToText";
+    };
+    readonly replace: {
+        readonly label: "替换";
+        readonly type: "replace";
+        readonly deleteMode: "convertToText";
+    };
+    readonly language: {
+        readonly label: "语种标记";
+        readonly type: "language";
+        readonly deleteMode: "convertToText";
+    };
+    readonly number: {
+        readonly label: "数字读法";
+        readonly type: "number";
+    };
+    readonly formula: {
+        readonly label: "读公式";
+        readonly type: "formula";
+    };
+    readonly aiRewrite: {
+        readonly label: "AI 改写";
+        readonly type: "aiRewrite";
+    };
+    readonly upload: {
+        readonly label: "上传文稿";
+        readonly type: "upload";
+    };
+};
+export type CustomTagType = 'stop' | 'customStop' | 'continue' | 'pinyin' | 'replace' | 'language';
+export declare const LanguageOptions: readonly LanguageOption[];
+export declare const StopOptions: readonly [{
+    readonly label: "停顿 0.5 秒";
+    readonly value: 0.5;
+}, {
+    readonly label: "停顿 1 秒";
+    readonly value: 1;
+}];
+export declare const allToolTypes: TtsToolType[];
+export declare const resolveTtsEditorFeatures: (voiceVersion: number, overrides?: TtsEditorFeatures) => ResolvedTtsEditorFeatures;
+export declare const getInitContent: () => JSONContent;

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config';
+export * from './number-to-text';
+export * from './sanitize-pasted-text';
+export * from './split-sentence';
+export * from './transform-data';
+export type { TtsInputData, TtsPlayment } from '../type';