@netless/appliance-plugin 1.1.1 → 1.1.3-4.beta.0

package/dist/component/svg/mermaid.d.ts

@@ -0,0 +1,109 @@
+import { Transformer } from "./markmap";
+/**
+ * Mermaid 管理器（单例模式）
+ * 统一管理 mermaid 代码块的存储、HTML 生成和 markdown 扩展
+ * 使用 workId 作为命名空间，避免多个 ISvgElement 实例互相影响
+ */
+export declare class MermaidManager {
+    private static instance;
+    private mermaidCodeBlocksByWorkId;
+    private constructor();
+    /**
+     * 获取 MermaidManager 单例实例
+     */
+    static getInstance(): MermaidManager;
+    /**
+     * 生成唯一的 mermaid ID
+     */
+    generateId(): string;
+    /**
+     * 生成 mermaid HTML 容器
+     * @param id mermaid ID
+     * @param mermaidCode mermaid 代码（可选，如果提供则存储）
+     * @param workId 工作 ID（用于命名空间隔离）
+     * @returns HTML 字符串
+     */
+    createContainer(id: string, mermaidCode?: string, workId?: string): string;
+    /**
+     * 获取 mermaid 代码块
+     * @param id mermaid ID
+     * @param workId 工作 ID（用于命名空间隔离）
+     * @returns mermaid 代码或 undefined
+     */
+    getCode(id: string, workId: string): string | undefined;
+    /**
+     * 清空指定 workId 的 mermaid 代码块
+     * @param workId 工作 ID（如果未提供，清空所有）
+     */
+    clear(workId?: string): void;
+    /**
+     * 扩展 markdown-it 的渲染规则，处理 mermaid 代码块
+     * @param transformer Transformer 实例
+     * @param workId 工作 ID（用于命名空间隔离）
+     */
+    extendMarkdown(transformer: Transformer, workId: string): void;
+    static generateId(): string;
+    static createContainer(id: string, mermaidCode?: string, workId?: string): string;
+    static getCode(id: string, workId: string): string | undefined;
+    static clear(workId?: string): void;
+    static extendMarkdown(transformer: Transformer, workId: string): void;
+}
+/**
+ * Mermaid 渲染器工具类
+ * 负责处理 markmap 中的 mermaid 图表渲染相关逻辑
+ */
+export declare class MermaidRenderer {
+    /**
+     * 检查 markmap 节点及其子节点是否包含 mermaid 代码块
+     * @param node markmap 节点数据
+     * @returns 如果节点或其子节点包含 mermaid 代码块，返回 true
+     */
+    static checkNodeHasMermaid(node: any): boolean;
+    /**
+     * 等待 DOM 更新后渲染 Mermaid 图表
+     * @param svgElement SVG 元素
+     * @param workId 工作 ID
+     * @returns Promise<void>
+     */
+    static renderMermaidAfterDOMUpdate(svgElement: SVGSVGElement, workId: string): Promise<void>;
+    /**
+     * 渲染所有 mermaid 容器中的图表
+     * @param svgElement SVG 元素
+     * @param workId 工作 ID
+     * @returns Promise<void>
+     */
+    static renderMermaidBlocks(svgElement: SVGSVGElement, workId: string): Promise<void>;
+    /**
+     * 检测是否是 Safari 浏览器
+     * @returns 如果是 Safari 返回 true，否则返回 false
+     */
+    static isSafari(): boolean;
+    /**
+     * 将 mermaid SVG 从 foreignObject 移出，直接添加到 markmap SVG 中（Safari 兼容性处理）
+     * 克隆 mermaid SVG 元素，设置正确的尺寸和位置，然后将 foreignObject 中的 mermaid-container 透明度设为 0
+     * @param svgElement markmap SVG 元素
+     * @returns Promise<void>
+     */
+    static transformMermaidSvgToMarkmapSvg(svgElement: SVGSVGElement): Promise<void>;
+    /**
+     * 在 root 数据中注入 mermaid HTML
+     * 找到包含 mermaid 代码块的节点，将 HTML 添加到其 content 中
+     * @param root markmap root 数据
+     * @param markdown markdown 文本
+     * @param workId 工作 ID（用于命名空间隔离）
+     * @returns 修改后的 root 数据
+     */
+    static injectMermaidHtml(root: any, markdown: string, workId: string): any;
+    /**
+     * 解码 HTML 实体
+     * @param str HTML 字符串
+     * @returns 解码后的字符串
+     */
+    private static decodeHtmlEntities;
+    /**
+     * 检查 divElement 中是否包含 mermaid SVG 元素
+     * @param divElement HTMLDivElement 或 SVGSVGElement 元素
+     * @returns 如果包含 mermaid SVG 元素，返回 true，否则返回 false
+     */
+    static hasMermaidSvg(divElement: HTMLDivElement | SVGSVGElement): boolean;
+}

package/dist/component/svg/snapshot.d.ts

@@ -0,0 +1,31 @@
+import { IBackgroundThreadInitOption } from "../../core/backGroundThread";
+import { MasterControlForWorker } from "../../core/mainEngine";
+import { BaseShapeTool } from "../../core/tools";
+import { ICameraOpt, IWorkerMessage } from "../../core/types";
+import { VBackgroundNodeManager } from "./vNodeManager";
+import { View } from "../../plugin/types";
+import { IMarkmapOptions } from "./markmap";
+export declare class BackgroundSnapshotThreadImpl {
+    viewId: string;
+    fullLayer: HTMLDivElement;
+    master: MasterControlForWorker;
+    vNodes: VBackgroundNodeManager;
+    private cameraOpt?;
+    readonly opt: IBackgroundThreadInitOption;
+    workShapes: Map<string, BaseShapeTool>;
+    get camera(): ICameraOpt;
+    get view(): View | undefined;
+    get markmapOptions(): Partial<IMarkmapOptions> | undefined;
+    constructor(viewId: string, opt: IBackgroundThreadInitOption);
+    createOffscreenCanvas(opt: IBackgroundThreadInitOption): void;
+    setCameraOpt(cameraOpt: ICameraOpt): Promise<void>;
+    getPagePoint(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+    getSnapshot(data: IWorkerMessage): Promise<void>;
+    private createWorkShapeNode;
+    private setFullWork;
+    runFullWork(data: IWorkerMessage): Promise<void>;
+    destroy(): void;
+}

package/dist/component/svg/svgElemt.d.ts

@@ -0,0 +1,43 @@
+import { EToolsKey, ISVGOptions } from "../../core";
+import { ISVGElementToolProps } from "./types";
+import { VBackgroundNodeManager } from "./vNodeManager";
+import type { BackgroundThreadEngineImpl } from "./manager";
+import { Markmap } from "./markmap";
+import type { Collector } from "../../collector";
+import type { BackgroundSnapshotThreadImpl } from "./snapshot";
+export declare class ISvgElement {
+    readonly toolsType: EToolsKey;
+    readonly vNodes: VBackgroundNodeManager;
+    private workOptions;
+    readonly workId: string;
+    markmapInstance: ReturnType<typeof Markmap.create> | null;
+    private isDestroyed;
+    private element;
+    readonly manager: BackgroundThreadEngineImpl | BackgroundSnapshotThreadImpl;
+    get fullLayer(): HTMLDivElement;
+    get collector(): Collector | undefined;
+    get scenePath(): string | undefined;
+    constructor(props: ISVGElementToolProps);
+    init(): Promise<void>;
+    private createElement;
+    private render;
+    private isSameSize;
+    private isSamePosition;
+    private isSameZIndex;
+    private isSameState;
+    private isSameData;
+    private updateElementPosition;
+    private updateSvg;
+    private fit;
+    private serializeData;
+    private transformState;
+    updateCamera(): Promise<void>;
+    setWorkOptions(toolsOpt: ISVGOptions, forceRender?: boolean): Promise<void>;
+    destroy(): void;
+    getRectFromLayer(): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}

package/dist/component/svg/svgToImageLoader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SVG to Image 库的按需加载工具
+ * 使用 dom-to-image 库，用于将包含 SVG foreignObject 的 DOM 转换为图片
+ * dom-to-image 支持 SVG foreignObject，可以可靠地将 DOM 节点转换为图片
+ */
+type DomToImageLib = {
+    toPng: (node: Node, options?: any) => Promise<string>;
+    toBlob: (node: Node, options?: any) => Promise<Blob>;
+    toJpeg: (node: Node, options?: any) => Promise<string>;
+    toSvg: (node: Node, options?: any) => Promise<string>;
+};
+/**
+ * 按需加载 svg-to-image 库（使用 dom-to-image）
+ * @returns Promise<DomToImageLib> 返回加载的库对象
+ */
+export declare function loadSvgToImageLib(): Promise<DomToImageLib>;
+/**
+ * 检查库是否已加载
+ */
+export declare function isSvgToImageLibLoaded(): boolean;
+/**
+ * 获取已加载的库（如果未加载则返回 null）
+ */
+export declare function getSvgToImageLib(): DomToImageLib | null;
+export {};

package/dist/component/svg/types.d.ts

@@ -0,0 +1,10 @@
+import { ISVGOptions } from "../../core";
+import { BackgroundThreadEngineImpl } from "./manager";
+import { BackgroundSnapshotThreadImpl } from "./snapshot";
+import { VBackgroundNodeManager } from "./vNodeManager";
+export interface ISVGElementToolProps {
+    workId: string;
+    toolsOpt: ISVGOptions;
+    vNodes: VBackgroundNodeManager;
+    manager: BackgroundThreadEngineImpl | BackgroundSnapshotThreadImpl;
+}

package/dist/component/svg/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function loadAllImages(element: HTMLDivElement): Promise<unknown[]>;
+export declare function loadSvg(svg: SVGSVGElement): Promise<void>;
+export declare function loadAllSvgs(divElement: HTMLDivElement): Promise<void>;
+export declare function loadMermaidSvg(divElement: HTMLDivElement | SVGSVGElement): Promise<void>;
+export declare function divToImageElement(container: HTMLDivElement, options?: {
+    width?: number;
+    height?: number;
+    scale?: number;
+}): Promise<HTMLImageElement | null>;

package/dist/component/svg/vNodeManager.d.ts

@@ -0,0 +1,28 @@
+import { ObserverMap } from "../../core/utils/ObserverMap";
+import { ISvgElement } from "./svgElemt";
+export interface IBackgroundNodeMapItem {
+    name: string;
+    workShape: ISvgElement;
+}
+/**
+ * 背景节点管理器
+ * 覆盖父类的 curNodeMap 类型，使用 IBackgroundNodeMapItem 作为节点项类型
+ * IBackgroundNodeMapItem 是 BaseNodeMapItem 的简化版本，专门用于背景节点管理
+ */
+export declare class VBackgroundNodeManager {
+    viewId: string;
+    fullLayer?: HTMLDivElement;
+    curNodeMap: ObserverMap<string, IBackgroundNodeMapItem>;
+    constructor(viewId: string);
+    init(fullLayer: HTMLDivElement): void;
+    get(name: string): IBackgroundNodeMapItem | undefined;
+    setInfo(name: string, info: Partial<IBackgroundNodeMapItem>): void;
+    getNodeRectFormShape(key: string): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | undefined;
+    delete(name: string): void;
+    clear(): void;
+}

package/dist/component/textEditor/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types';
-export * from './manager';
+export * from "./types";
+export * from "./manager";

package/dist/component/textEditor/manager.d.ts

@@ -1,13 +1,20 @@
 import { TextEditorInfo, TextOptions } from "./types";
 import { BaseSubWorkModuleProps } from "../../plugin/types";
-import { ICameraOpt, IWorkerMessage } from "../../core";
+import { ICameraOpt, IUpdateNodeOpt, IWorkerMessage } from "../../core";
 import type EventEmitter2 from "eventemitter2";
 import { BaseApplianceManager } from "../../plugin/baseApplianceManager";
+import { WorkId } from "../../collector/types";
+export declare const TextBoxPadding = 5;
 export interface TextEditorManager {
     readonly internalMsgEmitter: EventEmitter2;
+    readonly publicMsgEmitter: EventEmitter2;
     readonly control: BaseApplianceManager;
+    UndoTickerId?: number;
     editors: Map<string, TextEditorInfo>;
+    /** 当前激活的文本编辑器 */
     activeId?: string;
+    /** 添加撤销栈 */
+    addUndoTicker(undoTickerId: number, viewId: string): void;
     /** 通过view组建中更新文本 */
     updateForViewEdited(activeId?: string, info?: TextEditorInfo): void;
     /** 过滤文本编辑器 */
@@ -17,7 +24,7 @@ export interface TextEditorManager {
     /** 校验是否删除空文本或事失焦 */
     checkEmptyTextBlur(): void;
     /** 激活文本编辑组件 */
-    active(workId: string): void;
+    active(workId: string, undoTickerId?: number): void;
     /** 不激活文本编辑组件 */
     unActive(blurId: string): void;
     /** 创建文本来源于main */
@@ -48,6 +55,7 @@ export interface TextEditorManager {
         viewId: string;
         canWorker: boolean;
         canSync: boolean;
+        updateNodeOpt?: IUpdateNodeOpt;
     }, undoTickerId?: number): void;
     /** 编辑文本 */
     /** 获取组建信息 */
@@ -64,16 +72,23 @@ export interface TextEditorManager {
     onServiceDerive(data: IWorkerMessage): void;
     /** 监听camera变化 */
     onCameraChange(cameraOpt: ICameraOpt, viewId: string): void;
+    /** 插入文本 */
+    insertText(viewId: string, x: number, y: number, textContent: string): WorkId | undefined;
+    /** 更新指定文本 */
+    updateText(workId: WorkId, textContent: string): void;
 }
 export declare class TextEditorManagerImpl implements TextEditorManager {
     readonly internalMsgEmitter: EventEmitter2;
+    readonly publicMsgEmitter: EventEmitter2;
     readonly control: BaseApplianceManager;
     editors: Map<string, TextEditorInfo>;
     activeId?: string;
     private proxyMap;
     private taskqueue;
+    private undoTickerId?;
     constructor(props: BaseSubWorkModuleProps);
     get collector(): import("../../collector").Collector | undefined;
+    set UndoTickerId(value: number);
     filterEditor(viewId: string): Map<string, TextEditorInfo>;
     get interceptors(): {
         set: (workId: string, info: TextEditorInfo) => true | undefined;
@@ -81,12 +96,14 @@ export declare class TextEditorManagerImpl implements TextEditorManager {
         clear(): boolean;
     };
     computeTextActive(point: [number, number], viewId: string): void;
+    checkLocalTextBlur: import("lodash").DebouncedFunc<() => void>;
     checkEmptyTextBlur(): void;
     onCameraChange(cameraOpt: ICameraOpt, viewId: string): void;
     onServiceDerive(data: IWorkerMessage): void;
     updateForViewEdited(activeId: string, info: TextEditorInfo): void;
-    active(workId: string): void;
+    active(workId: string, undoTickerId?: number): void;
     unActive(blurId: string): void;
+    addUndoTicker(undoTickerId: number, viewId: string): void;
     createTextForMasterController(params: TextEditorInfo & {
         workId: string;
         viewId: string;
@@ -114,4 +131,6 @@ export declare class TextEditorManagerImpl implements TextEditorManager {
     deleteBatch(workIds: string[], canSync?: boolean | undefined, canWorker?: boolean | undefined): void;
     clear(viewId: string, justLocal?: boolean): void;
     destory(): void;
+    insertText(viewId: string, x: number, y: number, textContent: string): WorkId | undefined;
+    updateText(workId: WorkId, textContent: string): void;
 }

package/dist/component/textEditor/types.d.ts

@@ -1,4 +1,4 @@
-import { EDataType, EvevtWorkState } from "../../core";
+import { EDataType, EventWorkState, IUpdateNodeOpt } from "../../core";
 import { BaseShapeOptions } from "../../core/tools";
 export declare enum ETextEditorType {
     Text = 1,
@@ -6,8 +6,8 @@ export declare enum ETextEditorType {
 }
 export type VerticalAlignType = "top" | "middle" | "bottom";
 export type TextAlignType = "left" | "center" | "right";
-export type FontWeightType = 'bold' | 'normal';
-export type FontStyleType = 'italic' | 'normal';
+export type FontWeightType = "bold" | "normal";
+export type FontStyleType = "italic" | "normal";
 export interface TextOptions extends BaseShapeOptions {
     fontColor: string;
     fontSize: number;
@@ -26,7 +26,7 @@ export interface TextOptions extends BaseShapeOptions {
     boxPoint?: [number, number];
     boxSize?: [number, number];
     /** 状态 */
-    workState?: EvevtWorkState;
+    workState?: EventWorkState;
     /** 正在编辑的用户 */
     uid?: string;
 }
@@ -47,4 +47,5 @@ export type TextEditorInfo = {
     dataType?: EDataType;
     translate?: [number, number];
     justLocal?: boolean;
+    updateNodeOpt?: IUpdateNodeOpt;
 };

package/dist/component/textEditor/utils.d.ts

@@ -1,3 +1,4 @@
 import { EToolsKey } from "../../core";
 import { ETextEditorType } from "./types";
 export declare function getTextEditorType(toolsKey: EToolsKey): ETextEditorType | undefined;
+export declare function escapeCSS(id: string): string;

package/dist/component/textEditor/view.d.ts

@@ -1,73 +1,53 @@
-import React, { FocusEventHandler, KeyboardEventHandler } from "react";
+import React from "react";
 import { TextEditorInfo, TextOptions } from "./types";
-import { ApplianceViewManagerLike, EmitEventType } from "../../plugin/types";
-export declare const Max_Font_Size = 80;
-export interface TextSelectorManagerProps {
-    selectIds: string[];
+import { EmitEventType } from "../../plugin/types";
+export interface TextManagerProps {
     className?: string;
     editors?: Map<string, TextEditorInfo>;
-    activeTextId?: string;
+    selectIds?: string[];
     box?: {
         x: number;
         y: number;
         w: number;
         h: number;
     };
-    manager: ApplianceViewManagerLike;
     showFloatBtns?: boolean;
     operationType?: EmitEventType;
+    rightBoundBreak?: boolean;
+}
+export interface TextSelectorManagerProps extends TextManagerProps {
+    handleTextEditorPointerDown: (workId: string) => void;
+    handleTextEditorPointerUp: () => void;
 }
 export interface TextViewProps {
     workId: string;
     data: TextEditorInfo;
-    isSelect?: boolean;
-    isActive?: boolean;
-    manager: ApplianceViewManagerLike;
 }
 export interface TextSelectorViewProps extends TextViewProps {
-    left: string;
-    top: string;
-    selectIds?: string[];
     updateOptInfo: (param: {
         activeTextId: string;
         update: Partial<TextOptions>;
-        syncData?: Pick<TextEditorInfo, 'canSync' | 'canWorker'>;
+        syncData?: Pick<TextEditorInfo, "canSync" | "canWorker">;
     }) => void;
+    handlePointerDown: (workId: string) => void;
+    handlePointerUp: () => void;
 }
 export interface TextEditorProps extends TextViewProps {
     showFloatBtns: boolean;
-    handleKeyUp: KeyboardEventHandler<HTMLDivElement>;
-    handleFocus: FocusEventHandler<HTMLDivElement>;
-    runAnimation: () => void;
-    updateOptInfo: (param: {
-        activeTextId: string;
-        update: Partial<TextOptions>;
-        syncData?: Pick<TextEditorInfo, 'canSync' | 'canWorker'>;
-    }) => void;
-}
-export declare const TextView: (props: TextViewProps) => React.JSX.Element;
-export declare const TextSelectorView: React.MemoExoticComponent<(props: TextSelectorViewProps) => React.JSX.Element>;
-export declare const TextEditor: (props: TextEditorProps) => React.JSX.Element;
-export declare class TextViewInSelector extends React.Component<TextSelectorManagerProps, {
-    hasEditor: boolean;
-}> {
-    constructor(props: TextSelectorManagerProps);
-    getInnerText(target: HTMLDivElement): string[];
-    updateOptInfo(param: {
-        activeTextId: string;
-        update: Partial<TextOptions>;
-        syncData?: Pick<TextEditorInfo, 'canSync' | 'canWorker'>;
-    }): void;
-    get editorUI(): JSX.Element[] | null;
-    render(): React.JSX.Element;
-}
-export declare class TextEditorContainer extends TextViewInSelector {
-    ref: React.RefObject<HTMLDivElement> | undefined;
-    isRunAnimation?: number;
-    constructor(props: TextSelectorManagerProps);
-    runAnimation(): void;
-    handleKeyUp(e: any): void;
-    handleFocus(e: any): void;
-    get editorUI(): JSX.Element[] | null;
-    render(): React.JSX.Element;
+    rightBoundBreak: boolean;
+    handleKeyUp: (div: HTMLDivElement) => void;
+    handleFocus: (div: HTMLDivElement) => void;
+    runAnimation: (callback?: () => void) => void;
+    updateSize: (updateId: string, boxSize: [number, number]) => void;
 }
+/**
+ * 文本编辑器类型
+ * hover: 当前文本被当前用户获焦中
+ * editing: 当前文本编辑中(被其他用户编辑中)
+ * active: 当前文本可编辑状态被激活(暂无用户编辑)
+ * none: 无状态
+ */
+export type TextEditorType = "hover" | "editing" | "active" | "none";
+export declare const TextSelectorView: (props: TextSelectorViewProps) => React.JSX.Element;
+export declare const TextViewInSelector: (props: TextSelectorManagerProps) => React.JSX.Element;
+export declare const TextEditorContainer: (props: TextManagerProps) => React.JSX.Element;

package/dist/core/autoShape/index.d.ts

@@ -0,0 +1,12 @@
+import { serializeAutoShapeWork } from "./mapper";
+import type { AutoShapeContext, AutoShapeMappedWork, AutoShapePoint, AutoShapeResult } from "./types";
+export * from "./types";
+export declare function buildAutoShapeContext(params: {
+    rawPoints: AutoShapePoint[];
+    pencilOptions: AutoShapeContext["pencilOptions"];
+    viewId: string;
+    scenePath?: string;
+}): AutoShapeContext | null;
+export declare function detectAutoShape(context: AutoShapeContext): AutoShapeResult;
+export declare function mapAutoShapeResult(result: AutoShapeResult, context: AutoShapeContext): AutoShapeMappedWork | null;
+export { serializeAutoShapeWork };

package/dist/core/autoShape/mapper.d.ts

@@ -0,0 +1,3 @@
+import type { AutoShapeDefinition, AutoShapeMappedWork } from "./types";
+export declare const defaultAutoShapeMappers: Record<Exclude<AutoShapeDefinition["kind"], "none">, AutoShapeDefinition["mapper"]>;
+export declare function serializeAutoShapeWork(work: AutoShapeMappedWork): string;

package/dist/core/autoShape/recognizer.d.ts

@@ -0,0 +1,8 @@
+import type { AutoShapeContext, AutoShapePoint, AutoShapeResult } from "./types";
+export declare function createAutoShapeContext(params: {
+    rawPoints: AutoShapePoint[];
+    pencilOptions: AutoShapeContext["pencilOptions"];
+    viewId: string;
+    scenePath?: string;
+}): AutoShapeContext | null;
+export declare function recognizeAutoShape(context: AutoShapeContext): AutoShapeResult;

package/dist/core/autoShape/registry.d.ts

@@ -0,0 +1,2 @@
+import type { AutoShapeDefinition } from "./types";
+export declare function getAutoShapeDefinitions(): AutoShapeDefinition[];

package/dist/core/autoShape/templates.d.ts

@@ -0,0 +1,2 @@
+import type { AutoShapeTemplateDefinition } from "./types";
+export declare const defaultAutoShapeTemplates: AutoShapeTemplateDefinition[];

package/dist/core/autoShape/types.d.ts

@@ -0,0 +1,78 @@
+import type { EToolsKey } from "../enum";
+import type { ShapeOptions } from "../tools";
+import type { PencilOptions } from "../tools/pencil";
+export type AutoShapePoint = [number, number];
+export type AutoShapeKind = "straight" | "arrow" | "rectangle" | "ellipse" | "triangle" | "rhombus" | "star" | "none";
+export interface AutoShapeBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export interface AutoShapeMetrics {
+    pathLength: number;
+    chordLength: number;
+    straightness: number;
+    closureDistance: number;
+    closureRatio: number;
+    bboxWidth: number;
+    bboxHeight: number;
+    bboxDiagonal: number;
+    aspectRatio: number;
+    cornerCount: number;
+    angleVariance: number;
+    radialVariance: number;
+    bboxCornerCloseness: number;
+    diamondCloseness: number;
+}
+export interface AutoShapeContext {
+    viewId: string;
+    scenePath?: string;
+    pencilOptions: PencilOptions;
+    rawPoints: AutoShapePoint[];
+    points: AutoShapePoint[];
+    start: AutoShapePoint;
+    end: AutoShapePoint;
+    bbox: AutoShapeBounds;
+    metrics: AutoShapeMetrics;
+}
+export interface AutoShapeTemplateDefinition {
+    id: string;
+    semanticKind: Exclude<AutoShapeKind, "none">;
+    points: AutoShapePoint[];
+    threshold?: number;
+}
+export interface AutoShapeCandidate {
+    kind: Exclude<AutoShapeKind, "none">;
+    templateId: string;
+    score: number;
+    threshold: number;
+    distance: number;
+}
+export interface AutoShapeResult {
+    kind: AutoShapeKind;
+    score: number;
+    threshold: number;
+    recognized: boolean;
+    bbox: AutoShapeBounds;
+    start: AutoShapePoint;
+    end: AutoShapePoint;
+    points: AutoShapePoint[];
+    templateId?: string;
+    metrics: AutoShapeMetrics;
+    candidates: AutoShapeCandidate[];
+}
+export interface AutoShapeMappedWork {
+    toolsType: EToolsKey;
+    opt: ShapeOptions;
+    op: number[];
+}
+export type AutoShapePostProcessor = (candidate: AutoShapeCandidate, context: AutoShapeContext) => AutoShapeCandidate | null;
+export type AutoShapeMapper = (result: AutoShapeResult, context: AutoShapeContext) => AutoShapeMappedWork | null;
+export interface AutoShapeDefinition {
+    kind: Exclude<AutoShapeKind, "none">;
+    templates: AutoShapeTemplateDefinition[];
+    postProcessor?: AutoShapePostProcessor;
+    mapper: AutoShapeMapper;
+    enabledInV1?: boolean;
+}

package/dist/core/backGroundThread/index.d.ts

@@ -0,0 +1,35 @@
+import { MasterControlForWorker } from "../mainEngine";
+import { IBatchMainMessage, ILayerOptionType, IWorkerMessage } from "../types";
+import { AppViewDisplayerManager, MainViewDisplayerManager } from "../../plugin/baseViewContainerManager";
+import { BackgroundThreadEngineImpl } from "../../component/svg/manager";
+import { ICanvasOptionType } from "./types";
+import { BackgroundSnapshotThreadImpl } from "../../component/svg/snapshot";
+export interface IBackgroundThreadInitOption {
+    master: MasterControlForWorker;
+    container: HTMLDivElement;
+    canvasOpt: ICanvasOptionType;
+    layerOpt: ILayerOptionType;
+    displayer: MainViewDisplayerManager | AppViewDisplayerManager;
+    post(sp: Omit<IBatchMainMessage, "render">): void;
+}
+export interface BackgroundThreadManager {
+    master: MasterControlForWorker;
+    backgroundThreadMap: Map<string, BackgroundThreadEngineImpl>;
+    createBackgroundThread(viewId: string, opt: IBackgroundThreadInitOption): BackgroundThreadEngineImpl;
+    createSnapshotThread(viewId: string, opt: IBackgroundThreadInitOption): BackgroundSnapshotThreadImpl;
+    consume(msg: Set<IWorkerMessage>): Promise<void>;
+    post(sp: Omit<IBatchMainMessage, "render">): void;
+    destroy(): void;
+}
+export declare class BackgroundThreadManagerImpl implements BackgroundThreadManager {
+    backgroundThreadMap: Map<string, BackgroundThreadEngineImpl>;
+    private snapshotThread?;
+    master: MasterControlForWorker;
+    constructor(master: MasterControlForWorker);
+    createBackgroundThread(viewId: string, opt: IBackgroundThreadInitOption): BackgroundThreadEngineImpl;
+    createSnapshotThread(viewId: string, opt: IBackgroundThreadInitOption): BackgroundSnapshotThreadImpl;
+    consume(msg: Set<IWorkerMessage>): Promise<void>;
+    consumeTargetOne(viewId: string, msg: IWorkerMessage): Promise<void>;
+    post: (msg: Omit<IBatchMainMessage, "render">) => void;
+    destroy(): void;
+}

package/dist/core/backGroundThread/types.d.ts

@@ -0,0 +1,12 @@
+import { IOffscreenCanvasOptionType, ILayerOptionType, IBatchMainMessage } from "..";
+import { MainViewDisplayerManager, AppViewDisplayerManager } from "../../plugin/baseViewContainerManager";
+import { MasterControlForWorker } from "../mainEngine";
+export type ICanvasOptionType = IOffscreenCanvasOptionType;
+export interface IMainThreadInitOption {
+    container: HTMLDivElement;
+    canvasOpt: ICanvasOptionType;
+    layerOpt: ILayerOptionType;
+    master: MasterControlForWorker;
+    displayer: MainViewDisplayerManager | AppViewDisplayerManager;
+    post(sp: Omit<IBatchMainMessage, "render">): void;
+}