@sepveneto/dao 0.0.5 → 0.1.1

package/dist/scene/container/Container.d.ts

@@ -0,0 +1,200 @@
+import { Matrix, Rectangle, Vector2 } from '../../maths';
+import { EventMode } from '../../system';
+import { RenderGroup } from './RenderGroup';
+import { ObservablePoint } from '../../maths/Point';
+import { default as EventEmitter } from 'eventemitter3';
+import { FederatedEventEmitterTypes } from '../../events/FederatedEventMap';
+import { EffectMixin, EffectMixinConstructor } from './mixins/effectMixin';
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { SortMixin, SortMixinConstructor } from './mixins/sortMixin';
+import { MeasureMixin, MeasureMixinConstructor } from './mixins/measureMixin';
+import { DestroyOptions } from './destroyTypes';
+import { ChildrenHelperMixin } from './mixins/childrenHelperMixin';
+/** @internal */
+export declare const UPDATE_COLOR = 1;
+/** @internal */
+export declare const UPDATE_BLEND = 2;
+/** @internal */
+export declare const UPDATE_VISIBLE = 4;
+/** @internal */
+export declare const UPDATE_TRANSFORM = 8;
+export type ContainerChild = Container;
+export type IHitArea = {
+    contains(x: number, y: number): boolean;
+};
+export interface ContainerOptions<C extends ContainerChild = ContainerChild> extends EffectMixinConstructor, SortMixinConstructor, MeasureMixinConstructor {
+    label?: string;
+    isRenderGroup?: boolean;
+    alpha?: number;
+    angle?: number;
+    children?: C[];
+    parent?: Container;
+    rotation?: number;
+    scale?: Vector2 | number;
+    pivot?: Vector2 | number;
+    origin?: Vector2 | number;
+    position?: Vector2;
+    skew?: Vector2;
+    visible?: boolean;
+    x?: number;
+    y?: number;
+    boundsArea?: Rectangle;
+}
+export interface Container extends EffectMixin, SortMixin, MeasureMixin, ChildrenHelperMixin {
+}
+export declare class Container<C extends ContainerChild = ContainerChild> extends EventEmitter<FederatedEventEmitterTypes> {
+    label: string;
+    destroyed: boolean;
+    renderGroup: RenderGroup;
+    parentRenderGroup: RenderGroup | null;
+    parent: Container | null;
+    eventMode: EventMode;
+    hitArea: IHitArea | null;
+    boundsArea: Rectangle;
+    /** @internal */
+    _position: ObservablePoint;
+    /** @private */
+    includeInBuild: boolean;
+    readonly renderPipeId: string;
+    /** @private */
+    didChange: boolean;
+    /** @private */
+    didViewUpdate: boolean;
+    /** @private */
+    isSimple: boolean;
+    /** @private */
+    measurable: boolean;
+    /** @private */
+    relativeRenderGroupDepth: number;
+    _attrUpdateTick: number;
+    _localTransformUpdateTick: number;
+    /**
+     * @private
+     */
+    _updateFlags: number;
+    /**
+     * @internal
+     */
+    localDisplayStatus: number;
+    /**
+     * @internal
+     */
+    globalDisplayStatus: number;
+    children: C[];
+    localTransform: Matrix;
+    relativeGroupTransform: Matrix;
+    groupTransform: Matrix;
+    _rotation: number;
+    _worldTransform: Matrix;
+    /**
+     * 归一化的x坐标在x轴上的投影, cosx
+     */
+    _cx: number;
+    /**
+     * 归一化的y坐标在x轴上的投影, sinx
+     */
+    _sx: number;
+    /**
+     * 归一化的x坐标在y轴上的投影, cosy
+     */
+    _cy: number;
+    /**
+     * 归一化的y坐标在y轴上的投影, siny
+     */
+    _sy: number;
+    /**
+     * 在x轴和y轴上的倾斜值
+     * @internal
+     */
+    _skew: ObservablePoint;
+    /**
+     * @internal
+     */
+    _scale: ObservablePoint;
+    /**
+     * @internal
+     */
+    _origin: ObservablePoint;
+    /**
+     * @internal
+     */
+    _pivot: ObservablePoint;
+    /**
+     * @internal
+     */
+    localAlpha: number;
+    /**
+     * @internal
+     */
+    groupColor: number;
+    /**
+     * @internal
+     * TODO: tint
+     */
+    localColor: number;
+    /**
+     * @internal
+     */
+    groupAlpha: number;
+    /**
+     * @internal
+     */
+    groupColorAlpha: number;
+    constructor(options?: ContainerOptions<C>);
+    get renderable(): boolean;
+    set renderable(value: boolean);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get isRenderGroup(): boolean;
+    set isRenderGroup(value: boolean);
+    get zIndex(): number;
+    set zIndex(value: number);
+    _updateIsSimple(): void;
+    sortChildren(): void;
+    depthOfChildModified(): void;
+    enableRenderGroup(): void;
+    disableRenderGroup(): void;
+    collectRenderables(renderPipes: any, instructionSet: any): void;
+    collectRenderablesWithEffects(renderPipes: any, instructionSet: InstructionSet): void;
+    collectRenderableSimple(renderPipes: any, instructionSet: InstructionSet): void;
+    setFromMatrix(matrix: Matrix): void;
+    /**
+     * 更新仿射变换矩阵
+     */
+    _updateSkew(): void;
+    updateLocalTransform(): void;
+    get alpha(): number;
+    set alpha(value: number);
+    get root(): Container<ContainerChild>;
+    get worldTransform(): Matrix;
+    get x(): number;
+    set x(value: number);
+    get position(): Vector2;
+    set position(value: Vector2);
+    get y(): number;
+    set y(value: number);
+    get rotation(): number;
+    set rotation(value: number);
+    get angle(): number;
+    set angle(value: number);
+    get skew(): Vector2;
+    set skew(value: Vector2);
+    get scale(): Vector2;
+    set scale(value: Vector2);
+    get pivot(): Vector2;
+    set pivot(value: Vector2);
+    get origin(): Vector2;
+    set origin(value: Vector2);
+    get width(): number;
+    set width(_value: number);
+    get height(): number;
+    set height(_value: number);
+    addChild<U extends C[]>(...children: U): U[0];
+    removeChild<U extends C[]>(...children: U): U[0] | undefined;
+    _onUpdate(point?: Vector2): void;
+    toGlobal(position: Vector2, skipUpdate?: boolean): Vector2;
+    toLocal(position: Vector2, from?: Container, skipUpdate?: boolean): Vector2;
+    getGlobalTransform(skipUpdate?: boolean): Matrix;
+    getGlobalPosition(skipUpdate?: boolean): Vector2;
+    destroy(options?: DestroyOptions): void;
+}

package/dist/scene/container/RenderGroup.d.ts

@@ -0,0 +1,31 @@
+import { Matrix } from '../../maths';
+import { Container } from './Container';
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { ViewContainer } from '../ViewContainer';
+export declare class RenderGroup {
+    worldTransform: Matrix;
+    localTransform: Matrix;
+    root: Container;
+    instructionSet: InstructionSet;
+    structureDidChange: boolean;
+    renderGroupParent: RenderGroup;
+    renderGroupChildren: RenderGroup[];
+    readonly childrenToUpdate: Record<number, {
+        list: Container[];
+        index: number;
+    }>;
+    readonly childrenRenderablesToUpdate: {
+        list: Container[];
+        index: number;
+    };
+    constructor(root: Container);
+    init(root: Container): void;
+    addChild(child: Container): void;
+    removeChild(child: Container): void;
+    removeChildren(children: Container[]): void;
+    private _removeRenderGroupChild;
+    onChildViewUpdate(child: Container): void;
+    onChildUpdate(child: Container): void;
+    updateRenderable(renderable: ViewContainer): void;
+    destroy(): void;
+}

package/dist/scene/container/__tests__/Container.Sort.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scene/container/__tests__/RenderGroup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scene/container/__tests__/transform-visibility.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scene/container/__tests__/transform.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scene/container/destroyTypes.d.ts

@@ -0,0 +1,9 @@
+type TypeOrBool<T> = T | boolean;
+export type DestroyOptions = TypeOrBool<{
+    children?: boolean;
+    context?: boolean;
+    texture?: boolean;
+    textureSource?: boolean;
+    style?: boolean;
+}>;
+export {};

package/dist/scene/container/mixins/childrenHelperMixin.d.ts

@@ -0,0 +1,5 @@
+import { Container, ContainerChild } from '../..';
+export interface ChildrenHelperMixin<C = Container> {
+    removeChildren(beginIndex?: number, endIndex?: number): C[];
+}
+export declare const childrenHelperMixin: ChildrenHelperMixin<ContainerChild>;

package/dist/scene/container/mixins/effectMixin.d.ts

@@ -0,0 +1,16 @@
+import { Container } from '../Container';
+import { StencilMask } from '../../mask/StencilMask';
+import { Graphics } from '../../graphics';
+export type Mask = Graphics | null;
+export type MaskEffect = StencilMask;
+export interface EffectMixinConstructor {
+    mask?: Mask;
+}
+export interface EffectMixin extends Required<EffectMixinConstructor> {
+    effects?: MaskEffect[];
+    _maskEffect?: MaskEffect;
+    mask: Mask;
+    addEffect(effect: MaskEffect): void;
+    removeEffect(effect: MaskEffect): void;
+}
+export declare const effectMixin: Partial<Container>;

package/dist/scene/container/mixins/measureMixin.d.ts

@@ -0,0 +1,14 @@
+import { Bounds } from '../../../maths/Bounds';
+import { Container } from '../Container';
+export interface MeasureMixinConstructor {
+    width?: number;
+    height?: number;
+}
+export interface MeasureMixin extends Required<MeasureMixinConstructor> {
+    _localBoundsCacheData: any;
+    _localBounds: Bounds;
+    getLocalBounds: () => Bounds;
+    _setWidth: (value: number, localWidth: number) => void;
+    _setHeight: (value: number, localHeight: number) => void;
+}
+export declare const measureMixin: Partial<Container>;

package/dist/scene/container/mixins/sortMixin.d.ts

@@ -0,0 +1,13 @@
+import { Container } from '../Container';
+export interface SortMixinConstructor {
+    zIndex?: number;
+    sortDirty?: boolean;
+    sortableChildren?: boolean;
+}
+export interface SortMixin extends Required<SortMixinConstructor> {
+    /**
+     * @internal
+     */
+    _zIndex: number;
+}
+export declare const sortMixin: Partial<Container>;

package/dist/scene/container/utils/updateRenderGroupTransform.d.ts

@@ -0,0 +1,4 @@
+import { Container } from '../Container';
+import { RenderGroup } from '../RenderGroup';
+export declare function updateRenderGroupTransform(renderGroup?: RenderGroup, updateChildRenderGroup?: boolean): void;
+export declare function updateTransform(container: Container, updateFlags: number): void;

package/dist/scene/container/utils/validateRenderables.d.ts

@@ -0,0 +1,2 @@
+import { RenderGroup } from '../RenderGroup';
+export declare function validateRenderables(renderGroup: RenderGroup, renderPipes: any): boolean;

package/dist/scene/container/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function clearList(list: unknown[], index?: number): void;
+export declare function assignWithIgnore<T extends Record<string, any>>(target: T, options: T, ignore?: Record<string, boolean>): void;

package/dist/scene/graphics/Graphics.d.ts

@@ -0,0 +1,19 @@
+import { ViewContainer } from '../ViewContainer';
+import { GraphicsContext } from './GraphicsContext';
+export declare class Graphics extends ViewContainer {
+    renderPipeId: string;
+    context: GraphicsContext;
+    constructor(options?: GraphicsContext);
+    setStrokeStyle(...args: Parameters<GraphicsContext['setStrokeStyle']>): this;
+    rect(x: number, y: number, w: number, h: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cpy2y: number, x: number, y: number): this;
+    lineTo(...args: Parameters<GraphicsContext['lineTo']>): this;
+    moveTo(...args: Parameters<GraphicsContext['moveTo']>): this;
+    stroke(...args: Parameters<GraphicsContext['stroke']>): this;
+    beginPath(): this;
+    closePath(): this;
+    fill(color: string): this;
+    private _callContextMethod;
+    protected updateBounds(): void;
+    get bounds(): import('../../maths/Bounds').Bounds;
+}

package/dist/scene/graphics/GraphicsContext.d.ts

@@ -0,0 +1,61 @@
+import { Bounds } from '../../maths/Bounds';
+import { GraphicsPath } from './path/GraphicsPath';
+interface StrokeAttributes {
+    width?: number;
+    /**
+     * 1: inside
+     * 0.5: center
+     * 0: outside
+     */
+    alignment?: number;
+    cap?: 'butt' | 'round' | 'square';
+    join?: 'round' | 'bevel' | 'miter';
+    miterLimit?: number;
+    pixelLine?: boolean;
+    alpha?: number;
+}
+interface FillStyle {
+    color?: string;
+}
+type FillInstruction = {
+    action: 'fill';
+    data: {
+        style: ConvertedFillStyle;
+        path: GraphicsPath;
+    };
+};
+type StrokeInstruction = {
+    action: 'stroke';
+    data: {
+        style: ConvertedStrokeStyle;
+        path: GraphicsPath;
+    };
+};
+type GraphicsInstruction = FillInstruction | StrokeInstruction;
+type ConvertedStrokeStyle = Required<StrokeAttributes & Omit<Required<FillStyle>, 'color'> & {
+    color: string;
+}>;
+type ConvertedFillStyle = {
+    color: string;
+    alpha: number;
+};
+export declare class GraphicsContext {
+    _strokeStyle: ConvertedStrokeStyle;
+    static defaultStrokeStyle: ConvertedStrokeStyle;
+    private _activePath;
+    private _bounds;
+    instructions: GraphicsInstruction[];
+    setStrokeStyle(style: StrokeAttributes & FillStyle): void;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): this;
+    rect(x: number, y: number, w: number, h: number): this;
+    beginPath(): this;
+    closePath(): this;
+    fill(color: string): this;
+    stroke(): void;
+    private _initNextPathLocation;
+    get bounds(): Bounds;
+    clone(): GraphicsContext;
+}
+export {};

package/dist/scene/graphics/GraphicsPipe.d.ts

@@ -0,0 +1,15 @@
+import { CanvasRenderer } from '../../renderer';
+import { Graphics } from './Graphics';
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { ShapePrimitive } from './path/ShapePath';
+export declare class GraphicsPipe {
+    private _renderer;
+    static desc: {
+        readonly name: "graphics";
+    };
+    constructor(renderer: CanvasRenderer);
+    addRenderable(graphics: Graphics, instructionSet: InstructionSet): void;
+    execute(instruction: Graphics): void;
+    destroy(): void;
+}
+export declare function buildShapePath(ctx: CanvasRenderingContext2D, shape: ShapePrimitive): void;

package/dist/scene/graphics/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Graphics';
+export * from './GraphicsContext';
+export * from './GraphicsPipe';

package/dist/scene/graphics/path/GraphicsPath.d.ts

@@ -0,0 +1,25 @@
+import { Bounds } from '../../../maths/Bounds';
+import { ShapePath } from './ShapePath';
+type PathInstruction = {
+    action: 'moveTo' | 'lineTo' | 'closePath' | 'bezierCurveTo' | 'rect';
+    data: any[];
+};
+export declare class GraphicsPath {
+    instructions: PathInstruction[];
+    private _dirty;
+    private _shapePath;
+    rect(x: number, y: number, w: number, h: number): this;
+    lineTo(...args: [number, number]): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): this;
+    moveTo(...args: [number, number]): this;
+    closePath(): this;
+    get shapePath(): ShapePath;
+    get bounds(): Bounds;
+    getLastPoint(): {
+        x: any;
+        y: any;
+    };
+    clear(): void;
+    clone(): GraphicsPath;
+}
+export {};

package/dist/scene/graphics/path/ShapePath.d.ts

@@ -0,0 +1,27 @@
+import { GraphicsPath } from './GraphicsPath';
+import { Bounds } from '../../../maths/Bounds';
+import { Rectangle } from '../../../maths';
+export interface ShapePrimitive {
+    type: 'rectangle' | 'polygon';
+    getBounds(): Rectangle;
+}
+export declare class ShapePath {
+    private _currentPoly;
+    shapePrimitives: {
+        shape: ShapePrimitive;
+    }[];
+    private _graphicsPath;
+    private _bounds;
+    constructor(graphicsPath: GraphicsPath);
+    private _ensurePoly;
+    lineTo(x: number, y: number): this;
+    rect(x: number, y: number, w: number, h: number): this;
+    drawShape(shape: Rectangle): this;
+    moveTo(x: number, y: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): this;
+    startPoly(x: number, y: number): this;
+    endPloy(closePath?: boolean): void;
+    closePath(): this;
+    buildPath(): this;
+    get bounds(): Bounds;
+}

package/dist/scene/graphics/path/buildAdaptiveBezier.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param points
+ * @param sX
+ * @param sY
+ * @param cp1x
+ * @param cp1y
+ * @param cp2x
+ * @param cp2y
+ * @param eX
+ * @param eY
+ * @param smoothness
+ * @internal
+ */
+export declare function buildAdaptiveBezier(points: number[], sX: number, sY: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, eX: number, eY: number, smoothness?: number): number[];

package/dist/scene/index.d.ts

@@ -0,0 +1,6 @@
+export * from './container/Container';
+export * from './sprite/Sprite';
+export * from './container/RenderGroup';
+export * from './graphics';
+export * from './text';
+export * from './ViewContainer';

package/dist/scene/mask/StencilMask.d.ts

@@ -0,0 +1,14 @@
+import { Instruction } from '../../renderer/InstructionSet';
+import { Bounds } from '../../maths/Bounds';
+import { Mask } from '../container/mixins/effectMixin';
+import { Container } from '../container/Container';
+export interface StencilMaskInstruction extends Instruction {
+    mask: StencilMask;
+    action: string;
+}
+export declare class StencilMask {
+    pipe: string;
+    mask?: Mask;
+    constructor(mask: Mask);
+    addLocalBounds(bounds: Bounds, localRoot: Container): void;
+}

package/dist/scene/mask/StencilMaskPipe.d.ts

@@ -0,0 +1,16 @@
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { MaskEffect } from '../container/mixins/effectMixin';
+import { StencilMaskInstruction } from './StencilMask';
+import { CanvasRenderer } from '../../renderer';
+export declare class StencilMaskPipe {
+    static desc: {
+        readonly name: "stencilMask";
+    };
+    private _renderer;
+    private _canvasMaskStack;
+    constructor(renderer: CanvasRenderer);
+    push(mask: MaskEffect, instructionSet: InstructionSet): void;
+    pop(mask: MaskEffect, instructionSet: InstructionSet): void;
+    execute(instruction: StencilMaskInstruction): void;
+    destroy(): void;
+}

package/dist/scene/sprite/Sprite.d.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from '../../maths';
+import { ViewContainer } from '../ViewContainer';
+import { Texture } from '../../renderer/texture/Texture';
+import { ContainerOptions } from '..';
+export interface SpriteOptions extends ContainerOptions {
+    texture?: Texture;
+}
+export declare class Sprite extends ViewContainer {
+    _texture: Texture;
+    anchor: Vector2;
+    readonly renderPipeId = "sprite";
+    private _width;
+    private _height;
+    constructor(options?: SpriteOptions | Texture);
+    set texture(value: Texture);
+    get texture(): Texture;
+    get height(): number;
+    set height(value: number);
+    get width(): number;
+    set width(value: number);
+    protected updateBounds(): void;
+}

package/dist/scene/sprite/SpritePipe.d.ts

@@ -0,0 +1,12 @@
+import { CanvasRenderer } from '../../renderer';
+import { Sprite } from './Sprite';
+import { InstructionSet } from '../../renderer/InstructionSet';
+export declare class SpritePipe {
+    private _renderer;
+    static desc: {
+        readonly name: "sprite";
+    };
+    constructor(renderer: CanvasRenderer);
+    addRenderable(sprite: Sprite, instructionSet: InstructionSet): void;
+    destroy(): void;
+}

package/dist/scene/sprite/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Sprite';
+export * from './SpritePipe';

package/dist/scene/text/Text.d.ts

@@ -0,0 +1,40 @@
+import { ObservablePoint } from '../../maths/Point';
+import { ViewContainer } from '../ViewContainer';
+import { Vector2 } from '../../maths';
+import { TextStyle, TextStyleOptions } from './TextStyle';
+import { DestroyOptions } from '../container/destroyTypes';
+import { ContainerOptions } from '..';
+export interface TextOptions extends ContainerOptions {
+    text?: string | number;
+    style?: TextStyleOptions;
+    resolution?: number;
+}
+export declare class Text extends ViewContainer {
+    readonly renderPipeId = "text";
+    _anchor: ObservablePoint;
+    /**
+     * @internal
+     */
+    _didTextUpdate: boolean;
+    _resolution: number;
+    _autoResolution: boolean;
+    private _text;
+    private _style;
+    constructor(options: TextOptions);
+    set resolution(value: number);
+    get resolution(): number;
+    get anchor(): Vector2;
+    set anchor(value: Vector2);
+    get text(): string;
+    set text(value: string | number);
+    get style(): TextStyle;
+    set style(value: TextStyle | TextStyleOptions);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    onViewUpdate(): void;
+    protected updateBounds(): void;
+    get styleKey(): string;
+    destroy(options?: DestroyOptions): void;
+}

package/dist/scene/text/TextPipe.d.ts

@@ -0,0 +1,25 @@
+import { CanvasRenderer } from '../../renderer';
+import { Text } from './Text';
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { Texture } from '../../main';
+export declare class TextPipe {
+    static desc: {
+        readonly name: "text";
+    };
+    private _renderer;
+    constructor(renderer: CanvasRenderer);
+    addRenderable(text: Text, instructionSet: InstructionSet): void;
+    validateRenderable(text: Text): boolean;
+    initCacheText(text: Text): {
+        currentKey: string;
+        transform: import('../../main').Matrix;
+        bounds: import('../../maths/Bounds').Bounds;
+        roundPixels: number;
+        renderable: Text;
+        texture: Texture | null;
+        destroy: () => void;
+    };
+    private _getRuntimeText;
+    private _updateRuntimeText;
+    destroy(): void;
+}