@leafer/interface 1.0.0-rc.3 → 1.0.0-rc.30

package/src/layouter/ILayouter.ts

@@ -34,6 +34,7 @@ export interface ILayouterConfig {
 export interface ILayouter extends IControl {
     target: ILeaf
     layoutedBlocks: ILayoutBlockData[]
+    extraBlock: ILayoutBlockData
 
     totalTimes: number
     times: number
@@ -54,6 +55,8 @@ export interface ILayouter extends IControl {
     partLayout(): void
     fullLayout(): void
 
+    addExtra(leaf: ILeaf): void
+
     createBlock(data: ILeafList | ILeaf[]): ILayoutBlockData
     getBlocks(list: ILeafList): ILayoutBlockData[]
     addBlocks(current: ILayoutBlockData[]): void

package/src/math/IMath.ts

@@ -1,26 +1,54 @@
-import { IObject } from '../data/IData'
+import { IFourNumber, IObject } from '../data/IData'
 
 export interface IPointData {
     x: number
     y: number
 }
 
+export interface IUnitPointData {
+    type?: 'percent' | 'px'
+    x: number
+    y: number
+}
+
+export interface IFromToData {
+    from: IPointData
+    to: IPointData
+}
+
+export interface IScrollPointData {
+    scrollX: number
+    scrollY: number
+}
+
+export interface IClientPointData {
+    clientX: number
+    clientY: number
+}
+
 export interface IPoint extends IPointData {
-    set(x?: number, y?: number): void
-    copy(point: IPointData): IPoint
+    set(x?: number | IPointData, y?: number): IPoint
+    get(): IPointData
     clone(): IPoint
 
-    rotate(angle: number, center?: IPointData): IPoint
+    move(x: number, y: number): IPoint
+    scale(scaleX: number, scaleY?: number): IPoint
+    scaleOf(origin: IPointData, scaleX: number, scaleY?: number): IPoint
+    rotate(rotation: number, origin?: IPointData): IPoint
+    rotateOf(origin: IPointData, rotation: number): IPoint
+    getRotation(origin: IPointData, to: IPointData, toOrigin?: IPointData): number
 
     toInnerOf(matrix: IMatrixData, to?: IPointData): IPoint
     toOuterOf(matrix: IMatrixData, to?: IPointData): IPoint
 
-    getCenter(to: IPointData): IPointData
+    getCenter(to: IPointData): IPoint
     getDistance(to: IPointData): number
+    getDistancePoint(to: IPointData, distance: number, changeTo?: boolean): IPoint
+
     getAngle(to: IPointData): number
     getAtan2(to: IPointData): number
 
-    reset(): void
+    reset(): IPoint
 }
 
 export interface IRadiusPointData extends IPointData {
@@ -47,29 +75,38 @@ export interface IOffsetBoundsData extends IBoundsData {
     offsetY: number
 }
 
-export interface IBoundsDataHandle {
+export interface IBoundsDataFn {
     (target: any): IBoundsData
 }
 
-export interface IBounds extends IBoundsData {
-    set(x?: number, y?: number, width?: number, height?: number): void
-    copy(bounds: IBoundsData): IBounds
+export interface IBounds extends IBoundsData, ITwoPointBoundsData {
+    set(x?: number | IBoundsData, y?: number, width?: number, height?: number): IBounds
+    get(): IBoundsData
     clone(): IBounds
 
+    move(x: number, y: number): IBounds
     scale(scaleX: number, scaleY?: number): IBounds
+    scaleOf(origin: IPointData, scaleX: number, scaleY?: number): IBounds
     toOuterOf(matrix: IMatrixData, to?: IBoundsData): IBounds
-    getFitMatrix(put: IBoundsData): IMatrix
+    toInnerOf(matrix: IMatrixData, to?: IBoundsData): IBounds
+    getFitMatrix(put: IBoundsData, baseScale?: number): IMatrix
 
-    spread(size: number): IBounds
+    spread(fourNumber: IFourNumber): IBounds
+    shrink(fourNumber: IFourNumber): IBounds
     ceil(): IBounds
     unsign(): IBounds
+    float(maxLength?: number): 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
+    addList(boundsList: IBoundsData[]): IBounds
+    setList(boundsList: IBoundsData[]): IBounds
+    addListWithFn(list: IObject[], boundsDataHandle: IBoundsDataFn): IBounds
+    setListWithFn(list: IObject[], boundsDataHandle: IBoundsDataFn): IBounds
+
+    setPoint(point: IPointData): IBounds
+    setPoints(points: IPointData[]): IBounds
+    addPoint(point: IPointData): IBounds
+    getPoints(): IPointData[] // topLeft, topRight, bottomRight, bottomLeft
 
     hitPoint(point: IPointData, pointMatrix?: IMatrixData): boolean
     hitRadiusPoint(point: IRadiusPointData, pointMatrix?: IMatrixWithLayoutData): boolean
@@ -91,19 +128,15 @@ export interface ITwoPointBoundsData {
     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 {
+export interface IAutoBoxData {
     top?: number
     right?: number
     bottom?: number
     left?: number
+}
+
 
+export interface IAutoBoundsData extends IAutoBoxData {
     width?: number
     height?: number
 }
@@ -125,17 +158,24 @@ export interface IMatrixData {
     f: number
 }
 
-export interface IMatrixDecompositionData {
-    x: number
-    y: number
+export interface IScaleData {
     scaleX: number
     scaleY: number
+}
+
+export interface IScaleRotationData extends IScaleData {
     rotation: number
+}
+
+export interface ISkewData {
     skewX: number
     skewY: number
 }
 
-export type IMatrixDecompositionAttr =
+export interface ILayoutData extends IScaleRotationData, ISkewData, IPointData {
+}
+
+export type ILayoutAttr =
     | 'x'
     | 'y'
     | 'scaleX'
@@ -144,15 +184,21 @@ export type IMatrixDecompositionAttr =
     | '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
+
+export interface ILayoutBoundsData extends ILayoutData, IBoundsData {
+}
+export interface IMatrix extends IMatrixWithScaleData {
+
+    set(a: number | IMatrixData, b: number, c: number, d: number, e: number, f: number): IMatrix
+    setWith(dataWithScale: IMatrixWithScaleData): IMatrix  // set scaleX scaleY
+    get(): IMatrixData
     clone(): IMatrix
 
     translate(x: number, y: number): IMatrix
     translateInner(x: number, y: number): IMatrix
 
     scale(x: number, y?: number): IMatrix
+    scaleWith(x: number, y?: number): IMatrix // change scaleX scaleY
     scaleOfOuter(origin: IPointData, x: number, y?: number): IMatrix
     scaleOfInner(origin: IPointData, x: number, y?: number): IMatrix
 
@@ -164,19 +210,34 @@ export interface IMatrix extends IMatrixData {
     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
+    multiply(child: IMatrixData): IMatrix
+    multiplyParent(parent: IMatrixData): IMatrix
+
+    divide(child: IMatrixData): IMatrix
+    divideParent(parent: IMatrixData): IMatrix
     invert(): IMatrix
+    invertWith(): IMatrix  // change scaleX scaleY
 
     toOuterPoint(inner: IPointData, to?: IPointData, distance?: boolean): void
     toInnerPoint(outer: IPointData, to?: IPointData, distance?: boolean): void
 
-    decompose(): IMatrixDecompositionData
+    setLayout(data: ILayoutData, origin?: IPointData): IMatrix
+    getLayout(origin?: IPointData, firstSkewY?: boolean): ILayoutData
+
+    withScale(scaleX?: number, scaleY?: number): IMatrixWithScaleData
 
     reset(): void
 }
 
 export interface IMatrixWithBoundsData extends IMatrixData, IBoundsData { }
 
-export interface IMatrixWithLayoutData extends IMatrixData, IMatrixDecompositionData, IBoundsData { }
+export interface IMatrixWithScaleData extends IMatrixData, IScaleData { }
+
+export interface IMatrixWithOptionScaleData extends IMatrixData {
+    scaleX?: number
+    scaleY?: number
+}
+
+export interface IMatrixWithBoundsScaleData extends IMatrixData, IBoundsData, IScaleData { }
+
+export interface IMatrixWithLayoutData extends IMatrixData, ILayoutBoundsData { }

package/src/path/IPathDrawer.ts

@@ -16,8 +16,9 @@ export interface IPathDrawer {
     roundRect(x: number, y: number, width: number, height: number, radius?: number | number[]): void
 }
 
-export interface IPathCreator {
+export interface IPathCreator extends IPathDrawer {
     path: IPathCommandData
+    __path: IPathCommandData
 
     beginPath(): IPathCreator
 
@@ -27,9 +28,9 @@ export interface 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
+    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
+    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
@@ -38,4 +39,6 @@ export interface IPathCreator {
     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
+
+    clearPath(): IPathCreator
 }

package/src/platform/IPlatform.ts

@@ -1,35 +1,53 @@
-import { IFunction } from '../function/IFunction'
+import { IFunction, IStringFunction } 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'
+import { ICanvasType } from '../canvas/ISkiaCanvas'
 
 export interface IPlatform {
     name?: 'web' | 'node' | 'miniapp'
     os?: 'Mac' | 'Windows' | 'Linux'
+    toURL(text: string, fileType?: 'text' | 'svg'): string
     requestRender?(render: IFunction): void
     canvas?: ILeaferCanvas
+    canvasType?: ICanvasType
     isWorker?: boolean
     isMobile?: boolean
     devicePixelRatio?: number
     intWheelDeltaY?: boolean // firefox / Windows need
     conicGradientSupport?: boolean
     conicGradientRotate90?: boolean // firefox need rotate
-    fullImageShadow?: boolean // safari need 
+    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>
+        download(url: string, filename: string): Promise<void>
         loadImage(url: string): Promise<any>
         noRepeat?: string  // fix: 微信小程序 createPattern 直接使用 no-repeat 有bug，导致无法显示
     },
+    roundRectPatch?: boolean //  fix: skia-canvas roundRect
+    ellipseToCurve?: boolean, // fix: skia 绘制圆环和椭圆弧
+    event?: {
+        stopDefault(origin: IObject): void
+        stopNow(origin: IObject): void
+        stop(origin: IObject): void
+    },
     miniapp?: IMiniapp
-    imageSuffix?: string // 需要带上后缀区分dom中image标签的缓存，否则会导致浏览器缓存跨域问题
+    image: {
+        hitCanvasSize: number // 图片生成碰撞画布的最大尺寸(单边)
+        maxCacheSize: number // 最大等级缓存，一般取当前屏幕大小，默认2k: 2560 * 1600
+        maxPatternSize: number // 最大repeat pattern缓存, 默认4k: 4096 * 2160
+        prefix?: string // url加前缀
+        suffix?: string  // 需要带上后缀区分dom中image标签的缓存，否则会导致浏览器缓存跨域问题
+        crossOrigin: string | false // 跨域设置
+        getRealURL: IStringFunction // 处理前缀、后缀
+    }
 }
 
 

package/src/plugin/IPlugin.ts

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

package/src/renderer/IRenderer.ts

@@ -1,13 +1,14 @@
 import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
 import { ILeaf } from '../display/ILeaf'
-import { IBounds, IMatrix } from '../math/IMath'
+import { IBounds, IMatrixWithScaleData } from '../math/IMath'
 import { IFunction } from '../function/IFunction'
 import { IControl } from '../control/IControl'
 
 export interface IRenderOptions {
+    includes?: boolean,
     bounds?: IBounds,
     hideBounds?: IBounds,
-    matrix?: IMatrix,
+    matrix?: IMatrixWithScaleData,
     inCamera?: boolean
 }
 
@@ -31,6 +32,7 @@ export interface IRenderer extends IControl {
 
     waitAgain: boolean
     changed: boolean
+    ignore: boolean
 
     config: IRendererConfig
 

package/src/selector/ISelector.ts

@@ -1,35 +1,64 @@
 import { ILeaf } from '../display/ILeaf'
 import { ILeafList } from '../data/IList'
 import { IPointData } from '../math/IMath'
+import { IBranch } from '../display/IBranch'
 
-export interface ISelectPathResult {
-    leaf: ILeaf
+export interface IPickResult {
+    target: ILeaf
     path: ILeafList
     throughPath?: ILeafList
 }
 
-export interface ISelectPathOptions {
+export interface IPickOptions {
     name?: string
+    hitRadius?: number
     through?: boolean
+    target?: IBranch
+    findList?: ILeaf[]
+    bottomList?: IPickBottom[]  // 底部可拾取的虚拟元素
     exclude?: ILeafList
     ignoreHittable?: boolean
 }
 
+export interface IPickBottom {
+    target: ILeaf
+    proxy?: ILeaf
+}
+
 export interface ISelectorConfig {
 
 }
 
+export type IAnswer = 0 | 1 | 2 | 3
+
+export interface IFindCondition {
+    id?: number | string,
+    className?: string,
+    tag?: string | string[]
+}
+
+export interface IFindMethod {
+    (leaf: ILeaf, options?: any): IAnswer
+}
+
+export interface ISelectorProxy {
+    list: ILeaf[]
+}
+
 export interface ISelector {
     target: ILeaf
 
+    proxy?: ISelectorProxy
+
     config: ISelectorConfig
 
-    getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult
+    getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult
 
-    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[]
+    getBy(condition: number | string | IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[]
+    getByInnerId(innerId: number, branch?: ILeaf): ILeaf
+    getById(id: string, branch?: ILeaf): ILeaf
+    getByClassName(className: string, branch?: ILeaf): ILeaf[]
+    getByTag(tag: string, branch?: ILeaf): ILeaf[]
+    getByMethod(method: IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[]
     destroy(): void
 }