@leafer/interface 1.0.0-alpha.7 → 1.0.0-bate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/interface",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-bate",
   "description": "@leafer/interface",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",

package/src/app/IApp.ts

@@ -0,0 +1,6 @@
+import { ILeafer } from './ILeafer'
+
+export interface IApp extends ILeafer {
+    children: ILeafer[]
+    realCanvas: boolean
+}

package/src/app/ILeafer.ts

@@ -2,36 +2,40 @@ import { ILeaf } from '../display/ILeaf'
 import { IRenderer, IRendererConfig } from '../renderer/IRenderer'
 import { IHitCanvas, ILeaferCanvas, ILeaferCanvasConfig, IHitCanvasConfig } from '../canvas/ILeaferCanvas'
 import { ILayouter, ILayouterConfig } from '../layouter/ILayouter'
-import { ISelector } from '../selector/ISelector'
-import { IInteraction, IInteractionConfig } from '../interaction/IInteraction'
-import { IWatcher } from '../watcher/IWatcher'
+import { ISelector, ISelectorConfig } from '../selector/ISelector'
+import { IInteraction, IInteractionCanvas, IInteractionConfig } from '../interaction/IInteraction'
+import { IWatcher, IWatcherConfig } from '../watcher/IWatcher'
 import { IAutoBounds, IScreenSizeData } from '../math/IMath'
 import { ICanvasManager } from '../canvas/ICanvasManager'
 import { IHitCanvasManager } from '../canvas/IHitCanvasManager'
 import { IImageManager } from '../image/IImageManager'
+import { IEventListenerId } from '../event/IEventer'
 import { IObject } from '../data/IData'
 import { IZoomView } from '../display/IView'
-import { ISupperLeafer } from './ISupperLeafer'
+import { IApp } from './IApp'
 import { ILeaferImage, ILeaferImageConfig } from '../image/ILeaferImage'
-import { IEvent } from '../event/IEvent'
+import { IControl } from '../control/IControl'
 
 
+export type ILeaferType = 'draw' | 'design' | 'board' | 'document' | 'user'
 export interface ILeaferConfig extends IRendererConfig, ILeaferCanvasConfig, IInteractionConfig, ILayouterConfig {
     start?: boolean
-    zoom?: boolean
-    move?: boolean
+    type?: ILeaferType
+    realCanvas?: boolean
 }
 
-export interface ILeafer extends IZoomView {
+export interface ILeafer extends IZoomView, IControl {
 
-    creator: ICreator
-
-    readonly isSupperLeafer: boolean
-    parent?: ISupperLeafer
+    readonly isApp: boolean
+    parent?: IApp
 
     running: boolean
+    ready: boolean
+    viewReady: boolean
 
-    autoLayout?: IAutoBounds
+    pixelRatio: number
+
+    view: unknown
 
     canvas: ILeaferCanvas
     renderer: IRenderer
@@ -46,26 +50,39 @@ export interface ILeafer extends IZoomView {
     hitCanvasManager?: IHitCanvasManager
     imageManager: IImageManager
 
-    start(): void
-    stop(): void
+    autoLayout?: IAutoBounds
+
+    config: ILeaferConfig
+
+    __eventIds: IEventListenerId[]
+
+    init(userConfig?: ILeaferConfig, parentApp?: IApp): void
+
+    forceFullRender(): void
 
     resize(size: IScreenSizeData): void
 }
 
-export interface ICreator {
-    ui?(tag: string, data?: IObject): ILeaf
-    event?(type: string, event: IEvent): IEvent
+export interface ILeaferTypeFunction {
+    (leafer: ILeafer): void
+}
 
+export interface ILeaferTypeList {
+    [key: string]: ILeaferTypeFunction
+}
+
+
+export interface ICreator {
     image?(options?: ILeaferImageConfig): ILeaferImage
     canvas?(options?: ILeaferCanvasConfig, manager?: ICanvasManager): ILeaferCanvas
     hitCanvas?(options?: IHitCanvasConfig, manager?: ICanvasManager): IHitCanvas
 
-    watcher?(target: ILeaf): IWatcher
-    layouter?(target: ILeaf): ILayouter
-    renderer?(target: ILeaf, canvas: ILeaferCanvas, options: IRendererConfig): IRenderer
-    selector?(target: ILeaf): ISelector
+    watcher?(target: ILeaf, options?: IWatcherConfig): IWatcher
+    layouter?(target: ILeaf, options?: ILayouterConfig): ILayouter
+    renderer?(target: ILeaf, canvas: ILeaferCanvas, options?: IRendererConfig): IRenderer
+    selector?(target: ILeaf, options?: ISelectorConfig): ISelector
 
-    interaction?(target: ILeaf, canvas: ILeaferCanvas, selector: ISelector, options?: IInteractionConfig): IInteraction
+    interaction?(target: ILeaf, canvas: IInteractionCanvas, selector: ISelector, options?: IInteractionConfig): IInteraction
 }
 
 export interface IUICreator {

package/src/canvas/ICanvas.ts

@@ -1,6 +1,6 @@
 type GlobalCompositeOperation = 'color' | 'color-burn' | 'color-dodge' | 'copy' | 'darken' | 'destination-atop' | 'destination-in' | 'destination-out' | 'destination-over' | 'difference' | 'exclusion' | 'hard-light' | 'hue' | 'lighten' | 'lighter' | 'luminosity' | 'multiply' | 'overlay' | 'saturation' | 'screen' | 'soft-light' | 'source-atop' | 'source-in' | 'source-out' | 'source-over' | 'xor'
 type CanvasDirection = 'inherit' | 'ltr' | 'rtl'
-export type ICanvasFillRule = 'evenodd' | 'nonzero'
+export type IWindingRule = 'evenodd' | 'nonzero'
 // type CanvasFontKerning = 'auto' | 'none' | 'normal'
 // type CanvasFontStretch = 'condensed' | 'expanded' | 'extra-condensed' | 'extra-expanded' | 'normal' | 'semi-condensed' | 'semi-expanded' | 'ultra-condensed' | 'ultra-expanded'
 // type CanvasFontVariantCaps = 'all-petite-caps' | 'all-small-caps' | 'normal' | 'petite-caps' | 'small-caps' | 'titling-caps' | 'unicase'
@@ -10,9 +10,7 @@ type CanvasTextAlign = 'center' | 'end' | 'left' | 'right' | 'start'
 type CanvasTextBaseline = 'alphabetic' | 'bottom' | 'hanging' | 'ideographic' | 'middle' | 'top'
 //type CanvasTextRendering = 'auto' | 'geometricPrecision' | 'optimizeLegibility' | 'optimizeSpeed'
 
-/** This Canvas 2D API interface is used to declare a path that can then be used on a CanvasRenderingContext2D object. The path methods of the CanvasRenderingContext2D interface are also present on this interface, which gives you the convenience of being able to retain and replay your path whenever desired. */
 export interface IPath2D extends CanvasPath {
-    /** Adds to the path the path given by the argument. */
     addPath(path: IPath2D, transform?: DOMMatrix2DInit): void
 }
 
@@ -35,12 +33,12 @@ interface CanvasDrawImage {
 
 interface CanvasDrawPath {
     beginPath(): void
-    clip(fillRule?: ICanvasFillRule): void
-    clip(path: IPath2D, fillRule?: ICanvasFillRule): void
-    fill(fillRule?: ICanvasFillRule): void
-    fill(path: IPath2D, fillRule?: ICanvasFillRule): void
-    isPointInPath(x: number, y: number, fillRule?: ICanvasFillRule): boolean
-    isPointInPath(path: IPath2D, x: number, y: number, fillRule?: ICanvasFillRule): boolean
+    clip(fillRule?: IWindingRule): void
+    clip(path: IPath2D, fillRule?: IWindingRule): void
+    fill(fillRule?: IWindingRule): void
+    fill(path: IPath2D, fillRule?: IWindingRule): void
+    isPointInPath(x: number, y: number, fillRule?: IWindingRule): boolean
+    isPointInPath(path: IPath2D, x: number, y: number, fillRule?: IWindingRule): boolean
     isPointInStroke(x: number, y: number): boolean
     isPointInStroke(path: IPath2D, x: number, y: number): boolean
     stroke(): void
@@ -60,13 +58,7 @@ interface CanvasFilters {
     filter: string
 }
 
-/** An opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */
 export interface CanvasGradient {
-    /**
-     * Adds a color stop with the given color to the gradient at the given offset. 0.0 is the offset at one end of the gradient, 1.0 is the offset at the other end.
-     *
-     * Throws an 'IndexSizeError' DOMException if the offset is out of range. Throws a 'SyntaxError' DOMException if the color cannot be parsed.
-     */
     addColorStop(offset: number, color: string): void
 }
 
@@ -89,11 +81,11 @@ interface CanvasImageSmoothing {
 }
 
 interface CanvasPath {
-    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): 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
     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void
     closePath(): void
-    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void
     lineTo(x: number, y: number): void
     moveTo(x: number, y: number): void
     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void
@@ -111,9 +103,7 @@ interface CanvasPathDrawingStyles {
     setLineDash(segments: number[]): void
 }
 
-/** An opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */
 export interface CanvasPattern {
-    /** Sets the transformation matrix that will be used when rendering the pattern during a fill or stroke painting operation. */
     setTransform(transform?: DOMMatrix2DInit): void
 }
 
@@ -135,16 +125,14 @@ interface CanvasRenderingContext2DSettings {
     desynchronized?: boolean
     willReadFrequently?: boolean
 }
-
-/** The CanvasRenderingContext2D interface, part of the Canvas API, provides the 2D rendering context for the drawing surface of a <canvas> element. It is used for drawing shapes, text, images, and other objects. */
-export interface ICanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
+export interface ICanvasContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
     readonly canvas: HTMLCanvasElement
     getContextAttributes(): CanvasRenderingContext2DSettings
 }
 
-declare var ICanvasRenderingContext2D: {
-    prototype: ICanvasRenderingContext2D
-    new(): ICanvasRenderingContext2D
+declare var ICanvasContext2D: {
+    prototype: ICanvasContext2D
+    new(): ICanvasContext2D
 }
 
 interface CanvasShadowStyles {
@@ -165,7 +153,6 @@ interface CanvasUserInterface {
 }
 
 
-/** The dimensions of a piece of text in the canvas, as created by the CanvasRenderingContext2D.measureText() method. */
 export interface ITextMetrics {
     /** Returns the measurement described below. */
     readonly actualBoundingBoxAscent: number
@@ -277,7 +264,6 @@ interface DOMMatrixReadOnly {
     rotateFromVector(x?: number, y?: number): DOMMatrix
     scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix
     scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix
-    /** @deprecated */
     scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix
     skewX(sx?: number): DOMMatrix
     skewY(sy?: number): DOMMatrix

package/src/canvas/ILeaferCanvas.ts

@@ -1,19 +1,18 @@
 import { IObject } from '../data/IData'
 import { IBounds, IMatrixData, IBoundsData, IAutoBoundsData, IAutoBounds, IScreenSizeData, IMatrixWithBoundsData, IPointData } from '../math/IMath'
-import { ICanvasRenderingContext2D, ICanvasFillRule, IPath2D, ITextMetrics, CanvasGradient, CanvasPattern } from './ICanvas'
+import { ICanvasContext2D, IWindingRule, IPath2D, ITextMetrics, CanvasGradient, CanvasPattern } from './ICanvas'
 import { IResizeEventListener } from '../event/IEvent'
-import { ICanvasDrawPath } from './ICanvasPathDrawer'
+import { IPathDrawer } from '../path/IPathDrawer'
 import { InnerId } from '../event/IEventer'
 import { ICanvasManager } from './ICanvasManager'
 
-export interface ILeaferCanvasContext extends ICanvasRenderingContext2D {
-
-}
-
 export interface ILeaferCanvasConfig extends IAutoBoundsData {
     view?: string | IObject
     fill?: string
     pixelRatio?: number
+    smooth?: boolean
+    hittable?: boolean
+    offscreen?: boolean
     webgl?: boolean
 }
 
@@ -30,7 +29,7 @@ export interface ICanvasStrokeOptions {
     miterLimit?: number
 }
 
-export interface ICanvasAttr extends ICanvasStrokeOptions {
+export interface ICanvasAttr extends ICanvasStrokeOptions, IObject {
 
     smooth: boolean // imageSmoothingEnabled: boolean
     smoothLevel: string // imageSmoothingQuality: string
@@ -67,14 +66,15 @@ interface ICanvasMethod {
     save(): void
     restore(): void
 
-    fill(path?: IPath2D | ICanvasFillRule, rule?: ICanvasFillRule): void
+    fill(path?: IPath2D | IWindingRule, rule?: IWindingRule): void
     stroke(path?: IPath2D): void
-    clip(path?: IPath2D | ICanvasFillRule, rule?: ICanvasFillRule): void
+    clip(path?: 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
 
+    transform(a: number, 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
@@ -100,32 +100,38 @@ interface ICanvasMethod {
 
     // custom
 
-    setStroke(strokeStyle: string | object, strokeWidth: number, options?: ICanvasStrokeOptions): void
-    setShadow(x: number, y: number, blur: number, color?: string): void
-    setBlur(blur: number): void
+    saveBlendMode(blendMode?: string): void
+    restoreBlendMode(): void
 
+    hitFill(point: IPointData, fillRule?: string): boolean
+    hitStroke(point: IPointData, strokeWidth?: number): boolean
+
+    setStroke(strokeStyle: string | object, strokeWidth: number, options?: ICanvasStrokeOptions): void
+    setStrokeOptions(options: ICanvasStrokeOptions): void
 
     setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData): void
 
+    setWorldShadow(x: number, y: number, blur: number, color?: string): void
+    setWorldBlur(blur: number): void
+
+    copyWorld(canvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData, blendMode?: string): void
+    copyWorldToInner(canvas: ILeaferCanvas, fromWorld: IMatrixWithBoundsData, toInnerBounds: IBoundsData, blendMode?: string): void
+    useMask(maskCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void
 
-    hitPath(point: IPointData, fillRule?: string): boolean
-    hitStroke(point: IPointData): boolean
+    fillWorld(bounds: IBoundsData, color: string | object, blendMode?: string): void
+    strokeWorld(bounds: IBoundsData, color: string | object, blendMode?: string): void
+    clipWorld(bounds: IBoundsData, ceilPixel?: boolean): void
+    clearWorld(bounds: IBoundsData, ceilPixel?: boolean): void
 
-    replaceBy(canvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void
-    copy(canvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData, blendMode?: string): void
-    copyWorldToLocal(canvas: ILeaferCanvas, fromWorld: IMatrixWithBoundsData, toLocalBounds: IBoundsData, blendMode?: string): void
-    fillBounds(bounds: IBoundsData, color: string | object, blendMode?: string): void
-    strokeBounds(bounds: IBoundsData, color: string | object, blendMode?: string): void
-    clipBounds(bounds: IBoundsData): void
-    clearBounds(bounds: IBoundsData): void
     clear(): void
 }
 
-export interface ILeaferCanvas extends ICanvasAttr, ICanvasMethod, ICanvasDrawPath {
-
-    manager: ICanvasManager
+export interface ILeaferCanvas extends ICanvasAttr, ICanvasMethod, IPathDrawer {
 
     readonly innerId: InnerId
+    name: string
+
+    manager: ICanvasManager
 
     width: number
     height: number
@@ -133,29 +139,45 @@ export interface ILeaferCanvas extends ICanvasAttr, ICanvasMethod, ICanvasDrawPa
     pixelRatio: number
     readonly pixelWidth: number
     readonly pixelHeight: number
+    readonly allowBackgroundColor?: boolean
 
     bounds: IBounds
 
+    config: ILeaferCanvasConfig
+
+    autoLayout: boolean
+
     view: unknown
-    context: ILeaferCanvasContext
+    parentView: unknown
+
+    unreal?: boolean
+
+    offscreen: boolean
+
+    context: ICanvasContext2D
 
     recycled?: boolean
 
-    debug(): void
+    worldTransform: IMatrixData
+
+    init(): void
+
+    setBackgroundColor(color: string): void
+    setHittable(hittable: boolean): void
 
-    autoLayout(autoBounds: IAutoBounds, listener: IResizeEventListener): void
+    startAutoLayout(autoBounds: IAutoBounds, listener: IResizeEventListener): void
     stopAutoLayout(): void
 
     resize(size: IScreenSizeData): void
-    pixel(num: number): number
+    setViewSize(size: IScreenSizeData): void
 
     // other
     isSameSize(options: ILeaferCanvasConfig): boolean
-    getSameCanvas(useSameTransform?: boolean): ILeaferCanvas
+    getSameCanvas(useSameWorldTransform?: boolean): ILeaferCanvas
     getBiggerCanvas(addWidth: number, addHeight: number): ILeaferCanvas
-    useSameTransform(canvas: ILeaferCanvas): void
     recycle(): void
 
+    unrealCanvas(): void
     destroy(): void
 }
 

package/src/control/IControl.ts

@@ -0,0 +1,5 @@
+export interface IControl {
+    start(): void
+    stop(): void
+    destroy(): void
+}

package/src/data/IData.ts

@@ -3,8 +3,7 @@ export type __Boolean = boolean // boolean | string  will convert to boolean
 export type __String = string //  string  | other   will convert to string
 export type __Object = IObject // will convert to object
 export type __Value = __Number | __Boolean | __String | __Object  // 
-
-
+export type ITimer = any
 export interface IObject {
     [name: string]: any
 }

package/src/data/ILeafData.ts

@@ -5,8 +5,13 @@ export interface IDataProcessor extends IObject {
     __leaf: ILeaf
     __input: IObject
     __middle: IObject
+    __get(name: string): unknown
+
     __setInput(name: string, value: unknown): void
     __getInput(name: string): unknown
+    __removeInput(name: string): void
+    __getInputData(): IObject
+
     __setMiddle(name: string, value: unknown): void
     __getMiddle(name: string): unknown
     destroy(): void

package/src/display/IBranch.ts

@@ -3,7 +3,7 @@ import { ILeaf } from './ILeaf'
 export interface IBranch extends ILeaf {
     children: ILeaf[]
 
-    __updateSortChildren(): void
-    add(child: ILeaf, index?: number): void
-    remove(child?: ILeaf): void
+    // __updateSortChildren(): void
+    // add(child: ILeaf, index?: number): void
+    // remove(child?: ILeaf): void
 }