@leafer/canvas 1.0.0-beta.9 → 1.0.0-rc.2

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@leafer/canvas",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.2",
   "description": "@leafer/canvas",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -19,15 +22,15 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/file": "1.0.0-beta.9",
-    "@leafer/list": "1.0.0-beta.9",
-    "@leafer/math": "1.0.0-beta.9",
-    "@leafer/data": "1.0.0-beta.9",
-    "@leafer/path": "1.0.0-beta.9",
-    "@leafer/debug": "1.0.0-beta.9",
-    "@leafer/platform": "1.0.0-beta.9"
+    "@leafer/file": "1.0.0-rc.2",
+    "@leafer/list": "1.0.0-rc.2",
+    "@leafer/math": "1.0.0-rc.2",
+    "@leafer/data": "1.0.0-rc.2",
+    "@leafer/path": "1.0.0-rc.2",
+    "@leafer/debug": "1.0.0-rc.2",
+    "@leafer/platform": "1.0.0-rc.2"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.2"
   }
 }

package/src/Canvas.ts

@@ -156,8 +156,13 @@ export class Canvas implements ICanvasAttr {
     @contextMethod()
     public restore(): void { }
 
-    @contextMethod()
-    public transform(_a: number, _b: number, _c: number, _d: number, _e: number, _f: number): void { }
+    public transform(a: number | IMatrixData, b?: number, c?: number, d?: number, e?: number, f?: number): void {
+        if (typeof a === 'object') {
+            this.context.transform(a.a, a.b, a.c, a.d, a.e, a.f)
+        } else {
+            this.context.transform(a, b, c, d, e, f)
+        }
+    }
 
     @contextMethod()
     public translate(_x: number, _y: number): void { }

package/src/HitCanvasManager.ts

@@ -1,4 +1,4 @@
-import { IScreenSizeData, IHitCanvasManager, ILeaf, IHitCanvas, ILeaferCanvas, ILeafList } from '@leafer/interface'
+import { IScreenSizeData, IHitCanvasManager, ILeaf, IHitCanvas, ILeafList } from '@leafer/interface'
 import { LeafList } from '@leafer/list'
 import { Creator } from '@leafer/platform'
 
@@ -10,8 +10,6 @@ export class HitCanvasManager extends CanvasManager implements IHitCanvasManager
     protected pathTypeList: ILeafList = new LeafList()
     protected imageTypeList: ILeafList = new LeafList()
 
-    public get(_size: IScreenSizeData): ILeaferCanvas { return undefined }
-
     public getImageType(leaf: ILeaf, size: IScreenSizeData): IHitCanvas {
         this.imageTypeList.push(leaf)
         return Creator.hitCanvas(size)
@@ -31,13 +29,15 @@ export class HitCanvasManager extends CanvasManager implements IHitCanvasManager
     }
 
     protected __clearLeafList(leafList: ILeafList): void {
-        leafList.forEach(leaf => {
-            if (leaf.__hitCanvas) {
-                leaf.__hitCanvas.destroy()
-                leaf.__hitCanvas = null
-            }
-        })
-        leafList.reset()
+        if (leafList.length) {
+            leafList.forEach(leaf => {
+                if (leaf.__hitCanvas) {
+                    leaf.__hitCanvas.destroy()
+                    leaf.__hitCanvas = null
+                }
+            })
+            leafList.reset()
+        }
     }
 
     public clear(): void {

package/src/LeaferCanvasBase.ts

@@ -1,4 +1,4 @@
-import { IBounds, ILeaferCanvas, ICanvasStrokeOptions, ILeaferCanvasConfig, IMatrixData, IBoundsData, IAutoBounds, IScreenSizeData, IResizeEventListener, IMatrixWithBoundsData, IPointData, InnerId, ICanvasManager, IWindingRule, IBlendMode, IExportImageType, IExportFileType, IBlob } from '@leafer/interface'
+import { IBounds, ILeaferCanvas, ICanvasStrokeOptions, ILeaferCanvasConfig, IMatrixData, IBoundsData, IAutoBounds, IScreenSizeData, IResizeEventListener, IMatrixWithBoundsData, IPointData, InnerId, ICanvasManager, IWindingRule, IBlendMode, IExportImageType, IExportFileType, IBlob, ICursorType } from '@leafer/interface'
 import { Bounds, BoundsHelper, IncrementId } from '@leafer/math'
 import { Creator, Platform } from '@leafer/platform'
 import { DataHelper } from '@leafer/data'
@@ -16,7 +16,7 @@ export const canvasSizeAttrs = ['width', 'height', 'pixelRatio']
 
 export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
-    public readonly innerId: InnerId
+    declare public readonly innerId: InnerId
 
     public name: string
 
@@ -26,7 +26,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     public get pixelWidth(): number { return this.width * this.pixelRatio }
     public get pixelHeight(): number { return this.height * this.pixelRatio }
 
-    public get allowBackgroundColor(): boolean { return this.view && this.parentView && !this.offscreen }
+    public get allowBackgroundColor(): boolean { return this.view && this.parentView }
 
     public bounds: IBounds
     public clientBounds: IBoundsData
@@ -40,8 +40,6 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
     public unreal?: boolean
 
-    public offscreen: boolean
-
     public recycled?: boolean
 
     public worldTransform: IMatrixData = {} as IMatrixData
@@ -60,7 +58,6 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         this.autoLayout = !width || !height
 
         this.pixelRatio = pixelRatio
-        this.offscreen = Platform.isWorker || config.offscreen
         this.config = config
 
         this.init()
@@ -68,7 +65,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
     public init(): void { }
 
-    protected __createContext(): void {
+    public __createContext(): void {
         this.context = this.view.getContext('2d')
         this.__bindContext()
     }
@@ -86,7 +83,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         })
     }
 
-    public toDataURL(type?: IExportImageType, quality?: number): string {
+    public toDataURL(type?: IExportImageType, quality?: number): string | Promise<string> {
         const canvas = this.getSaveCanvas(type)
         const data = Platform.origin.canvasToDataURL(canvas.view, type, quality)
         canvas.recycle()
@@ -149,6 +146,8 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     public startAutoLayout(_autoBounds: IAutoBounds, _listener: IResizeEventListener): void { }
     public stopAutoLayout(): void { }
 
+    public setCursor(_cursor: ICursorType | ICursorType[]): void { }
+
     public setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData, onlyTranslate?: boolean): void {
         const { pixelRatio } = this
         const w = this.worldTransform
@@ -188,6 +187,12 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         }
     }
 
+    public useWorldTransform(worldTransform?: IMatrixData): void {
+        if (worldTransform) this.worldTransform = worldTransform
+        const w = this.worldTransform
+        if (w) this.setTransform(w.a, w.b, w.c, w.d, w.e, w.f)
+    }
+
     public setStroke(color: string | object, strokeWidth: number, options?: ICanvasStrokeOptions): void {
         if (strokeWidth) this.strokeWidth = strokeWidth
         if (color) this.strokeStyle = color
@@ -261,6 +266,12 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         if (blendMode) this.blendMode = 'source-over'
     }
 
+    public copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: IBlendMode): void {
+        this.resetTransform()
+        this.copyWorld(canvas, from, to, blendMode)
+        this.useWorldTransform()
+    }
+
     public useMask(maskCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void {
         this.copyWorld(maskCanvas, fromBounds, toBounds, 'destination-in')
     }
@@ -321,10 +332,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
         canvas.save()
 
-        if (useSameWorldTransform) {
-            const w = this.worldTransform
-            canvas.setTransform(w.a, w.b, w.c, w.d, w.e, w.f)
-        }
+        if (useSameWorldTransform) canvas.useWorldTransform({ ...this.worldTransform })
 
         return canvas
     }
@@ -342,17 +350,17 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     }
 
     public recycle(): void {
-        this.restore()
-        this.manager ? this.manager.recycle(this) : this.destroy()
+        if (!this.recycled) {
+            this.restore()
+            this.manager ? this.manager.recycle(this) : this.destroy()
+        }
     }
 
+    public updateRender(): void { }
+
     public unrealCanvas(): void { }
 
     public destroy(): void {
-        this.manager = null
-        this.view = null
-        this.parentView = null
-        this.context = null
-        this.config = null
+        this.manager = this.view = this.parentView = null
     }
 }

package/types/index.d.ts

@@ -0,0 +1,159 @@
+import { ICanvasManager, ILeaferCanvas, IScreenSizeData, IHitCanvasManager, ILeafList, ILeaf, IHitCanvas, ICanvasAttr, InnerId, ICanvasContext2D, IBlendMode, IMatrixData, IPath2D, IWindingRule, ITextMetrics, IBounds, IBoundsData, ILeaferCanvasConfig, IExportFileType, IBlob, IExportImageType, IAutoBounds, IResizeEventListener, ICursorType, ICanvasStrokeOptions, IPointData, IMatrixWithBoundsData, IPathDrawer } from '@leafer/interface';
+
+declare class CanvasManager implements ICanvasManager {
+    list: ILeaferCanvas[];
+    add(canvas: ILeaferCanvas): void;
+    get(size: IScreenSizeData): ILeaferCanvas;
+    recycle(old: ILeaferCanvas): void;
+    clearRecycled(): void;
+    clear(): void;
+    destroy(): void;
+}
+
+declare class HitCanvasManager extends CanvasManager implements IHitCanvasManager {
+    protected pathTypeList: ILeafList;
+    protected imageTypeList: ILeafList;
+    getImageType(leaf: ILeaf, size: IScreenSizeData): IHitCanvas;
+    getPathType(leaf: ILeaf): IHitCanvas;
+    clearImageType(): void;
+    clearPathType(): void;
+    protected __clearLeafList(leafList: ILeafList): void;
+    clear(): void;
+}
+
+declare class Canvas implements ICanvasAttr {
+    readonly innerId: InnerId;
+    width: number;
+    height: number;
+    context: ICanvasContext2D;
+    smooth: boolean;
+    smoothLevel: ImageSmoothingQuality;
+    opacity: number;
+    set blendMode(value: IBlendMode);
+    get blendMode(): IBlendMode;
+    fillStyle: string | object;
+    strokeStyle: string | object;
+    strokeWidth: number;
+    strokeCap: string;
+    strokeJoin: string;
+    set dashPattern(value: number[]);
+    get dashPattern(): number[];
+    dashOffset: number;
+    miterLimit: number;
+    shadowBlur: number;
+    shadowColor: string;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    filter: string;
+    font: string;
+    fontKerning: string;
+    fontStretch: string;
+    fontVariantCaps: string;
+    textAlign: string;
+    textBaseline: string;
+    textRendering: string;
+    wordSpacing: string;
+    letterSpacing: string;
+    direction: string;
+    __bindContext(): void;
+    setTransform(_a: number | IMatrixData, _b?: number, _c?: number, _d?: number, _e?: number, _f?: number): void;
+    resetTransform(): void;
+    getTransform(): IMatrixData;
+    save(): void;
+    restore(): void;
+    transform(a: number | IMatrixData, b?: number, c?: number, d?: number, e?: number, f?: number): void;
+    translate(_x: number, _y: number): void;
+    scale(_x: number, _y: number): void;
+    rotate(_angle: number): void;
+    fill(_path2d?: IPath2D | IWindingRule, _rule?: IWindingRule): void;
+    stroke(_path2d?: IPath2D): void;
+    clip(_path2d?: IPath2D | IWindingRule, _rule?: IWindingRule): void;
+    fillRect(_x: number, _y: number, _width: number, _height: number): void;
+    strokeRect(_x: number, _y: number, _width: number, _height: number): void;
+    clearRect(_x: number, _y: number, _width: number, _height: number): void;
+    drawImage(image: CanvasImageSource, sx: number, sy: number, sw?: number, sh?: number, dx?: number, dy?: number, dw?: number, dh?: number): void;
+    beginPath(): void;
+    moveTo(_x: number, _y: number): void;
+    lineTo(_x: number, _y: number): void;
+    bezierCurveTo(_cp1x: number, _cp1y: number, _cp2x: number, _cp2y: number, _x: number, _y: number): void;
+    quadraticCurveTo(_cpx: number, _cpy: number, _x: number, _y: number): void;
+    closePath(): void;
+    arc(_x: number, _y: number, _radius: number, _startAngle: number, _endAngle: number, _anticlockwise?: boolean): void;
+    arcTo(_x1: number, _y1: number, _x2: number, _y2: number, _radius: number): void;
+    ellipse(_x: number, _y: number, _radiusX: number, _radiusY: number, _rotation: number, _startAngle: number, _endAngle: number, _anticlockwise?: boolean): void;
+    rect(_x: number, _y: number, _width: number, _height: number): void;
+    roundRect(_x: number, _y: number, _width: number, _height: number, _radius?: number | number[]): void;
+    createConicGradient(_startAngle: number, _x: number, _y: number): CanvasGradient;
+    createLinearGradient(_x0: number, _y0: number, _x1: number, _y1: number): CanvasGradient;
+    createPattern(_image: CanvasImageSource, _repetition: string | null): CanvasPattern | null;
+    createRadialGradient(_x0: number, _y0: number, _r0: number, _x1: number, _y1: number, _r1: number): CanvasGradient;
+    fillText(_text: string, _x: number, _y: number, _maxWidth?: number): void;
+    measureText(_text: string): ITextMetrics;
+    strokeText(_text: string, _x: number, _y: number, _maxWidth?: number): void;
+    destroy(): void;
+}
+
+declare const canvasSizeAttrs: string[];
+declare class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
+    readonly innerId: InnerId;
+    name: string;
+    manager: ICanvasManager;
+    pixelRatio: number;
+    get pixelWidth(): number;
+    get pixelHeight(): number;
+    get allowBackgroundColor(): boolean;
+    bounds: IBounds;
+    clientBounds: IBoundsData;
+    config: ILeaferCanvasConfig;
+    autoLayout: boolean;
+    view: any;
+    parentView: any;
+    unreal?: boolean;
+    recycled?: boolean;
+    worldTransform: IMatrixData;
+    protected savedBlendMode: IBlendMode;
+    constructor(config?: ILeaferCanvasConfig, manager?: ICanvasManager);
+    init(): void;
+    __createContext(): void;
+    toBlob(type?: IExportFileType, quality?: number): Promise<IBlob>;
+    toDataURL(type?: IExportImageType, quality?: number): string | Promise<string>;
+    saveAs(filename: string, quality?: number): Promise<boolean>;
+    getSaveCanvas(type: string): ILeaferCanvas;
+    resize(size: IScreenSizeData): void;
+    updateViewSize(): void;
+    updateClientBounds(): void;
+    startAutoLayout(_autoBounds: IAutoBounds, _listener: IResizeEventListener): void;
+    stopAutoLayout(): void;
+    setCursor(_cursor: ICursorType | ICursorType[]): void;
+    setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData, onlyTranslate?: boolean): void;
+    useWorldTransform(worldTransform?: IMatrixData): void;
+    setStroke(color: string | object, strokeWidth: number, options?: ICanvasStrokeOptions): void;
+    setStrokeOptions(options: ICanvasStrokeOptions): void;
+    saveBlendMode(blendMode: IBlendMode): void;
+    restoreBlendMode(): void;
+    hitFill(point: IPointData, fillRule?: IWindingRule): boolean;
+    hitStroke(point: IPointData, strokeWidth?: number): boolean;
+    setWorldShadow(x: number, y: number, blur: number, color?: string): void;
+    setWorldBlur(blur: number): void;
+    copyWorld(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: IBlendMode): void;
+    copyWorldToInner(canvas: ILeaferCanvas, fromWorld: IMatrixWithBoundsData, toInnerBounds: IBoundsData, blendMode?: IBlendMode): void;
+    copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: IBlendMode): void;
+    useMask(maskCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void;
+    useEraser(eraserCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void;
+    fillWorld(bounds: IBoundsData, color: string | object, blendMode?: IBlendMode): void;
+    strokeWorld(bounds: IBoundsData, color: string | object, blendMode?: IBlendMode): void;
+    clearWorld(bounds: IBoundsData, ceilPixel?: boolean): void;
+    clipWorld(bounds: IBoundsData, ceilPixel?: boolean): void;
+    clear(): void;
+    isSameSize(size: IScreenSizeData): boolean;
+    getSameCanvas(useSameWorldTransform?: boolean): ILeaferCanvas;
+    getBiggerCanvas(addWidth: number, addHeight: number): ILeaferCanvas;
+    recycle(): void;
+    updateRender(): void;
+    unrealCanvas(): void;
+    destroy(): void;
+}
+
+declare function canvasPatch(drawer: IPathDrawer): void;
+
+export { CanvasManager, HitCanvasManager, LeaferCanvasBase, canvasPatch, canvasSizeAttrs };