@sepveneto/dao 0.0.5 → 0.1.0

package/dist/events/FederatedEvent.d.ts

@@ -0,0 +1,15 @@
+import { Vector2 } from '../maths';
+import { Container } from '../scene';
+import { EventSystem } from '../system';
+export declare class FederatedEvent {
+    readonly system: EventSystem;
+    target: Container;
+    currentTarget: Container;
+    nativeEvent: PointerEvent;
+    global: Vector2;
+    type: string;
+    path: Container[];
+    constructor(system: EventSystem);
+    getLocalPosition(container: Container, points?: Vector2): Vector2;
+    composedPath(): Container[];
+}

package/dist/events/FederatedEventMap.d.ts

@@ -0,0 +1,13 @@
+import { FederatedEvent } from './FederatedEvent';
+export type FederatedEventMap = {
+    pointerdown: FederatedEvent;
+    pointermove: FederatedEvent;
+    globalpointermove: FederatedEvent;
+    pointerup: FederatedEvent;
+    pointerupoutside: FederatedEvent;
+    pointerover: FederatedEvent;
+    pointerout: FederatedEvent;
+};
+export type FederatedEventEmitterTypes = {
+    [K in keyof FederatedEventMap]: [event: FederatedEventMap[K]];
+};

package/dist/events/__tests__/EventSystem.test.d.ts

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

package/dist/main.d.ts

@@ -1,29 +1,9 @@
-import { Scene } from './Scene';
-import { EventSystem } from './system/EventSystem';
-import { InputSystem } from './system/InputSystem';
-export * from './Scene';
-export * from './system/InputSystem';
-export * from './GameObject';
-export * from './Projection';
 export * from './ResourceManager';
-export * from './SortStragety';
-export * from './system/TweenManager';
-export * from './Camera';
-export * from './Display';
-export * from './Container';
-export type GameConfig = {
-    width?: number;
-    height?: number;
-    canvas: HTMLCanvasElement;
-};
-export declare class Game {
-    private lastTime;
-    private scene;
-    private renderer;
-    input: InputSystem;
-    events: EventSystem;
-    config: Required<GameConfig>;
-    constructor(canvas: HTMLCanvasElement, config: GameConfig);
-    start(scene: Scene): void;
-    loop(timestamp: number): void;
-}
+export * from './renderer';
+export * from './app';
+export * from './ticker';
+export * from './maths';
+export * from './Loader';
+export * from './maths';
+export * from './scene';
+export * from './renderer/texture/Texture';

package/dist/maths/Bounds.d.ts

@@ -0,0 +1,31 @@
+import { Matrix } from './Matrix';
+import { Container } from '../scene/container/Container';
+import { Rectangle } from './shapes/Rectangle';
+export declare class Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    matrix: Matrix;
+    private _rectangle;
+    constructor(minX?: number, minY?: number, maxX?: number, maxY?: number);
+    clone(): Bounds;
+    isEmpty(): boolean;
+    clear(): void;
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get left(): number;
+    get right(): number;
+    get top(): number;
+    get bottom(): number;
+    get isValid(): boolean;
+    set(x0: number, y0: number, x1: number, y1: number): void;
+    addBounds(bounds: Bounds, matrix?: Matrix): void;
+    addRect(rect: Rectangle, matrix?: Matrix): void;
+    addFrame(x0: number, y0: number, x1: number, y1: number, matrix?: Matrix): void;
+    get rectangle(): Rectangle;
+    addBoundsMask(mask: Bounds): void;
+}
+export declare function getLocalBounds(target: Container, bounds: Bounds, relativeMatrix?: Matrix): Bounds;

package/dist/maths/Matrix.d.ts

@@ -0,0 +1,85 @@
+import { Vector2 } from '.';
+/**
+ * Two Pi.
+ * @type {number}
+ * @category maths
+ * @standard
+ */
+export declare const PI_2: number;
+/**
+ * The data structure that contains the position, scale, pivot, skew and rotation of an object.
+ * This is used by the {@link Matrix} class to decompose the matrix into its components.
+ * @category maths
+ * @advanced
+ */
+/**
+ * The data structure that contains the position, scale, pivot, skew and rotation of an object.
+ * This is used by the {@link Matrix} class to decompose the matrix into its components.
+ * @category maths
+ * @advanced
+ */
+export interface TransformableObject {
+    /** The position of the object */
+    position: Vector2;
+    /** The scale of the object */
+    scale: Vector2;
+    /** The skew of the object */
+    skew: Vector2;
+    /** The rotation of the object */
+    rotation: number;
+    pivot: Vector2;
+}
+export declare class Matrix {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    /**
+     * A * B
+     */
+    static append(A: Matrix, B: Matrix): Matrix;
+    apply(pos: Vector2): Vector2;
+    appendFrom(a: Matrix, b: Matrix): void;
+    set(a: number, b: number, c: number, d: number, tx: number, ty: number): void;
+    applyInverse(pos: Vector2, newPos?: Vector2): Vector2;
+    copyFrom(matrix: Matrix): this;
+    /**
+     * Decomposes the matrix into its individual transform components.
+     * Extracts position, scale, rotation and skew values from the matrix.
+     * @example
+     * ```ts
+     * // Basic decomposition
+     * const matrix = new Matrix()
+     *     .translate(100, 100)
+     *     .rotate(Math.PI / 4)
+     *     .scale(2, 2);
+     *
+     * const transform = {
+     *     position: new Point(),
+     *     scale: new Point(),
+     *     pivot: new Point(),
+     *     skew: new Point(),
+     *     rotation: 0
+     * };
+     *
+     * matrix.decompose(transform);
+     * console.log(transform.position); // Point(100, 100)
+     * console.log(transform.rotation); // ~0.785 (PI/4)
+     * console.log(transform.scale); // Point(2, 2)
+     * ```
+     * @remarks
+     * - Handles combined transformations
+     * - Accounts for pivot points
+     * - Chooses between rotation/skew based on transform type
+     * - Uses radians for rotation and skew
+     * @param transform - The transform object to store the decomposed values
+     * @returns The transform with the newly applied properties
+     * @see {@link Matrix.setTransform} For composing from components
+     * @see {@link TransformableObject} For transform structure
+     */
+    decompose(transform: TransformableObject): TransformableObject;
+    clone(): Matrix;
+}

package/dist/maths/Point.d.ts

@@ -0,0 +1,17 @@
+import { Vector2 } from '.';
+export interface Observer<T> {
+    _onUpdate: (point?: T) => void;
+}
+export declare class ObservablePoint {
+    _x: number;
+    _y: number;
+    private readonly _observer;
+    constructor(observer: Observer<ObservablePoint>, x?: number, y?: number);
+    set(x?: number, y?: number): this;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    copyFrom(value: Vector2): this;
+    toVector2(): Vector2;
+}

package/dist/maths/const.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Conversion factor for converting radians to degrees.
+ * @type {number} RAD_TO_DEG
+ * @category maths
+ * @standard
+ */
+export declare const RAD_TO_DEG: number;
+/**
+ * Conversion factor for converting degrees to radians.
+ * @type {number}
+ * @category maths
+ * @standard
+ */
+export declare const DEG_TO_RAD: number;

package/dist/maths/index.d.ts

@@ -0,0 +1,18 @@
+export declare class Vector2 {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    set(xora: number, y?: number): void;
+    copyFrom(data: Vector2): void;
+}
+export * from './Matrix';
+export * from './shapes/Rectangle';
+/**
+ * Rounds to next power of two.
+ * @function nextPow2
+ * @param {number} v - input value
+ * @returns {number} - next rounded power of two
+ * @category maths
+ * @advanced
+ */
+export declare function nextPow2(v: number): number;

package/dist/maths/shapes/Polygon.d.ts

@@ -0,0 +1,10 @@
+import { Rectangle } from './Rectangle';
+export declare class Polygon {
+    points: number[];
+    closePath: boolean;
+    readonly type = "polygon";
+    construction(): void;
+    get lastX(): number;
+    get lastY(): number;
+    getBounds(): Rectangle;
+}

package/dist/maths/shapes/Rectangle.d.ts

@@ -0,0 +1,11 @@
+export declare class Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    readonly type = "rectangle";
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    getBounds(): Rectangle;
+    copyFrom(rectangle: Rectangle): Rectangle;
+    contains(x: number, y: number): boolean;
+}

package/dist/renderer/CanvasPool.d.ts

@@ -0,0 +1,11 @@
+export type CanvasAndContext = {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    context: CanvasRenderingContext2D;
+};
+declare class CanvasPoolClass {
+    private _canvasPool;
+    constructor();
+    getOptimalCanvasAndContext(minWidth: number, minHeight: number, resolution?: number): CanvasAndContext;
+}
+export declare const CanvasPool: CanvasPoolClass;
+export {};

package/dist/renderer/InstructionSet.d.ts

@@ -0,0 +1,18 @@
+export interface Instruction {
+    readonly renderPipeId: string;
+}
+/**
+ * 对数组的简单封装
+ * 出于性能优的考虑，不会主观的调整数组的大小
+ * 因此length没有使用价值
+ */
+export declare class InstructionSet {
+    readonly instructions: Instruction[];
+    instructionSize: number;
+    /**
+     * @internal
+     */
+    renderPipes: any;
+    reset(): void;
+    add(instruction: Instruction): void;
+}

package/dist/renderer/index.d.ts

@@ -0,0 +1,66 @@
+import { Matrix } from '../maths';
+import { EventSystem, RenderGroupSystem } from '../system';
+import { Container } from '../scene/container/Container';
+import { RenderGroup } from '../scene/container/RenderGroup';
+import { SpritePipe } from '../scene/sprite/SpritePipe';
+import { TextPipe } from '../scene/text/TextPipe';
+import { GraphicsPipe } from '../scene/graphics';
+import { BatchPipe } from '../scene/batcher';
+import { TextSystem } from '../scene/text/TextSystem';
+import { StencilMaskPipe } from '../scene/mask/StencilMaskPipe';
+import { ExtractSystemTypes } from '../utils/type';
+import { ExtractSystem } from '../system/ExtractSystem';
+import { CanvasContextSystem } from '../system/CanvasContextSystem';
+import { TextureSource } from './texture/TextureSource';
+import { ViewSystem } from '../system/ViewSystem';
+import { default as EventEmitter } from 'eventemitter3';
+declare const systems: (typeof ViewSystem | typeof EventSystem | typeof RenderGroupSystem | typeof TextSystem | typeof ExtractSystem | typeof CanvasContextSystem)[];
+declare const pipes: (typeof GraphicsPipe | typeof BatchPipe | typeof TextPipe | typeof SpritePipe | typeof StencilMaskPipe)[];
+type RenderOptions = {
+    clearColor?: string;
+    container: Container;
+    transform?: Matrix;
+    target?: {
+        source: TextureSource;
+    };
+};
+export type CanvasSystems = ExtractSystemTypes<typeof systems>;
+export type CanvasPipes = ExtractSystemTypes<typeof pipes>;
+export interface RendererOptions {
+    width?: number;
+    height?: number;
+    backgroundColor?: string;
+    roundPixels?: boolean;
+    autoStart?: boolean;
+    resolution?: number;
+    /**
+      * Should the canvas be resized to preserve its screen width and height regardless
+      * of the resolution of the renderer.
+      */
+    autoDensity?: boolean;
+}
+export interface CanvasRenderer extends CanvasSystems {
+}
+export declare class CanvasRenderer extends EventEmitter {
+    uid: number;
+    context: CanvasRenderingContext2D;
+    background: {
+        color: string;
+    };
+    renderedObject: Container;
+    _roundPixels: 0 | 1;
+    resolution: number;
+    activeRenderGroup: RenderGroup;
+    renderPipes: CanvasPipes;
+    constructor();
+    get canvas(): HTMLCanvasElement;
+    private _addPipes;
+    private _addSystems;
+    init(options: RendererOptions): Promise<void>;
+    get roundPixels(): boolean;
+    render(args: Container | RenderOptions): void;
+    clear(options: RenderOptions): void;
+    destroy(): void;
+    resize(width: number, height: number, resolution?: number): void;
+}
+export {};

package/dist/renderer/texture/RenderTexture.d.ts

@@ -0,0 +1,7 @@
+import { Texture } from './Texture';
+import { TextureSourceOptions } from './TextureSource';
+export interface RenderTextureOptions extends TextureSourceOptions {
+}
+export declare class RenderTexture extends Texture {
+    static create(options: RenderTextureOptions): RenderTexture;
+}

package/dist/renderer/texture/Texture.d.ts

@@ -0,0 +1,25 @@
+import { Rectangle } from '../../maths';
+import { TextureSource } from './TextureSource';
+export interface TextureOptions<TextureSourceType extends TextureSource = TextureSource> {
+    source?: TextureSourceType;
+    label?: string;
+    frame?: Rectangle;
+    orig?: Rectangle;
+    rotate?: number;
+}
+export declare class Texture<T extends TextureSource = TextureSource> {
+    static EMPTY: Texture;
+    label: string;
+    _source: T;
+    orig: Rectangle;
+    frame: Rectangle;
+    readonly rotate: number;
+    destroyed: boolean;
+    noFrame: boolean;
+    constructor({ source, label, frame, orig, rotate, }?: TextureOptions<T>);
+    get source(): T;
+    set source(value: T);
+    get width(): number;
+    get height(): number;
+    update(): void;
+}

package/dist/renderer/texture/TextureSource.d.ts

@@ -0,0 +1,50 @@
+import { default as EventEmitter } from 'eventemitter3';
+export type TextureSourceOptions<T extends Record<string, any> = any> = {
+    label?: string;
+    resource?: T;
+    width?: number;
+    height?: number;
+    resolution?: number;
+};
+export declare class TextureSource<T extends Record<string, any> = any> extends EventEmitter {
+    static defaultOptions: {
+        resolution: number;
+    };
+    label: string;
+    /**
+     * @internal
+     */
+    _resolution: number;
+    /** the pixel width of this texture source. This is the REAL pure number, not accounting resolution */
+    pixelWidth: number;
+    /** the pixel height of this texture source. This is the REAL pure number, not accounting resolution */
+    pixelHeight: number;
+    /**
+      */
+    /**
+     * the width of this texture source, accounting for resolution
+     * eg pixelWidth 200, resolution 2, then width will be 100
+     */
+    width: number;
+    /**
+     * the height of this texture source, accounting for resolution
+     * eg pixelHeight 200, resolution 2, then height will be 100
+     */
+    height: number;
+    resource: T;
+    constructor(options: TextureSourceOptions<T>);
+    get resolution(): number;
+    set resolution(value: number);
+    get resourceWidth(): any;
+    get resourceHeight(): any;
+    resize(width?: number, height?: number, resolution?: number): boolean;
+}
+export interface CanvasSourceOptions extends TextureSourceOptions<HTMLCanvasElement> {
+    autoDensity?: boolean;
+}
+export declare class CanvasSource extends TextureSource<HTMLCanvasElement> {
+    autoDensity: boolean;
+    constructor(options?: CanvasSourceOptions);
+    resizeCanvas(): void;
+    resize(width?: number, height?: number, resolution?: number): boolean;
+}

package/dist/scene/ViewContainer.d.ts

@@ -0,0 +1,22 @@
+import { Bounds } from '../maths/Bounds';
+import { Container } from './container/Container';
+import { Vector2 } from '../maths';
+import { InstructionSet } from '../renderer/InstructionSet';
+import { DestroyOptions } from './container/destroyTypes';
+export type Renderable = ViewContainer;
+export interface RuntimeData {
+    destroy: () => void;
+}
+export declare abstract class ViewContainer<RUNTIME_DATA extends RuntimeData = any> extends Container {
+    _runtimeData: Record<number, RUNTIME_DATA>;
+    _roundPixels: 0 | 1;
+    protected _bounds: Bounds;
+    get bounds(): Bounds;
+    protected abstract updateBounds(): void;
+    protected onViewUpdate(): void;
+    collectRenderableSimple(renderPipes: Record<string, any>, instructionSet: InstructionSet): void;
+    containsPoint(point: Vector2): boolean;
+    get roundPixels(): boolean;
+    set roundPixels(value: boolean);
+    destroy(options?: DestroyOptions): void;
+}

package/dist/scene/batcher/Batcher.d.ts

@@ -0,0 +1,10 @@
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { BatchableElement } from './BatcherPipe';
+export declare class Batcher {
+    renderPipeId: string;
+    elements: BatchableElement[];
+    elementSize: number;
+    add(elm: BatchableElement): void;
+    build(instructionSet: InstructionSet): void;
+    destroy(): void;
+}

package/dist/scene/batcher/BatcherPipe.d.ts

@@ -0,0 +1,34 @@
+import { CanvasRenderer } from '../../renderer';
+import { Batcher } from './Batcher';
+import { Matrix } from '../../maths';
+import { Instruction, InstructionSet } from '../../renderer/InstructionSet';
+import { Container } from '../../main';
+import { Bounds } from '../../maths/Bounds';
+import { Texture } from '../../renderer/texture/Texture';
+export type BatchableElement = {
+    renderable: Container;
+    texture: Texture;
+    transform: Matrix;
+    bounds: Bounds;
+    roundPixels: number;
+    getColor: () => number;
+};
+export declare class Batch implements Instruction {
+    renderPipeId: string;
+    elements: BatchableElement[];
+}
+export declare class BatchPipe {
+    private _renderer;
+    private _activeBatch;
+    static desc: {
+        readonly name: "batch";
+    };
+    constructor(renderer: CanvasRenderer);
+    get batch(): Batcher;
+    buildStart(): void;
+    buildEnd(instructionSet: InstructionSet): void;
+    break(instructionSet: InstructionSet): void;
+    addToBatch(batchElement: Omit<BatchableElement, 'getColor'>, _instructionSet: InstructionSet): void;
+    execute(batch: Batch): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './Batcher';
+export * from './BatcherPipe';