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

package/src/math/IMath.ts

@@ -0,0 +1,182 @@
+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): IPoint
+
+    toInnerOf(matrix: IMatrixData, to?: IPointData): IPoint
+    toOuterOf(matrix: IMatrixData, to?: IPointData): IPoint
+
+    getCenter(to: IPointData): IPointData
+    getDistance(to: IPointData): number
+    getAngle(to: IPointData): number
+    getAtan2(to: IPointData): number
+
+    reset(): void
+}
+
+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
+
+    scale(scaleX: number, scaleY?: number): IBounds
+    toOuterOf(matrix: IMatrixData, to?: IBoundsData): IBounds
+    getFitMatrix(put: IBoundsData): IMatrix
+
+    spread(size: number): IBounds
+    ceil(): IBounds
+    unsign(): IBounds
+
+    add(bounds: IBoundsData): IBounds
+    addList(boundsList: IBounds[]): IBounds
+    setByList(boundsList: IBounds[], addMode?: boolean): IBounds
+    addListWithHandle(list: IObject[], boundsDataHandle: IBoundsDataHandle): IBounds
+    setByListWithHandle(list: IObject[], boundsDataHandle: IBoundsDataHandle, addMode: boolean): IBounds
+    setByPoints(points: IPointData[]): IBounds
+
+    hitPoint(point: IPointData, pointMatrix?: IMatrixData): boolean
+    hitRadiusPoint(point: IRadiusPointData, pointMatrix?: IMatrixWithLayoutData): boolean
+    hit(bounds: IBoundsData, boundsMatrix?: IMatrixData): boolean
+    includes(bounds: IBoundsData, boundsMatrix?: IMatrixData): boolean
+
+    intersect(bounds: IBoundsData, boundsMatrix?: IMatrixData): IBounds
+    getIntersect(bounds: IBoundsData, boundsMatrix?: IMatrixData): IBounds
+
+    isSame(bounds: IBoundsData): boolean
+    isEmpty(): boolean
+    reset(): void
+}
+
+export interface ITwoPointBoundsData {
+    minX: number
+    minY: number
+    maxX: number
+    maxY: number
+}
+
+export interface ITwoPointBounds extends ITwoPointBoundsData {
+    addPoint(x: number, y: number): void
+    addBounds(x: number, y: number, width: number, height: 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 IMatrixDecompositionData {
+    x: number
+    y: number
+    scaleX: number
+    scaleY: number
+    rotation: number
+    skewX: number
+    skewY: number
+}
+
+export type IMatrixDecompositionAttr =
+    | 'x'
+    | 'y'
+    | 'scaleX'
+    | 'scaleY'
+    | 'rotation'
+    | 'skewX'
+    | 'skewY'
+
+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
+    translateInner(x: number, y: number): IMatrix
+
+    scale(x: number, y?: number): IMatrix
+    scaleOfOuter(origin: IPointData, x: number, y?: number): IMatrix
+    scaleOfInner(origin: IPointData, x: number, y?: number): IMatrix
+
+    rotate(angle: number): IMatrix
+    rotateOfOuter(origin: IPointData, angle: number): IMatrix
+    rotateOfInner(origin: IPointData, angle: number): IMatrix
+
+    skew(x: number, y?: number): IMatrix
+    skewOfOuter(origin: IPointData, x: number, y?: number): IMatrix
+    skewOfInner(origin: IPointData, x: number, y?: number): IMatrix
+
+    multiply(matrix: IMatrixData): IMatrix
+    divide(matrix: IMatrixData): IMatrix
+    preMultiply(matrix: IMatrixData): IMatrix
+    invert(): IMatrix
+
+    toOuterPoint(inner: IPointData, to?: IPointData, distance?: boolean): void
+    toInnerPoint(outer: IPointData, to?: IPointData, distance?: boolean): void
+
+    decompose(): IMatrixDecompositionData
+
+    reset(): void
+}
+
+export interface IMatrixWithBoundsData extends IMatrixData, IBoundsData { }
+
+export interface IMatrixWithLayoutData extends IMatrixData, IMatrixDecompositionData, 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 anticlockwise = 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, anticlockwise]
+export type ArcCommandData = [Command, x, y, radius, startAngle, endAngle, anticlockwise]
+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/path/IPathDrawer.ts

@@ -0,0 +1,41 @@
+import { IPathCommandData } from './IPathCommand'
+export interface IPathDrawer {
+    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
+}
+
+export interface IPathCreator {
+    path: IPathCommandData
+
+    beginPath(): IPathCreator
+
+    moveTo(x: number, y: number): IPathCreator
+    lineTo(x: number, y: number): IPathCreator
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): IPathCreator
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): IPathCreator
+    closePath(): IPathCreator
+
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): IPathCreator
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): IPathCreator
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): IPathCreator
+
+    rect(x: number, y: number, width: number, height: number): IPathCreator
+    roundRect(x: number, y: number, width: number, height: number, radius?: number | number[]): IPathCreator
+
+    // new
+    drawEllipse(x: number, y: number, radiusX: number, radiusY: number, rotation?: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPathCreator
+    drawArc(x: number, y: number, radius: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPathCreator
+    drawPoints(points: number[], curve?: boolean | number, close?: boolean): IPathCreator
+}

package/src/platform/IPlatform.ts

@@ -0,0 +1,49 @@
+import { IFunction } from '../function/IFunction'
+import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
+import { ILeaf } from '../display/ILeaf'
+import { IExportFileType, IExportImageType } from '../file/IFileType'
+import { IBoundsData, ISizeData } from '../math/IMath'
+import { IObject } from '../data/IData'
+
+export interface IPlatform {
+    name?: 'web' | 'node' | 'miniapp'
+    os?: 'Mac' | 'Windows' | 'Linux'
+    requestRender?(render: IFunction): void
+    canvas?: ILeaferCanvas
+    isWorker?: boolean
+    isMobile?: boolean
+    devicePixelRatio?: number
+    intWheelDeltaY?: boolean // firefox / Windows need
+    conicGradientSupport?: boolean
+    conicGradientRotate90?: boolean // firefox need rotate
+    fullImageShadow?: boolean // safari need 
+    syncDomFont?: boolean // firefox need
+    layout?(target: ILeaf): void
+    realtimeLayout?: boolean
+    origin?: {
+        createCanvas(width: number, height: number, format?: 'svg' | 'pdf'): any
+        canvasToDataURL(canvas: any, type?: IExportImageType, quality?: number): string | Promise<string>
+        canvasToBolb(canvas: any, type?: IExportFileType, quality?: number): Promise<any>
+        canvasSaveAs(canvas: any, filename: string, quality?: number): Promise<void>
+        loadImage(url: string): Promise<any>
+        noRepeat?: string  // fix: 微信小程序 createPattern 直接使用 no-repeat 有bug，导致无法显示
+    },
+    miniapp?: IMiniapp
+    imageSuffix?: string // 需要带上后缀区分dom中image标签的缓存，否则会导致浏览器缓存跨域问题
+}
+
+
+export interface IMiniappSelect extends IObject { }
+
+export interface IMiniappSizeView extends ISizeData {
+    view: any
+}
+
+export interface IMiniapp {
+    select(name: string): IMiniappSelect
+    getBounds(select: IMiniappSelect): Promise<IBoundsData>
+    getSizeView(select: IMiniappSelect): Promise<IMiniappSizeView>
+    onWindowResize(fun: IFunction): void
+    offWindowResize(fun: IFunction): void
+    saveToAlbum(path: string): Promise<any>
+}

package/src/plugin/IPlugin.ts

@@ -0,0 +1,10 @@
+import { ILeafer } from '../app/ILeafer'
+import { IObject } from '../data/IData'
+
+export interface IPlugin extends IObject {
+    name?: string
+    importVersion: string
+    import: string[]
+    run(LeaferUI: IObject, config: IObject): void
+    onLeafer?(leafer: ILeafer): void
+}

package/src/renderer/IRenderer.ts

@@ -0,0 +1,53 @@
+import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
+import { ILeaf } from '../display/ILeaf'
+import { IBounds, IMatrix } from '../math/IMath'
+import { IFunction } from '../function/IFunction'
+import { IControl } from '../control/IControl'
+
+export interface IRenderOptions {
+    bounds?: IBounds,
+    hideBounds?: IBounds,
+    matrix?: IMatrix,
+    inCamera?: boolean
+}
+
+export interface IRendererConfig {
+    usePartRender?: boolean
+    maxFPS?: number
+    fill?: string
+}
+
+export interface IRenderer extends IControl {
+    target: ILeaf
+    canvas: ILeaferCanvas
+    updateBlocks: IBounds[]
+
+    FPS: number
+    totalTimes: number
+    times: number
+
+    running: boolean
+    rendering: boolean
+
+    waitAgain: boolean
+    changed: boolean
+
+    config: IRendererConfig
+
+    update(): void
+
+    requestLayout(): void
+
+    render(callback?: IFunction): void
+    renderAgain(): void
+    renderOnce(callback?: IFunction): void
+    partRender(): void
+    clipRender(bounds: IBounds): void
+    fullRender(): void
+
+    renderHitView(options: IRenderOptions): void
+    renderBoundsView(options: IRenderOptions): void
+
+    addBlock(block: IBounds): void
+    mergeBlocks(): void
+}

package/src/selector/ISelector.ts

@@ -0,0 +1,35 @@
+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 {
+    name?: string
+    through?: boolean
+    exclude?: ILeafList
+    ignoreHittable?: boolean
+}
+
+export interface ISelectorConfig {
+
+}
+
+export interface ISelector {
+    target: ILeaf
+
+    config: ISelectorConfig
+
+    getByPoint(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/task/ITaskProcessor.ts

@@ -0,0 +1,44 @@
+import { IFunction } from '../function/IFunction'
+
+export interface ITaskProcessorConfig {
+    onComplete?: IFunction
+    onTask?: IFunction
+    onError?: IFunction
+    parallel?: number
+}
+
+export interface ITaskProcessor {
+    config: ITaskProcessorConfig
+    running: boolean
+    isComplete: boolean
+    percent: number
+    total: number
+    index: number
+    finishedIndex: number
+    remain: number
+    start(): void
+    pause(): void
+    resume(): void
+    skip(): void
+    stop(): void
+    add(taskCallback: IFunction, options?: ITaskOptions | number): ITaskItem
+    destroy(): void
+}
+
+export interface ITaskItem {
+    parent: ITaskProcessor
+    parallel: boolean
+    isComplete: boolean
+    isCancel: boolean
+    time: number
+    run(): Promise<void>
+    complete(): void
+    cancel(): void
+}
+
+export interface ITaskOptions {
+    start?: boolean // default true
+    time?: number // default 1
+    parallel?: boolean // default true
+    delay?: number // default 0
+}

package/src/watcher/IWatcher.ts

@@ -0,0 +1,34 @@
+import { ILeaf } from '../display/ILeaf'
+import { ILeafList } from '../data/IList'
+import { IControl } from '../control/IControl'
+
+export interface IWatchEventData {
+    updatedList: ILeafList
+}
+
+export interface IWatcherConfig {
+
+}
+
+export interface IWatcher extends IControl {
+    target: ILeaf
+
+    totalTimes: number
+
+    disabled: boolean
+    running: boolean
+    changed: boolean
+
+    hasVisible: boolean
+    hasAdd: boolean
+    hasRemove: boolean
+    readonly childrenChanged: boolean
+
+    config: IWatcherConfig
+
+    updatedList: ILeafList
+
+    disable(): void
+
+    update(): void
+}