@maketribe/ms-app 3.2.42 → 3.2.44

package/dist/types/components/basic/lexical-editor/LexicalComposer.vue.d.ts

@@ -0,0 +1,99 @@
+import './plugins/RichTextEditorPlugin';
+import './plugins/HashtagPlugin';
+import './plugins/ListPlugin';
+import './plugins/CheckListPlugin';
+import './plugins/TablePlugin';
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    htmlConfig: {
+        type: ObjectConstructor;
+        default(): undefined;
+    };
+    namespace: {
+        type: StringConstructor;
+        default: string;
+    };
+    editable: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    importCss: {
+        type: StringConstructor;
+        default: string;
+    };
+    importScripts: {
+        type: StringConstructor;
+        default: string;
+    };
+    modules: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    templates: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+}, {
+    setContent: (content?: string) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (error: Error) => void;
+    "update:modelValue": (value: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    htmlConfig: {
+        type: ObjectConstructor;
+        default(): undefined;
+    };
+    namespace: {
+        type: StringConstructor;
+        default: string;
+    };
+    editable: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    importCss: {
+        type: StringConstructor;
+        default: string;
+    };
+    importScripts: {
+        type: StringConstructor;
+        default: string;
+    };
+    modules: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    templates: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+}>> & {
+    onError?: ((error: Error) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}, {
+    modelValue: string;
+    namespace: string;
+    editable: boolean;
+    modules: unknown[];
+    templates: unknown[];
+    htmlConfig: Record<string, any>;
+    importCss: string;
+    importScripts: string;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/basic/lexical-editor/composables/index.d.ts

@@ -0,0 +1,9 @@
+export * from './useCharacterLimit';
+export * from './listenerManager';
+export * from './utils';
+export * from './useLexicalCommandsLog';
+export * from './useLexicalIsTextContentEmpty';
+export * from './useLexicalEditorState';
+export * from './useElementBlockSelection';
+export * from './useTableOfContents';
+export * from "./lexicalEditor";

package/dist/types/components/basic/lexical-editor/composables/lexicalEditor.d.ts

@@ -0,0 +1,137 @@
+import type { CreateEditorArgs, LexicalEditor, LexicalNode, NodeKey } from 'lexical';
+/**
+ * 编辑器模块
+ */
+export type LexicalEditorModule = {
+    name: string;
+    title: string;
+    cover?: string;
+    template: string;
+    editorCss?: string | null | undefined;
+    options: Array<any>;
+};
+/**
+ * 编辑器模版类型
+ */
+export type LexicalEditorTemplate = {
+    name: string;
+    title: string;
+    cover?: string;
+    template: string;
+    editorCss?: string | null | undefined;
+};
+/**
+ * 编辑器上下文
+ */
+export type LexicalEditorContextData = {
+    importCss: string;
+    importScript: string;
+    importStyles: string;
+    modules: Array<LexicalEditorModule>;
+    templates: Array<LexicalEditorTemplate>;
+};
+/**
+ * 快捷工具条
+ */
+export type ShortcutToolsType = {
+    exist: (node: LexicalNode) => boolean;
+    tools: (Array<{
+        key?: string;
+        title: string;
+        icon: string;
+        action: (node: any, dom?: HTMLElement) => unknown;
+    }> | ((nodeKey?: NodeKey | string) => Array<any> | null));
+};
+/**
+ * 编辑器插件
+ */
+export type LexicalEditorPlugin = {
+    nodes?: Array<any>;
+    tools?: Array<{
+        icon: string;
+        text: string;
+        action: (editor: LexicalEditor) => void;
+        disbale?: (node: LexicalNode) => boolean;
+        sort: number;
+    }>;
+    shortcutTools?: (editor: LexicalEditor) => Array<ShortcutToolsType>;
+    useMounted: (editor: LexicalEditor) => any;
+    modules?: Array<LexicalEditorModule>;
+    templates?: Array<LexicalEditorTemplate>;
+};
+/**
+ * 编辑器上下文
+ */
+export type LexicalEditorContext = LexicalEditorContextData & {
+    editor: LexicalEditor;
+    stageId: string;
+    tools: Array<{
+        icon: string;
+        text: string;
+        action: (editor: LexicalEditor) => void;
+        disbale?: (node: LexicalNode) => boolean;
+        sort: number;
+    }>;
+    shortcutTools: Array<ShortcutToolsType>;
+};
+/**
+ * 编辑器配置项
+ */
+export type LexicalEditorOptions = CreateEditorArgs & LexicalEditorContextData;
+/**
+ * 注册编辑器插件
+ * @param nodes
+ */
+export declare const registerEditorPlugin: (plugin: LexicalEditorPlugin, namespace?: string) => void;
+/**
+ *
+ * @param options 配置项
+ */
+export declare const useLexicalEditor: (options: LexicalEditorOptions, errHandle?: (error: Error) => void) => {
+    setEditornitializeContent: (content?: string) => void;
+    editor: LexicalEditor;
+};
+/**
+ * 获取当前编辑器上下文
+ * @param namespace
+ * @returns
+ */
+export declare const useLexicalEditorContext: (namespace?: string) => {
+    editor: LexicalEditor;
+    stageId: string;
+    modules: LexicalEditorModule[];
+    templates: LexicalEditorTemplate[];
+    importCss: string;
+    importScript: string;
+    importStyles: string;
+    shortcutToolsList: ShortcutToolsType[];
+    toolbarExtendPlugins: {
+        icon: string;
+        text: string;
+        action: (editor: LexicalEditor) => void;
+        disbale?: (node: LexicalNode) => boolean;
+        sort: number;
+    }[];
+    findLexicalEditorModule(name: string): LexicalEditorModule | undefined;
+    findLexicalEditorTemplate(name: string): LexicalEditorTemplate | undefined;
+};
+/**
+ * 注册模块
+ * @param options
+ */
+export declare const registerLexicalEditorModule: (options: LexicalEditorModule, namespace?: string) => void;
+/**
+ * 卸载模块
+ * @param name
+ */
+export declare const unRegisterLexicalEditorModule: (name: string) => void;
+/**
+ * 注册模版
+ * @param options
+ */
+export declare const registerLexicalEditorTemplate: (options: LexicalEditorTemplate, namespace?: string) => void;
+/**
+ * 卸载模版
+ * @param name
+ */
+export declare const unRegisterLexicalEditorTemplate: (name: string) => void;

package/dist/types/components/basic/{doc-editor/core/element-block.d.ts → lexical-editor/composables/useElementBlockSelection.d.ts}

@@ -3,17 +3,10 @@ import { LexicalCommand, NodeKey, LexicalEditor } from 'lexical';
  * toolsbar的函数
  */
 export type SelectElementBlockToolsbarFunction = (nodeKey?: NodeKey | string) => Array<any> | null;
-/**
- * 元素抗选中类型
- */
-export type SelectElementBlocktEventType = {
-    nodeKey: NodeKey | string;
-    toolsbars: Array<any> | SelectElementBlockToolsbarFunction;
-};
 /**
  * 选中元素快
  */
-export declare const SELECTED_ELEMENTBLOCK_COMMAND: LexicalCommand<SelectElementBlocktEventType | null>;
+export declare const SELECTED_ELEMENTBLOCK_COMMAND: LexicalCommand<NodeKey | string | null>;
 /**
  * 移除元素快
  */
@@ -30,8 +23,7 @@ export type SelectExistFunc = (el: HTMLElement) => HTMLElement | null;
  * 判断选中的方法
  */
 export type ElementSelectionHandle = (el: HTMLElement) => undefined;
+export declare const isNodeSelected: (editor: LexicalEditor, key: NodeKey) => boolean;
+export declare const clearSelection: (editor: LexicalEditor) => Promise<undefined>;
+export declare const setSelected: (editor: LexicalEditor, selected: boolean, key: string) => Promise<undefined>;
 export declare const setElementBlockSelection: (editor: LexicalEditor, nodeKey: string) => Promise<void>;
-/**
- * 使用元素块选中
- */
-export declare const useElementBlockSelection: (func: SelectExistFunc, toolsbars: Array<any> | SelectElementBlockToolsbarFunction) => void;

package/dist/types/components/basic/lexical-editor/composables/useLexicalEditorState.d.ts

@@ -0,0 +1,106 @@
+import type { ElementFormatType, LexicalEditor, LexicalNode } from 'lexical';
+/**
+ * 编辑配置项
+ */
+type LexicalEditOptions = {
+    rootFontSize?: number;
+    fontSizeOptions?: Array<{
+        value: string;
+        label: string;
+    }>;
+    fontfamilyOptoins?: Array<{
+        value: string;
+        label: string;
+    }>;
+};
+/**
+ * 获取编辑器状态
+ * @param editorInstance
+ * @returns
+ */
+export declare const useLexicalEditorState: (editor?: LexicalEditor, options?: LexicalEditOptions) => {
+    canUndo: import("vue").Ref<boolean>;
+    undoCommand: () => void;
+    canRedo: import("vue").Ref<boolean>;
+    redoCommand: () => void;
+    canTextStyleDisabled: import("vue").Ref<boolean>;
+    setTextStyle: (token: string, value?: string) => void;
+    fontSize: import("vue").Ref<string>;
+    fontSizeOptions: {
+        value: string;
+        label: string;
+    }[];
+    fontColor: import("vue").Ref<string>;
+    bgColor: import("vue").Ref<string>;
+    fontFamily: import("vue").Ref<any>;
+    fontfamilyOptoins: {
+        value: string;
+        label: string;
+    }[];
+    canBold: import("vue").Ref<boolean>;
+    canItalic: import("vue").Ref<boolean>;
+    canUnderline: import("vue").Ref<boolean>;
+    canStrikethrough: import("vue").Ref<boolean>;
+    canSubscript: import("vue").Ref<boolean>;
+    canSuperscript: import("vue").Ref<boolean>;
+    alignList: import("vue").Ref<ElementFormatType[]>;
+    alignValue: import("vue").Ref<ElementFormatType>;
+    canLink: import("vue").Ref<boolean>;
+    linkValue: import("vue").Ref<string>;
+    activeNode: import("vue").Ref<{
+        constructor: import("lexical").KlassConstructor<typeof LexicalNode>;
+        __type: string;
+        __key: string;
+        __parent: null | import("lexical").NodeKey;
+        __prev: null | import("lexical").NodeKey;
+        __next: null | import("lexical").NodeKey;
+        getType: () => string;
+        isInline: () => boolean;
+        isAttached: () => boolean;
+        isSelected: (selection?: null | import("lexical").BaseSelection) => boolean;
+        getKey: () => import("lexical").NodeKey;
+        getIndexWithinParent: () => number;
+        getParent: <T extends import("lexical").ElementNode>() => T | null;
+        getParentOrThrow: <T extends import("lexical").ElementNode>() => T;
+        getTopLevelElement: () => import("lexical").ElementNode | import("lexical").DecoratorNode<unknown> | null;
+        getTopLevelElementOrThrow: () => import("lexical").ElementNode | import("lexical").DecoratorNode<unknown>;
+        getParents: () => Array<import("lexical").ElementNode>;
+        getParentKeys: () => Array<import("lexical").NodeKey>;
+        getPreviousSibling: <T extends LexicalNode>() => T | null;
+        getPreviousSiblings: <T extends LexicalNode>() => Array<T>;
+        getNextSibling: <T extends LexicalNode>() => T | null;
+        getNextSiblings: <T extends LexicalNode>() => Array<T>;
+        getCommonAncestor: <T extends import("lexical").ElementNode = import("lexical").ElementNode>(node: LexicalNode) => T | null;
+        is: (object: LexicalNode | null | undefined) => boolean;
+        isBefore: (targetNode: LexicalNode) => boolean;
+        isParentOf: (targetNode: LexicalNode) => boolean;
+        getNodesBetween: (targetNode: LexicalNode) => Array<LexicalNode>;
+        isDirty: () => boolean;
+        getLatest: () => LexicalNode;
+        getWritable: () => LexicalNode;
+        getTextContent: () => string;
+        getTextContentSize: () => number;
+        createDOM: (_config: import("lexical").EditorConfig, _editor: LexicalEditor) => HTMLElement;
+        updateDOM: (_prevNode: unknown, _dom: HTMLElement, _config: import("lexical").EditorConfig) => boolean;
+        exportDOM: (editor: LexicalEditor) => import("lexical").DOMExportOutput;
+        exportJSON: () => import("lexical").SerializedLexicalNode;
+        remove: (preserveEmptyParent?: boolean) => void;
+        replace: <N extends LexicalNode>(replaceWith: N, includeChildren?: boolean) => N;
+        insertAfter: (nodeToInsert: LexicalNode, restoreSelection?: boolean) => LexicalNode;
+        insertBefore: (nodeToInsert: LexicalNode, restoreSelection?: boolean) => LexicalNode;
+        isParentRequired: () => boolean;
+        createParentElementNode: () => import("lexical").ElementNode;
+        selectStart: () => import("lexical").RangeSelection;
+        selectEnd: () => import("lexical").RangeSelection;
+        selectPrevious: (anchorOffset?: number, focusOffset?: number) => import("lexical").RangeSelection;
+        selectNext: (anchorOffset?: number, focusOffset?: number) => import("lexical").RangeSelection;
+        markDirty: () => void;
+    } | null>;
+    contentTypeList: {
+        value: string;
+        label: string;
+    }[];
+    curContentTypeDesc: import("vue").Ref<string>;
+    setContentType: (type: string) => void;
+};
+export {};

package/dist/types/components/basic/{doc-editor/core/composables/useEffect.d.ts → lexical-editor/composables/utils.d.ts}

@@ -3,3 +3,7 @@ import type { WatchOptionsBase } from 'vue';
  * @internal
  */
 export declare function useEffect(cb: () => (() => any) | undefined, options?: WatchOptionsBase): void;
+/**
+ * @internal
+ */
+export declare function useMounted(cb: () => undefined | (() => any)): void;

package/dist/types/components/basic/lexical-editor/index.d.ts

@@ -0,0 +1,5 @@
+import "./assets/iconfont.js";
+export * from "./composables";
+export * from "./plugins";
+export { default as LexicalComposer } from './LexicalComposer.vue';
+export { default as EditorStage } from './stage';

package/dist/types/components/basic/lexical-editor/nodes/HtmlElementDecoratorNode.d.ts

@@ -0,0 +1,108 @@
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, Spread, SerializedLexicalNode, LexicalEditor } from 'lexical';
+import { DecoratorNode } from 'lexical';
+import { Component } from 'vue';
+/**
+ * 节点序列化
+ */
+export type SerializedHtmlElementDecoratorNode = Spread<{
+    tag: string;
+    style?: string;
+    class?: string;
+}, SerializedLexicalNode>;
+/**
+ * 隔离的HTML节点
+ */
+export declare class HtmlElementDecoratorNode extends DecoratorNode<Component | null> {
+    __tagName: string;
+    __class?: string;
+    __style: string;
+    static getType(): string;
+    static clone(node: HtmlElementDecoratorNode): HtmlElementDecoratorNode;
+    static importJSON(serializedNode: SerializedHtmlElementDecoratorNode): HtmlElementDecoratorNode;
+    static importDOM(): DOMConversionMap | null;
+    /**
+     *
+     * @param tagName
+     * @param className
+     * @param style
+     * @param key
+     */
+    constructor(tagName: string, className?: string, style?: string, key?: NodeKey);
+    /**
+     * 名称
+     * @returns
+     */
+    getName(): string;
+    /**
+     * 描述
+     * @returns
+     */
+    getDesc(): string | undefined;
+    /**
+     * 导出JSON
+     * @returns
+     */
+    exportJSON(): SerializedHtmlElementDecoratorNode;
+    /**
+     * 导出DOM
+     * @returns
+     */
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    /**
+     * 创建渲染DOM
+     * @param config
+     * @returns
+     */
+    createDOM(config: EditorConfig): HTMLElement;
+    /**
+     * 隔离渲染函数
+     * @param editor
+     * @param config
+     * @returns
+     */
+    decorate(editor: LexicalEditor, config: EditorConfig): Component | null;
+    /**
+     * 设置样式
+     * @param style
+     * @returns
+     */
+    setStyle(style: string): this;
+    /**
+     * 添加样式
+     * @param plaload
+     */
+    addStyle(plaload: any): this;
+    /**
+     * 获取样式对象
+     */
+    getStyleObj(): any;
+    /**
+     * 更新DOM
+     * @param _prevNode
+     * @param _dom
+     * @param _config
+     * @returns
+     */
+    updateDOM(prevNode: LexicalNode, dom: HTMLElement, config: EditorConfig): boolean;
+    /**
+     * 是否是独立的
+     * @returns
+     */
+    isIsolated(): boolean;
+    /**
+     *  如果是内联元素的话会导致容器将其当字符串处理 将会有换行符存在
+     * @returns
+     */
+    isInline(): boolean;
+    /**
+     * 是否允许键盘选择
+     * @returns
+     */
+    isKeyboardSelectable(): boolean;
+}
+/**
+ * 判断是否是隔离的HTML节点
+ * @param node
+ * @returns
+ */
+export declare function $isHtmlElementDecoratorNode(node: HtmlElementDecoratorNode | LexicalNode | null | undefined): node is HtmlElementDecoratorNode;

package/dist/types/components/basic/lexical-editor/nodes/HtmlElementNode.d.ts

@@ -0,0 +1,84 @@
+import type { DOMConversionMap, SerializedElementNode, NodeKey, Spread, EditorConfig, DOMExportOutput, LexicalEditor, LexicalNode } from 'lexical';
+import { ElementNode } from 'lexical';
+/**
+ * 节点序列化
+ */
+export type SerializedHtmlElementNode = Spread<{
+    tag: string;
+    style?: string;
+    class?: string;
+}, SerializedElementNode>;
+/**
+ * 其他位置Html节点
+ */
+export declare class HtmlElementNode extends ElementNode {
+    __tagName: string;
+    __class?: string;
+    static getType(): string;
+    static clone(node: HtmlElementNode): HtmlElementNode;
+    static importJSON(serializedNode: SerializedHtmlElementNode): HtmlElementNode;
+    static importDOM(): DOMConversionMap | null;
+    /**
+     *
+     * @param tagName
+     * @param className
+     * @param style
+     * @param key
+     */
+    constructor(tagName: string, className?: string, style?: string, key?: NodeKey);
+    /**
+     * 名称
+     * @returns
+     */
+    getName(): string;
+    /**
+     * 描述
+     * @returns
+     */
+    getDesc(): string | undefined;
+    /**
+     * 添加样式
+     * @param plaload
+     */
+    addStyle(plaload: any): this;
+    /**
+     * 获取样式对象
+     */
+    getStyleObj(): any;
+    /**
+     * 导出JSON
+     * @returns
+     */
+    exportJSON(): SerializedHtmlElementNode;
+    /**
+     * 导出DOM
+     * @returns
+     */
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    /**
+     * 创建渲染DOM
+     * @param config
+     * @returns
+     */
+    createDOM(config: EditorConfig): HTMLElement;
+    /**
+     * 开始折叠
+     * 目前看 删除节点的时候会调用
+     * @returns
+     */
+    collapseAtStart(): boolean;
+    /**
+     * 更新DOM
+     * @param _prevNode
+     * @param _dom
+     * @param _config
+     * @returns
+     */
+    updateDOM(prevNode: LexicalNode, dom: HTMLElement, config: EditorConfig): boolean;
+}
+/**
+ * 判断是否是HtmlElementNode
+ * @param node
+ * @returns
+ */
+export declare function $isHtmlElementNode(node: HtmlElementNode | LexicalNode | null | undefined): node is HtmlElementNode;

package/dist/types/components/basic/lexical-editor/nodes/ImageNode.d.ts

@@ -0,0 +1,85 @@
+import type { DOMConversionMap, EditorConfig, LexicalNode, NodeKey, Spread, LexicalEditor } from 'lexical';
+import { Component } from 'vue';
+import { HtmlElementDecoratorNode, SerializedHtmlElementDecoratorNode } from "./HtmlElementDecoratorNode";
+import { type LexicalCommand } from 'lexical';
+/**
+ * 插入图片指令
+ */
+export declare const INSERT_IMAGE_COMMAND: LexicalCommand<{
+    src: string;
+    alt?: string;
+    style?: string;
+}>;
+/**
+ * 图片节点序列化
+ */
+export type SerializedImageNode = Spread<{
+    src: string;
+    alt?: string;
+}, SerializedHtmlElementDecoratorNode>;
+/**
+ * 定义图片节点
+ */
+export declare class ImageNode extends HtmlElementDecoratorNode {
+    __src: string;
+    __alt?: string;
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    static importJSON(serializedNode: SerializedImageNode): ImageNode;
+    static importDOM(): DOMConversionMap | null;
+    constructor(src: string, alt?: string, className?: string, style?: string, key?: NodeKey);
+    /**
+     * 隔离渲染函数
+     * @param editor
+     * @param config
+     * @returns
+     */
+    decorate(editor: LexicalEditor, config: EditorConfig): Component | null;
+    /**
+     * 导出JSON
+     * @returns
+     */
+    exportJSON(): SerializedImageNode;
+    /**
+     * 设置src
+     * @param src
+     * @returns
+     */
+    setSrc(src: string): this;
+    /**
+     * 设置 alt
+     * @param alt
+     * @returns
+     */
+    setAlt(alt: string): this;
+    /**
+     * 创建DOM
+     * @param config
+     * @returns
+     */
+    createDOM(config: EditorConfig): HTMLElement;
+    /**
+     * 更新DOM
+     * @param _prevNode
+     * @param _dom
+     * @param _config
+     * @returns
+     */
+    updateDOM(prevNode: ImageNode, dom: HTMLElement, config: EditorConfig): boolean;
+    /**
+     * @returns
+     */
+    isInline(): boolean;
+}
+/**
+ * 创建图片节点
+ * @param src
+ * @returns
+ */
+export declare function $createImageNode(src: string, alt?: string, className?: string, style?: string): ImageNode;
+/**
+ * 判断是否是图片节点
+ * @param node
+ * @returns
+ */
+export declare function $isImageNode(node: ImageNode | LexicalNode | null | undefined): node is ImageNode;