@netless/appliance-plugin 1.0.0-beta.0

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

@@ -0,0 +1,42 @@
+import { Group, Label, Polyline } from "spritejs";
+import { BaseNodeMapItem, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeTool, BaseShapeToolProps } from "./base";
+import { TextOptions } from "../../component/textEditor";
+import { ShapeNodes } from "./utils";
+import { VNodeManager } from "../worker/vNodeManager";
+export declare class TextShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: TextOptions;
+    oldRect?: IRectType;
+    constructor(props: BaseShapeToolProps);
+    consume(): IMainMessage;
+    consumeAll(): IMainMessage;
+    private draw;
+    consumeService(props: {
+        isFullWork: boolean;
+        replaceId?: string;
+        isDrawLabel?: boolean;
+    }): IRectType | undefined;
+    updataOptService(updateNodeOpt: IUpdateNodeOpt): IRectType | undefined;
+    clearTmpPoints(): void;
+    static getFontWidth(param: {
+        text: string;
+        ctx: OffscreenCanvasRenderingContext2D;
+        opt: TextOptions;
+        worldScaling: number[];
+    }): number;
+    static createLabels(textOpt: TextOptions, layer: Group): (Polyline | Label)[];
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+        targetNode?: BaseNodeMapItem;
+    }): IRectType | undefined;
+    static getRectFromLayer(layer: Group, name: string): IRectType | undefined;
+}

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

@@ -0,0 +1,39 @@
+import { EPostMessageType, EToolsKey } from "../enum";
+import { IRectType } from "../types";
+import type { Ellipse, Group, Path, Polyline, Rect, Sprite } from "spritejs";
+import { PencilOptions, PencilShape } from "./pencil";
+import { LaserPenOptions, LaserPenShape } from "./laserPen";
+import { EraserOptions, EraserShape } from "./eraser";
+import { StarOptions, StarShape } from "./star";
+import { SelectorOptions, SelectorShape } from "./selector";
+import { ArrowOptions, ArrowShape } from "./arrow";
+import { StraightOptions, StraightShape } from "./straight";
+import { EllipseOptions, EllipseShape } from "./ellipse";
+import { PolygonOptions, PolygonShape } from "./polygon";
+import { RectangleOptions, RectangleShape } from "./rectangle";
+import { VNodeManager } from "../worker/vNodeManager";
+import { SpeechBalloonOptions, SpeechBalloonShape } from "./speechBalloon";
+import { TextShape } from "./text";
+import { TextOptions } from "../../component/textEditor";
+import { ImageOptions, ImageShape } from "./image";
+import type { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+export type ShapeTools = typeof PencilShape | typeof LaserPenShape | typeof EraserShape | typeof StarShape | typeof SelectorShape | typeof ArrowShape | typeof EllipseShape | typeof RectangleShape | typeof StarShape | typeof PolygonShape | typeof TextShape | typeof SpeechBalloonShape | typeof ImageShape;
+export type ShapeOptions = PencilOptions | LaserPenOptions | EraserOptions | StarOptions | SelectorOptions | ArrowOptions | EllipseOptions | RectangleOptions | StarOptions | PolygonOptions | StraightOptions | TextOptions | SpeechBalloonOptions | ImageOptions;
+export type ShapeNodes = Group | Path | Polyline | Rect | Ellipse | Sprite;
+export interface CombineConsumeResult {
+    type: EPostMessageType;
+    rect: IRectType | undefined;
+    consumeIndex: number;
+}
+export interface ShapeStateInfo {
+    willClear: boolean;
+}
+export declare function getShapeTools(toolsType: EToolsKey): typeof PencilShape | typeof LaserPenShape | typeof ArrowShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof StarShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof TextShape | typeof EraserShape | typeof SelectorShape | typeof ImageShape | undefined;
+export declare function getShapeInstance(param: {
+    toolsType: EToolsKey;
+    toolsOpt: ShapeOptions;
+    vNodes: VNodeManager;
+    fullLayer: Group;
+    drawLayer?: Group;
+}, serviceWork?: ServiceWorkForFullWorker): SelectorShape | PencilShape | LaserPenShape | ArrowShape | StraightShape | EllipseShape | PolygonShape | StarShape | RectangleShape | SpeechBalloonShape | TextShape | EraserShape | ImageShape | undefined;
+export declare function findShapeBody(nodes: ShapeNodes[]): ShapeNodes[];

package/dist/core/types.d.ts

@@ -0,0 +1,295 @@
+import type { Scene } from 'spritejs';
+import { BaseCollectorReducerAction, INormalPushMsg, ISerializableStorageData } from '../collector/types';
+import { ETextEditorType, FontStyleType, FontWeightType, TextOptions } from '../component/textEditor/types';
+import { EmitEventType } from '../plugin/types';
+import { ECanvasContextType, ECanvasShowType, EDataType, EPostMessageType, EScaleType, EToolsKey, ElayerType, EvevtWorkState } from './enum';
+import { BaseShapeOptions, BaseShapeTool, ShapeOptions } from './tools';
+import type { SelectorShape } from './tools';
+import type { Direction } from "re-resizable/lib/resizer";
+import { ShapeOptType } from '../displayer/types';
+export type IworkId = string | number;
+export type IqueryTask = Partial<IWorkerMessage> | undefined;
+export type ViewWorkerOptions = {
+    offscreenCanvasOpt: IOffscreenCanvasOptionType;
+    layerOpt: ILayerOptionType;
+    dpr: number;
+    originalPoint: [number, number];
+    cameraOpt: ICameraOpt;
+};
+export interface ICanvasSceneType {
+    /** canvas 上下文 */
+    /** canvas 宽度 */
+    width: number;
+    /** canvas 高度 */
+    height: number;
+    /** canvas */
+    canvas: HTMLCanvasElement;
+}
+export interface IOffscreenCanvasOptionType {
+    /** offscreenCanvas 宽度 */
+    width: number;
+    /** offscreenCanvas 高度 */
+    height: number;
+    /** 上下文类型,默认webgl2 */
+    contextType?: ECanvasContextType;
+    /** 是否自动渲染,默认自动渲染 */
+    autoRender?: boolean;
+    /** 缓冲区大小，默认1500 */
+    bufferSize?: number;
+    [key: string]: any;
+}
+export interface ILayerOptionType {
+    offscreen?: boolean;
+    handleEvent?: boolean;
+    depth?: boolean;
+    width: number;
+    height: number;
+    bufferSize?: number;
+}
+export interface IUpdateNodeOpt {
+    scale?: [number, number];
+    box?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    dir?: Direction;
+    translate?: [number, number];
+    selectorColor?: string;
+    strokeColor?: string;
+    fillColor?: string;
+    fontColor?: string;
+    fontBgColor?: string;
+    isOpacity?: boolean;
+    pos?: [number, number];
+    workState?: EvevtWorkState;
+    useAnimation?: boolean;
+    zIndex?: number;
+    zIndexLayer?: ElayerType;
+    originPos?: [number, number];
+    ops?: string;
+    angle?: number;
+    centralPoint?: [number, number];
+    selectScale?: number[];
+    boxScale?: [number, number];
+    boxTranslate?: [number, number];
+    bold?: FontWeightType;
+    italic?: FontStyleType;
+    underline?: boolean;
+    lineThrough?: boolean;
+    fontSize?: number;
+    pointMap?: Map<string, [number, number][]>;
+    textInfos?: Map<string, Partial<TextOptions>>;
+    isLocked?: boolean;
+    toolsType?: EToolsKey;
+    willRefresh?: boolean;
+    [key: string]: any;
+}
+export type IWorkerMessage = Omit<Partial<BaseCollectorReducerAction>, 'op'> & {
+    viewId: string;
+    msgType: EPostMessageType;
+    dataType: EDataType;
+    scenePath?: string;
+    workState?: EvevtWorkState;
+    op?: number[];
+    offscreenCanvasOpt?: IOffscreenCanvasOptionType;
+    dpr?: number;
+    vertex?: string;
+    fragment?: string;
+    workId?: IworkId;
+    workOption?: BaseShapeOptions;
+    toolsType?: EToolsKey;
+    uid?: string;
+    cameraOpt?: ICameraOpt;
+    translate?: [number, number];
+    scale?: number;
+    currentToolsData?: IActiveToolsDataType;
+    updateNodeOpt?: IUpdateNodeOpt;
+    layerOpt?: ILayerOptionType;
+    drawCount?: number;
+    useAnimation?: boolean;
+    willRefreshSelector?: boolean;
+    willSyncService?: boolean;
+    willRefresh?: boolean;
+    isActiveZIndex?: boolean;
+    selectStore?: Map<string, {
+        ops?: string;
+        opt?: BaseShapeOptions;
+        updateNodeOpt?: IUpdateNodeOpt;
+    }>;
+    willSerializeData?: boolean;
+    isRunSubWork?: boolean;
+    undoTickerId?: number;
+    scenes?: ISerializableStorageData;
+    textType?: ETextEditorType;
+    mainTasksqueueCount?: number;
+    textUpdateForWoker?: boolean;
+    tasksqueue?: Map<string, IWorkerMessage>;
+    point?: [number, number];
+    [key: string]: any;
+};
+export interface IRectType {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface IMainMessage extends INormalPushMsg {
+    type: EPostMessageType;
+    dataType?: EDataType;
+    imageBitmap?: ImageBitmap | OffscreenCanvas;
+    rect?: IRectType;
+    dpr?: number;
+    translate?: [number, number];
+    scale?: number;
+    removeIds?: Array<string>;
+    /** 是否是完整的一次任务 */
+    isFullWork?: boolean;
+    drawCount?: number;
+    selectIds?: Array<string>;
+    padding?: number;
+    selectRect?: IRectType;
+    selectorColor?: string;
+    strokeColor?: string;
+    fillColor?: string;
+    isOpacity?: boolean;
+    updateNodeOpts?: Map<string, IUpdateNodeOpt>;
+    willSyncService?: boolean;
+    newWorkDatas?: Map<string, {
+        op: number[];
+        opt: BaseShapeOptions;
+        workId: IworkId;
+        toolsType: EToolsKey;
+    }>;
+    undoTickerId?: number;
+    scenePath?: string;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    workState?: EvevtWorkState;
+    canTextEdit?: boolean;
+    canRotate?: boolean;
+    canLock?: boolean;
+    scaleType?: EScaleType;
+    textOpt?: TextOptions;
+    viewId?: string;
+    points?: [number, number][];
+    isRefresh?: boolean;
+    renderRect?: IRectType;
+    isLocked?: boolean;
+    shapeOpt?: ShapeOptType;
+    toolsTypes?: EToolsKey[];
+}
+export interface IMainMessageRenderData {
+    viewId: string;
+    rect?: IRectType;
+    imageBitmap?: ImageBitmap;
+    isDrawAll?: boolean;
+    drawCanvas?: ECanvasShowType;
+    isClear?: boolean;
+    isClearAll?: boolean;
+    clearCanvas?: ECanvasShowType;
+    /** 是否需要销毁imageBitmap */
+    isUnClose?: boolean;
+    isFullWork?: boolean;
+    workerType?: EDataType.Local | EDataType.Service;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    translate?: [number, number];
+}
+export interface IBatchMainMessage {
+    /** 绘制数据 */
+    render?: Array<IMainMessageRenderData>;
+    /** 同步服务端数据 */
+    sp?: Array<IMainMessage>;
+    drawCount?: number;
+    workerTasksqueueCount?: number;
+}
+export interface ICameraOpt {
+    centerX: number;
+    centerY: number;
+    scale: number;
+    width: number;
+    height: number;
+}
+export interface IUpdateSelectorPropsType {
+    updateSelectorOpt: IUpdateNodeOpt;
+    willRefreshSelector?: boolean;
+    willSyncService?: boolean;
+    willSerializeData?: boolean;
+    emitEventType?: EmitEventType;
+    isSync?: boolean;
+    textUpdateForWoker?: boolean;
+    scene?: Scene;
+}
+export interface IUpdateSelectorCallbackPropsType {
+    res?: IMainMessage;
+    param: IUpdateSelectorPropsType;
+    postData: Pick<IBatchMainMessage, 'sp' | 'render'>;
+    workShapeNode: SelectorShape;
+    newServiceStore: Map<string, {
+        opt: BaseShapeOptions;
+        toolsType: EToolsKey;
+        ops?: string;
+    }>;
+}
+export interface IActiveToolsDataType {
+    toolsType: EToolsKey;
+    toolsOpt: ShapeOptions;
+}
+export interface IActiveWorkDataType {
+    workState: EvevtWorkState;
+    toolsOpt?: ShapeOptions;
+    viewId?: string;
+    workId?: IworkId;
+    undoTickerId?: number;
+}
+export type IServiceWorkItem = {
+    toolsType: EToolsKey;
+    animationWorkData?: number[];
+    animationIndex?: number;
+    type: EPostMessageType;
+    node?: BaseShapeTool;
+    updateNodeOpt?: IUpdateNodeOpt;
+    ops?: string;
+    isDel?: boolean;
+    timer?: number;
+    useAnimation?: boolean;
+    bindSelector?: string;
+    selectIds?: string[];
+    oldRect?: IRectType;
+    totalRect?: IRectType;
+    isDiff?: boolean;
+};
+export type BaseNodeMapItem = {
+    name: string;
+    rect: IRectType;
+    op: number[];
+    opt: BaseShapeOptions;
+    centerPos: [number, number];
+    toolsType: EToolsKey;
+    canRotate: boolean;
+    scaleType: EScaleType;
+};
+export type Size = {
+    /**
+     * 宽
+     */
+    width: number;
+    /**
+     * 高
+     */
+    height: number;
+};
+export type Rectangle = Size & {
+    /**
+     * 矩形的左上角 x 坐标
+     */
+    originX: number;
+    /**
+     * 矩形的左上角 y 坐标
+     */
+    originY: number;
+};

package/dist/core/utils/bezier.d.ts

@@ -0,0 +1,43 @@
+import { Vec2d } from "./primitives/Vec2d";
+/**
+ * @desc 贝塞尔曲线算法，包含了3阶贝塞尔
+ */
+export declare class Bezier {
+    static bezier(num: number, points: Vec2d[]): Vec2d[];
+    /**
+     * @desc 获取点，这里可以设置点的个数
+     * @param {number} num 点个数
+     * @param {Vec2d} p1 点坐标
+     * @param {Vec2d} p2 点坐标
+     * @param {Vec2d} p3 点坐标
+     * @param {Vec2d} p4 点坐标
+     * 如果参数是 num, p1, p2 为一阶贝塞尔
+     * 如果参数是 num, p1, c1, p2 为二阶贝塞尔
+     * 如果参数是 num, p1, c1, c2, p2 为三阶贝塞尔
+     */
+    static getBezierPoints(num: number | undefined, p1: Vec2d, p2: Vec2d, p3?: Vec2d, p4?: Vec2d): Vec2d[];
+    /**
+     * @desc 一阶贝塞尔
+     * @param {number} t 当前百分比
+     * @param {Vec2d} p1 起点坐标
+     * @param {Vec2d} p2 终点坐标
+     */
+    static oneBezier(t: number, p1: Vec2d, p2: Vec2d): Vec2d;
+    /**
+     * @desc 二阶贝塞尔
+     * @param {number} t 当前百分比
+     * @param {Array} p1 起点坐标
+     * @param {Array} p2 终点坐标
+     * @param {Array} cp 控制点
+     */
+    static twoBezier(t: number, p1: Vec2d, cp: Vec2d, p2: Vec2d): Vec2d;
+    /**
+     * @desc 三阶贝塞尔
+     * @param {number} t 当前百分比
+     * @param {Array} p1 起点坐标
+     * @param {Array} p2 终点坐标
+     * @param {Array} cp1 控制点1
+     * @param {Array} cp2 控制点2
+     */
+    static threeBezier(t: number, p1: Vec2d, cp1: Vec2d, cp2: Vec2d, p2: Vec2d): Vec2d;
+}

package/dist/core/utils/getSvgPathFromPoints.d.ts

@@ -0,0 +1,10 @@
+import { PointLike } from './primitives/Point2d';
+/**
+ * Turn an array of points into a path of quadradic curves.
+ *
+ * @param points - The points returned from perfect-freehand
+ * @param closed - Whether the stroke is closed
+ *
+ * @public
+ */
+export declare function getSvgPathFromPoints(points: PointLike[], closed?: boolean): string;