@leafer/interface 1.0.0-beta.15 → 1.0.0-beta.16

package/src/canvas/ISkiaCanvas.ts

@@ -0,0 +1,20 @@
+import { IExportFileType, IExportImageType } from '../file/IFileType'
+
+export type ICanvasType = 'skia' | 'canvas' | 'wx'
+
+export interface ISkiaCanvas {
+    toBuffer(format: IExportFileType, config: ISkiaCanvasExportConfig): Promise<any>
+    toBufferSync(format: IExportFileType, config: ISkiaCanvasExportConfig): any
+    toDataURL(format: IExportImageType, config: ISkiaCanvasExportConfig): Promise<string>
+    toDataURLSync(format: IExportImageType, config: ISkiaCanvasExportConfig): string
+    saveAs(filename: string, config: ISkiaCanvasExportConfig): Promise<void>
+    saveAsSync(filename: string, config: ISkiaCanvasExportConfig): void
+}
+
+export interface ISkiaCanvasExportConfig {
+    page?: number,
+    matte?: string,
+    density?: number,
+    quality?: number,
+    outline?: boolean
+}

package/src/control/IControl.ts

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

package/src/data/IData.ts

@@ -0,0 +1,28 @@
+export type __Number = number // number | string    will convert to number
+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 type IPathString = string
+
+export interface IObject {
+    [name: string]: any
+}
+
+export interface IBooleanMap {
+    [name: string]: boolean
+}
+
+export interface INumberMap {
+    [name: string]: number
+}
+
+export interface IStringMap {
+    [name: string]: string
+}
+
+export interface IDataTypeHandle {
+    (target: any): void
+}

package/src/data/ILeafData.ts

@@ -0,0 +1,27 @@
+import { ILeaf, ILeafComputedData } from '../display/ILeaf'
+import { IObject } from './IData'
+
+export interface IDataProcessor extends IObject {
+    __leaf: ILeaf
+    __input: IObject
+    __middle: IObject
+
+    __single: boolean
+    __checkSingle(): void
+
+    __get(name: string): any
+
+    __setInput(name: string, value: any): void
+    __getInput(name: string): any
+    __removeInput(name: string): void
+    __getInputData(): IObject
+
+    __setMiddle(name: string, value: any): void
+    __getMiddle(name: string): any
+
+    destroy(): void
+}
+
+export interface ILeafData extends IDataProcessor, ILeafComputedData {
+
+}

package/src/data/IList.ts

@@ -0,0 +1,45 @@
+import { ILeaf } from '../display/ILeaf'
+import { INumberMap } from './IData'
+
+export interface ILeafMap {
+    [name: string]: ILeaf
+}
+
+export interface ILeafArrayMap {
+    [name: string]: ILeaf[]
+}
+
+export type ILeafListItemCallback = (item: ILeaf, index?: number) => void
+
+export interface ILeafList {
+    list: ILeaf[]
+    keys: INumberMap
+    readonly length: number
+    has(leaf: ILeaf): boolean
+    indexAt(index: number): ILeaf
+    indexOf(leaf: ILeaf): number
+    unshift(leaf: ILeaf): void
+    pushList(list: ILeaf[]): void
+    push(leaf: ILeaf): void
+    sort(reverse?: boolean): void
+    remove(leaf: ILeaf): void
+    forEach(itemCallback: ILeafListItemCallback): void
+    clone(): ILeafList
+    reset(): void
+    destroy(): void
+}
+
+export interface ILeafLevelList {
+    levelMap: ILeafArrayMap
+    keys: INumberMap
+    levels: number[]
+    readonly length: number
+    has(leaf: ILeaf): boolean
+    without(leaf: ILeaf): boolean
+    sort(reverse?: boolean): void
+    pushList(list: ILeaf[]): void
+    push(leaf: ILeaf): void
+    forEach(itemCallback: ILeafListItemCallback): void
+    reset(): void
+    destroy(): void
+}

package/src/display/IBranch.ts

@@ -0,0 +1,10 @@
+import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
+import { IRenderOptions } from '../renderer/IRenderer'
+import { ILeaf } from './ILeaf'
+
+export interface IBranch extends ILeaf {
+    children: ILeaf[]
+    __renderBranch?(canvas: ILeaferCanvas, options: IRenderOptions): void
+    addMany(...children: ILeaf[]): void
+    removeAll(destroy?: boolean): void
+}

package/src/display/ILeaf.ts

@@ -0,0 +1,385 @@
+import { ILeafer } from '../app/ILeafer'
+import { IEventer } from '../event/IEventer'
+
+import { ILeaferCanvas, IHitCanvas } from '../canvas/ILeaferCanvas'
+import { IRenderOptions } from '../renderer/IRenderer'
+
+import { IObject, __Number, __Boolean, __Value, __String } from '../data/IData'
+import { IMatrixWithBoundsData, IMatrix, IPointData, IBoundsData, IRadiusPointData, IMatrixDecompositionAttr, IMatrixWithLayoutData } from '../math/IMath'
+import { IFunction } from '../function/IFunction'
+
+import { ILeafDataProxy } from './module/ILeafDataProxy'
+import { ILeafMatrix } from './module/ILeafMatrix'
+import { ILeafBounds } from './module/ILeafBounds'
+import { ILeafLayout, ILayoutBoundsType, ILayoutLocationType } from '../layout/ILeafLayout'
+import { ILeafHit } from './module/ILeafHit'
+import { ILeafRender } from './module/ILeafRender'
+import { ILeafMask } from './module/ILeafMask'
+import { ILeafData } from '../data/ILeafData'
+
+
+export interface ICachedLeaf {
+    canvas: ILeaferCanvas,
+    matrix?: IMatrix,
+    bounds: IBoundsData
+}
+
+
+export interface ILeafAttrData {
+    // layer data
+    id: __String
+    name: __String
+    className: __String
+
+    blendMode: IBlendMode
+    opacity: __Number
+    visible: __Boolean
+    isMask: __Boolean
+    isEraser: __Boolean
+    zIndex: __Number
+
+    // layout data
+    x: __Number
+    y: __Number
+    width: __Number
+    height: __Number
+    scaleX: __Number
+    scaleY: __Number
+    rotation: __Number
+    skewX: __Number
+    skewY: __Number
+
+    scale: __Number | IPointData // helper
+    around: 'center' | IPointData
+
+    draggable: __Boolean
+
+    hittable: __Boolean
+    hitFill: IHitType
+    hitStroke: IHitType
+    hitChildren: __Boolean
+    hitSelf: __Boolean
+    hitRadius: __Number
+
+    cursor: ICursorType | ICursorType[]
+}
+
+export type IHitType =
+    | 'path'
+    | 'pixel'
+    | 'all'
+    | 'none'
+
+export type IBlendMode =
+    | 'pass-through'
+    | 'normal'
+    | 'multiply'
+    | 'screen'
+    | 'overlay'
+    | 'darken'
+    | 'lighten'
+    | 'color-dodge'
+    | 'color-burn'
+    | 'hard-light'
+    | 'soft-light'
+    | 'difference'
+    | 'exclusion'
+    | 'hue'
+    | 'saturation'
+    | 'color'
+    | 'luminosity'
+    | 'source-over'  // other
+    | 'source-in'
+    | 'source-out'
+    | 'source-atop'
+    | 'destination-over'
+    | 'destination-in'
+    | 'destination-out'
+    | 'destination-atop'
+
+export type IResizeType = 'size' | 'scale'
+export interface IImageCursor {
+    url: string
+    x?: number
+    y?: number
+}
+
+export type IAround = 'center' | IPointData
+
+export type ICursorType =
+    | IImageCursor
+    | 'auto'
+    | 'default'
+    | 'none'
+    | 'context-menu'
+    | 'help'
+    | 'pointer'
+    | 'progress'
+    | 'wait'
+    | 'cell'
+    | 'crosshair'
+    | 'text'
+    | 'vertical-text'
+    | 'alias'
+    | 'copy'
+    | 'move'
+    | 'no-drop'
+    | 'not-allowed'
+    | 'grab'
+    | 'grabbing'
+    | 'e-resize'
+    | 'n-resize'
+    | 'ne-resize'
+    | 'nw-resize'
+    | 's-resize'
+    | 'se-resize'
+    | 'sw-resize'
+    | 'w-resize'
+    | 'ew-resize'
+    | 'ns-resize'
+    | 'nesw-resize'
+    | 'nwse-resize'
+    | 'col-resize'
+    | 'row-resize'
+    | 'all-scroll'
+    | 'zoom -in'
+    | 'zoom-out'
+
+export interface ICursorTypeMap {
+    [name: string]: ICursorType | ICursorType[]
+}
+export interface ILeafInputData extends IObject {
+    tag?: string
+
+    // layer data
+    id?: __String
+    name?: __String
+    className?: __String
+
+    blendMode?: IBlendMode
+    opacity?: __Number
+    visible?: __Boolean
+    isMask?: __Boolean
+    isEraser?: __Boolean
+    zIndex?: __Number
+
+    // layout data
+    x?: __Number
+    y?: __Number
+    width?: __Number
+    height?: __Number
+    scaleX?: __Number
+    scaleY?: __Number
+    rotation?: __Number
+    skewX?: __Number
+    skewY?: __Number
+
+    scale?: __Number | IPointData // helper
+    around?: IAround
+
+    draggable?: __Boolean
+
+    hittable?: __Boolean
+    hitFill?: IHitType
+    hitStroke?: IHitType
+    hitChildren?: __Boolean
+    hitSelf?: __Boolean
+    hitRadius?: __Number
+
+    cursor?: ICursorType | ICursorType[]
+
+    children?: ILeafInputData[]
+}
+export interface ILeafComputedData {
+    // layer data
+    id?: string
+    name?: string
+    className?: string
+
+    blendMode?: IBlendMode
+    opacity?: number
+    visible?: boolean
+    isMask?: boolean
+    isEraser?: boolean
+    zIndex?: number
+
+    // layout data
+    x?: number
+    y?: number
+    width?: number
+    height?: number
+    scaleX?: number
+    scaleY?: number
+    rotation?: number
+    skewX?: number
+    skewY?: number
+
+    around?: IAround
+
+    draggable?: boolean
+
+    hittable?: boolean
+    hitFill?: IHitType
+    hitStroke?: IHitType
+    hitChildren?: boolean
+    hitSelf?: boolean
+    hitRadius?: number
+
+    cursor?: ICursorType | ICursorType[]
+
+    // other
+    __childBranchNumber?: number // 存在子分支的个数
+    __complex?: boolean // 外观是否复杂
+    __naturalWidth?: number
+    __naturalHeight?: number
+}
+
+export interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatrix, ILeafDataProxy, ILeafInputData, IEventer {
+    tag: string
+    readonly __tag: string
+    readonly innerName: string
+
+    readonly __DataProcessor: IObject // IDataProcessor
+    readonly __LayoutProcessor: IObject // ILeafLayout
+
+    leafer?: ILeafer
+    parent?: ILeaf
+
+    readonly isApp?: boolean
+    isLeafer?: boolean
+    isBranch?: boolean
+    isBranchLeaf?: boolean
+
+    __: ILeafData
+    __layout: ILeafLayout
+
+    __world: IMatrixWithLayoutData
+    __local: IMatrixWithBoundsData
+
+    __worldOpacity: number
+
+    readonly worldTransform: IMatrixWithLayoutData
+    readonly localTransform: IMatrixWithBoundsData
+
+    readonly boxBounds: IBoundsData
+    readonly worldBoxBounds: IBoundsData
+    readonly worldStrokeBounds: IBoundsData
+    readonly worldRenderBounds: IBoundsData
+
+    readonly worldOpacity: number
+
+    __renderTime?: number // μs 1000微秒 = 1毫秒
+
+    __level: number // 图层级别 root(1) -> hight
+    __tempNumber?: number // 用于临时运算储存状态
+
+    readonly resizeable: boolean
+
+    readonly __hasMirror: boolean
+
+    __hasMask?: boolean
+    __hasEraser?: boolean
+    __hitCanvas?: IHitCanvas
+
+    readonly __onlyHitMask: boolean
+    readonly __ignoreHitWorld: boolean
+
+    __parentWait?: IFunction[]
+    __leaferWait?: IFunction[]
+
+    destroyed: boolean
+
+    waitParent(item: IFunction): void
+    waitLeafer(item: IFunction): void
+    nextRender(item: IFunction): void
+
+    __bindLeafer(leafer: ILeafer | null): void
+
+    set(data: IObject): void
+    toJSON(): IObject
+    toString(): string
+
+    // ILeafData ->
+    __setAttr(attrName: string, newValue: __Value): void
+    __getAttr(attrName: string): __Value
+
+    forceUpdate(attrName?: string): void
+
+    // ILeafMatrix ->
+    __updateWorldMatrix(): void
+    __updateLocalMatrix(): void
+
+    // ILeafBounds ->
+    __updateWorldBounds(): void
+
+    __updateLocalBoxBounds(): void
+    __updateLocalStrokeBounds(): void
+    __updateLocalRenderBounds(): void
+
+    __updateBoxBounds(): void
+    __updateStrokeBounds(): void
+    __updateRenderBounds(): void
+
+    __updateNaturalSize(): void
+
+    __updateStrokeSpread(): number
+    __updateRenderSpread(): number
+
+    __onUpdateSize(): void
+
+    // IBranchMask ->
+    __updateEraser(value?: boolean): void
+    __updateMask(value?: boolean): void
+    __renderMask(canvas: ILeaferCanvas, content: ILeaferCanvas, mask: ILeaferCanvas): void
+    __removeMask(child?: ILeaf): void
+
+    // convert
+    getWorld(attrName: IMatrixDecompositionAttr): number
+    getBounds(type: ILayoutBoundsType, locationType?: ILayoutLocationType): IBoundsData
+
+    worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void
+    localToWorld(local: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void
+    worldToInner(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void
+    innerToWorld(inner: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void
+
+    getInnerPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData
+    getInnerPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData
+    getLocalPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData
+    getLocalPointByInner(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData
+    getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData
+    getWorldPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData
+
+    move(x: number, y?: number): void
+    scaleOf(origin: IPointData, x: number, y?: number): void
+    rotateOf(origin: IPointData, rotation: number): void
+    skewOf(origin: IPointData, x: number, y: number): void
+
+    // ILeafHit ->
+    __hitWorld(point: IRadiusPointData): boolean
+    __hit(local: IRadiusPointData): boolean
+    __drawHitPath(canvas: ILeaferCanvas): void
+    __updateHitCanvas(): void
+
+    // ILeafRender ->
+    __render(canvas: ILeaferCanvas, options: IRenderOptions): void
+    __drawFast(canvas: ILeaferCanvas, options: IRenderOptions): void
+    __draw(canvas: ILeaferCanvas, options: IRenderOptions): void
+
+    __renderShape(canvas: ILeaferCanvas, options: IRenderOptions): void
+
+    __updateWorldOpacity(): void
+    __updateChange(): void
+
+    // path
+    __drawPath(canvas: ILeaferCanvas): void
+    __drawRenderPath(canvas: ILeaferCanvas): void
+    __updatePath(): void
+    __updateRenderPath(): void
+
+    // branch
+    children?: ILeaf[]
+
+    __updateSortChildren(): void
+    add(child: ILeaf, index?: number): void
+    remove(child?: ILeaf, destroy?: boolean): void
+}

package/src/display/IView.ts

@@ -0,0 +1,10 @@
+import { IBranch } from './IBranch'
+import { ILeaf } from './ILeaf'
+import { ITransformEventData } from '../event/IEvent'
+
+export interface IZoomView extends IBranch {
+    zoomLayer?: ILeaf
+    moveLayer?: ILeaf
+    transformData?: ITransformEventData
+    setZoomLayer(zoomLayer: ILeaf, moveLayer?: ILeaf): void
+}

package/src/display/module/IBranchRender.ts

@@ -0,0 +1,10 @@
+import { ILeaferCanvas } from '../../canvas/ILeaferCanvas'
+import { IRenderOptions } from '../../renderer/IRenderer'
+import { IBranch } from '../IBranch'
+import { ILeafRender } from './ILeafRender'
+
+export type IBranchRenderModule = IBranchRender & ThisType<IBranch>
+
+export interface IBranchRender extends ILeafRender {
+    __renderBranch?(canvas: ILeaferCanvas, options: IRenderOptions): void
+}

package/src/display/module/ILeafBounds.ts

@@ -0,0 +1,23 @@
+import { ILeaf } from '../ILeaf'
+
+export type ILeafBoundsModule = ILeafBounds & ThisType<ILeaf>
+
+export interface ILeafBounds {
+    __updateWorldBounds?(): void
+
+    __updateLocalBoxBounds?(): void
+    __updateLocalStrokeBounds?(): void
+    __updateLocalRenderBounds?(): void
+
+    __updateBoxBounds?(): void
+    __updateStrokeBounds?(): void
+    __updateRenderBounds?(): void
+
+    __updateNaturalSize?(): void
+
+    __updateStrokeSpread?(): number
+    __updateRenderSpread?(): number
+
+    __onUpdateSize?(): void
+}
+

package/src/display/module/ILeafDataProxy.ts

@@ -0,0 +1,10 @@
+import { ILeaf } from '../ILeaf'
+import { __Value } from '../../data/IData'
+
+export type ILeafDataProxyModule = ILeafDataProxy & ThisType<ILeaf>
+
+export interface ILeafDataProxy {
+    __setAttr?(name: string, newValue: __Value): void
+    __getAttr?(name: string): __Value
+}
+

package/src/display/module/ILeafEventer.ts

@@ -0,0 +1,18 @@
+import { ILeaf } from '../ILeaf'
+import { IEventListener, IEventListenerId, IEventListenerOptions } from '../../event/IEventer'
+import { } from '@leafer/interface'
+import { IEvent } from '../../event/IEvent'
+import { IObject } from '../../data/IData'
+
+export type ILeafEventerModule = ILeafEventer & ThisType<ILeaf>
+
+export interface ILeafEventer {
+    on?(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void
+    off?(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void
+    on_?(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventListenerOptions | boolean): IEventListenerId
+    off_?(id: IEventListenerId | IEventListenerId[]): void
+    once?(type: string | string[], listener: IEventListener, capture?: boolean): void
+    emit?(type: string, event?: IEvent | IObject, capture?: boolean): void
+    emitEvent?(event?: IEvent, capture?: boolean): void
+    hasEvent?(type: string, capture?: boolean): boolean
+}

package/src/display/module/ILeafHit.ts

@@ -0,0 +1,12 @@
+import { IRadiusPointData } from '../../math/IMath'
+import { ILeaf } from '../ILeaf'
+import { ILeaferCanvas } from '../../canvas/ILeaferCanvas'
+
+export type ILeafHitModule = ILeafHit & ThisType<ILeaf>
+
+export interface ILeafHit {
+    __hitWorld?(point: IRadiusPointData): boolean
+    __hit?(local: IRadiusPointData): boolean
+    __drawHitPath?(canvas: ILeaferCanvas): void
+    __updateHitCanvas?(): void
+}

package/src/display/module/ILeafMask.ts

@@ -0,0 +1,12 @@
+import { ILeaf } from '../ILeaf'
+import { ILeaferCanvas } from '../../canvas/ILeaferCanvas'
+
+export type ILeafMaskModule = ILeafMask & ThisType<ILeaf>
+
+export interface ILeafMask {
+    __updateEraser?(value?: boolean): void
+    __updateMask?(value?: boolean): void
+    __renderMask?(canvas: ILeaferCanvas, content: ILeaferCanvas, mask: ILeaferCanvas): void
+    __removeMask?(child?: ILeaf): void
+}
+

package/src/display/module/ILeafMatrix.ts

@@ -0,0 +1,8 @@
+import { ILeaf } from '../ILeaf'
+
+export type ILeafMatrixModule = ILeafMatrix & ThisType<ILeaf>
+
+export interface ILeafMatrix {
+    __updateWorldMatrix?(): void
+    __updateLocalMatrix?(): void
+}

package/src/display/module/ILeafRender.ts

@@ -0,0 +1,16 @@
+import { ILeaferCanvas } from '../../canvas/ILeaferCanvas'
+import { IRenderOptions } from '../../renderer/IRenderer'
+import { ILeaf } from '../ILeaf'
+
+export type ILeafRenderModule = ILeafRender & ThisType<ILeaf>
+
+export interface ILeafRender {
+    __render?(canvas: ILeaferCanvas, options: IRenderOptions): void
+    __draw?(canvas: ILeaferCanvas, options: IRenderOptions): void
+    __drawFast?(canvas: ILeaferCanvas, options: IRenderOptions): void
+
+    __renderShape?(canvas: ILeaferCanvas, options: IRenderOptions): void
+
+    __updateWorldOpacity?(): void
+    __updateChange?(): void
+}