@tsparticles/engine 3.0.0-alpha.0

package/types/Core/Interfaces/IParticleColorStyle.d.ts

@@ -0,0 +1,4 @@
+export interface IParticleColorStyle {
+    fill?: string | CanvasGradient | CanvasPattern;
+    stroke?: string | CanvasGradient | CanvasPattern;
+}

package/types/Core/Interfaces/IParticleHslAnimation.d.ts

@@ -0,0 +1,6 @@
+import type { IParticleValueAnimation } from "./IParticleValueAnimation";
+export interface IParticleHslAnimation {
+    h: IParticleValueAnimation<number>;
+    l: IParticleValueAnimation<number>;
+    s: IParticleValueAnimation<number>;
+}

package/types/Core/Interfaces/IParticleLife.d.ts

@@ -0,0 +1,7 @@
+export interface IParticleLife {
+    count: number;
+    delay: number;
+    delayTime: number;
+    duration: number;
+    time: number;
+}

package/types/Core/Interfaces/IParticleMover.d.ts

@@ -0,0 +1,7 @@
+import type { IDelta } from "./IDelta";
+import type { Particle } from "../Particle";
+export interface IParticleMover {
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    move(particle: Particle, delta: IDelta): void;
+}

package/types/Core/Interfaces/IParticleOverride.d.ts

@@ -0,0 +1,6 @@
+export interface IParticleOverride {
+    fill?: string | CanvasGradient | CanvasPattern;
+    opacity?: number;
+    radius?: number;
+    stroke?: string | CanvasGradient | CanvasPattern;
+}

package/types/Core/Interfaces/IParticleRetinaProps.d.ts

@@ -0,0 +1,9 @@
+import type { IDistance } from "./IDistance";
+export interface IParticleRetinaProps {
+    attractDistance?: number;
+    maxDistance: Partial<IDistance>;
+    maxSpeed?: number;
+    moveDrift?: number;
+    moveSpeed?: number;
+    sizeAnimationSpeed?: number;
+}

package/types/Core/Interfaces/IParticleRoll.d.ts

@@ -0,0 +1,12 @@
+import type { AlterType } from "../../Enums/Types/AlterType";
+export interface IParticleRoll {
+    alter?: {
+        type: AlterType;
+        value: number;
+    };
+    angle: number;
+    enable: boolean;
+    horizontal: boolean;
+    speed: number;
+    vertical: boolean;
+}

package/types/Core/Interfaces/IParticleTransformValues.d.ts

@@ -0,0 +1,6 @@
+export interface IParticleTransformValues {
+    a?: number;
+    b?: number;
+    c?: number;
+    d?: number;
+}

package/types/Core/Interfaces/IParticleUpdater.d.ts

@@ -0,0 +1,21 @@
+import type { IDelta } from "./IDelta";
+import type { IParticleColorStyle } from "./IParticleColorStyle";
+import type { IParticleOverride } from "./IParticleOverride";
+import type { IParticleTransformValues } from "./IParticleTransformValues";
+import type { IParticlesOptions } from "../../Options/Interfaces/Particles/IParticlesOptions";
+import type { Particle } from "../Particle";
+import type { ParticlesOptions } from "../../Options/Classes/Particles/ParticlesOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export interface IParticleUpdater {
+    afterDraw?: (particle: Particle) => void;
+    beforeDraw?: (particle: Particle) => void;
+    getColorStyles?: (particle: Particle, context: CanvasRenderingContext2D, radius: number, opacity: number) => IParticleColorStyle;
+    getOverrides?: (particle: Particle, context: CanvasRenderingContext2D, radius: number, opacity: number) => IParticleOverride;
+    getTransformValues?: (particle: Particle) => IParticleTransformValues;
+    loadOptions?: (options: ParticlesOptions, ...sources: (RecursivePartial<IParticlesOptions> | undefined)[]) => void;
+    particleDestroyed?: (particle: Particle, override?: boolean) => void;
+    reset?: (particle: Particle) => void;
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/types/Core/Interfaces/IParticleValueAnimation.d.ts

@@ -0,0 +1,15 @@
+import type { AnimationStatus } from "../../Enums/AnimationStatus";
+export interface IParticleValueAnimation<T> {
+    decay?: number;
+    enable: boolean;
+    initialValue?: number;
+    loops?: number;
+    maxLoops?: number;
+    status?: AnimationStatus;
+    value: T;
+    velocity?: number;
+}
+export interface IParticleNumericValueAnimation extends IParticleValueAnimation<number> {
+    max: number;
+    min: number;
+}

package/types/Core/Interfaces/IParticlesInteractor.d.ts

@@ -0,0 +1,7 @@
+import type { IDelta } from "./IDelta";
+import type { IInteractor } from "./IInteractor";
+import type { Particle } from "../Particle";
+export interface IParticlesInteractor extends IInteractor {
+    interact(particle: Particle, delta: IDelta): Promise<void>;
+    isEnabled(particle: Particle): boolean;
+}

package/types/Core/Interfaces/IParticlesMover.d.ts

@@ -0,0 +1,7 @@
+import type { IDelta } from "./IDelta";
+import type { Particle } from "../Particle";
+export interface IParticleMover {
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    move(particle: Particle, delta: IDelta): void;
+}

package/types/Core/Interfaces/IPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { Container } from "../Container";
+import type { IContainerPlugin } from "./IContainerPlugin";
+import type { ISourceOptions } from "../../Types/ISourceOptions";
+import type { Options } from "../../Options/Classes/Options";
+export interface IPlugin {
+    readonly id: string;
+    getPlugin(container: Container): IContainerPlugin;
+    loadOptions(options: Options, source?: ISourceOptions): void;
+    needsPlugin(options?: ISourceOptions): boolean;
+}

package/types/Core/Interfaces/IPositionFromSizeParams.d.ts

@@ -0,0 +1,10 @@
+import type { ICoordinates, IRangedCoordinates } from "./ICoordinates";
+import type { IDimension } from "./IDimension";
+export interface IPositionFromSizeParams {
+    position?: Partial<ICoordinates>;
+    size: IDimension;
+}
+export interface IRangedPositionFromSizeParams {
+    position?: Partial<IRangedCoordinates>;
+    size: IDimension;
+}

package/types/Core/Interfaces/IRangeValue.d.ts

@@ -0,0 +1,4 @@
+export interface IRangeValue {
+    max: number;
+    min: number;
+}

package/types/Core/Interfaces/IRectSideResult.d.ts

@@ -0,0 +1,5 @@
+export interface IRectSideResult {
+    bounced: boolean;
+    position?: number;
+    velocity?: number;
+}

package/types/Core/Interfaces/IShapeDrawer.d.ts

@@ -0,0 +1,10 @@
+import type { ShapeDrawerAfterEffectFunction, ShapeDrawerDestroyFunction, ShapeDrawerDrawFunction, ShapeDrawerInitFunction, ShapeDrawerLoadFunction, ShapeDrawerParticleInitFunction, ShapeDrawerSidesCountFunction } from "../../Types/ShapeDrawerFunctions";
+export interface IShapeDrawer {
+    afterEffect?: ShapeDrawerAfterEffectFunction;
+    destroy?: ShapeDrawerDestroyFunction;
+    draw: ShapeDrawerDrawFunction;
+    getSidesCount?: ShapeDrawerSidesCountFunction;
+    init?: ShapeDrawerInitFunction;
+    loadShape?: ShapeDrawerLoadFunction;
+    particleInit?: ShapeDrawerParticleInitFunction;
+}

package/types/Core/Interfaces/IShapeValues.d.ts

@@ -0,0 +1,8 @@
+import type { IParticlesOptions } from "../../Options/Interfaces/Particles/IParticlesOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+export interface IShapeValues {
+    [key: string]: unknown;
+    close?: boolean;
+    fill?: boolean;
+    particles?: RecursivePartial<IParticlesOptions>;
+}

package/types/Core/Interfaces/ISlowParticleData.d.ts

@@ -0,0 +1,4 @@
+export interface ISlowParticleData {
+    factor: number;
+    inRange: boolean;
+}

package/types/Core/Interfaces/ITrailFillData.d.ts

@@ -0,0 +1,6 @@
+import type { IRgb } from "./Colors";
+export interface ITrailFillData {
+    color?: IRgb;
+    image?: HTMLImageElement;
+    opacity: number;
+}

package/types/Core/Particle.d.ts

@@ -0,0 +1,85 @@
+import type { ICenterCoordinates, ICoordinates, ICoordinates3d } from "./Interfaces/ICoordinates";
+import type { IHsl, IRgb } from "./Interfaces/Colors";
+import type { Container } from "./Container";
+import type { Engine } from "../engine";
+import type { IBubbleParticleData } from "./Interfaces/IBubbleParticleData";
+import type { IDelta } from "./Interfaces/IDelta";
+import type { IMovePathGenerator } from "./Interfaces/IMovePathGenerator";
+import type { IParticle } from "./Interfaces/IParticle";
+import type { IParticleHslAnimation } from "./Interfaces/IParticleHslAnimation";
+import type { IParticleNumericValueAnimation } from "./Interfaces/IParticleValueAnimation";
+import type { IParticleRetinaProps } from "./Interfaces/IParticleRetinaProps";
+import type { IParticleRoll } from "./Interfaces/IParticleRoll";
+import type { IParticlesOptions } from "../Options/Interfaces/Particles/IParticlesOptions";
+import type { IShapeValues } from "./Interfaces/IShapeValues";
+import type { ISlowParticleData } from "./Interfaces/ISlowParticleData";
+import { Interactivity } from "../Options/Classes/Interactivity/Interactivity";
+import { ParticleOutType } from "../Enums/Types/ParticleOutType";
+import type { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
+import type { RecursivePartial } from "../Types/RecursivePartial";
+import { Vector } from "./Utils/Vector";
+import { Vector3d } from "./Utils/Vector3d";
+export declare class Particle implements IParticle {
+    readonly container: Container;
+    backColor?: IHsl;
+    bubble: IBubbleParticleData;
+    close: boolean;
+    color?: IParticleHslAnimation;
+    destroyed: boolean;
+    direction: number;
+    fill: boolean;
+    group?: string;
+    id: number;
+    ignoresResizeRatio: boolean;
+    initialPosition: Vector;
+    initialVelocity: Vector;
+    interactivity: Interactivity;
+    lastPathTime: number;
+    misplaced: boolean;
+    moveCenter: ICenterCoordinates;
+    moveDecay: number;
+    offset: Vector;
+    opacity?: IParticleNumericValueAnimation;
+    options: ParticlesOptions;
+    outType: ParticleOutType;
+    pathDelay: number;
+    pathGenerator?: IMovePathGenerator;
+    pathRotation: boolean;
+    position: Vector3d;
+    randomIndexData?: number;
+    retina: IParticleRetinaProps;
+    roll?: IParticleRoll;
+    rotation: number;
+    shadowColor?: IRgb;
+    shape: string;
+    shapeData?: IShapeValues;
+    sides: number;
+    size: IParticleNumericValueAnimation;
+    slow: ISlowParticleData;
+    spawning: boolean;
+    strokeColor?: IParticleHslAnimation;
+    strokeOpacity?: number;
+    strokeWidth?: number;
+    unbreakable: boolean;
+    velocity: Vector;
+    zIndexFactor: number;
+    private readonly _engine;
+    constructor(engine: Engine, id: number, container: Container, position?: ICoordinates, overrideOptions?: RecursivePartial<IParticlesOptions>, group?: string);
+    destroy(override?: boolean): void;
+    draw(delta: IDelta): void;
+    getFillColor(): IHsl | undefined;
+    getMass(): number;
+    getPosition(): ICoordinates3d;
+    getRadius(): number;
+    getStrokeColor(): IHsl | undefined;
+    init(id: number, position?: ICoordinates, overrideOptions?: RecursivePartial<IParticlesOptions>, group?: string): void;
+    isInsideCanvas(): boolean;
+    isVisible(): boolean;
+    reset(): void;
+    private _calcPosition;
+    private _calculateVelocity;
+    private _checkOverlap;
+    private _getRollColor;
+    private _initPosition;
+    private _loadShapeData;
+}

package/types/Core/Particles.d.ts

@@ -0,0 +1,45 @@
+import type { ClickMode } from "../Enums/Modes/ClickMode";
+import type { Container } from "./Container";
+import type { Engine } from "../engine";
+import type { ICoordinates } from "./Interfaces/ICoordinates";
+import type { IDelta } from "./Interfaces/IDelta";
+import type { IMouseData } from "./Interfaces/IMouseData";
+import type { IParticlesOptions } from "../Options/Interfaces/Particles/IParticlesOptions";
+import { Particle } from "./Particle";
+import { QuadTree } from "./Utils/QuadTree";
+import type { RecursivePartial } from "../Types/RecursivePartial";
+export declare class Particles {
+    private readonly container;
+    array: Particle[];
+    lastZIndex: number;
+    limit: number;
+    movers: import("./Interfaces/IParticleMover").IParticleMover[];
+    needsSort: boolean;
+    pool: Particle[];
+    pushing?: boolean;
+    quadTree: QuadTree;
+    updaters: import("..").IParticleUpdater[];
+    zArray: Particle[];
+    private readonly _engine;
+    private readonly interactionManager;
+    private nextId;
+    constructor(engine: Engine, container: Container);
+    get count(): number;
+    addManualParticles(): void;
+    addParticle(position?: ICoordinates, overrideOptions?: RecursivePartial<IParticlesOptions>, group?: string, initializer?: (particle: Particle) => boolean): Particle | undefined;
+    clear(): void;
+    destroy(): void;
+    draw(delta: IDelta): Promise<void>;
+    handleClickMode(mode: ClickMode | string): void;
+    init(): void;
+    push(nb: number, mouse?: IMouseData, overrideOptions?: RecursivePartial<IParticlesOptions>, group?: string): void;
+    redraw(): Promise<void>;
+    remove(particle: Particle, group?: string, override?: boolean): void;
+    removeAt(index: number, quantity?: number, group?: string, override?: boolean): void;
+    removeQuantity(quantity: number, group?: string): void;
+    setDensity(): void;
+    update(delta: IDelta): Promise<void>;
+    private _applyDensity;
+    private _initDensityFactor;
+    private _pushParticle;
+}

package/types/Core/Retina.d.ts

@@ -0,0 +1,13 @@
+import type { Container } from "./Container";
+import type { Particle } from "./Particle";
+export declare class Retina {
+    private readonly container;
+    attractDistance: number;
+    maxSpeed: number;
+    pixelRatio: number;
+    reduceFactor: number;
+    sizeAnimationSpeed: number;
+    constructor(container: Container);
+    init(): void;
+    initParticle(particle: Particle): void;
+}

package/types/Core/Utils/Circle.d.ts

@@ -0,0 +1,8 @@
+import type { ICoordinates } from "../Interfaces/ICoordinates";
+import { Range } from "./Range";
+export declare class Circle extends Range {
+    readonly radius: number;
+    constructor(x: number, y: number, radius: number);
+    contains(point: ICoordinates): boolean;
+    intersects(range: Range): boolean;
+}

package/types/Core/Utils/Constants.d.ts

@@ -0,0 +1,12 @@
+export declare const generatedAttribute = "generated";
+export declare const touchEndEvent = "touchend";
+export declare const mouseDownEvent = "pointerdown";
+export declare const mouseUpEvent = "pointerup";
+export declare const mouseMoveEvent = "pointermove";
+export declare const touchStartEvent = "touchstart";
+export declare const touchMoveEvent = "touchmove";
+export declare const mouseLeaveEvent = "pointerleave";
+export declare const mouseOutEvent = "pointerout";
+export declare const touchCancelEvent = "touchcancel";
+export declare const resizeEvent = "resize";
+export declare const visibilityChangeEvent = "visibilitychange";

package/types/Core/Utils/EventListeners.d.ts

@@ -0,0 +1,21 @@
+import type { Container } from "../Container";
+export declare class EventListeners {
+    private readonly container;
+    private canPush;
+    private readonly handlers;
+    private resizeObserver?;
+    private resizeTimeout?;
+    constructor(container: Container);
+    addListeners(): void;
+    removeListeners(): void;
+    private doMouseTouchClick;
+    private handleClickMode;
+    private handleThemeChange;
+    private handleVisibilityChange;
+    private handleWindowResize;
+    private manageListeners;
+    private mouseDown;
+    private mouseTouchClick;
+    private mouseTouchFinish;
+    private mouseTouchMove;
+}

package/types/Core/Utils/ExternalInteractorBase.d.ts

@@ -0,0 +1,15 @@
+import type { Container } from "../Container";
+import type { IDelta } from "../Interfaces/IDelta";
+import type { IExternalInteractor } from "../Interfaces/IExternalInteractor";
+import { InteractorType } from "../../Enums/Types/InteractorType";
+import type { Particle } from "../Particle";
+export declare abstract class ExternalInteractorBase<TContainer extends Container = Container> implements IExternalInteractor {
+    protected readonly container: TContainer;
+    type: InteractorType;
+    protected constructor(container: TContainer);
+    abstract clear(particle: Particle, delta: IDelta): void;
+    abstract init(): void;
+    abstract interact(delta: IDelta): Promise<void>;
+    abstract isEnabled(particle?: Particle): boolean;
+    abstract reset(particle: Particle): void;
+}

package/types/Core/Utils/FrameManager.d.ts

@@ -0,0 +1,6 @@
+import type { Container } from "../Container";
+export declare class FrameManager {
+    private readonly container;
+    constructor(container: Container);
+    nextFrame(timestamp: DOMHighResTimeStamp): Promise<void>;
+}

package/types/Core/Utils/InteractionManager.d.ts

@@ -0,0 +1,18 @@
+import type { ClickMode } from "../../Enums/Modes/ClickMode";
+import type { Container } from "../Container";
+import type { Engine } from "../../engine";
+import type { IDelta } from "../Interfaces/IDelta";
+import type { Particle } from "../Particle";
+export declare class InteractionManager {
+    private readonly container;
+    private readonly _engine;
+    private _externalInteractors;
+    private readonly _interactors;
+    private _particleInteractors;
+    constructor(engine: Engine, container: Container);
+    externalInteract(delta: IDelta): Promise<void>;
+    handleClickMode(mode: ClickMode | string): void;
+    init(): void;
+    particlesInteract(particle: Particle, delta: IDelta): Promise<void>;
+    reset(particle: Particle): Promise<void>;
+}

package/types/Core/Utils/ParticlesInteractorBase.d.ts

@@ -0,0 +1,15 @@
+import type { Container } from "../Container";
+import type { IDelta } from "../Interfaces/IDelta";
+import type { IParticlesInteractor } from "../Interfaces/IParticlesInteractor";
+import { InteractorType } from "../../Enums/Types/InteractorType";
+import type { Particle } from "../Particle";
+export declare abstract class ParticlesInteractorBase<TContainer extends Container = Container> implements IParticlesInteractor {
+    protected readonly container: TContainer;
+    type: InteractorType;
+    protected constructor(container: TContainer);
+    abstract clear(particle: Particle, delta: IDelta): void;
+    abstract init(): void;
+    abstract interact(particle: Particle, delta: IDelta): Promise<void>;
+    abstract isEnabled(particle: Particle): boolean;
+    abstract reset(particle: Particle): void;
+}

package/types/Core/Utils/Plugins.d.ts

@@ -0,0 +1,51 @@
+import type { Container } from "../Container";
+import type { Engine } from "../../engine";
+import type { IContainerPlugin } from "../Interfaces/IContainerPlugin";
+import type { IInteractor } from "../Interfaces/IInteractor";
+import type { IMovePathGenerator } from "../Interfaces/IMovePathGenerator";
+import type { IParticleMover } from "../Interfaces/IParticleMover";
+import type { IParticleUpdater } from "../Interfaces/IParticleUpdater";
+import type { IParticlesOptions } from "../../Options/Interfaces/Particles/IParticlesOptions";
+import type { IPlugin } from "../Interfaces/IPlugin";
+import type { IShapeDrawer } from "../Interfaces/IShapeDrawer";
+import type { ISourceOptions } from "../../Types/ISourceOptions";
+import type { Options } from "../../Options/Classes/Options";
+import type { ParticlesOptions } from "../../Options/Classes/Particles/ParticlesOptions";
+import type { RecursivePartial } from "../../Types/RecursivePartial";
+import type { SingleOrMultiple } from "../../Types/SingleOrMultiple";
+type GenericInitializer<T> = (container: Container) => T;
+type InteractorInitializer = GenericInitializer<IInteractor>;
+type MoverInitializer = GenericInitializer<IParticleMover>;
+type UpdaterInitializer = GenericInitializer<IParticleUpdater>;
+export declare class Plugins {
+    readonly drawers: Map<string, IShapeDrawer>;
+    readonly interactors: Map<Container, IInteractor[]>;
+    readonly movers: Map<Container, IParticleMover[]>;
+    readonly pathGenerators: Map<string, IMovePathGenerator>;
+    readonly plugins: IPlugin[];
+    readonly presets: Map<string, RecursivePartial<import("../..").IOptions>>;
+    readonly updaters: Map<Container, IParticleUpdater[]>;
+    private readonly _engine;
+    private readonly _initializers;
+    constructor(engine: Engine);
+    addInteractor(name: string, initInteractor: InteractorInitializer): void;
+    addParticleMover(name: string, initMover: MoverInitializer): void;
+    addParticleUpdater(name: string, initUpdater: UpdaterInitializer): void;
+    addPathGenerator(type: string, pathGenerator: IMovePathGenerator): void;
+    addPlugin(plugin: IPlugin): void;
+    addPreset(presetKey: string, options: ISourceOptions, override?: boolean): void;
+    addShapeDrawer(types: SingleOrMultiple<string>, drawer: IShapeDrawer): void;
+    destroy(container: Container): void;
+    getAvailablePlugins(container: Container): Map<string, IContainerPlugin>;
+    getInteractors(container: Container, force?: boolean): IInteractor[];
+    getMovers(container: Container, force?: boolean): IParticleMover[];
+    getPathGenerator(type: string): IMovePathGenerator | undefined;
+    getPlugin(plugin: string): IPlugin | undefined;
+    getPreset(preset: string): ISourceOptions | undefined;
+    getShapeDrawer(type: string): IShapeDrawer | undefined;
+    getSupportedShapes(): IterableIterator<string>;
+    getUpdaters(container: Container, force?: boolean): IParticleUpdater[];
+    loadOptions(options: Options, sourceOptions: ISourceOptions): void;
+    loadParticlesOptions(container: Container, options: ParticlesOptions, ...sourceOptions: (RecursivePartial<IParticlesOptions> | undefined)[]): void;
+}
+export {};

package/types/Core/Utils/Point.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../Interfaces/ICoordinates";
+import type { Particle } from "../Particle";
+export declare class Point {
+    readonly position: ICoordinates;
+    readonly particle: Particle;
+    constructor(position: ICoordinates, particle: Particle);
+}

package/types/Core/Utils/QuadTree.d.ts

@@ -0,0 +1,22 @@
+import type { ICoordinates } from "../Interfaces/ICoordinates";
+import type { IDimension } from "../Interfaces/IDimension";
+import type { Particle } from "../Particle";
+import type { Point } from "./Point";
+import type { Range } from "./Range";
+import { Rectangle } from "./Rectangle";
+export declare class QuadTree {
+    readonly rectangle: Rectangle;
+    readonly capacity: number;
+    private _NE?;
+    private _NW?;
+    private _SE?;
+    private _SW?;
+    private _divided;
+    private readonly _points;
+    constructor(rectangle: Rectangle, capacity: number);
+    insert(point: Point): boolean;
+    query(range: Range, check?: (particle: Particle) => boolean, found?: Particle[]): Particle[];
+    queryCircle(position: ICoordinates, radius: number, check?: (particle: Particle) => boolean): Particle[];
+    queryRectangle(position: ICoordinates, size: IDimension, check?: (particle: Particle) => boolean): Particle[];
+    private subdivide;
+}

package/types/Core/Utils/Range.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../Interfaces/ICoordinates";
+export declare abstract class Range {
+    readonly position: ICoordinates;
+    protected constructor(x: number, y: number);
+    abstract contains(point: ICoordinates): boolean;
+    abstract intersects(range: Range): boolean;
+}

package/types/Core/Utils/Rectangle.d.ts

@@ -0,0 +1,9 @@
+import type { ICoordinates } from "../Interfaces/ICoordinates";
+import type { IDimension } from "../Interfaces/IDimension";
+import { Range } from "./Range";
+export declare class Rectangle extends Range {
+    readonly size: IDimension;
+    constructor(x: number, y: number, width: number, height: number);
+    contains(point: ICoordinates): boolean;
+    intersects(range: Range): boolean;
+}

package/types/Core/Utils/Vector.d.ts

@@ -0,0 +1,8 @@
+import type { ICoordinates } from "../Interfaces/ICoordinates";
+import { Vector3d } from "./Vector3d";
+export declare class Vector extends Vector3d {
+    protected constructor(xOrCoords: number | ICoordinates, y?: number);
+    static get origin(): Vector;
+    static clone(source: Vector): Vector;
+    static create(x: number | ICoordinates, y?: number): Vector;
+}

package/types/Core/Utils/Vector3d.d.ts

@@ -0,0 +1,29 @@
+import type { ICoordinates, ICoordinates3d } from "../Interfaces/ICoordinates";
+export declare class Vector3d implements ICoordinates3d {
+    x: number;
+    y: number;
+    z: number;
+    protected constructor(xOrCoords: number | ICoordinates3d | ICoordinates, y?: number, z?: number);
+    static get origin(): Vector3d;
+    get angle(): number;
+    set angle(angle: number);
+    get length(): number;
+    set length(length: number);
+    static clone(source: Vector3d): Vector3d;
+    static create(x: number | ICoordinates3d, y?: number, z?: number): Vector3d;
+    add(v: Vector3d): Vector3d;
+    addTo(v: Vector3d): void;
+    copy(): Vector3d;
+    distanceTo(v: Vector3d): number;
+    distanceToSq(v: Vector3d): number;
+    div(n: number): Vector3d;
+    divTo(n: number): void;
+    getLengthSq(): number;
+    mult(n: number): Vector3d;
+    multTo(n: number): void;
+    rotate(angle: number): Vector3d;
+    setTo(c: ICoordinates): void;
+    sub(v: Vector3d): Vector3d;
+    subFrom(v: Vector3d): void;
+    private updateFromAngle;
+}

package/types/Enums/AnimationStatus.d.ts

@@ -0,0 +1,4 @@
+export declare const enum AnimationStatus {
+    increasing = "increasing",
+    decreasing = "decreasing"
+}

package/types/Enums/Directions/MoveDirection.d.ts

@@ -0,0 +1,14 @@
+export declare const enum MoveDirection {
+    bottom = "bottom",
+    bottomLeft = "bottom-left",
+    bottomRight = "bottom-right",
+    left = "left",
+    none = "none",
+    right = "right",
+    top = "top",
+    topLeft = "top-left",
+    topRight = "top-right",
+    outside = "outside",
+    inside = "inside"
+}
+export type MoveDirectionAlt = "bottom-left" | "bottom-right" | "top-left" | "top-right";

package/types/Enums/Directions/OutModeDirection.d.ts

@@ -0,0 +1,6 @@
+export declare const enum OutModeDirection {
+    bottom = "bottom",
+    left = "left",
+    right = "right",
+    top = "top"
+}

package/types/Enums/Directions/RotateDirection.d.ts

@@ -0,0 +1,6 @@
+export declare const enum RotateDirection {
+    clockwise = "clockwise",
+    counterClockwise = "counter-clockwise",
+    random = "random"
+}
+export type RotateDirectionAlt = "counter-clockwise";

package/types/Enums/InteractivityDetect.d.ts

@@ -0,0 +1,5 @@
+export declare const enum InteractivityDetect {
+    canvas = "canvas",
+    parent = "parent",
+    window = "window"
+}