@sepveneto/dao 0.1.8 → 0.2.0

package/dist/events/FederatedEvent.d.ts

@@ -1,6 +1,6 @@
-import { Vector2 } from '../maths';
 import { Container } from '../scene';
 import { EventSystem } from '../system';
+import { Vector2 } from '../maths';
 export declare class FederatedEvent {
     readonly system: EventSystem;
     target: Container;
@@ -11,6 +11,6 @@ export declare class FederatedEvent {
     screen: Vector2;
     path: Container[];
     constructor(system: EventSystem);
-    getLocalPosition(container: Container, points?: Vector2): Vector2;
+    getLocalPosition(container: Container, points?: Vector2): import('../maths').Vector2Data;
     composedPath(): Container[];
 }

package/dist/events/FederatedEventMap.d.ts

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

package/dist/main.d.ts

@@ -1,9 +1,9 @@
-export * from './renderer';
 export * from './app';
-export * from './ticker';
+export * from './assets/Assets';
 export * from './maths';
 export * from './maths';
-export * from './scene';
-export * from './renderer/texture/Texture';
+export * from './renderer';
 export * from './renderer/texture/RenderTexture';
-export * from './assets/Assets';
+export * from './renderer/texture/Texture';
+export * from './scene';
+export * from './ticker';

package/dist/maths/Bounds.d.ts

@@ -1,5 +1,4 @@
 import { Matrix } from './Matrix';
-import { Container } from '../scene/container/Container';
 import { Rectangle } from './shapes/Rectangle';
 export declare class Bounds {
     minX: number;
@@ -9,9 +8,13 @@ export declare class Bounds {
     matrix: Matrix;
     private _rectangle;
     constructor(minX?: number, minY?: number, maxX?: number, maxY?: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
     clone(): Bounds;
     isEmpty(): boolean;
-    clear(): void;
+    clear(): this;
     pad(paddingX: number, paddingY?: number): this;
     get width(): number;
     set width(value: number);
@@ -28,5 +31,5 @@ export declare class Bounds {
     addFrame(x0: number, y0: number, x1: number, y1: number, matrix?: Matrix): void;
     get rectangle(): Rectangle;
     addBoundsMask(mask: Bounds): void;
+    containsPoint(x: number, y: number): boolean;
 }
-export declare function getLocalBounds(target: Container, bounds: Bounds, relativeMatrix?: Matrix): Bounds;

package/dist/maths/Matrix.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Vector2Data } from '.';
+import { Vector2Data, Vector2 } from '.';
 /**
  * Two Pi.
  * @type {number}
@@ -6,12 +6,6 @@ import { Vector2, Vector2Data } from '.';
  * @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.
@@ -37,17 +31,19 @@ export declare class Matrix {
     tx: number;
     ty: number;
     constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    static get IDENTITY(): Matrix;
     /**
      * A * B
      */
     static append(A: Matrix, B: Matrix): Matrix;
-    apply(pos: Vector2Data): Vector2;
+    identity(): this;
+    apply(pos: Vector2Data, newPos?: Vector2Data): Vector2Data;
     translate(x: number, y: number): this;
     rotate(angle: number): this;
     scale(x: number, y: number): this;
-    appendFrom(a: Matrix, b: Matrix): void;
+    appendFrom(a: Matrix, b: Matrix): this;
     set(a: number, b: number, c: number, d: number, tx: number, ty: number): void;
-    applyInverse(pos: Vector2Data, newPos?: Vector2): Vector2;
+    applyInverse(pos: Vector2Data, newPos?: Vector2Data): Vector2Data;
     copyFrom(matrix: Matrix): this;
     /**
      * Decomposes the matrix into its individual transform components.

package/dist/maths/Point.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Vector2Data } from '.';
+import { Vector2Data, Vector2 } from '.';
 export interface Observer<T> {
     _onUpdate: (point?: T) => void;
 }

package/dist/maths/getLocalBounds.d.ts

@@ -0,0 +1,4 @@
+import { Bounds } from './Bounds';
+import { Container } from '../scene';
+import { Matrix } from './Matrix';
+export declare function getLocalBounds(target: Container, bounds: Bounds, relativeMatrix?: Matrix): Bounds;

package/dist/maths/index.d.ts

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

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

@@ -1,10 +1,13 @@
+import { ShapePrimitive } from '../../scene/graphics/path/ShapePath';
 import { Rectangle } from './Rectangle';
-export declare class Polygon {
+export declare class Polygon implements ShapePrimitive {
     points: number[];
     closePath: boolean;
     readonly type = "polygon";
     construction(): void;
     get lastX(): number;
     get lastY(): number;
-    getBounds(): Rectangle;
+    strokeContains(x: number, y: number, strokeWidth: number, alignment?: number): boolean;
+    contains(x: number, y: number): boolean;
+    getBounds(out?: Rectangle): Rectangle;
 }

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

@@ -1,4 +1,5 @@
-export declare class Rectangle {
+import { ShapePrimitive } from '../../scene/graphics/path/ShapePath';
+export declare class Rectangle implements ShapePrimitive {
     x: number;
     y: number;
     width: number;
@@ -7,5 +8,6 @@ export declare class Rectangle {
     constructor(x?: number, y?: number, width?: number, height?: number);
     getBounds(): Rectangle;
     copyFrom(rectangle: Rectangle): Rectangle;
+    strokeContains(x: number, y: number, strokeWidth: number, alignment?: number): boolean;
     contains(x: number, y: number): boolean;
 }

package/dist/maths/utils.d.ts

@@ -0,0 +1,17 @@
+import { Bounds } from './Bounds';
+import { Matrix } from './Matrix';
+export declare const matrixPool: import('../utils/pool/Pool').Pool<Matrix, {}>;
+export declare const boundsPool: import('../utils/pool/Pool').Pool<Bounds, {}>;
+/**
+ * Calculates the squared distance from a point to a line segment defined by two endpoints.
+ * @param x - x coordinate of the point
+ * @param y - y coordinate of the point
+ * @param x1 - x coordinate of the first endpoint of the line segment
+ * @param y1 - y coordinate of the first endpoint of the line segment
+ * @param x2 - x coordinate of the second endpoint of the line segment
+ * @param y2 - y coordinate of the second endpoint of the line segment
+ * @returns The squared distance from the point to the line segment
+ * @category maths
+ * @internal
+ */
+export declare function squaredDistanceToLineSegment(x: number, y: number, x1: number, y1: number, x2: number, y2: number): number;

package/dist/renderer/CanvasPool.d.ts

@@ -1,7 +1,7 @@
-export type CanvasAndContext = {
+export interface CanvasAndContext {
     canvas: HTMLCanvasElement | OffscreenCanvas;
     context: CanvasRenderingContext2D;
-};
+}
 declare class CanvasPoolClass {
     private _canvasPool;
     constructor();

package/dist/renderer/RenderPipe.d.ts

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

package/dist/renderer/index.d.ts

@@ -1,29 +1,29 @@
 import { Matrix } from '../maths';
-import { EventSystem, RenderGroupSystem } from '../system';
-import { Container } from '../scene/container/Container';
+import { TextureSource } from './texture/TextureSource';
 import { RenderGroup } from '../scene/container/RenderGroup';
+import { ExtractSystemTypes } from '../utils/type';
+import { default as EventEmitter } from 'eventemitter3';
+import { BatchPipe } from '../scene/batcher';
+import { Container } from '../scene/container/Container';
+import { GraphicsPipe } from '../scene/graphics';
+import { StencilMaskPipe } from '../scene/mask/StencilMaskPipe';
 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 { ExtractSystem } from '../system/ExtractSystem';
 import { ViewSystem } from '../system/ViewSystem';
-import { default as EventEmitter } from 'eventemitter3';
+import { EventSystem, RenderGroupSystem } from '../system';
 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 = {
+interface 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 {
@@ -34,12 +34,12 @@ export interface RendererOptions {
     autoStart?: boolean;
     resolution?: number;
     /**
-      * Should the canvas be resized to preserve its screen width and height regardless
-      * of the resolution of the renderer.
-      */
+     * 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 interface CanvasRenderer extends CanvasSystems, EventEmitter {
 }
 export declare class CanvasRenderer extends EventEmitter {
     uid: number;

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

@@ -1,5 +1,5 @@
-import { Texture } from './Texture';
 import { TextureSourceOptions } from './TextureSource';
+import { Texture } from './Texture';
 export interface RenderTextureOptions extends TextureSourceOptions {
 }
 export declare class RenderTexture extends Texture {

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

@@ -1,6 +1,6 @@
+import { default as EventEmitter } from 'eventemitter3';
 import { Rectangle } from '../../maths';
 import { TextureSource } from './TextureSource';
-import { default as EventEmitter } from 'eventemitter3';
 export interface TextureOptions<TextureSourceType extends TextureSource = TextureSource> {
     source?: TextureSourceType;
     label?: string;

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

@@ -1,15 +1,16 @@
 import { default as EventEmitter } from 'eventemitter3';
-export type TextureSourceOptions<T extends Record<string, any> = any> = {
+export interface 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;
     };
+    readonly uid: number;
     label: string;
     /**
      * @internal
@@ -20,7 +21,7 @@ export declare class TextureSource<T extends Record<string, any> = any> extends
     /** 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

package/dist/scene/ViewContainer.d.ts

@@ -1,8 +1,8 @@
-import { Bounds } from '../maths/Bounds';
-import { Container, ContainerOptions } from './container/Container';
+import { ContainerOptions, Container } from './container/Container';
+import { DestroyOptions } from './container/destroyTypes';
 import { Vector2 } from '../maths';
 import { InstructionSet } from '../renderer/InstructionSet';
-import { DestroyOptions } from './container/destroyTypes';
+import { Bounds } from '../maths/Bounds';
 export type Renderable = ViewContainer;
 export interface RuntimeData {
     destroy: () => void;

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

@@ -1,5 +1,5 @@
-import { InstructionSet } from '../../renderer/InstructionSet';
 import { BatchableElement } from './BatcherPipe';
+import { InstructionSet } from '../../renderer/InstructionSet';
 export declare class Batcher {
     renderPipeId: string;
     elements: BatchableElement[];

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

@@ -1,18 +1,18 @@
-import { CanvasRenderer } from '../../renderer';
-import { Batcher } from './Batcher';
-import { Matrix } from '../../maths';
-import { Instruction, InstructionSet } from '../../renderer/InstructionSet';
 import { Container } from '../../main';
+import { Matrix } from '../../maths';
 import { Bounds } from '../../maths/Bounds';
+import { CanvasRenderer } from '../../renderer';
+import { Instruction, InstructionSet } from '../../renderer/InstructionSet';
 import { Texture } from '../../renderer/texture/Texture';
-export type BatchableElement = {
+import { Batcher } from './Batcher';
+export interface BatchableElement {
     renderable: Container;
     texture: Texture;
     transform: Matrix;
     bounds: Bounds;
     roundPixels: number;
     getColor: () => number;
-};
+}
 export declare class Batch implements Instruction {
     renderPipeId: string;
     elements: BatchableElement[];

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

@@ -1,16 +1,16 @@
-import { Matrix, Rectangle, Vector2, Vector2Data } 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';
+import { EffectMixin, EffectMixinConstructor } from './mixins/effectMixin';
+import { MeasureMixin, MeasureMixinConstructor } from './mixins/measureMixin';
 import { OnRenderMixin, OnRenderMixinConstructor } from './mixins/onRenderMixin';
+import { SortMixin, SortMixinConstructor } from './mixins/sortMixin';
+import { FederatedEventEmitterTypes } from '../../events/FederatedEventMap';
+import { Rectangle, Vector2Data, Matrix, Vector2 } from '../../maths';
+import { InstructionSet } from '../../renderer/InstructionSet';
+import { EventMode } from '../../system';
+import { default as EventEmitter } from 'eventemitter3';
+import { ObservablePoint } from '../../maths/Point';
+import { RenderGroup } from './RenderGroup';
 /** @internal */
 export declare const UPDATE_COLOR = 1;
 /** @internal */
@@ -20,16 +20,16 @@ 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 IHitArea {
+    contains: (x: number, y: number) => boolean;
+}
 export interface ContainerEvents extends FederatedEventEmitterTypes {
     destroyed: [container: Container];
     visibleChanged: [visible: boolean];
 }
-type AnyEvent = {
+interface AnyEvent {
     [K: ({} & string) | ({} & symbol)]: any;
-};
+}
 export interface ContainerOptions<C extends ContainerChild = ContainerChild> extends EffectMixinConstructor, SortMixinConstructor, MeasureMixinConstructor, OnRenderMixinConstructor {
     label?: string;
     isRenderGroup?: boolean;
@@ -139,8 +139,8 @@ export declare class Container<C extends ContainerChild = ContainerChild> extend
      */
     groupColor: number;
     /**
-     * @internal
      * TODO: tint
+     * @internal
      */
     localColor: number;
     /**
@@ -203,10 +203,10 @@ 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: Vector2Data, skipUpdate?: boolean): Vector2;
-    toLocal(position: Vector2Data, from?: Container, skipUpdate?: boolean): Vector2;
-    getGlobalTransform(skipUpdate?: boolean): Matrix;
-    getGlobalPosition(skipUpdate?: boolean): Vector2;
+    toGlobal(position: Vector2Data, target?: Vector2Data, skipUpdate?: boolean): Vector2Data;
+    toLocal(position: Vector2Data, from?: Container, target?: Vector2Data, skipUpdate?: boolean): Vector2Data;
+    getGlobalTransform(matrix?: Matrix, skipUpdate?: boolean): Matrix;
+    getGlobalPosition(point?: Vector2, skipUpdate?: boolean): Vector2;
     destroy(options?: DestroyOptions): void;
 }
 export {};

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

@@ -1,8 +1,8 @@
-import { Matrix } from '../../maths';
-import { Container } from './Container';
-import { InstructionSet } from '../../renderer/InstructionSet';
 import { ViewContainer } from '../ViewContainer';
+import { Container } from './Container';
 import { CanvasRenderer } from '../../renderer';
+import { Matrix } from '../../maths';
+import { InstructionSet } from '../../renderer/InstructionSet';
 export declare class RenderGroup {
     worldTransform: Matrix;
     localTransform: Matrix;

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

@@ -1,6 +1,6 @@
+import { MaskEffect } from '../mixins/effectMixin';
 import { Vector2Data } from '../../../maths';
 import { Bounds } from '../../../maths/Bounds';
-import { MaskEffect } from '../mixins/effectMixin';
 /** @internal */
 export declare class DummyEffect implements MaskEffect {
     pipe: string;

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

@@ -1,5 +1,5 @@
+import { ContainerOptions, Container } from '../Container';
 import { Vector2 } from '../../../maths';
-import { Container, ContainerOptions } from '../Container';
 import { Bounds } from '../../../maths/Bounds';
 interface DummyViewOptions extends ContainerOptions {
     x?: number;

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

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

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

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

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

@@ -1,5 +1,5 @@
-import { Bounds } from '../../../maths/Bounds';
 import { Container } from '../Container';
+import { Bounds } from '../../../maths/Bounds';
 export interface MeasureMixinConstructor {
     width?: number;
     height?: number;

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

@@ -1,4 +1,5 @@
-import { ViewContainer, ViewContainerOptions } from '../ViewContainer';
+import { ViewContainerOptions, ViewContainer } from '../ViewContainer';
+import { FillStyle, StrokeStyle } from './utils/FillTypes';
 import { GraphicsContext } from './GraphicsContext';
 export interface GraphicsOptions extends ViewContainerOptions {
     context?: GraphicsContext;
@@ -9,6 +10,10 @@ export declare class Graphics extends ViewContainer {
     constructor(options?: GraphicsOptions | GraphicsContext);
     get context(): GraphicsContext;
     set context(value: GraphicsContext);
+    get fillStyle(): GraphicsContext['fillStyle'];
+    set fillStyle(value: FillStyle);
+    get strokeStyle(): GraphicsContext['strokeStyle'];
+    set strokeStyle(value: StrokeStyle);
     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;
@@ -17,7 +22,7 @@ export declare class Graphics extends ViewContainer {
     stroke(...args: Parameters<GraphicsContext['stroke']>): this;
     beginPath(): this;
     closePath(): this;
-    fill(color: string): this;
+    fill(styel?: FillStyle): this;
     private _callContextMethod;
     protected updateBounds(): void;
     get bounds(): import('../../maths/Bounds').Bounds;

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

@@ -1,52 +1,33 @@
+import { ConvertedFillStyle, ConvertedStrokeStyle, FillStyle, StrokeStyle } from './utils/FillTypes';
+import { Vector2Data } from '../../maths';
 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 = {
+interface FillInstruction {
     action: 'fill';
     data: {
         style: ConvertedFillStyle;
         path: GraphicsPath;
     };
-};
-type StrokeInstruction = {
+}
+interface 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;
+    static defaultFillStyle: ConvertedFillStyle;
+    private _strokeStyle;
+    private _fillStyle;
     private _activePath;
     private _bounds;
     private _boundsDirty;
+    private _tick;
     instructions: GraphicsInstruction[];
-    setStrokeStyle(style: StrokeAttributes & FillStyle): void;
+    setStrokeStyle(style: StrokeStyle): void;
     clear(): this;
     protected onUpdate(): void;
     moveTo(x: number, y: number): this;
@@ -55,10 +36,15 @@ export declare class GraphicsContext {
     rect(x: number, y: number, w: number, h: number): this;
     beginPath(): this;
     closePath(): this;
-    fill(color: string): this;
-    stroke(): void;
+    get fillStyle(): ConvertedFillStyle;
+    set fillStyle(value: FillStyle);
+    get strokeStyle(): ConvertedStrokeStyle;
+    set strokeStyle(value: StrokeStyle);
+    fill(style?: FillStyle): this;
+    stroke(style?: StrokeStyle): this;
     private _initNextPathLocation;
     get bounds(): Bounds;
+    containsPoint(point: Vector2Data): boolean;
     clone(): GraphicsContext;
 }
 export {};

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

@@ -1,14 +1,16 @@
-import { CanvasRenderer } from '../../renderer';
 import { Graphics } from './Graphics';
-import { InstructionSet } from '../../renderer/InstructionSet';
 import { ShapePrimitive } from './path/ShapePath';
-export declare class GraphicsPipe {
+import { CanvasRenderer } from '../../renderer';
+import { InstructionSet } from '../../renderer/InstructionSet';
+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/graphics/__tests__/Graphics.Bounds.test.d.ts

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

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

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

package/dist/scene/graphics/__tests__/bounds.test.d.ts

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