@leafer/canvas 1.0.0-rc.8 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/canvas",
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0",
   "description": "@leafer/canvas",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,15 +22,15 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/file": "1.0.0-rc.8",
-    "@leafer/list": "1.0.0-rc.8",
-    "@leafer/math": "1.0.0-rc.8",
-    "@leafer/data": "1.0.0-rc.8",
-    "@leafer/path": "1.0.0-rc.8",
-    "@leafer/debug": "1.0.0-rc.8",
-    "@leafer/platform": "1.0.0-rc.8"
+    "@leafer/file": "1.0.0",
+    "@leafer/list": "1.0.0",
+    "@leafer/math": "1.0.0",
+    "@leafer/data": "1.0.0",
+    "@leafer/path": "1.0.0",
+    "@leafer/debug": "1.0.0",
+    "@leafer/platform": "1.0.0"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.8"
+    "@leafer/interface": "1.0.0"
   }
 }

package/src/Canvas.ts

@@ -24,9 +24,6 @@ export class Canvas implements ICanvasAttr {
 
     public readonly innerId: InnerId
 
-    public width: number
-    public height: number
-
     public context: ICanvasContext2D
 
     // canvas attr

package/src/CanvasManager.ts

@@ -28,10 +28,7 @@ export class CanvasManager implements ICanvasManager {
     }
 
     public recycle(old: ILeaferCanvas): void {
-        if (!old.recycled) {
-            old.clear()
-            old.recycled = true
-        }
+        old.recycled = true
     }
 
     public clearRecycled(): void {

package/src/LeaferCanvasBase.ts

@@ -1,16 +1,13 @@
-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 { IBounds, ILeaferCanvas, ICanvasStrokeOptions, ILeaferCanvasConfig, IExportOptions, IMatrixData, IBoundsData, IAutoBounds, IScreenSizeData, IResizeEventListener, IMatrixWithBoundsData, IPointData, InnerId, ICanvasManager, IWindingRule, IBlendMode, IExportImageType, IExportFileType, IBlob, ICursorType, ILeaferCanvasView, IRadiusPointData } from '@leafer/interface'
+import { Bounds, tempBounds, BoundsHelper, MatrixHelper, IncrementId } from '@leafer/math'
 import { Creator, Platform } from '@leafer/platform'
 import { DataHelper } from '@leafer/data'
-import { FileHelper } from '@leafer/file'
-import { Debug } from '@leafer/debug'
 
 import { Canvas } from './Canvas'
 
 
-const temp = new Bounds()
+const { copy } = MatrixHelper
 const minSize: IScreenSizeData = { width: 1, height: 1, pixelRatio: 1 }
-const debug = Debug.get('LeaferCanvasBase')
 
 export const canvasSizeAttrs = ['width', 'height', 'pixelRatio']
 
@@ -22,7 +19,12 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
     public manager: ICanvasManager
 
-    public pixelRatio: number
+    public size: IScreenSizeData = {} as IScreenSizeData
+
+    public get width(): number { return this.size.width }
+    public get height(): number { return this.size.height }
+
+    public get pixelRatio(): number { return this.size.pixelRatio }
     public get pixelWidth(): number { return this.width * this.pixelRatio }
     public get pixelHeight(): number { return this.height * this.pixelRatio }
 
@@ -35,7 +37,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
     public autoLayout: boolean
 
-    public view: any
+    public view: ILeaferCanvasView
     public parentView: any
 
     public unreal?: boolean
@@ -57,7 +59,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         const { width, height, pixelRatio } = config
         this.autoLayout = !width || !height
 
-        this.pixelRatio = pixelRatio
+        this.size.pixelRatio = pixelRatio
         this.config = config
 
         this.init()
@@ -66,52 +68,23 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     public init(): void { }
 
     public __createContext(): void {
-        this.context = this.view.getContext('2d')
+        const { view } = this
+        const { contextSettings } = this.config
+        this.context = contextSettings ? view.getContext('2d', contextSettings) : view.getContext('2d')
         this.__bindContext()
     }
 
-    public toBlob(type?: IExportFileType, quality?: number): Promise<IBlob> {
-        return new Promise((resolve) => {
-            const canvas = this.getSaveCanvas(type)
-            Platform.origin.canvasToBolb(canvas.view, type, quality).then((blob) => {
-                canvas.recycle()
-                resolve(blob)
-            }).catch((e) => {
-                debug.error(e)
-                resolve(null)
-            })
-        })
-    }
+    // @leafer-ui/export rewrite
 
-    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()
-        return data
-    }
+    public export(_filename: IExportFileType | string, _options?: IExportOptions | number | boolean): string | Promise<any> { return undefined }
 
-    public saveAs(filename: string, quality?: number): Promise<boolean> {
-        return new Promise((resolve) => {
-            const canvas = this.getSaveCanvas(FileHelper.fileType(filename))
-            Platform.origin.canvasSaveAs(canvas.view, filename, quality).then(() => {
-                canvas.recycle()
-                resolve(true)
-            }).catch((e) => {
-                debug.error(e)
-                resolve(false)
-            })
-        })
-    }
+    public toBlob(_type?: IExportFileType, _quality?: number): Promise<IBlob> { return undefined }
 
-    public getSaveCanvas(type: string): ILeaferCanvas {
-        const { backgroundColor, bounds } = this as ILeaferCanvas
-        const canvas = this.getSameCanvas()
-        if (['jpg', 'jpeg'].includes(type)) canvas.fillWorld(bounds, '#FFFFFF')
-        if (backgroundColor) canvas.fillWorld(bounds, backgroundColor)
-        canvas.copyWorld(this)
-        return canvas
-    }
+    public toDataURL(_type?: IExportImageType, _quality?: number): string | Promise<string> { return undefined }
 
+    public saveAs(_filename: string, _quality?: number): Promise<boolean> { return undefined }
+
+    // ---
 
     public resize(size: IScreenSizeData): void {
         if (this.isSameSize(size)) return
@@ -122,9 +95,10 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
             takeCanvas.copyWorld(this)
         }
 
-        DataHelper.copyAttrs(this, size, canvasSizeAttrs)
+        DataHelper.copyAttrs(this.size, size, canvasSizeAttrs)
+        this.size.pixelRatio || (this.size.pixelRatio = 1)
+
         this.bounds = new Bounds(0, 0, this.width, this.height)
-        this.pixelRatio || (this.pixelRatio = 1)
 
         if (!this.unreal) {
             this.updateViewSize()
@@ -142,37 +116,30 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
     public updateViewSize(): void { }
     public updateClientBounds(): void { }
+    public getClientBounds(update?: boolean): IBoundsData {
+        if (update) this.updateClientBounds()
+        return this.clientBounds || this.bounds
+    }
 
     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 {
+    public setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData): void {
         const { pixelRatio } = this
         const w = this.worldTransform
         if (parentMatrix) {
 
-            if (onlyTranslate) {
-                this.setTransform(
-                    w.a = matrix.a * pixelRatio,
-                    w.b = matrix.b * pixelRatio,
-                    w.c = matrix.c * pixelRatio,
-                    w.d = matrix.d * pixelRatio,
-                    w.e = (matrix.e + parentMatrix.e) * pixelRatio,
-                    w.f = (matrix.f + parentMatrix.f) * pixelRatio
-                )
-            } else {
-                const { a, b, c, d, e, f } = parentMatrix
-                this.setTransform(
-                    w.a = ((matrix.a * a) + (matrix.b * c)) * pixelRatio,
-                    w.b = ((matrix.a * b) + (matrix.b * d)) * pixelRatio,
-                    w.c = ((matrix.c * a) + (matrix.d * c)) * pixelRatio,
-                    w.d = ((matrix.c * b) + (matrix.d * d)) * pixelRatio,
-                    w.e = (((matrix.e * a) + (matrix.f * c) + e)) * pixelRatio,
-                    w.f = (((matrix.e * b) + (matrix.f * d) + f)) * pixelRatio
-                )
-            }
+            const { a, b, c, d, e, f } = parentMatrix
+            this.setTransform(
+                w.a = ((matrix.a * a) + (matrix.b * c)) * pixelRatio,
+                w.b = ((matrix.a * b) + (matrix.b * d)) * pixelRatio,
+                w.c = ((matrix.c * a) + (matrix.d * c)) * pixelRatio,
+                w.d = ((matrix.c * b) + (matrix.d * d)) * pixelRatio,
+                w.e = (((matrix.e * a) + (matrix.f * c) + e)) * pixelRatio,
+                w.f = (((matrix.e * b) + (matrix.f * d) + f)) * pixelRatio
+            )
 
         } else {
 
@@ -200,7 +167,7 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     }
 
     public setStrokeOptions(options: ICanvasStrokeOptions): void {
-        this.strokeCap = options.strokeCap
+        this.strokeCap = options.strokeCap === 'none' ? 'butt' : options.strokeCap
         this.strokeJoin = options.strokeJoin
         this.dashPattern = options.dashPattern
         this.dashOffset = options.dashOffset
@@ -216,15 +183,15 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         this.blendMode = this.savedBlendMode
     }
 
-    public hitFill(point: IPointData, fillRule?: IWindingRule): boolean {
-        return fillRule ? this.context.isPointInPath(point.x, point.y, fillRule) : this.context.isPointInPath(point.x, point.y)
-    }
+    // @leafer-ui/interaction rewrite
 
-    public hitStroke(point: IPointData, strokeWidth?: number): boolean {
-        this.strokeWidth = strokeWidth
-        return this.context.isPointInStroke(point.x, point.y)
-    }
+    public hitFill(_point: IPointData, _fillRule?: IWindingRule): boolean { return true }
+
+    public hitStroke(_point: IPointData, _strokeWidth?: number): boolean { return true }
+
+    public hitPixel(_radiusPoint: IRadiusPointData, _offset?: IPointData, _scale = 1): boolean { return true }
 
+    // ---
 
     public setWorldShadow(x: number, y: number, blur: number, color?: string): void {
         const { pixelRatio } = this
@@ -266,10 +233,10 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
         if (blendMode) this.blendMode = 'source-over'
     }
 
-    public copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: IBlendMode): void {
+    public copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: IBlendMode, onlyResetTransform?: boolean): void {
         this.resetTransform()
         this.copyWorld(canvas, from, to, blendMode)
-        this.useWorldTransform()
+        if (!onlyResetTransform) this.useWorldTransform() // restore world transform
     }
 
     public useMask(maskCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void {
@@ -283,37 +250,37 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     public fillWorld(bounds: IBoundsData, color: string | object, blendMode?: IBlendMode): void {
         if (blendMode) this.blendMode = blendMode
         this.fillStyle = color
-        temp.set(bounds).scale(this.pixelRatio)
-        this.fillRect(temp.x, temp.y, temp.width, temp.height)
+        tempBounds.set(bounds).scale(this.pixelRatio)
+        this.fillRect(tempBounds.x, tempBounds.y, tempBounds.width, tempBounds.height)
         if (blendMode) this.blendMode = 'source-over'
     }
 
     public strokeWorld(bounds: IBoundsData, color: string | object, blendMode?: IBlendMode): void {
         if (blendMode) this.blendMode = blendMode
         this.strokeStyle = color
-        temp.set(bounds).scale(this.pixelRatio)
-        this.strokeRect(temp.x, temp.y, temp.width, temp.height)
+        tempBounds.set(bounds).scale(this.pixelRatio)
+        this.strokeRect(tempBounds.x, tempBounds.y, tempBounds.width, tempBounds.height)
         if (blendMode) this.blendMode = 'source-over'
     }
 
     public clearWorld(bounds: IBoundsData, ceilPixel?: boolean): void {
-        temp.set(bounds).scale(this.pixelRatio)
-        if (ceilPixel) temp.ceil()
-        this.clearRect(temp.x, temp.y, temp.width, temp.height)
+        tempBounds.set(bounds).scale(this.pixelRatio)
+        if (ceilPixel) tempBounds.ceil()
+        this.clearRect(tempBounds.x, tempBounds.y, tempBounds.width, tempBounds.height)
     }
 
     public clipWorld(bounds: IBoundsData, ceilPixel?: boolean): void {
         this.beginPath()
-        temp.set(bounds).scale(this.pixelRatio)
-        if (ceilPixel) temp.ceil()
-        this.rect(temp.x, temp.y, temp.width, temp.height)
+        tempBounds.set(bounds).scale(this.pixelRatio)
+        if (ceilPixel) tempBounds.ceil()
+        this.rect(tempBounds.x, tempBounds.y, tempBounds.width, tempBounds.height)
         this.clip()
 
     }
 
     public clear(): void {
         const { pixelRatio } = this
-        this.clearRect(0, 0, this.width * pixelRatio, this.height * pixelRatio)
+        this.clearRect(0, 0, this.width * pixelRatio + 2, this.height * pixelRatio + 2)
     }
 
 
@@ -325,34 +292,20 @@ export class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
     // 需要有 manager变量
     public getSameCanvas(useSameWorldTransform?: boolean, useSameSmooth?: boolean): ILeaferCanvas {
-        const { width, height, pixelRatio } = this
-
-        const options = { width, height, pixelRatio }
-        const canvas = this.manager ? this.manager.get(options) : Creator.canvas(options)
-
+        const canvas = this.manager ? this.manager.get(this.size) : Creator.canvas({ ...this.size })
         canvas.save()
 
-        if (useSameWorldTransform) canvas.useWorldTransform({ ...this.worldTransform })
-        if (useSameSmooth) canvas.smooth = this.smooth
-
-        return canvas
-    }
-
-    public getBiggerCanvas(addWidth: number, addHeight: number): ILeaferCanvas {
-        let { width, height, pixelRatio } = this
-        if (addWidth) width += addWidth
-        if (addHeight) height += addHeight
 
-        const options = { width, height, pixelRatio }
-        const canvas = this.manager ? this.manager.get(options) : Creator.canvas(options)
+        if (useSameWorldTransform) copy(canvas.worldTransform, this.worldTransform), canvas.useWorldTransform()
+        if (useSameSmooth) canvas.smooth = this.smooth
 
-        canvas.save()
         return canvas
     }
 
-    public recycle(): void {
+    public recycle(clearBounds?: IBoundsData): void {
         if (!this.recycled) {
             this.restore()
+            clearBounds ? this.clearWorld(clearBounds, true) : this.clear()
             this.manager ? this.manager.recycle(this) : this.destroy()
         }
     }

package/src/index.ts

@@ -1,4 +1,3 @@
 export { CanvasManager } from './CanvasManager'
-export { HitCanvasManager } from './HitCanvasManager'
 export { LeaferCanvasBase, canvasSizeAttrs } from './LeaferCanvasBase'
 export { canvasPatch } from './patch'

package/types/index.d.ts

@@ -1,4 +1,4 @@
-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';
+import { ICanvasManager, ILeaferCanvas, IScreenSizeData, ICanvasAttr, InnerId, ICanvasContext2D, IBlendMode, IMatrixData, IPath2D, IWindingRule, ITextMetrics, IBounds, IBoundsData, ILeaferCanvasConfig, ILeaferCanvasView, IExportFileType, IExportOptions, IBlob, IExportImageType, IAutoBounds, IResizeEventListener, ICursorType, ICanvasStrokeOptions, IPointData, IRadiusPointData, IMatrixWithBoundsData, IPathDrawer } from '@leafer/interface';
 
 declare class CanvasManager implements ICanvasManager {
     list: ILeaferCanvas[];
@@ -10,21 +10,8 @@ declare class CanvasManager implements ICanvasManager {
     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;
@@ -98,7 +85,10 @@ declare class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     readonly innerId: InnerId;
     name: string;
     manager: ICanvasManager;
-    pixelRatio: number;
+    size: IScreenSizeData;
+    get width(): number;
+    get height(): number;
+    get pixelRatio(): number;
     get pixelWidth(): number;
     get pixelHeight(): number;
     get allowBackgroundColor(): boolean;
@@ -106,7 +96,7 @@ declare class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     clientBounds: IBoundsData;
     config: ILeaferCanvasConfig;
     autoLayout: boolean;
-    view: any;
+    view: ILeaferCanvasView;
     parentView: any;
     unreal?: boolean;
     recycled?: boolean;
@@ -115,29 +105,31 @@ declare class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     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;
+    export(_filename: IExportFileType | string, _options?: IExportOptions | number | boolean): string | Promise<any>;
+    toBlob(_type?: IExportFileType, _quality?: number): Promise<IBlob>;
+    toDataURL(_type?: IExportImageType, _quality?: number): string | Promise<string>;
+    saveAs(_filename: string, _quality?: number): Promise<boolean>;
     resize(size: IScreenSizeData): void;
     updateViewSize(): void;
     updateClientBounds(): void;
+    getClientBounds(update?: boolean): IBoundsData;
     startAutoLayout(_autoBounds: IAutoBounds, _listener: IResizeEventListener): void;
     stopAutoLayout(): void;
     setCursor(_cursor: ICursorType | ICursorType[]): void;
-    setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData, onlyTranslate?: boolean): void;
+    setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData): 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;
+    hitFill(_point: IPointData, _fillRule?: IWindingRule): boolean;
+    hitStroke(_point: IPointData, _strokeWidth?: number): boolean;
+    hitPixel(_radiusPoint: IRadiusPointData, _offset?: IPointData, _scale?: 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;
+    copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: IBlendMode, onlyResetTransform?: boolean): 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;
@@ -147,8 +139,7 @@ declare class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
     clear(): void;
     isSameSize(size: IScreenSizeData): boolean;
     getSameCanvas(useSameWorldTransform?: boolean, useSameSmooth?: boolean): ILeaferCanvas;
-    getBiggerCanvas(addWidth: number, addHeight: number): ILeaferCanvas;
-    recycle(): void;
+    recycle(clearBounds?: IBoundsData): void;
     updateRender(): void;
     unrealCanvas(): void;
     destroy(): void;
@@ -156,4 +147,4 @@ declare class LeaferCanvasBase extends Canvas implements ILeaferCanvas {
 
 declare function canvasPatch(drawer: IPathDrawer): void;
 
-export { CanvasManager, HitCanvasManager, LeaferCanvasBase, canvasPatch, canvasSizeAttrs };
+export { CanvasManager, LeaferCanvasBase, canvasPatch, canvasSizeAttrs };

package/src/HitCanvasManager.ts

@@ -1,48 +0,0 @@
-import { IScreenSizeData, IHitCanvasManager, ILeaf, IHitCanvas, ILeafList } from '@leafer/interface'
-import { LeafList } from '@leafer/list'
-import { Creator } from '@leafer/platform'
-
-import { CanvasManager } from './CanvasManager'
-
-
-export class HitCanvasManager extends CanvasManager implements IHitCanvasManager {
-
-    protected pathTypeList: ILeafList = new LeafList()
-    protected imageTypeList: ILeafList = new LeafList()
-
-    public getImageType(leaf: ILeaf, size: IScreenSizeData): IHitCanvas {
-        this.imageTypeList.add(leaf)
-        return Creator.hitCanvas(size)
-    }
-
-    public getPathType(leaf: ILeaf): IHitCanvas {
-        this.pathTypeList.add(leaf)
-        return Creator.hitCanvas()
-    }
-
-    public clearImageType(): void {
-        this.__clearLeafList(this.imageTypeList)
-    }
-
-    public clearPathType(): void {
-        this.__clearLeafList(this.pathTypeList)
-    }
-
-    protected __clearLeafList(leafList: ILeafList): void {
-        if (leafList.length) {
-            leafList.forEach(leaf => {
-                if (leaf.__hitCanvas) {
-                    leaf.__hitCanvas.destroy()
-                    leaf.__hitCanvas = null
-                }
-            })
-            leafList.reset()
-        }
-    }
-
-    public clear(): void {
-        this.clearPathType()
-        this.clearImageType()
-    }
-
-}