@sepveneto/dao 0.1.7 → 0.1.9

package/dist/maths/Bounds.d.ts

@@ -12,6 +12,7 @@ export declare class Bounds {
     clone(): Bounds;
     isEmpty(): boolean;
     clear(): void;
+    pad(paddingX: number, paddingY?: number): this;
     get width(): number;
     set width(value: number);
     get height(): number;

package/dist/maths/Matrix.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from '.';
+import { Vector2, Vector2Data } from '.';
 /**
  * Two Pi.
  * @type {number}
@@ -41,10 +41,13 @@ export declare class Matrix {
      * A * B
      */
     static append(A: Matrix, B: Matrix): Matrix;
-    apply(pos: Vector2): Vector2;
+    apply(pos: Vector2Data): Vector2;
+    translate(x: number, y: number): this;
+    rotate(angle: number): this;
+    scale(x: number, y: number): this;
     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;
+    applyInverse(pos: Vector2Data, newPos?: Vector2): Vector2;
     copyFrom(matrix: Matrix): this;
     /**
      * Decomposes the matrix into its individual transform components.

package/dist/maths/Point.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from '.';
+import { Vector2, Vector2Data } from '.';
 export interface Observer<T> {
     _onUpdate: (point?: T) => void;
 }
@@ -12,6 +12,6 @@ export declare class ObservablePoint {
     set x(value: number);
     get y(): number;
     set y(value: number);
-    copyFrom(value: Vector2): this;
+    copyFrom(value: Vector2Data): this;
     toVector2(): Vector2;
 }

package/dist/maths/index.d.ts

@@ -1,3 +1,7 @@
+export type Vector2Data = {
+    x: number;
+    y: number;
+};
 export declare class Vector2 {
     x: number;
     y: number;

package/dist/renderer/RenderPipe.d.ts

@@ -0,0 +1,6 @@
+import { Renderable } from '../scene';
+import { InstructionSet } from './InstructionSet';
+export interface RenderPipe<RENDERABLE = Renderable> {
+    validateRenderable: (renderable: RENDERABLE) => boolean;
+    addRenderable: (renderable: RENDERABLE, instructionSet: InstructionSet) => void;
+}

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

@@ -10,6 +10,7 @@ export declare class TextureSource<T extends Record<string, any> = any> extends
     static defaultOptions: {
         resolution: number;
     };
+    readonly uid: number;
     label: string;
     /**
      * @internal

package/dist/scene/ViewContainer.d.ts

@@ -15,6 +15,7 @@ export declare abstract class ViewContainer<RUNTIME_DATA extends RuntimeData = a
     _resolution: number;
     _roundPixels: 0 | 1;
     protected _bounds: Bounds;
+    protected _boundsDirty: boolean;
     get bounds(): Bounds;
     protected abstract updateBounds(): void;
     protected onViewUpdate(): void;

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

@@ -1,4 +1,4 @@
-import { Matrix, Rectangle, Vector2 } from '../../maths';
+import { Matrix, Rectangle, Vector2, Vector2Data } from '../../maths';
 import { EventMode } from '../../system';
 import { RenderGroup } from './RenderGroup';
 import { ObservablePoint } from '../../maths/Point';
@@ -10,6 +10,7 @@ import { SortMixin, SortMixinConstructor } from './mixins/sortMixin';
 import { MeasureMixin, MeasureMixinConstructor } from './mixins/measureMixin';
 import { DestroyOptions } from './destroyTypes';
 import { ChildrenHelperMixin } from './mixins/childrenHelperMixin';
+import { OnRenderMixin, OnRenderMixinConstructor } from './mixins/onRenderMixin';
 /** @internal */
 export declare const UPDATE_COLOR = 1;
 /** @internal */
@@ -24,11 +25,12 @@ export type IHitArea = {
 };
 export interface ContainerEvents extends FederatedEventEmitterTypes {
     destroyed: [container: Container];
+    visibleChanged: [visible: boolean];
 }
 type AnyEvent = {
     [K: ({} & string) | ({} & symbol)]: any;
 };
-export interface ContainerOptions<C extends ContainerChild = ContainerChild> extends EffectMixinConstructor, SortMixinConstructor, MeasureMixinConstructor {
+export interface ContainerOptions<C extends ContainerChild = ContainerChild> extends EffectMixinConstructor, SortMixinConstructor, MeasureMixinConstructor, OnRenderMixinConstructor {
     label?: string;
     isRenderGroup?: boolean;
     alpha?: number;
@@ -38,7 +40,7 @@ export interface ContainerOptions<C extends ContainerChild = ContainerChild> ext
     rotation?: number;
     scale?: Vector2 | number;
     pivot?: Vector2 | number;
-    origin?: Vector2 | number;
+    origin?: Vector2Data | number;
     position?: Vector2;
     skew?: Vector2;
     visible?: boolean;
@@ -47,9 +49,10 @@ export interface ContainerOptions<C extends ContainerChild = ContainerChild> ext
     boundsArea?: Rectangle;
     eventMode?: EventMode;
 }
-export interface Container extends EffectMixin, SortMixin, MeasureMixin, ChildrenHelperMixin, EventEmitter<ContainerEvents & AnyEvent> {
+export interface Container extends EffectMixin, SortMixin, MeasureMixin, ChildrenHelperMixin, EventEmitter<ContainerEvents & AnyEvent>, OnRenderMixin {
 }
 export declare class Container<C extends ContainerChild = ContainerChild> extends EventEmitter<ContainerEvents & AnyEvent> {
+    readonly uid: number;
     label: string;
     destroyed: boolean;
     renderGroup: RenderGroup;
@@ -73,7 +76,8 @@ export declare class Container<C extends ContainerChild = ContainerChild> extend
     measurable: boolean;
     /** @private */
     relativeRenderGroupDepth: number;
-    _attrUpdateTick: number;
+    _didViewChangeTick: number;
+    _didContainerChangeTick: number;
     _localTransformUpdateTick: number;
     /**
      * @private
@@ -190,8 +194,8 @@ export declare class Container<C extends ContainerChild = ContainerChild> extend
     set scale(value: Vector2);
     get pivot(): Vector2;
     set pivot(value: Vector2);
-    get origin(): Vector2;
-    set origin(value: Vector2);
+    get origin(): ObservablePoint;
+    set origin(value: Vector2Data | number);
     get width(): number;
     set width(_value: number);
     get height(): number;
@@ -199,8 +203,8 @@ export declare class Container<C extends ContainerChild = ContainerChild> extend
     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;
+    toGlobal(position: Vector2Data, skipUpdate?: boolean): Vector2;
+    toLocal(position: Vector2Data, from?: Container, skipUpdate?: boolean): Vector2;
     getGlobalTransform(skipUpdate?: boolean): Matrix;
     getGlobalPosition(skipUpdate?: boolean): Vector2;
     destroy(options?: DestroyOptions): void;

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

@@ -2,6 +2,7 @@ import { Matrix } from '../../maths';
 import { Container } from './Container';
 import { InstructionSet } from '../../renderer/InstructionSet';
 import { ViewContainer } from '../ViewContainer';
+import { CanvasRenderer } from '../../renderer';
 export declare class RenderGroup {
     worldTransform: Matrix;
     localTransform: Matrix;
@@ -18,12 +19,17 @@ export declare class RenderGroup {
         list: Container[];
         index: number;
     };
+    private readonly _onRenderContainers;
     constructor(root: Container);
     init(root: Container): void;
     addChild(child: Container): void;
     removeChild(child: Container): void;
     removeChildren(children: Container[]): void;
+    addRenderGroupChild(renderGroupChild: RenderGroup): void;
     private _removeRenderGroupChild;
+    addOnRender(container: Container): void;
+    removeOnRender(container: Container): void;
+    runOnRender(renderer: CanvasRenderer): void;
     onChildViewUpdate(child: Container): void;
     onChildUpdate(child: Container): void;
     updateRenderable(renderable: ViewContainer): void;

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

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

package/dist/scene/container/__tests__/DummyEffect.d.ts

@@ -0,0 +1,12 @@
+import { Vector2Data } from '../../../maths';
+import { Bounds } from '../../../maths/Bounds';
+import { MaskEffect } from '../mixins/effectMixin';
+/** @internal */
+export declare class DummyEffect implements MaskEffect {
+    pipe: string;
+    priority: number;
+    addBounds(bounds: Bounds): void;
+    addLocalBounds(bounds: Bounds): void;
+    containsPoint?(_point: Vector2Data): boolean;
+    destroy(): void;
+}

package/dist/scene/container/__tests__/DummyView.d.ts

@@ -0,0 +1,26 @@
+import { Vector2 } from '../../../maths';
+import { Container, ContainerOptions } from '../Container';
+import { Bounds } from '../../../maths/Bounds';
+interface DummyViewOptions extends ContainerOptions {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+/** @internal */
+export declare class DummyView extends Container {
+    batched: boolean;
+    renderPipeId: string;
+    renderableUpdateRequested: boolean;
+    _roundPixels: 1 | 0;
+    _lastUsed: number;
+    updateBounds: () => void;
+    containsPoint: (point: Vector2) => boolean;
+    destroy: () => void;
+    bounds: Bounds;
+    constructor(options?: DummyViewOptions);
+    onViewUpdate(): void;
+    get roundPixels(): boolean;
+    set roundPixels(_value: boolean);
+}
+export {};

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

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

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

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

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

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

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

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

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

@@ -6,9 +6,13 @@ export interface MeasureMixinConstructor {
 }
 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>;
+export declare function checkChildrenDidChange(container: Container, previousData: {
+    data: number[];
+    index: number;
+    didChange: boolean;
+}): boolean;

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

@@ -0,0 +1,9 @@
+import { CanvasRenderer } from '../../../renderer';
+import { Container } from '../..';
+export interface OnRenderMixinConstructor {
+    onRender?: ((renderer: CanvasRenderer) => void) | null;
+}
+export interface OnRenderMixin extends Required<OnRenderMixinConstructor> {
+    _onRender: ((renderer: CanvasRenderer) => void) | null;
+}
+export declare const onRenderMixin: Partial<Container>;

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

@@ -5,8 +5,10 @@ export interface GraphicsOptions extends ViewContainerOptions {
 }
 export declare class Graphics extends ViewContainer {
     renderPipeId: string;
-    context: GraphicsContext;
+    _context: GraphicsContext;
     constructor(options?: GraphicsOptions | GraphicsContext);
+    get context(): GraphicsContext;
+    set context(value: 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;

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

@@ -44,6 +44,7 @@ export declare class GraphicsContext {
     static defaultStrokeStyle: ConvertedStrokeStyle;
     private _activePath;
     private _bounds;
+    private _boundsDirty;
     instructions: GraphicsInstruction[];
     setStrokeStyle(style: StrokeAttributes & FillStyle): void;
     clear(): this;

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

@@ -2,13 +2,15 @@ import { CanvasRenderer } from '../../renderer';
 import { Graphics } from './Graphics';
 import { InstructionSet } from '../../renderer/InstructionSet';
 import { ShapePrimitive } from './path/ShapePath';
-export declare class GraphicsPipe {
+import { RenderPipe } from '../../renderer/RenderPipe';
+export declare class GraphicsPipe implements RenderPipe<Graphics> {
     private _renderer;
     static desc: {
         readonly name: "graphics";
     };
     constructor(renderer: CanvasRenderer);
     addRenderable(graphics: Graphics, instructionSet: InstructionSet): void;
+    validateRenderable(_renderable: Graphics): boolean;
     execute(instruction: Graphics): void;
     destroy(): void;
 }

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

@@ -1,12 +1,17 @@
 import { CanvasRenderer } from '../../renderer';
 import { Sprite } from './Sprite';
 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/TextPipe.d.ts

@@ -2,7 +2,8 @@ import { CanvasRenderer } from '../../renderer';
 import { Text } from './Text';
 import { InstructionSet } from '../../renderer/InstructionSet';
 import { Texture } from '../../main';
-export declare class TextPipe {
+import { RenderPipe } from '../../renderer/RenderPipe';
+export declare class TextPipe implements RenderPipe<Text> {
     static desc: {
         readonly name: "text";
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sepveneto/dao",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "scripts": {
     "docs:dev": "vitepress dev docs",