@netless/appliance-plugin 1.1.42-beta.3 → 1.1.43-beta.0

package/dist/core/mainThread/subLocalThread.d.ts

@@ -22,7 +22,7 @@ export interface SubLocalThread {
         workId: string;
     }): void;
     setWorkOptions(workId: string, opt: BaseShapeOptions): void;
-    consumeDrawAll(data: IWorkerMessage, serviceWork: SubServiceThread): void;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: SubServiceThread): Promise<void>;
     consumeDraw(data: IWorkerMessage, serviceWork: SubServiceThread): Promise<void>;
     colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;
     hasSelector(): boolean;
@@ -35,7 +35,7 @@ export interface SubLocalThread {
     consumeFull(data: IWorkerMessage): Promise<void>;
     removeWork(data: IWorkerMessage): void;
     removeSelector(data: IWorkerMessage): Promise<void>;
-    updateFullSelectWork(data: IWorkerMessage): void;
+    updateFullSelectWork(data: IWorkerMessage): Promise<void>;
     cursorHover(msg: IWorkerMessage): void;
     cursorBlur(): void;
     checkTextActive(data: IWorkerMessage): Promise<void>;
@@ -70,8 +70,12 @@ export declare class SubLocalMainThreadImpl implements SubLocalThread {
     private consumeCount;
     private combineDrawActiveId?;
     private readonly eraserBatchScheduler;
+    private disposeVNodeRevisionObserver?;
+    private bitmapEraserRenderQueue;
+    private bitmapEraserRevalidationQueued;
     constructor(opt: ISubThreadInitOption);
-    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
+    private scheduleActiveBitmapEraserRevalidation;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "requestId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
     createLocalWork(data: IWorkerMessage): void;
     updateSelector(params: IUpdateSelectorPropsType & {
         callback?: ((props: {
@@ -92,7 +96,7 @@ export declare class SubLocalMainThreadImpl implements SubLocalThread {
     checkTextActive(data: IWorkerMessage): Promise<void>;
     cursorHover(msg: IWorkerMessage): void;
     cursorBlur(): void;
-    updateFullSelectWork(data: IWorkerMessage): void;
+    updateFullSelectWork(data: IWorkerMessage): Promise<void>;
     removeSelector(data: IWorkerMessage): Promise<void>;
     removeWork(data: IWorkerMessage): void;
     removeNode(key: string): void;
@@ -111,8 +115,10 @@ export declare class SubLocalMainThreadImpl implements SubLocalThread {
     getWorkShape(workId: string): BaseShapeTool | undefined;
     getWorkShapes(): Map<string, BaseShapeTool>;
     consumeDraw(data: IWorkerMessage, serviceWork: SubServiceThread): Promise<void>;
-    private drawEraserCombine;
-    consumeDrawAll(data: IWorkerMessage, serviceWork: SubServiceThread): void;
+    private enqueueBitmapEraserRender;
+    private drawPencilEraserCombine;
+    private postEraserBatch;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: SubServiceThread): Promise<void>;
     getToolsOpt(): IActiveToolsDataType | undefined;
     setToolsOpt(opt: IActiveToolsDataType): void;
     setWorkOptions(workId: string, opt: BaseShapeOptions): void;

package/dist/core/mainThread/subServiceThread.d.ts

@@ -11,6 +11,7 @@ export interface SubServiceThread {
     consumeFull(data: IWorkerMessage): void;
     removeWork(data: IWorkerMessage): void;
     runSelectWork(data: IWorkerMessage): void;
+    flush(): Promise<void>;
 }
 export declare class SubServiceMainThreadImpl implements SubServiceThread {
     readonly vNodes: VNodeManager;
@@ -18,11 +19,11 @@ export declare class SubServiceMainThreadImpl implements SubServiceThread {
     workShapes: Map<string, IServiceWorkItem>;
     selectorWorkShapes: Map<string, IServiceWorkItem>;
     private willRunEffectSelectorIds;
-    private runEffectId?;
-    private animationId?;
     private syncUnitTime;
+    private readonly animationScheduler;
+    private readonly effectScheduler;
     constructor(opt: ISubThreadInitOption);
-    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "requestId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
     destroy(): void;
     clearAll(): void;
     private runEffect;
@@ -35,6 +36,7 @@ export declare class SubServiceMainThreadImpl implements SubServiceThread {
     private computNextAnimationIndex;
     private animationDraw;
     private runAnimation;
+    flush(): Promise<void>;
     private hasDiffData;
     private activeWorkShape;
     private removeNode;

package/dist/core/msgEvent/base.d.ts

@@ -21,6 +21,9 @@ export declare abstract class BaseMsgMethod {
     collectForLocalWorker(data: [IWorkerMessage, IqueryTask][], isSync?: boolean): void;
     collectForServiceWorker(actions: BaseCollectorReducerAction[]): void;
     abstract collect(data: unknown, isSync?: boolean): void;
+    protected onAbort(_undoTickerId?: number): void;
+    abort(viewId?: string, workId?: string): boolean;
     pause(viewId?: string, scenePath?: string): Promise<number | undefined>;
-    recover(): void;
+    recover(viewId?: string, scenePath?: string): void;
+    discardRecovery(viewId?: string, scenePath?: string): void;
 }

package/dist/core/msgEvent/baseForWorker.d.ts

@@ -10,5 +10,5 @@ export declare abstract class BaseMsgMethodForWorker {
     serviceWork: ServiceWorkForFullWorker | undefined;
     threadEngine: WorkThreadEngineForFullWorker | undefined;
     registerForWorker(threadEngine: WorkThreadEngineForFullWorker): this;
-    abstract consume(data: IWorkerMessage): boolean | undefined;
+    abstract consume(data: IWorkerMessage): boolean | Promise<boolean | undefined> | undefined;
 }

package/dist/core/msgEvent/copyNode/forWorker.d.ts

@@ -3,6 +3,6 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class CopyNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
 }

package/dist/core/msgEvent/forWorker.d.ts

@@ -8,5 +8,5 @@ export declare class MethodBuilderWorker {
     constructor(emitTypes: EmitEventType[]);
     build(type: EmitEventType): MsgMethodForWorker<BaseMsgMethodForWorker> | undefined;
     registerForWorker(threadEngine: WorkThreadEngineForFullWorker): this;
-    consumeForWorker(data: IWorkerMessage): boolean;
+    consumeForWorker(data: IWorkerMessage): Promise<boolean>;
 }

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

@@ -13,8 +13,10 @@ export declare class MethodBuilderMain {
     destroy(): void;
     pause(): Promise<this>;
     finishActiveContinuousMethods(viewId: string, scenePath: string): Promise<number[]>;
-    recover(): this;
+    abortActiveContinuousMethods(viewId: string, workId?: string): boolean;
+    recover(viewId?: string, scenePath?: string): this;
+    discardRecovery(viewId?: string, scenePath?: string): this;
     static emitMethod(emtType: InternalMsgEmitterType, type: EmitEventType, data: unknown): undefined;
-    static activeListener(callback: (isActive: boolean) => void): void;
-    static unmountActiveListener(callback: (isActive: boolean) => void): void;
+    static activeListener(callback: (isActive: boolean, viewId?: string) => void): void;
+    static unmountActiveListener(callback: (isActive: boolean, viewId?: string) => void): void;
 }

package/dist/core/msgEvent/rotateNode/forMain.d.ts

@@ -13,5 +13,6 @@ export declare class RotateNodeMethod extends BaseMsgMethod {
     protected lastEmtData?: RotateNodeEmtData;
     readonly emitEventType: EmitEventType;
     private cacheOriginRotate;
+    protected onAbort(): void;
     collect(data: RotateNodeEmtData, isSync?: boolean): void;
 }

package/dist/core/msgEvent/rotateNode/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class RotateNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/scaleNode/forMain.d.ts

@@ -19,6 +19,7 @@ export declare class ScaleNodeMethod extends BaseMsgMethod {
     readonly emitEventType: EmitEventType;
     private targetText;
     private cacheTextInfo;
+    protected onAbort(undoTickerId?: number): void;
     private setTextStyle;
     collect(data: ScaleNodeEmtData, isSync?: boolean): Promise<void>;
 }

package/dist/core/msgEvent/scaleNode/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class ScaleNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/setColor/forMain.d.ts

@@ -19,6 +19,7 @@ export declare class SetColorNodeMethod extends BaseMsgMethod {
     protected lastEmtData?: SetColorNodeEmtData;
     readonly emitEventType: EmitEventType;
     private undoTickerId?;
+    protected onAbort(undoTickerId?: number): void;
     private ensureUndoTicker;
     private setTextColor;
     collect(data: SetColorNodeEmtData, isSync?: boolean): void;

package/dist/core/msgEvent/setColor/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class SetColorNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/setFont/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class SetFontStyleMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/setLock/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class SetLockMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/setPoint/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class SetPointMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/setShape/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class SetShapeOptMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/setZIndex/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class ZIndexNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/msgEvent/translateNode/forMain.d.ts

@@ -16,5 +16,6 @@ export declare class TranslateNodeMethod extends BaseMsgMethod {
     protected lastEmtData?: TranslateNodeEmtData;
     readonly emitEventType: EmitEventType;
     private cachePosition;
+    protected onAbort(): void;
     collect(data: TranslateNodeEmtData, isSync?: boolean): void;
 }

package/dist/core/msgEvent/translateNode/forWorker.d.ts

@@ -3,7 +3,7 @@ import { BaseMsgMethodForWorker } from "../baseForWorker";
 import { IWorkerMessage } from "../../types";
 export declare class TranslateNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
-    consume(data: IWorkerMessage): boolean | undefined;
+    consume(data: IWorkerMessage): Promise<boolean> | undefined;
     consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
     private updateSelectorCallback;
 }

package/dist/core/renderRuntimeFallback.d.ts

@@ -0,0 +1,2 @@
+export declare const WebGLProgramUnavailableErrorCode: "WEBGL_PROGRAM_UNAVAILABLE";
+export declare function isWebGLProgramUnavailableMessage(message: unknown): boolean;

package/dist/core/rendererBusinessTask.d.ts

@@ -0,0 +1,30 @@
+export interface RendererBusinessTaskOptions {
+    business: string;
+    stage: string;
+    timeoutMs?: number;
+}
+export declare class RendererBusinessTimeoutError extends Error {
+    readonly code = "RENDERER_BUSINESS_TIMEOUT";
+    readonly business: string;
+    readonly stage: string;
+    readonly elapsedMs: number;
+    reported: boolean;
+    constructor(options: RendererBusinessTaskOptions);
+}
+export declare class RendererBusinessError extends Error {
+    readonly code = "RENDERER_BUSINESS_ERROR";
+    readonly business: string;
+    readonly stage: string;
+    readonly cause: unknown;
+    reported: boolean;
+    constructor(error: unknown, options: Pick<RendererBusinessTaskOptions, "business" | "stage">);
+}
+export type RendererBusinessTaskError = RendererBusinessTimeoutError | RendererBusinessError;
+export declare function waitForRendererBusiness<T>(task: PromiseLike<T>, options: RendererBusinessTaskOptions): Promise<T>;
+export declare function isRendererBusinessTimeoutError(error: unknown): error is RendererBusinessTimeoutError;
+export declare function isRendererBusinessTaskError(error: unknown): error is RendererBusinessTaskError;
+export declare function toRendererBusinessError(error: unknown, options: Pick<RendererBusinessTaskOptions, "business" | "stage">): RendererBusinessTaskError;
+export declare function formatRendererBusinessError(error: unknown, fallback: Pick<RendererBusinessTaskOptions, "business" | "stage">, context: {
+    viewId: string;
+    renderer: string;
+}): string;

package/dist/core/serviceRenderScheduler.d.ts

@@ -0,0 +1,33 @@
+export type ServiceRenderSchedule = (callback: () => void) => number;
+export interface ServiceRenderSchedulerOptions {
+    run: () => void | Promise<void>;
+    schedule: ServiceRenderSchedule;
+    cancel: (handle: number) => void;
+    onError?: (error: unknown) => void;
+}
+export declare function flushServiceRenderBarrier(serviceWork: {
+    flush(): Promise<void>;
+} | undefined, layers: Array<{
+    readonly prepareRender: PromiseLike<unknown>;
+}>): Promise<void>;
+/**
+ * Keeps the normal frame-delayed service render cadence while allowing a
+ * protocol barrier to immediately drain every requested frame.
+ */
+export declare class ServiceRenderScheduler {
+    private readonly options;
+    private scheduledHandle?;
+    private activeTask?;
+    private flushTask?;
+    private pending;
+    private destroyed;
+    private failure?;
+    constructor(options: ServiceRenderSchedulerOptions);
+    request(immediate?: boolean): void;
+    flush(): Promise<void>;
+    destroy(): void;
+    private scheduleTask;
+    private cancelScheduledTask;
+    private startTask;
+    private flushPending;
+}

package/dist/core/tools/base.d.ts

@@ -100,7 +100,7 @@ export declare abstract class BaseShapeTool {
     abstract consumeAll(props: {
         data?: IWorkerMessage;
         workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
-    }): BaseConsumeResultType;
+    }): BaseConsumeResultType | Promise<BaseConsumeResultType>;
     /** 消费服务端数据，返回绘制结果 */
     abstract consumeService(props: {
         isFullWork: boolean;

package/dist/core/tools/bitmapEraserFastPath.d.ts

@@ -0,0 +1,8 @@
+import type { BaseNodeMapItem, IRectType } from "../types";
+export type BitmapEraserFastPathNodeKind = "vector" | "delete-on-done" | "blocked";
+export declare function classifyBitmapEraserFastPathNode(node: BaseNodeMapItem): BitmapEraserFastPathNodeKind;
+export declare function worldPointsToScreen(points: ReadonlyArray<{
+    x: number;
+    y: number;
+}>, worldPosition: readonly [number, number], worldScaling: readonly [number, number]): Array<[number, number]>;
+export declare function capsuleTrackIntersectsRect(points: ReadonlyArray<readonly [number, number]>, radius: number, rect: IRectType): boolean;

package/dist/core/tools/eraserFaces.d.ts

@@ -18,18 +18,25 @@ export interface EraserRuntimeFields extends EraserPersistenceFields {
     doingLines?: SerializerEraserLines;
 }
 type DoingGeometryTransform = (matrix: readonly [number, number, number, number, number, number]) => void;
-export declare function setOutgoingEraserGeometryDelta(opt: object, delta: {
-    matrix: [number, number, number, number, number, number];
+type EraserAffineMatrix = [number, number, number, number, number, number];
+type EraserGeometryDeltaValue = {
+    matrix: EraserAffineMatrix;
     fromDigest: string;
     toDigest: string;
-}): void;
-export declare function getOutgoingEraserGeometryDelta(opt: object): {
-    matrix: [number, number, number, number, number, number];
-    fromDigest: string;
-    toDigest: string;
-} | undefined;
+};
+export declare function setOutgoingEraserGeometryDelta(owner: object, workId: string, delta: EraserGeometryDeltaValue, gestureOwner?: object): void;
+/**
+ * Resolve a delta only when the caller is about to publish the object update.
+ * Selector scale updates are absolute to the gesture baseline, while the
+ * receiver already contains the last published frame. Advancing here keeps
+ * smooth-sync and Done-only sync on the same protocol.
+ */
+export declare function getOutgoingEraserGeometryDelta(owner: object | undefined, workId: string): EraserGeometryDeltaValue | undefined;
+/** Apply an absolute gesture transform to local Doing geometry exactly once. */
+export declare function applyLocalDoingGeometryTransform(owner: object, workId: string, gestureOwner: object | undefined, matrix: EraserAffineMatrix): boolean;
 export declare function registerDoingGeometryTransform(owner: object, workId: string, transform: DoingGeometryTransform, cancel?: () => void): () => void;
 export declare function applyDoingGeometryTransform(owner: object, workId: string, matrix: readonly [number, number, number, number, number, number]): void;
+export declare function hasDoingGeometryTransform(owner: object, workId: string): boolean;
 export declare function cancelDoingForGeometryMismatch(owner: object, workId: string): void;
 export declare function transformEraserLines(lines: SerializerEraserLines, matrix: readonly [number, number, number, number, number, number]): void;
 export declare const DEFAULT_ERASER_FACE_SCALE = 16;
@@ -38,12 +45,20 @@ export declare function shouldDropCancelledEraseResult(cancelledTxnIds: Readonly
 export declare function normalizeEraserPersistence<T extends EraserPersistenceFields>(previous: T | undefined, incoming: T): T;
 export declare function stripEraserRuntimeFields<T extends EraserRuntimeFields>(value: T): T;
 export declare function restoreEraserPersistence<T extends EraserPersistenceFields>(target: T, snapshot: EraserPersistenceFields): T;
-export declare function commitEraserFaces(persistent: EraserPersistenceFields, doingLines: SerializerEraserLines): EraserPersistenceFields;
+export declare function commitEraserFaces(persistent: EraserPersistenceFields, doingLines: SerializerEraserLines, prepared?: SerializedEraserFaces): EraserPersistenceFields;
+export declare function accumulateEraserFaces(prepared: SerializedEraserFaces | undefined, doingLines: SerializerEraserLines): SerializedEraserFaces;
 export declare function encodeEraserFaces(faces: EraserFace[], scale?: number): SerializedEraserFaces;
 export declare function decodeEraserFaces(value: SerializedEraserFaces): EraserFace[];
 export declare function eraserLinesToFaces(lines: SerializerEraserLines, scale?: number): EraserFace[];
 export declare function unionEraserFaces(committed: EraserFace[], doing: EraserFace[], scale?: number): EraserFace[];
+/**
+ * Freeze runtime strokes into faces before applying an object transform.
+ * A scalar stroke width cannot represent a non-uniformly scaled circle, while
+ * transformed face vertices preserve scale, rotation, translation and mirror.
+ */
+export declare function transformPendingEraserFaces(prepared: EraserFace[] | undefined, doingLines: SerializerEraserLines, matrix: readonly [number, number, number, number, number, number]): EraserFace[];
 export declare function transformEraserFaces(faces: EraserFace[], matrix: readonly [number, number, number, number, number, number]): EraserFace[];
+export declare function transformSerializedEraserFaces(value: SerializedEraserFaces, matrix: readonly [number, number, number, number, number, number]): SerializedEraserFaces;
 export declare function geometryDigest(op: number[], centerPos: number[]): string;
 export declare function isValidEraserGeometryDelta(delta: {
     matrix: readonly number[];

package/dist/core/tools/image.d.ts

@@ -53,6 +53,7 @@ export declare class ImageShape extends BaseShapeTool {
         isFullWork: boolean;
         worker: WorkThreadEngineForSimpleWorker | LocalWorkForFullWorker | WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker | SubLocalMainThreadImpl | SnapshotThreadImpl | SubServiceMainThreadImpl;
         replaceId?: string;
+        requestId?: string;
     }): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
     static getScaleType(opt: ImageOptions): EScaleType.all | EScaleType.proportional;

package/dist/core/tools/pencilEraserBitMap.d.ts

@@ -13,14 +13,19 @@ export interface SerializerEraserItem {
 export type SerializerEraserLines = Array<SerializerEraserItem>;
 export interface BitMapEraserOptions extends BaseShapeOptions {
     thickness: number;
+    /** @deprecated Bitmap Eraser now always uses the FullLayer Doing mask. */
+    fullLayerDoingMask?: boolean;
+    maxImageWidth?: number;
+    maxImageHeight?: number;
     removeOnDone?: boolean;
 }
+type BitmapWorkerEngine = LocalWorkForFullWorker | SubLocalMainThreadImpl;
 export declare class BitMapEraserShape extends BaseShapeTool {
     readonly canRotate: boolean;
     readonly scaleType: EScaleType;
     readonly toolsType: EToolsKey;
     private static readonly eraserSizes;
-    protected tmpPoints: Array<Point2d>;
+    protected tmpPoints: Point2d[];
     protected workOptions: BitMapEraserOptions;
     worldPosition: [number, number];
     worldScaling: [number, number];
@@ -28,19 +33,23 @@ export declare class BitMapEraserShape extends BaseShapeTool {
     eraserPolyline?: [number, number, number, number];
     oldRect: IRectType | undefined;
     private committedPointIndex;
+    private candidateWorkIds;
+    private doingPointBatches;
+    private doingLines;
     private readonly changedNodes;
-    private readonly doingLines;
-    private readonly doingTransformDisposers;
     private readonly deletedNodes;
     private changedRect?;
+    private lastSceneRevision;
+    private readonly pendingDeleteIds;
+    private readonly hiddenRenderNodes;
+    private fullLayerPreviewGroup?;
+    private disposeVNodeObserver?;
     constructor(props: BaseShapeToolProps);
-    /** 批量合并消费本地数据,返回绘制结果 */
-    combineConsume(props: {
-        workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
+    /** Consume exactly one accepted input batch and publish one FullLayer preview. */
+    combineConsume(_props: {
+        workerEngine?: BitmapWorkerEngine;
     }): IMainMessage | undefined;
     consumeService(): undefined;
-    private updateTempPoints;
-    private getChangeNodes;
     consume(props: {
         data: IWorkerMessage;
         isFullWork: boolean;
@@ -54,16 +63,16 @@ export declare class BitMapEraserShape extends BaseShapeTool {
         opt: import("./utils").ShapeOptions;
         type: EPostMessageType;
     };
-    private computEraserPointLines;
     consumeAll(props: {
-        workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
-    }): {
+        workerEngine?: BitmapWorkerEngine;
+    }): Promise<{
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
         type: EPostMessageType;
     } | {
         rect: IRectType | undefined;
+        eraseTxnCommitStatus: "applied";
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
@@ -75,12 +84,51 @@ export declare class BitMapEraserShape extends BaseShapeTool {
         ops: string;
         willUpdateNodes: Map<string, BaseNodeMapItem>;
         willDeleteNodes: Set<string>;
+        eraseTxnCommitStatus: "applied";
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
-    };
+    } | {
+        rect: IRectType | undefined;
+        willUpdateNodes: Map<string, BaseNodeMapItem>;
+        willDeleteNodes: Set<string>;
+        eraseTxnRecoveryRequired: boolean;
+        eraseTxnCommitStatus: "failed";
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
+        type: EPostMessageType;
+    }>;
     clearTmpPoints(): void;
-    private commitDoingFaces;
-    private confirmChangedNodeDeletions;
+    shouldRevalidateVNodeRevision(): boolean;
+    private syncWorldTransform;
+    private getEraserThickness;
+    private updateTempPoints;
     private getDeltaPoints;
+    private recordFinalPointBatch;
+    private recordDoingPointBatch;
+    private getDoingPointBatches;
+    private getDoingLines;
+    private getCandidateWorkIds;
+    private appendFullLayerPreview;
+    private getFullLayerPreviewGroup;
+    private getTrackRect;
+    private getScreenTrack;
+    private collectVectorCandidateWorkIds;
+    private hideDeleteCandidatesForPoints;
+    private collectDeleteCandidatesForDone;
+    private hideRenderNodesForId;
+    private restoreNoLongerClearablePendingDeletes;
+    private snapshotDoneCandidates;
+    private collectDoneVectorChanges;
+    private normalizeClippedLine;
+    private commitDoingFaces;
+    private renderChangedNodes;
+    private commitPendingDeletions;
+    private clearFullLayerPreview;
+    private startVNodeObservation;
+    private stopVNodeObservation;
+    private restoreFailedDoneCandidates;
+    private computEraserPointLines;
 }
+export {};

package/dist/core/tools/text.d.ts

@@ -50,13 +50,14 @@ export declare class TextShape extends BaseShapeTool {
         replaceId?: string;
         isDrawLabel?: boolean;
         boxRect?: IRectType;
+        isActive?: () => boolean;
     }): Promise<IRectType | undefined>;
     updataOptService(): IRectType | undefined;
     updataOptServiceAsync(updateNodeOpt: IUpdateNodeOpt, isDrawLabel?: boolean, boxRect?: IRectType): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
     static getSafetySnippetRatio(layer: Group): number;
     static getSafetySnippetFontLength(fontSize: number): number;
-    static createLabels(textOpt: TextOptions, layer: Group, groupRect: IRectType): Promise<{
+    static createLabels(textOpt: TextOptions, layer: Group, groupRect: IRectType, isActive?: () => boolean): Promise<{
         labels: (Group | Polyline | Sprite | Label)[];
         maxWidth: number;
     }>;