@leafer/interface 1.0.0-alpha.1

package/src/interaction/IInteraction.ts

@@ -0,0 +1,53 @@
+import { INumberFunction, IPointDataFunction } from '../function/IFunction'
+import { IPointerEvent, IMoveEvent, IZoomEvent, IRotateEvent } from '../event/IUIEvent'
+import { ILeaf } from '../display/ILeaf'
+import { IPointData } from '../math/IMath'
+
+export interface IInteraction {
+    target: ILeaf
+    config: IInteractionConfig
+    running: boolean
+
+    pointerMoveIgnore: boolean
+
+    start(): void
+    stop(): void
+
+    pointerDown(data: IPointerEvent): void
+    pointerMove(data: IPointerEvent): void
+    pointerUp(data: IPointerEvent): void
+    pointerCancel(): void
+
+    move(data: IMoveEvent): void
+    zoom(data: IZoomEvent): void
+    rotate(data: IRotateEvent): void
+
+    destroy(): void
+}
+
+export interface IInteractionConfig {
+    wheel?: IWheelConfig
+    pointer?: IPointerConfig
+
+}
+
+export interface IWheelConfig {
+    zoomMode?: boolean
+    zoomSpeed?: number // 取值范围 0 ～ 1, 默认0.5
+    moveSpeed?: number
+    rotateSpeed?: number // 取值范围 0 ～ 1, 默认0.5
+    delta?: IPointData
+    getScale?: INumberFunction
+    getMove?: IPointDataFunction
+}
+
+export interface IPointerConfig {
+    hitRadius?: number
+    through?: boolean
+    clickTime?: number
+    longPressTime?: number
+    transformTime?: number
+    dragDistance?: number
+    swipeDistance?: number
+    autoMoveDistance?: number
+}

package/src/layout/ILeafLayout.ts

@@ -0,0 +1,87 @@
+import { IBoundsData, IMatrixData } from '../math/IMath'
+import { ILeaf } from '../display/ILeaf'
+
+export type ILayoutLocationType = 'world' | 'relative' | 'local'
+export type ILayoutBoundsType = 'content' | 'box' | 'event' | 'margin' | 'render'
+
+export interface ILeafLayout {
+
+    leaf: ILeaf
+
+    useZoomProxy: boolean
+
+    // local
+
+    boxBounds: IBoundsData    //  | content + padding |
+    eventBounds: IBoundsData  //  | boxBounds + border |  
+    renderBounds: IBoundsData //  | eventBounds + shadow |
+
+    // auto layout
+    marginBounds: IBoundsData //  | eventBounds + margin |
+    contentBounds: IBoundsData // | content |  
+
+    // relative
+
+    //relativeBoxBounds: IBoundsData = leaf.__local
+    relativeEventBounds: IBoundsData
+    relativeRenderBounds: IBoundsData
+
+    // state
+
+    // matrix changed
+    matrixChanged: boolean
+    positionChanged: boolean // x, y
+    scaleChanged: boolean // scaleX scaleY
+    rotationChanged: boolean // rotaiton, skewX scaleY 数据更新
+
+    // bounds changed
+    boundsChanged: boolean
+
+    boxBoundsChanged: boolean
+    eventBoundsChanged: boolean
+    renderBoundsChanged: boolean
+
+    localBoxBoundsChanged: boolean // position
+
+    // face changed
+    surfaceChanged: boolean
+    opacityChanged: boolean
+
+    hitCanvasChanged: boolean
+
+    childrenSortChanged?: boolean
+
+    // keep state
+    affectScaleOrRotation: boolean
+    affectRotation: boolean
+    eventBoundsSpreadWidth: number
+    renderBoundsSpreadWidth: number
+    renderShapeBoundsSpreadWidth: number
+
+    update(): void
+
+    getTransform(type: ILayoutLocationType): IMatrixData
+    getBounds(type: ILayoutLocationType, boundsType: ILayoutBoundsType): IBoundsData
+
+    // 独立 / 引用 boxBounds
+    eventBoundsSpread(): void
+    renderBoundsSpread(): void
+    eventBoundsSpreadCancel(): void
+    renderBoundsSpreadCancel(): void
+
+    // bounds
+    boxBoundsChange(): void
+    eventBoundsChange(): void
+    renderBoundsChange(): void
+
+    // matrix
+    positionChange(): void
+    scaleChange(): void
+    rotationChange(): void
+
+    // face
+    surfaceChange(): void
+    opacityChange(): void
+
+    destroy(): void
+}

package/src/layouter/ILayouter.ts

@@ -0,0 +1,52 @@
+import { IBounds } from '../math/IMath'
+import { ILeaf } from '../display/ILeaf'
+import { ILeafList } from '../data/IList'
+
+export interface ILayoutChangedData {
+    matrixList: ILeaf[]
+    boundsList: ILeaf[]
+    surfaceList: ILeaf[]
+}
+
+export interface ILayoutBlockData {
+    updatedList: ILeafList
+    updatedBounds: IBounds
+
+    beforeBounds: IBounds
+    afterBounds: IBounds
+
+    setBefore?(): void
+    setAfter?(): void
+    merge?(data: ILayoutBlockData): void
+    destroy(): void
+}
+
+export interface IPartLayoutConfig {
+    maxBlocks?: number
+    maxTimes?: number
+}
+
+export interface ILayouterConfig {
+    partLayout?: IPartLayoutConfig
+}
+
+export interface ILayouter {
+    target: ILeaf
+    layoutedBlocks: ILayoutBlockData[]
+    totalTimes: number
+    times: number
+    config: ILayouterConfig
+    running: boolean
+
+    start(): void
+    stop(): void
+
+    createBlock(data: ILeafList | ILeaf[]): ILayoutBlockData
+    getBlocks(list: ILeafList): ILayoutBlockData[]
+    setBlocks(current: ILayoutBlockData[]): void
+
+    layout(): void
+    partLayout(): void
+    fullLayout(): void
+    destroy(): void
+}

package/src/math/IMath.ts

@@ -0,0 +1,141 @@
+import { IObject } from '../data/IData'
+
+export interface IPointData {
+    x: number
+    y: number
+}
+
+export interface IPoint extends IPointData {
+    set(x?: number, y?: number): void
+    copy(point: IPointData): IPoint
+    clone(): IPoint
+
+    rotate(angle: number, center?: IPointData): void
+
+    toLocal(matrix: IMatrixData): void
+    toWorld(matrix: IMatrixData): void
+
+    getCenter(to: IPointData): IPointData
+    getDistance(to: IPointData): number
+    getAngle(to: IPointData): number
+    getAtan2(to: IPointData): number
+}
+
+export interface IRadiusPointData extends IPointData {
+    radiusX: number
+    radiusY: number
+}
+
+export interface ISizeData {
+    width: number
+    height: number
+}
+export interface ISize extends ISizeData {
+
+}
+
+export interface IScreenSizeData extends ISizeData {
+    pixelRatio?: number
+}
+
+export interface IBoundsData extends IPointData, ISizeData { }
+
+export interface IOffsetBoundsData extends IBoundsData {
+    offsetX: number
+    offsetY: number
+}
+
+export interface IBoundsDataHandle {
+    (target: any): IBoundsData
+}
+
+export interface IBounds extends IBoundsData {
+    set(x?: number, y?: number, width?: number, height?: number): void
+    copy(bounds: IBoundsData): IBounds
+    clone(): IBounds
+
+    timesMatrix(matrix: IMatrixData): IBounds
+    divideMatrix(matrix: IMatrixData): IBounds
+    getFitMatrix(put: IBoundsData): IMatrix
+    spread(size: number): void
+    ceil(): void
+
+    add(bounds: IBoundsData): void
+    addList(boundsList: IBounds[]): void
+    setByList(boundsList: IBounds[], addMode?: boolean): void
+    addListWithHandle(list: IObject[], boundsDataHandle: IBoundsDataHandle): void
+    setByListWithHandle(list: IObject[], boundsDataHandle: IBoundsDataHandle, addMode: boolean): void
+    setByBoundsTimesMatrix(fromBounds: IBoundsData, fromMatrix: IMatrixData): void
+    setByPoints(points: IPointData[]): void
+
+    hitPoint(point: IPointData, pointMatrix?: IMatrixData): boolean
+    hitRadiusPoint(point: IRadiusPointData, pointMatrix?: IMatrixData): boolean
+    hit(bounds: IBoundsData, boundsMatrix?: IMatrixData): boolean
+    includes(bounds: IBoundsData, boundsMatrix?: IMatrixData): boolean
+
+    getIntersect(bounds: IBoundsData, boundsMatrix?: IMatrixData): IBounds
+    setByIntersect(bounds: IBoundsData, boundsMatrix?: IMatrixData): void
+
+    isSame(bounds: IBoundsData): boolean
+    isEmpty(): boolean
+    empty(): void
+}
+
+export interface ITwoPointBoundsData {
+    minX: number
+    minY: number
+    maxX: number
+    maxY: number
+}
+
+export interface ITwoPointBounds extends ITwoPointBoundsData {
+    addPoint(x: number, y: number): void
+    add(pointBounds: ITwoPointBoundsData): void
+}
+
+
+export interface IAutoBoundsData {
+    top?: number
+    right?: number
+    bottom?: number
+    left?: number
+
+    width?: number
+    height?: number
+}
+
+
+export interface IAutoBounds extends IAutoBoundsData {
+    set(top?: number, right?: number, bottom?: number, left?: number, width?: number, height?: number): void
+    copy(auto: IAutoBoundsData): void
+    getBoundsFrom(parent: ISizeData): IBounds
+}
+
+
+export interface IMatrixData {
+    a: number
+    b: number
+    c: number
+    d: number
+    e: number
+    f: number
+}
+export interface IMatrix extends IMatrixData {
+    set(a: number, b: number, c: number, d: number, e: number, f: number): void
+    copy(matrix: IMatrixData): IMatrix
+    clone(): IMatrix
+
+    translate(x: number, y: number): IMatrix
+    scale(x: number, y?: number): IMatrix
+    rotate(angle: number): IMatrix
+
+    times(matrix: IMatrixData): void
+    divide(matrix: IMatrixData): void
+    invert(): void
+
+    toWorldPoint(local: IPointData, world?: IPointData): void
+    toLocalPoint(world: IPointData, local?: IPointData): void
+}
+
+
+export interface IMatrixWithBoundsData extends IMatrixData, IBoundsData { }

package/src/path/IPathCommand.ts

@@ -0,0 +1,50 @@
+type Command = number
+type x = number
+type y = number
+type x1 = number
+type y1 = number
+type x2 = number
+type y2 = number
+type radiusX = number
+type radiusY = number
+type xAxisRotation = number
+type largeArcFlag = number
+type sweepFlag = number
+
+
+export type MCommandData = [Command, x, y]
+export type HCommandData = [Command, x]
+export type VCommandData = [Command, y]
+export type LCommandData = MCommandData
+
+export type CCommandData = [Command, x1, y1, x2, y2, x, y]
+export type SCommandData = [Command, x2, y2, x, y]
+
+export type QCommandData = [Command, x1, y1, x, y]
+export type TCommandData = [Command, x, y]
+
+export type ZCommandData = [Command]
+
+export type ACommandData = [Command, radiusX, radiusY, xAxisRotation, largeArcFlag, sweepFlag, x, y]
+
+
+// 非svg标准的canvas绘图命令
+type width = number
+type height = number
+type rotation = number
+type startAngle = number
+type endAngle = number
+type counterclockwise = boolean
+type cornerRadius = number | number[]
+type radius = number
+
+export type RectCommandData = [Command, x, y, width, height]
+export type RoundRectCommandData = [Command, x, y, width, height, cornerRadius]
+export type EllipseCommandData = [Command, x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise]
+export type ArcCommandData = [Command, x, y, radius, startAngle, endAngle, counterclockwise]
+export type ArcToCommandData = [Command, x1, y1, x2, y2, radius]
+
+
+export type CanvasPathCommand = 1 | 2 | 5 | 7 | 11 // M | L | C | Q | Z   canvas可以绘制的命令
+
+export type IPathCommandData = number[] // ...(MCommandData | LCommandData | CCommandData | QCommandData | ZCommandData)

package/src/platform/IPlatform.ts

@@ -0,0 +1,7 @@
+import { IFunction } from '../function/IFunction'
+import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
+
+export interface IPlatform {
+    requestRender?(render: IFunction): void
+    canvas?: ILeaferCanvas
+}

package/src/plugin/IPlugin.ts

@@ -0,0 +1,11 @@
+import { IObject } from '../data/IData'
+
+export interface IPlugin {
+    name: string
+    version: string
+    author: string
+    license: string
+    description: string
+    dependencies: string[]
+    run(params: IObject): void
+}

package/src/renderer/IRenderer.ts

@@ -0,0 +1,37 @@
+import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
+import { ILeaf } from '../display/ILeaf'
+import { IBounds, IMatrix } from '../math/IMath'
+import { IFunction } from '../function/IFunction'
+import { ILayoutBlockData } from '../layouter/ILayouter'
+
+export interface IRenderOptions {
+    bounds?: IBounds,
+    hideBounds?: IBounds,
+    matrix?: IMatrix,
+    inCamera?: boolean
+}
+
+export interface IRendererConfig {
+    maxFPS?: number
+}
+
+export interface IRenderer {
+    canvas: ILeaferCanvas
+    target: ILeaf
+    layoutedBlocks: ILayoutBlockData[]
+    running: boolean
+    totalTimes: number
+    times: number
+    config: IRendererConfig
+
+    FPS: number
+
+    start(): void
+    stop(): void
+
+    requestLayout(): void
+    render(callback?: IFunction): void
+    clipRender(bounds: IBounds): void
+    fullRender(bounds?: IBounds): void
+    destroy(): void
+}

package/src/selector/ISelector.ts

@@ -0,0 +1,28 @@
+import { ILeaf } from '../display/ILeaf'
+import { ILeafList } from '../data/IList'
+import { IPointData } from '../math/IMath'
+
+export interface ISelectPathResult {
+    leaf: ILeaf
+    path: ILeafList
+    throughPath?: ILeafList
+}
+
+export interface ISelectPathOptions {
+    through?: boolean
+    exclude?: ILeafList
+}
+
+export interface ISelector {
+    target: ILeaf
+
+    defaultPath: ILeafList
+    getHitPointPath(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult
+
+    find(name: number | string, branch?: ILeaf): ILeaf | ILeaf[]
+    getByInnerId(name: number, branch?: ILeaf): ILeaf
+    getById(name: string, branch?: ILeaf): ILeaf
+    getByClassName(name: string, branch?: ILeaf): ILeaf[]
+    getByTagName(name: string, branch?: ILeaf): ILeaf[]
+    destroy(): void
+}

package/src/watcher/IWatcher.ts

@@ -0,0 +1,25 @@
+import { ILeaf } from '../display/ILeaf'
+import { ILeafList } from '../data/IList'
+
+export interface IWatchEventData {
+    updatedList: ILeafList
+}
+
+export interface IWatcherConfig {
+
+}
+
+export interface IWatcher {
+    target: ILeaf
+    updatedList: ILeafList
+    totalTimes: number
+    config: IWatcherConfig
+    running: boolean
+    changed: boolean
+
+    start(): void
+    stop(): void
+
+    update(): void
+    destroy(): void
+}