@sepveneto/dao 0.1.8 → 0.2.0

package/dist/ticker/Ticker.d.ts

@@ -1,284 +1,284 @@
 export type TickerCallback<T> = (this: T, ticker: Ticker) => any;
 export declare class Ticker {
     /**
-      * Target frame rate in frames per millisecond.
-      * Used for converting deltaTime to a scalar time delta.
-      * @example
-      * ```ts
-      * // Default is 0.06 (60 FPS)
-      * console.log(Ticker.targetFPMS); // 0.06
-      *
-      * // Calculate target frame duration
-      * const frameDuration = 1 / Ticker.targetFPMS; // ≈ 16.67ms
-      *
-      * // Use in custom timing calculations
-      * const deltaTime = elapsedMS * Ticker.targetFPMS;
-      * ```
-      * @remarks
-      * - Default is 0.06 (equivalent to 60 FPS)
-      * - Used in deltaTime calculations
-      * - Affects all ticker instances
-      * @default 0.06
-      * @see {@link Ticker#deltaTime} For time scaling
-      * @see {@link Ticker#FPS} For actual frame rate
-      */
+     * Target frame rate in frames per millisecond.
+     * Used for converting deltaTime to a scalar time delta.
+     * @example
+     * ```ts
+     * // Default is 0.06 (60 FPS)
+     * console.log(Ticker.targetFPMS); // 0.06
+     *
+     * // Calculate target frame duration
+     * const frameDuration = 1 / Ticker.targetFPMS; // ≈ 16.67ms
+     *
+     * // Use in custom timing calculations
+     * const deltaTime = elapsedMS * Ticker.targetFPMS;
+     * ```
+     * @remarks
+     * - Default is 0.06 (equivalent to 60 FPS)
+     * - Used in deltaTime calculations
+     * - Affects all ticker instances
+     * @default 0.06
+     * @see {@link Ticker#deltaTime} For time scaling
+     * @see {@link Ticker#FPS} For actual frame rate
+     */
     static targetFPMS: number;
     /**
-      * Whether or not this ticker should invoke the method {@link Ticker#start|start}
-      * automatically when a listener is added.
-      * @example
-      * ```ts
-      * // Default behavior (manual start)
-      * const ticker = new Ticker();
-      * ticker.autoStart = false;
-      * ticker.add(() => {
-      *     // Won't run until ticker.start() is called
-      * });
-      *
-      * // Auto-start behavior
-      * const autoTicker = new Ticker();
-      * autoTicker.autoStart = true;
-      * autoTicker.add(() => {
-      *     // Runs immediately when added
-      * });
-      * ```
-      * @default false
-      * @see {@link Ticker#start} For manually starting the ticker
-      * @see {@link Ticker#stop} For manually stopping the ticker
-      */
+     * Whether or not this ticker should invoke the method {@link Ticker#start|start}
+     * automatically when a listener is added.
+     * @example
+     * ```ts
+     * // Default behavior (manual start)
+     * const ticker = new Ticker();
+     * ticker.autoStart = false;
+     * ticker.add(() => {
+     *     // Won't run until ticker.start() is called
+     * });
+     *
+     * // Auto-start behavior
+     * const autoTicker = new Ticker();
+     * autoTicker.autoStart = true;
+     * autoTicker.add(() => {
+     *     // Runs immediately when added
+     * });
+     * ```
+     * @default false
+     * @see {@link Ticker#start} For manually starting the ticker
+     * @see {@link Ticker#stop} For manually stopping the ticker
+     */
     autoStart: boolean;
     /**
-      * Scalar representing the delta time factor.
-      * This is a dimensionless value representing the fraction of a frame at the target framerate.
-      * At 60 FPS, this value is typically around 1.0.
-      *
-      * This is NOT in milliseconds - it's a scalar multiplier for frame-independent animations.
-      * For actual milliseconds, use {@link Ticker#deltaMS}.
-      * @example
-      * ```ts
-      * // Frame-independent animation using deltaTime scalar
-      * ticker.add((ticker) => {
-      *     // Rotate sprite by 0.1 radians per frame, scaled by deltaTime
-      *     sprite.rotation += 0.1 * ticker.deltaTime;
-      * });
-      * ```
-      */
+     * Scalar representing the delta time factor.
+     * This is a dimensionless value representing the fraction of a frame at the target framerate.
+     * At 60 FPS, this value is typically around 1.0.
+     *
+     * This is NOT in milliseconds - it's a scalar multiplier for frame-independent animations.
+     * For actual milliseconds, use {@link Ticker#deltaMS}.
+     * @example
+     * ```ts
+     * // Frame-independent animation using deltaTime scalar
+     * ticker.add((ticker) => {
+     *     // Rotate sprite by 0.1 radians per frame, scaled by deltaTime
+     *     sprite.rotation += 0.1 * ticker.deltaTime;
+     * });
+     * ```
+     */
     deltaTime: number;
     /**
-      * Scalar time elapsed in milliseconds from last frame to this frame.
-      * Provides precise timing for animations and updates.
-      *
-      * This value is capped by setting {@link Ticker#minFPS|minFPS}
-      * and is scaled with {@link Ticker#speed|speed}.
-      *
-      * If the platform supports DOMHighResTimeStamp,
-      * this value will have a precision of 1 µs.
-      *
-      * Defaults to target frame time
-      *
-      * > [!NOTE] The cap may be exceeded by scaling.
-      * @example
-      * ```ts
-      * // Animation timing
-      * ticker.add((ticker) => {
-      *     // Use millisecond timing for precise animations
-      *     const progress = (ticker.deltaMS / animationDuration);
-      *     sprite.alpha = Math.min(1, progress);
-      * });
-      * ```
-      * @default 16.66
-      */
+     * Scalar time elapsed in milliseconds from last frame to this frame.
+     * Provides precise timing for animations and updates.
+     *
+     * This value is capped by setting {@link Ticker#minFPS|minFPS}
+     * and is scaled with {@link Ticker#speed|speed}.
+     *
+     * If the platform supports DOMHighResTimeStamp,
+     * this value will have a precision of 1 µs.
+     *
+     * Defaults to target frame time
+     *
+     * > [!NOTE] The cap may be exceeded by scaling.
+     * @example
+     * ```ts
+     * // Animation timing
+     * ticker.add((ticker) => {
+     *     // Use millisecond timing for precise animations
+     *     const progress = (ticker.deltaMS / animationDuration);
+     *     sprite.alpha = Math.min(1, progress);
+     * });
+     * ```
+     * @default 16.66
+     */
     deltaMS: number;
     /**
-      * Time elapsed in milliseconds from the last frame to this frame.
-      * This value is not capped or scaled and provides raw timing information.
-      *
-      * Unlike {@link Ticker#deltaMS}, this value is unmodified by speed scaling or FPS capping.
-      * @example
-      * ```ts
-      * ticker.add((ticker) => {
-      *     console.log(`Raw frame time: ${ticker.elapsedMS}ms`);
-      * });
-      * ```
-      */
+     * Time elapsed in milliseconds from the last frame to this frame.
+     * This value is not capped or scaled and provides raw timing information.
+     *
+     * Unlike {@link Ticker#deltaMS}, this value is unmodified by speed scaling or FPS capping.
+     * @example
+     * ```ts
+     * ticker.add((ticker) => {
+     *     console.log(`Raw frame time: ${ticker.elapsedMS}ms`);
+     * });
+     * ```
+     */
     elapsedMS: number;
     /**
-      * The last time update was invoked, in milliseconds since epoch.
-      * Similar to performance.now() timestamp format.
-      *
-      * Used internally for calculating time deltas between frames.
-      * @example
-      * ```ts
-      * ticker.add((ticker) => {
-      *     const currentTime = performance.now();
-      *     const timeSinceLastFrame = currentTime - ticker.lastTime;
-      *     console.log(`Time since last frame: ${timeSinceLastFrame}ms`);
-      * });
-      * ```
-      */
+     * The last time update was invoked, in milliseconds since epoch.
+     * Similar to performance.now() timestamp format.
+     *
+     * Used internally for calculating time deltas between frames.
+     * @example
+     * ```ts
+     * ticker.add((ticker) => {
+     *     const currentTime = performance.now();
+     *     const timeSinceLastFrame = currentTime - ticker.lastTime;
+     *     console.log(`Time since last frame: ${timeSinceLastFrame}ms`);
+     * });
+     * ```
+     */
     lastTime: number;
     /**
-      * Factor of current {@link Ticker#deltaTime|deltaTime}.
-      * Used to scale time for slow motion or fast-forward effects.
-      * @example
-      * ```ts
-      * // Basic speed adjustment
-      * ticker.speed = 0.5; // Half speed (slow motion)
-      * ticker.speed = 2.0; // Double speed (fast forward)
-      *
-      * // Temporary speed changes
-      * function slowMotion() {
-      *     const normalSpeed = ticker.speed;
-      *     ticker.speed = 0.2;
-      *     setTimeout(() => {
-      *         ticker.speed = normalSpeed;
-      *     }, 1000);
-      * }
-      * ```
-      */
+     * Factor of current {@link Ticker#deltaTime|deltaTime}.
+     * Used to scale time for slow motion or fast-forward effects.
+     * @example
+     * ```ts
+     * // Basic speed adjustment
+     * ticker.speed = 0.5; // Half speed (slow motion)
+     * ticker.speed = 2.0; // Double speed (fast forward)
+     *
+     * // Temporary speed changes
+     * function slowMotion() {
+     *     const normalSpeed = ticker.speed;
+     *     ticker.speed = 0.2;
+     *     setTimeout(() => {
+     *         ticker.speed = normalSpeed;
+     *     }, 1000);
+     * }
+     * ```
+     */
     speed: number;
     /**
-      * Whether or not this ticker has been started.
-      *
-      * `true` if {@link Ticker#start|start} has been called.
-      * `false` if {@link Ticker#stop|Stop} has been called.
-      *
-      * While `false`, this value may change to `true` in the
-      * event of {@link Ticker#autoStart|autoStart} being `true`
-      * and a listener is added.
-      * @example
-      * ```ts
-      * // Check ticker state
-      * const ticker = new Ticker();
-      * console.log(ticker.started); // false
-      *
-      * // Start and verify
-      * ticker.start();
-      * console.log(ticker.started); // true
-      * ```
-      */
+     * Whether or not this ticker has been started.
+     *
+     * `true` if {@link Ticker#start|start} has been called.
+     * `false` if {@link Ticker#stop|Stop} has been called.
+     *
+     * While `false`, this value may change to `true` in the
+     * event of {@link Ticker#autoStart|autoStart} being `true`
+     * and a listener is added.
+     * @example
+     * ```ts
+     * // Check ticker state
+     * const ticker = new Ticker();
+     * console.log(ticker.started); // false
+     *
+     * // Start and verify
+     * ticker.start();
+     * console.log(ticker.started); // true
+     * ```
+     */
     started: boolean;
     /**
-      * Internal tick method bound to ticker instance.
-      * This is because in early 2015, Function.bind
-      * is still 60% slower in high performance scenarios.
-      * Also separating frame requests from update method
-      * so listeners may be called at any time and with
-      * any animation API, just invoke ticker.update(time).
-      * @param time - Time since last tick.
-      */
+     * Internal tick method bound to ticker instance.
+     * This is because in early 2015, Function.bind
+     * is still 60% slower in high performance scenarios.
+     * Also separating frame requests from update method
+     * so listeners may be called at any time and with
+     * any animation API, just invoke ticker.update(time).
+     * @param time - Time since last tick.
+     */
     private readonly _tick;
     /** Internal current frame request ID */
     private _requestId;
     /**
-      * Internal value managed by minFPS property setter and getter.
-      * This is the maximum allowed milliseconds between updates.
-      */
+     * Internal value managed by minFPS property setter and getter.
+     * This is the maximum allowed milliseconds between updates.
+     */
     private _maxElapsedMS;
     /**
-      * Internal value managed by maxFPS property setter and getter.
-      * This is the minimum allowed milliseconds between updates.
-      */
+     * Internal value managed by maxFPS property setter and getter.
+     * This is the minimum allowed milliseconds between updates.
+     */
     private _minElapsedMS;
     /** The last time keyframe was executed. Maintains a relatively fixed interval with the previous value. */
     private _lastFrame;
     private _head;
     constructor();
     /**
-      * Triggers an update.
-      *
-      * An update entails setting the
-      * current {@link Ticker#elapsedMS|elapsedMS},
-      * the current {@link Ticker#deltaTime|deltaTime},
-      * invoking all listeners with current deltaTime,
-      * and then finally setting {@link Ticker#lastTime|lastTime}
-      * with the value of currentTime that was provided.
-      *
-      * This method will be called automatically by animation
-      * frame callbacks if the ticker instance has been started
-      * and listeners are added.
-      * @example
-      * ```ts
-      * // Basic manual update
-      * const ticker = new Ticker();
-      * ticker.update(performance.now());
-      * ```
-      * @param currentTime - The current time of execution (defaults to performance.now())
-      * @see {@link Ticker#deltaTime} For frame delta value
-      * @see {@link Ticker#elapsedMS} For raw elapsed time
-      */
+     * Triggers an update.
+     *
+     * An update entails setting the
+     * current {@link Ticker#elapsedMS|elapsedMS},
+     * the current {@link Ticker#deltaTime|deltaTime},
+     * invoking all listeners with current deltaTime,
+     * and then finally setting {@link Ticker#lastTime|lastTime}
+     * with the value of currentTime that was provided.
+     *
+     * This method will be called automatically by animation
+     * frame callbacks if the ticker instance has been started
+     * and listeners are added.
+     * @example
+     * ```ts
+     * // Basic manual update
+     * const ticker = new Ticker();
+     * ticker.update(performance.now());
+     * ```
+     * @param currentTime - The current time of execution (defaults to performance.now())
+     * @see {@link Ticker#deltaTime} For frame delta value
+     * @see {@link Ticker#elapsedMS} For raw elapsed time
+     */
     update(currentTime?: number): void;
     /**
-      * The frames per second at which this ticker is running.
-      * The default is approximately 60 in most modern browsers.
-      * > [!NOTE] This does not factor in the value of
-      * > {@link Ticker#speed|speed}, which is specific
-      * > to scaling {@link Ticker#deltaTime|deltaTime}.
-      * @example
-      * ```ts
-      * // Basic FPS monitoring
-      * ticker.add(() => {
-      *     console.log(`Current FPS: ${Math.round(ticker.FPS)}`);
-      * });
-      * ```
-      * @readonly
-      */
+     * The frames per second at which this ticker is running.
+     * The default is approximately 60 in most modern browsers.
+     * > [!NOTE] This does not factor in the value of
+     * > {@link Ticker#speed|speed}, which is specific
+     * > to scaling {@link Ticker#deltaTime|deltaTime}.
+     * @example
+     * ```ts
+     * // Basic FPS monitoring
+     * ticker.add(() => {
+     *     console.log(`Current FPS: ${Math.round(ticker.FPS)}`);
+     * });
+     * ```
+     * @readonly
+     */
     get FPS(): number;
     /**
-      * Manages the minimum amount of milliseconds required to
-      * elapse between invoking {@link Ticker#update|update}.
-      *
-      * This will effect the measured value of {@link Ticker#FPS|FPS}.
-      *
-      * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
-      * Otherwise it will be at least `minFPS`.
-      *
-      * If `maxFPS` is set below the current `minFPS`, `minFPS` is automatically lowered to match.
-      * This keeps the two limits consistent.
-      * @example
-      * ```ts
-      * // Cap the frame rate
-      * const ticker = new Ticker();
-      * ticker.maxFPS = 60; // Never go above 60 FPS
-      *
-      * // Use with minFPS for frame rate clamping
-      * ticker.minFPS = 30;
-      * ticker.maxFPS = 60;
-      *
-      * // maxFPS below minFPS pushes minFPS down
-      * ticker.maxFPS = 20; // minFPS is now also 20
-      * ```
-      * @default 0
-      */
+     * Manages the minimum amount of milliseconds required to
+     * elapse between invoking {@link Ticker#update|update}.
+     *
+     * This will effect the measured value of {@link Ticker#FPS|FPS}.
+     *
+     * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
+     * Otherwise it will be at least `minFPS`.
+     *
+     * If `maxFPS` is set below the current `minFPS`, `minFPS` is automatically lowered to match.
+     * This keeps the two limits consistent.
+     * @example
+     * ```ts
+     * // Cap the frame rate
+     * const ticker = new Ticker();
+     * ticker.maxFPS = 60; // Never go above 60 FPS
+     *
+     * // Use with minFPS for frame rate clamping
+     * ticker.minFPS = 30;
+     * ticker.maxFPS = 60;
+     *
+     * // maxFPS below minFPS pushes minFPS down
+     * ticker.maxFPS = 20; // minFPS is now also 20
+     * ```
+     * @default
+     */
     get maxFPS(): number;
     set maxFPS(value: number);
     /**
-      * Manages the maximum amount of milliseconds allowed to
-      * elapse between invoking {@link Ticker#update|update}.
-      *
-      * This value is used to cap {@link Ticker#deltaTime|deltaTime},
-      * but does not effect the measured value of {@link Ticker#FPS|FPS}.
-      *
-      * When setting this property it is clamped to a value between
-      * `0` and `Ticker.targetFPMS * 1000` (typically 60).
-      *
-      * If `maxFPS` is currently set (non-zero) and `minFPS` is set above it,
-      * `maxFPS` is automatically raised to match. This keeps the two limits consistent.
-      * @example
-      * ```ts
-      * // Set minimum acceptable frame rate
-      * const ticker = new Ticker();
-      * ticker.minFPS = 30; // Never go below 30 FPS
-      *
-      * // Use with maxFPS for frame rate clamping
-      * ticker.minFPS = 30;
-      * ticker.maxFPS = 60;
-      *
-      * // minFPS above maxFPS pushes maxFPS up
-      * ticker.minFPS = 50; // maxFPS is raised to 50
-      * ```
-      * @default 10
-      */
+     * Manages the maximum amount of milliseconds allowed to
+     * elapse between invoking {@link Ticker#update|update}.
+     *
+     * This value is used to cap {@link Ticker#deltaTime|deltaTime},
+     * but does not effect the measured value of {@link Ticker#FPS|FPS}.
+     *
+     * When setting this property it is clamped to a value between
+     * `0` and `Ticker.targetFPMS * 1000` (typically 60).
+     *
+     * If `maxFPS` is currently set (non-zero) and `minFPS` is set above it,
+     * `maxFPS` is automatically raised to match. This keeps the two limits consistent.
+     * @example
+     * ```ts
+     * // Set minimum acceptable frame rate
+     * const ticker = new Ticker();
+     * ticker.minFPS = 30; // Never go below 30 FPS
+     *
+     * // Use with maxFPS for frame rate clamping
+     * ticker.minFPS = 30;
+     * ticker.maxFPS = 60;
+     *
+     * // minFPS above maxFPS pushes maxFPS up
+     * ticker.minFPS = 50; // maxFPS is raised to 50
+     * ```
+     * @default
+     */
     get minFPS(): number;
     set minFPS(value: number);
     add<T = any>(fn: TickerCallback<T>, context?: T, priority?: number): this;

package/dist/ticker/TickerListener.d.ts

@@ -11,11 +11,11 @@ export declare class TickerListener<T = any> {
     match(fn: TickerCallback<T>, context?: any): boolean;
     emit(ticker: Ticker): TickerListener<any>;
     /**
-      * Destroy and don't use after this.
-      * @param hard - `true` to remove the `next` reference, this
-      *        is considered a hard destroy. Soft destroy maintains the next reference.
-      * @returns The listener to redirect while emitting or removing.
-      */
+     * Destroy and don't use after this.
+     * @param hard - `true` to remove the `next` reference, this
+     *        is considered a hard destroy. Soft destroy maintains the next reference.
+     * @returns The listener to redirect while emitting or removing.
+     */
     destroy(hard?: boolean): TickerListener<any>;
     connect(previous: TickerListener): void;
 }

package/dist/utils/color.d.ts

@@ -0,0 +1,8 @@
+export declare function parseHexToRgba(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    rgb: string;
+    hex: string;
+};

package/dist/utils/index.d.ts

@@ -7,6 +7,5 @@ export declare function loadImage(url: string): Promise<{
     w: number;
     h: number;
 }>;
-export declare function createDebug(ns: string): (...args: any[]) => void;
 export declare function updateBounds(bounds: Bounds, anchor: ObservablePoint, texture: Texture): void;
 export declare function applyMixins(base: any, ...mixins: Parameters<typeof Object.getOwnPropertyDescriptors>[0][]): void;

package/dist/utils/pool/Pool.d.ts

@@ -0,0 +1,17 @@
+export interface PoolItem {
+    init?: (data: any) => void;
+    reset?: () => void;
+    destroy?: () => void;
+    [key: string]: any;
+}
+export type PoolItemConstructor<K extends PoolItem> = new () => K;
+export declare class Pool<T extends PoolItem, I = NonNullable<T['init']>> {
+    readonly _classType: PoolItemConstructor<T>;
+    private readonly _pool;
+    private _index;
+    private _count;
+    constructor(ClassType: PoolItemConstructor<T>);
+    get(data?: I): T;
+    return(item: T): void;
+    clear(): void;
+}

package/dist/utils/pool/PoolGroup.d.ts

@@ -0,0 +1,6 @@
+import { PoolItem, PoolItemConstructor, Pool } from './Pool';
+export declare class PoolGroupClass {
+    private readonly _poolsByClass;
+    getPool<T extends PoolItem>(ClassType: PoolItemConstructor<T>): Pool<T>;
+}
+export declare const BigPool: PoolGroupClass;