@sepveneto/dao 0.1.8 → 0.2.0

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

@@ -1,9 +1,9 @@
 import { Bounds } from '../../../maths/Bounds';
 import { ShapePath } from './ShapePath';
-type PathInstruction = {
+interface PathInstruction {
     action: 'moveTo' | 'lineTo' | 'closePath' | 'bezierCurveTo' | 'rect';
     data: any[];
-};
+}
 export declare class GraphicsPath {
     instructions: PathInstruction[];
     private _dirty;

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

@@ -1,9 +1,11 @@
 import { GraphicsPath } from './GraphicsPath';
-import { Bounds } from '../../../maths/Bounds';
 import { Rectangle } from '../../../maths';
+import { Bounds } from '../../../maths/Bounds';
 export interface ShapePrimitive {
     type: 'rectangle' | 'polygon';
-    getBounds(): Rectangle;
+    contains: (x: number, y: number) => boolean;
+    strokeContains: (x: number, y: number, strokeWidth: number, alignment?: number) => boolean;
+    getBounds: (out?: Rectangle) => Rectangle;
 }
 export declare class ShapePath {
     private _currentPoly;
@@ -20,7 +22,7 @@ export declare class ShapePath {
     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;
+    endPloy(closePath?: boolean): this;
     closePath(): this;
     buildPath(): this;
     get bounds(): Bounds;

package/dist/scene/graphics/utils/FillTypes.d.ts

@@ -0,0 +1,28 @@
+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;
+}
+export interface FillStyle {
+    color?: string;
+    alpha?: number;
+}
+export interface StrokeStyle extends FillStyle, StrokeAttributes {
+}
+export type ConvertedStrokeStyle = Required<StrokeAttributes & Omit<Required<FillStyle>, 'color'> & {
+    color: string;
+}>;
+export interface ConvertedFillStyle {
+    color: string;
+    alpha: number;
+}
+export {};

package/dist/scene/graphics/utils/convertInputToStyle.d.ts

@@ -0,0 +1,15 @@
+import { ConvertedFillStyle, ConvertedStrokeStyle, FillStyle, StrokeStyle } from './FillTypes';
+export declare function toStrokeStyle(style: StrokeStyle, defaultStyle: ConvertedStrokeStyle): {
+    color: string;
+    alpha: number;
+    width: number;
+    alignment: number;
+    cap: "butt" | "round" | "square";
+    join: "round" | "bevel" | "miter";
+    miterLimit: number;
+    pixelLine: boolean;
+};
+export declare function toFillStyle(value: FillStyle, defaultStyle: ConvertedFillStyle): {
+    color: string;
+    alpha: number;
+};

package/dist/scene/graphics/utils/getMaxMiterRatio.d.ts

@@ -0,0 +1,11 @@
+import { GraphicsPath } from '../path/GraphicsPath';
+/**
+ * Computes the maximum miter ratio from polygon corner angles in a graphics path.
+ * The miter ratio determines how much the stroke padding must expand to contain miter joins
+ * at sharp angles. Returns a value >= 1, clamped by the miterLimit.
+ * @param path - The graphics path containing polygon shapes
+ * @param miterLimit - The maximum allowed miter ratio
+ * @returns The maximum miter ratio found in all polygon corners, clamped by miterLimit
+ * @internal
+ */
+export declare function getMaxMiterRatio(path: GraphicsPath, miterLimit: number): number;

package/dist/scene/index.d.ts

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

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

@@ -1,7 +1,7 @@
+import { Container } from '../container/Container';
+import { Mask } from '../container/mixins/effectMixin';
 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;

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

@@ -1,7 +1,7 @@
-import { InstructionSet } from '../../renderer/InstructionSet';
 import { MaskEffect } from '../container/mixins/effectMixin';
 import { StencilMaskInstruction } from './StencilMask';
 import { CanvasRenderer } from '../../renderer';
+import { InstructionSet } from '../../renderer/InstructionSet';
 export declare class StencilMaskPipe {
     static desc: {
         readonly name: "stencilMask";

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

@@ -1,7 +1,7 @@
+import { ContainerOptions } from '..';
 import { Vector2 } from '../../maths';
-import { ViewContainer } from '../ViewContainer';
 import { Texture } from '../../renderer/texture/Texture';
-import { ContainerOptions } from '..';
+import { ViewContainer } from '../ViewContainer';
 export interface SpriteOptions extends ContainerOptions {
     texture?: Texture;
 }

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

@@ -1,12 +1,17 @@
-import { CanvasRenderer } from '../../renderer';
 import { Sprite } from './Sprite';
+import { CanvasRenderer } from '../../renderer';
 import { InstructionSet } from '../../renderer/InstructionSet';
-export declare class SpritePipe {
+import { RenderPipe } from '../../renderer/RenderPipe';
+export declare class SpritePipe implements RenderPipe<Sprite> {
     private _renderer;
     static desc: {
         readonly name: "sprite";
     };
     constructor(renderer: CanvasRenderer);
     addRenderable(sprite: Sprite, instructionSet: InstructionSet): void;
+    private _updateBatchableSprite;
+    validateRenderable(sprite: Sprite): boolean;
+    private _getRuntimeSprite;
+    private _initCacheSprite;
     destroy(): void;
 }

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

@@ -1,9 +1,9 @@
+import { ContainerOptions } from '..';
+import { DestroyOptions } from '../container/destroyTypes';
+import { TextStyleOptions, TextStyle } from './TextStyle';
+import { Vector2 } from '../../maths';
 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;

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

@@ -1,8 +1,9 @@
-import { CanvasRenderer } from '../../renderer';
 import { Text } from './Text';
-import { InstructionSet } from '../../renderer/InstructionSet';
 import { Texture } from '../../main';
-export declare class TextPipe {
+import { CanvasRenderer } from '../../renderer';
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { RenderPipe } from '../../renderer/RenderPipe';
+export declare class TextPipe implements RenderPipe<Text> {
     static desc: {
         readonly name: "text";
     };
@@ -17,7 +18,7 @@ export declare class TextPipe {
         roundPixels: number;
         renderable: Text;
         texture: Texture | null;
-        destroy: () => void;
+        destroy(): void;
     };
     private _getRuntimeText;
     private _updateRuntimeText;

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

@@ -333,7 +333,7 @@ export type TextStyleWhiteSpace = 'normal' | 'pre' | 'pre-line';
  * @category text
  * @standard
  */
-export type TextDropShadow = {
+export interface TextDropShadow {
     /**
      * The opacity of the drop shadow.
      * - Range: 0 to 1
@@ -399,7 +399,7 @@ export type TextDropShadow = {
      * @default 5
      */
     distance: number;
-};
+}
 /**
  * Constructor options used for `TextStyle` instances. Defines the visual appearance and layout of text.
  * @example
@@ -607,7 +607,7 @@ export declare class TextStyle {
     set fill(value: string);
     get align(): TextStyleAlign;
     set align(value: TextStyleAlign);
-    get wordWarp(): boolean;
+    get wordWrap(): boolean;
     set wordWrap(value: boolean);
     get fontFamily(): string | string[];
     set fontFamily(value: string | string[]);

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

@@ -1,6 +1,6 @@
-import { CanvasRenderer } from '../../renderer';
 import { Text } from './Text';
 import { TextStyle } from './TextStyle';
+import { CanvasRenderer } from '../../renderer';
 import { Texture } from '../../renderer/texture/Texture';
 import { TextureSource } from '../../renderer/texture/TextureSource';
 export declare class TextSystem {

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

@@ -1,5 +1,5 @@
-import { CanvasAndContext } from '../../renderer/CanvasPool';
 import { TextStyle } from './TextStyle';
+import { CanvasAndContext } from '../../renderer/CanvasPool';
 import { Rectangle } from '../../maths/shapes/Rectangle';
 export declare const NEWLINE_MATCH_REGEX: RegExp;
 /**
@@ -27,9 +27,9 @@ export declare class TextMetrics {
     maxLineWidth: number;
     fontProperties: FontMetrics;
     /**
-      * String used for calculate font metrics.
-      * These characters are all tall to help calculate the height required for text.
-      */
+     * String used for calculate font metrics.
+     * These characters are all tall to help calculate the height required for text.
+     */
     static METRICS_STRING: string;
     /** Baseline symbol for calculate font metrics. */
     static BASELINE_SYMBOL: string;
@@ -44,22 +44,22 @@ export declare class TextMetrics {
     static measureText(text: string, style: TextStyle): TextMetrics;
     static _measureText(text: string, letterSpacing: number): number;
     /**
-      * A Unicode "character", or "grapheme cluster", can be composed of multiple Unicode code points,
-      * such as letters with diacritical marks (e.g. `'\u0065\u0301'`, letter e with acute)
-      * or emojis with modifiers (e.g. `'\uD83E\uDDD1\u200D\uD83D\uDCBB'`, technologist).
-      * The new `Intl.Segmenter` API in ES2022 can split the string into grapheme clusters correctly. If it is not available,
-      * PixiJS will fallback to use the iterator of String, which can only spilt the string into code points.
-      * If you want to get full functionality in environments that don't support `Intl.Segmenter` (such as Firefox),
-      * you can use other libraries such as [grapheme-splitter]{@link https://www.npmjs.com/package/grapheme-splitter}
-      * or [graphemer]{@link https://www.npmjs.com/package/graphemer} to create a polyfill. Since these libraries can be
-      * relatively large in size to handle various Unicode grapheme clusters properly, PixiJS won't use them directly.
-      */
+     * A Unicode "character", or "grapheme cluster", can be composed of multiple Unicode code points,
+     * such as letters with diacritical marks (e.g. `'\u0065\u0301'`, letter e with acute)
+     * or emojis with modifiers (e.g. `'\uD83E\uDDD1\u200D\uD83D\uDCBB'`, technologist).
+     * The new `Intl.Segmenter` API in ES2022 can split the string into grapheme clusters correctly. If it is not available,
+     * PixiJS will fallback to use the iterator of String, which can only spilt the string into code points.
+     * If you want to get full functionality in environments that don't support `Intl.Segmenter` (such as Firefox),
+     * you can use other libraries such as [grapheme-splitter]{@link https://www.npmjs.com/package/grapheme-splitter}
+     * or [graphemer]{@link https://www.npmjs.com/package/graphemer} to create a polyfill. Since these libraries can be
+     * relatively large in size to handle various Unicode grapheme clusters properly, PixiJS won't use them directly.
+     */
     static graphemeSegmenter: (s: string) => string[];
     /**
-      * Calculates the ascent, descent and fontSize of a given font-style
-      * @param font - String representing the style of the font
-      * @returns Font properties object
-      */
+     * Calculates the ascent, descent and fontSize of a given font-style
+     * @param font - String representing the style of the font
+     * @returns Font properties object
+     */
     static measureFont(font: string): FontMetrics;
 }
 export declare function createCanvas(width?: number, height?: number): HTMLCanvasElement;

package/dist/system/CanvasContextSystem.d.ts

@@ -1,5 +1,5 @@
-import { Matrix } from '../maths';
 import { CanvasRenderer } from '../renderer';
+import { Matrix } from '../maths';
 export declare class CanvasContextSystem {
     static desc: {
         readonly name: "canvasContext";

package/dist/system/EventSystem.d.ts

@@ -1,20 +1,21 @@
-import { Container } from '../scene/container/Container';
 import { CanvasRenderer } from '../renderer';
-import { Vector2 } from '../maths';
 import { FederatedEventMap } from '../events/FederatedEventMap';
+import { Container } from '../scene/container/Container';
 import { FederatedEvent } from '../events/FederatedEvent';
+import { Vector2 } from '../maths';
 export type EventMode = 'none' | 'static' | 'passive';
-type EmitterListener = {
-    fn(...args: any[]): any;
+interface EmitterListener {
+    fn: (...args: any[]) => any;
     context: any;
     once: boolean;
-};
+}
 export type EmitterListeners = Record<string, EmitterListener | EmitterListener[]>;
 export declare class EventSystem {
     renderer: CanvasRenderer;
     domElement: HTMLElement;
     rootTarget: Container;
     resolution: number;
+    private eventPool;
     private readonly _allInteractiveElements;
     private _hitElements;
     private readonly _rootPointerEvent;
@@ -43,6 +44,10 @@ export declare class EventSystem {
     _onPointerUp(nativeEvent: PointerEvent): void;
     _isInteractive(eventMode: EventMode): eventMode is "static";
     private _bootstrapEvent;
+    allocateEvent<T extends FederatedEvent>(constructor: {
+        new (ctx: EventSystem): T;
+    }): T;
+    private freeEvent;
     createPointEvent(from: FederatedEvent, type?: string, target?: Container): FederatedEvent;
     clonePointEvent(from: FederatedEvent, type?: string): FederatedEvent;
     mapPositionToPoint(point: Vector2, x: number, y: number): Vector2;

package/dist/system/ExtractSystem.d.ts

@@ -2,11 +2,11 @@ import { Rectangle } from '../maths';
 import { CanvasRenderer } from '../renderer';
 import { RenderTexture } from '../renderer/texture/RenderTexture';
 import { Container } from '../scene';
-export type GenerateTextureOptions = {
+export interface GenerateTextureOptions {
     target: Container;
     frame?: Rectangle;
     resolution?: number;
-};
+}
 export declare class ExtractSystem {
     static desc: {
         readonly name: "extract";

package/dist/system/ViewSystem.d.ts

@@ -1,12 +1,12 @@
 import { Rectangle } from '../maths';
 import { Texture } from '../renderer/texture/Texture';
 import { CanvasSource } from '../renderer/texture/TextureSource';
-export type ViewSystemOptions = {
+export interface ViewSystemOptions {
     width?: number;
     height?: number;
     resolution?: number;
     autoDensity?: boolean;
-};
+}
 export declare class ViewSystem {
     static desc: {
         readonly name: "view";