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

package/src/event/IEvent.ts

@@ -0,0 +1,111 @@
+import { IEventer } from './IEventer'
+import { IWatchEventData } from '../watcher/IWatcher'
+import { ILayoutBlockData } from '../layouter/ILayouter'
+import { ILeaf } from '../display/ILeaf'
+import { IScreenSizeData, IPointData } from '../math/IMath'
+
+export interface IEvent {
+    type?: string
+    target?: IEventTarget
+    current?: IEventTarget
+
+    bubbles?: boolean
+    phase?: number
+
+    isStopDefault?: boolean
+    isStop?: boolean
+    isStopNow?: boolean
+    stopDefault?(): void
+    stopNow?(): void
+    stop?(): void
+}
+
+export interface IEventTarget extends IEventer {
+
+}
+
+export interface ILeaferEvent {
+
+}
+
+export interface IRenderEvent {
+
+}
+
+export interface IAnimateEvent {
+
+}
+
+export interface IChildEvent extends IEvent {
+    parent?: ILeaf
+    child?: ILeaf
+}
+
+export interface IResizeEvent extends IEvent {
+    readonly width: number
+    readonly height: number
+    readonly pixelRatio: number
+
+    readonly bigger: boolean
+    readonly smaller: boolean
+    readonly samePixelRatio: boolean
+    readonly old: IScreenSizeData
+}
+
+export interface IResizeEventListener {
+    (event: IResizeEvent): void
+}
+
+export interface IUpdateEvent extends IEvent {
+
+}
+
+export interface IPropertyEvent extends IEvent {
+    readonly attrName: string
+    readonly oldValue: unknown
+    readonly newValue: unknown
+}
+
+export interface ILayoutEvent extends IEvent {
+    readonly data: ILayoutBlockData[]
+    readonly times: number
+}
+
+export interface IWatchEvent extends IEvent {
+    readonly data: IWatchEventData
+}
+
+export interface ITransformEventData {
+    x: number
+    y: number
+    scaleX: number
+    scaleY: number
+    rotation: number
+
+    readonly zooming: boolean
+    readonly moving: boolean
+    readonly rotating: boolean
+    readonly changing: boolean
+}
+
+export interface ITransformEvent extends IEvent, ITransformEventData {
+    readonly x: number
+    readonly y: number
+    readonly scaleX: number
+    readonly scaleY: number
+    readonly rotation: number
+}
+export type TransformMode = 'move' | 'zoom' | 'rotate'
+
+
+export interface IMultiTouchData {
+    move: IPointData,
+    scale: number,
+    angle: number,
+    center: IPointData
+}
+
+export interface IKeepTouchData {
+    from: IPointData
+    to: IPointData
+}

package/src/event/IEventer.ts

@@ -0,0 +1,43 @@
+import { IEvent, IFunction, IObject } from '@leafer/interface'
+import { ILeafEventer } from '../display/module/ILeafEventer'
+
+export type IEventListener = IFunction
+
+export interface IEventListenerOptions {
+    capture?: boolean
+    once?: boolean
+}
+
+export interface IEventListenerItem extends IEventListenerOptions {
+    listener: IEventListener
+}
+
+export interface IEventListenerMap {
+    [name: string]: IEventListenerItem[]
+}
+
+export interface IEventListenerId {
+    type: string | string[]
+    listener: IEventListener
+    options?: IEventListenerOptions | boolean
+}
+
+export type InnerId = number
+
+export interface IEventer extends ILeafEventer {
+
+    readonly innerId: InnerId
+    __captureMap?: IEventListenerMap
+    __bubbleMap?: IEventListenerMap
+
+    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): void
+    emit(type: string, event?: IEvent | IObject, capture?: boolean): void
+    emitEvent(event?: IEvent, capture?: boolean): void
+    hasEvent(type: string, capture?: boolean): boolean
+
+    destroy(): void
+}

package/src/event/IUIEvent.ts

@@ -0,0 +1,88 @@
+import { IObject } from '../data/IData'
+import { ILeafList } from '../data/IList'
+import { IEvent } from './IEvent'
+import { ILeaferImage } from '../image/ILeaferImage'
+import { ILeaf } from '../display/ILeaf'
+import { IPointData } from '../math/IMath'
+
+export interface IUIEvent extends IEvent {
+    x: number
+    y: number
+
+    altKey?: boolean
+    ctrlKey?: boolean
+    shiftKey?: boolean
+    metaKey?: boolean
+    readonly spaceKey?: boolean
+
+    readonly left?: boolean
+    readonly right?: boolean
+    readonly middle?: boolean
+    buttons?: number
+
+    path?: ILeafList
+    throughPath?: ILeafList // 穿透path，不受层级影响，从上到下只要碰撞到区域就算，一般点击的时候
+
+    origin?: IObject
+
+    getInner?(target?: ILeaf): IPointData
+    getLocal?(target?: ILeaf): IPointData
+}
+
+
+export interface IPointerEvent extends IUIEvent {
+    width?: number
+    height?: number
+    pointerType?: PointerType
+    pressure?: number
+    tangentialPressure?: number
+    tiltX?: number
+    tiltY?: number
+    twist?: number
+}
+export type PointerType = 'mouse' | 'pen' | 'touch'
+
+export interface IDragEvent extends IPointerEvent {
+    moveX: number
+    moveY: number
+    totalX?: number
+    totalY?: number
+
+    getInnerMove?(target?: ILeaf): IPointData
+    getLocalMove?(target?: ILeaf): IPointData
+    getInnerTotal?(target?: ILeaf): IPointData
+    getLocalTotal?(target?: ILeaf): IPointData
+}
+
+export interface IDropEvent extends IPointerEvent {
+    list: ILeafList
+    data?: IObject
+}
+
+export interface IRotateEvent extends IUIEvent {
+    rotation: number
+}
+
+export interface IZoomEvent extends IUIEvent {
+    scale: number
+}
+
+export interface IMoveEvent extends IDragEvent {
+
+}
+
+export interface ISwipeEvent extends IDragEvent {
+
+}
+
+export interface IKeyEvent extends IUIEvent {
+    code?: string
+    key?: string
+}
+
+export interface IImageEvent extends IEvent {
+    image?: ILeaferImage
+    attrName?: string
+    attrValue?: IObject
+    error?: string | IObject
+}

package/src/file/IFileType.ts

@@ -0,0 +1,2 @@
+export type IExportImageType = 'jpg' | 'png' | 'webp'
+export type IExportFileType = IExportImageType | 'svg' | 'pdf' | 'json'

package/src/function/IFunction.ts

@@ -0,0 +1,13 @@
+import { IPointData } from '../math/IMath'
+
+export interface IFunction {
+    (...arg: any): any
+}
+
+export interface INumberFunction {
+    (...arg: any): number
+}
+
+export interface IPointDataFunction {
+    (...arg: any): IPointData
+}

package/src/image/IImageManager.ts

@@ -0,0 +1,18 @@
+import { ILeaferImage, ILeaferImageConfig } from './ILeaferImage'
+import { ITaskProcessor } from '../task/ITaskProcessor'
+
+interface ILeaferImageMap {
+    [name: string]: ILeaferImage
+}
+
+export interface IImageManager {
+    map: ILeaferImageMap
+    recycledList: ILeaferImage[]
+    tasker: ITaskProcessor
+    patternTasker: ITaskProcessor
+    readonly isComplete: boolean
+    get(config: ILeaferImageConfig): ILeaferImage
+    recycle(image: ILeaferImage): void
+    clearRecycled(): void
+    destroy(): void
+}

package/src/image/ILeaferImage.ts

@@ -0,0 +1,43 @@
+import { IObject } from '../data/IData'
+import { InnerId } from '../event/IEventer'
+import { IExportFileType } from '../file/IFileType'
+
+export interface ILeaferImageConfig {
+    url: string
+    thumb?: string
+    format?: IExportFileType
+}
+
+export interface ILeaferImageOnLoaded {
+    (image?: ILeaferImage): any
+}
+
+export interface ILeaferImageOnError {
+    (error?: string | IObject, image?: ILeaferImage): any
+}
+
+export interface ILeaferImage {
+    readonly innerId: InnerId
+    readonly url: string
+
+    view: unknown
+    width: number
+    height: number
+
+    isSVG: boolean
+
+    readonly completed: boolean
+    ready: boolean
+    error: IObject
+    loading: boolean
+
+    use: number
+    config: ILeaferImageConfig
+
+    load(onSuccess?: ILeaferImageOnLoaded, onError?: ILeaferImageOnError): number
+    unload(index: number, stopEvent?: boolean): void
+    getCanvas(width: number, height: number, opacity?: number, _filters?: IObject): unknown
+    destroy(): void
+}
+
+export type IImageStatus = 'wait' | 'thumb-loading' | 'thumb-success' | 'thumb-error' | 'loading' | 'success' | 'error' 

package/src/interaction/IInteraction.ts

@@ -0,0 +1,106 @@
+import { INumberFunction, IPointDataFunction } from '../function/IFunction'
+import { IPointerEvent, IMoveEvent, IZoomEvent, IRotateEvent, IUIEvent, IKeyEvent } from '../event/IUIEvent'
+import { ILeaf, ICursorType } from '../display/ILeaf'
+import { ILeafList } from '../data/IList'
+import { IPointData } from '../math/IMath'
+import { ISelector, ISelectPathOptions } from '../selector/ISelector'
+import { IBounds } from '../math/IMath'
+import { IControl } from '../control/IControl'
+import { IKeepTouchData } from '../event/IEvent'
+import { ILeaferCanvas } from '../canvas/ILeaferCanvas'
+import { IObject } from '../data/IData'
+
+export interface IInteraction extends IControl {
+    target: ILeaf
+    canvas: IInteractionCanvas
+    selector: ISelector
+
+    running: boolean
+    readonly dragging: boolean
+    readonly moveMode: boolean
+
+    config: IInteractionConfig
+
+    cursor: ICursorType | ICursorType[]
+    readonly hitRadius: number
+
+    shrinkCanvasBounds: IBounds
+
+    downData: IPointerEvent
+    hoverData: IPointerEvent
+    downTime: number
+
+    receive(event: any): void
+
+    pointerDown(data?: IPointerEvent, defaultPath?: boolean): void
+    pointerMove(data?: IPointerEvent): void
+    pointerMoveReal(data: IPointerEvent): void
+    pointerUp(data?: IPointerEvent): void
+    pointerCancel(): void
+
+    multiTouch(data: IUIEvent, list: IKeepTouchData[]): void
+
+    move(data: IMoveEvent): void
+    zoom(data: IZoomEvent): void
+    rotate(data: IRotateEvent): void
+
+    keyDown(data: IKeyEvent): void
+    keyUp(data: IKeyEvent): void
+
+    findPath(data: IPointerEvent, options?: ISelectPathOptions): ILeafList
+
+    updateDownData(data?: IPointerEvent): void
+    updateHoverData(data: IPointerEvent): void
+    updateCursor(hoverData?: IPointerEvent): void
+
+    emit(type: string, data: IUIEvent, path?: ILeafList, excludePath?: ILeafList): void
+}
+
+export interface IInteractionCanvas extends ILeaferCanvas {
+
+}
+
+export interface IInteractionConfig {
+    wheel?: IWheelConfig
+    pointer?: IPointerConfig
+    zoom?: IZoomConfig
+    move?: IMoveConfig
+    eventer?: IObject
+}
+
+export interface IZoomConfig {
+    min?: number
+    max?: number
+}
+
+export interface IMoveConfig {
+    holdSpaceKey?: boolean
+    dragEmpty?: boolean
+    dragOut?: boolean
+    autoDistance?: number
+}
+
+export interface IWheelConfig {
+    zoomMode?: boolean
+    zoomSpeed?: number // 取值范围 0 ～ 1, 默认0.5
+    moveSpeed?: number
+    rotateSpeed?: number // 取值范围 0 ～ 1, 默认0.5
+    delta?: IPointData  // 以chrome为基准, 鼠标滚动一格的距离
+    getScale?: INumberFunction
+    getMove?: IPointDataFunction
+    preventDefault?: boolean
+}
+
+export interface IPointerConfig {
+    hitRadius?: number
+    through?: boolean
+    tapMore?: boolean
+    tapTime?: number
+    longPressTime?: number
+    transformTime?: number
+    dragHover?: boolean
+    dragDistance?: number
+    swipeDistance?: number
+    ignoreMove?: boolean // 性能优化字段, 控制move事件触发次数
+    preventDefault?: boolean
+}

package/src/layout/ILeafLayout.ts

@@ -0,0 +1,94 @@
+import { IBoundsData, IMatrixData } from '../math/IMath'
+import { ILeaf } from '../display/ILeaf'
+
+export type ILayoutLocationType = 'world' | 'local' | 'inner'
+export type ILayoutBoundsType = 'content' | 'box' | 'stroke' | 'margin' | 'render'
+
+export interface ILeafLayout {
+
+    leaf: ILeaf
+
+    useZoomProxy: boolean
+
+    // inner
+
+    boxBounds: IBoundsData    //  | content + padding |
+    strokeBounds: IBoundsData  //  | boxBounds + border |  
+    renderBounds: IBoundsData //  | strokeBounds + shadow |
+
+    // auto layout
+    marginBounds: IBoundsData //  | strokeBounds + margin |
+    contentBounds: IBoundsData // | content |  
+
+    // local
+
+    //localBoxBounds: IBoundsData = leaf.__local
+    localStrokeBounds: IBoundsData
+    localRenderBounds: IBoundsData
+
+    // state
+
+    // matrix changed
+    matrixChanged: boolean // include positionChanged scaleChanged skewChanged
+    positionChanged: boolean // x, y
+    originChanged?: boolean // originX originY
+    scaleChanged: boolean // scaleX scaleY
+    rotationChanged: boolean // rotaiton, skewX scaleY 数据更新
+
+    // bounds changed
+    boundsChanged: boolean
+
+    boxChanged: boolean
+    strokeChanged: boolean
+    renderChanged: boolean
+
+    localBoxChanged: boolean // position
+
+    // face changed
+    surfaceChanged: boolean
+    opacityChanged: boolean
+
+    hitCanvasChanged: boolean
+
+    childrenSortChanged?: boolean
+
+    // keep state
+    affectScaleOrRotation: boolean
+    affectRotation: boolean
+    affectChildrenSort?: boolean
+
+    strokeSpread: number
+    renderSpread: number
+    strokeBoxSpread: number
+    renderShapeSpread: number
+
+    checkUpdate(force?: boolean): void
+
+    getTransform(locationType: ILayoutLocationType): IMatrixData
+    getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType): IBoundsData
+
+    // 独立 / 引用 boxBounds
+    spreadStroke(): void
+    spreadRender(): void
+    spreadStrokeCancel(): void
+    spreadRenderCancel(): void
+
+    // bounds
+    boxChange(): void
+    localBoxChange(): void
+    strokeChange(): void
+    renderChange(): void
+
+    // matrix
+    positionChange(): void
+    scaleChange(): void
+    rotationChange(): void
+
+    // face
+    surfaceChange(): void
+    opacityChange(): void
+
+    childrenSortChange(): void
+
+    destroy(): void
+}

package/src/layouter/ILayouter.ts

@@ -0,0 +1,60 @@
+import { IBounds } from '../math/IMath'
+import { ILeaf } from '../display/ILeaf'
+import { ILeafList } from '../data/IList'
+import { IControl } from '../control/IControl'
+
+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 extends IControl {
+    target: ILeaf
+    layoutedBlocks: ILayoutBlockData[]
+
+    totalTimes: number
+    times: number
+
+    disabled: boolean
+    running: boolean
+    layouting: boolean
+
+    waitAgain: boolean
+
+    config: ILayouterConfig
+
+    disable(): void
+
+    layout(): void
+    layoutAgain(): void
+    layoutOnce(): void
+    partLayout(): void
+    fullLayout(): void
+
+    createBlock(data: ILeafList | ILeaf[]): ILayoutBlockData
+    getBlocks(list: ILeafList): ILayoutBlockData[]
+    addBlocks(current: ILayoutBlockData[]): void
+}