@jiant/canvable 0.0.1-fix

package/README.md

@@ -0,0 +1,85 @@
+# Canvable
+
+Canvable é uma biblioteca para criação de cenas em canvas com um sistema de nós, permitindo a construção de elementos e interações de forma intuitiva, similar a uma engine de jogos 2D. A biblioteca oferece suporte para objetos gráficos, entrada de usuário, câmera, e muito mais, permitindo criar experiências interativas de maneira modular e flexível.
+
+## Instalação
+
+### Usando NPM
+
+Se você está utilizando o NPM, pode instalar a biblioteca com:
+
+```bash
+npm install @jiant/canvable
+```
+
+### Usando Yarn
+
+Se você está utilizando o Yarn, pode instalar com:
+
+```bash
+yarn add @jiant/canvable
+```
+
+## Exemplos de Uso
+
+### Criando uma Cena
+
+A seguir está um exemplo básico de como criar uma cena e adicionar um objeto nela:
+
+```typescript
+import { Circle, getCanvas, Scene } from "@jiant/canvable";
+import "./style.css";
+
+// Obtendo o canvas
+const canvas = getCanvas("app")!;
+const ctx = canvas.getContext("2d")!;
+
+// Criando a cena
+const scene = new Scene(ctx);
+
+// Criando um círculo
+const circle = new Circle();
+
+// Adicionando o círculo à cena
+scene.addObject(circle);
+```
+
+### Loop de Jogo
+
+Você pode adicionar um loop de jogo para atualizar e mover os objetos da cena:
+
+```typescript
+scene.gameLoop((deltaTime, total) => {
+  circle.pos.x = Math.sin(total) * 100 + 200;
+});
+```
+
+---
+
+## Funcionalidades
+
+### Cenas e Objetos
+
+- **Cena**: Contém e gerencia objetos, como círculos, retângulos, entre outros. Permite manipulação de câmera e desenhos.
+- **Objetos**: Elementos gráficos que podem ser adicionados à cena, como `Circle`, `Rectangle`, etc.
+
+### Funções de Entrada
+
+- **isPressed**: Verifica se uma tecla ou botão está pressionado continuamente.
+- **justPressed**: Detecta o momento exato em que uma tecla ou botão é pressionado pela primeira vez.
+
+### Câmera
+
+- Suporte para uma câmera 2D que pode ser movida e ampliada (zoom).
+
+---
+
+## Contribuições
+
+Contribuições são bem-vindas! Se você deseja melhorar ou adicionar novos recursos à biblioteca, sinta-se à vontade para abrir um **Pull Request**.
+
+---
+
+## Licença
+
+Este projeto está licenciado sob a [MIT License](LICENSE).

package/dist/main.d.mts

@@ -0,0 +1,239 @@
+/**
+ * A 2D vector class for mathematical operations and physics calculations
+ */
+declare class Vector2D {
+    x: number;
+    y: number;
+    /**
+     * Creates a new Vector2D instance
+     * @param x - The x component of the vector
+     * @param y - The y component of the vector
+     */
+    constructor(x?: number, y?: number);
+    /**
+     * Adds another vector to this vector
+     * @param vector - The vector to add
+     * @param self - If true, modifies the current vector in place, otherwise returns a new vector
+     * @returns A new Vector2D representing the sum
+     */
+    add(vector: Vector2D, self?: boolean): Vector2D;
+    /**
+     * Subtracts another vector from this vector
+     * @param vector - The vector to subtract
+     * @param self - If true, modifies the current vector in place, otherwise returns a new vector
+     * @returns A new Vector2D representing the difference
+     */
+    subtract(vector: Vector2D, self?: boolean): Vector2D;
+    /**
+     * Multiplies this vector by a scalar value
+     * @param scalar - The scalar value to multiply by
+     * @returns A new Vector2D scaled by the input value
+     */
+    multiply(scalar: number): Vector2D;
+    /**
+     * Divides this vector by a scalar value
+     * @param scalar - The scalar value to divide by
+     * @throws {Error} If scalar is zero
+     * @returns A new Vector2D divided by the scalar value
+     */
+    divide(scalar: number): Vector2D;
+    /**
+     * Calculates the magnitude (length) of this vector
+     * @returns The magnitude of the vector
+     */
+    magnitude(): number;
+    /**
+     * Creates a normalized (unit) vector pointing in the same direction
+     * @returns A new Vector2D with magnitude 1 (or 0 if this vector is 0)
+     */
+    normalize(): Vector2D;
+    /**
+     * Calculates the dot product with another vector
+     * @param vector - The vector to calculate the dot product with
+     * @returns The dot product of the two vectors
+     */
+    dot(vector: Vector2D): number;
+    /**
+     * Calculates the 2D cross product with another vector
+     * @param vector - The vector to calculate the cross product with
+     * @returns The magnitude of the cross product
+     */
+    cross(vector: Vector2D): number;
+    /**
+     * Calculates the angle between this vector and another vector
+     * @param vector - The vector to calculate the angle with
+     * @returns The angle in radians between the two vectors
+     */
+    angle(vector: Vector2D): number;
+    /**
+     * Rotates the vector by a given angle
+     * @param angle - The angle to rotate by (in radians)
+     * @returns A new Vector2D rotated by the specified angle
+     */
+    rotate(angle: number): Vector2D;
+    /**
+     * Calculates the distance to another vector
+     * @param vector - The vector to calculate the distance to
+     * @returns The distance between the two vectors
+     */
+    distance(vector: Vector2D): number;
+    /**
+     * Projects this vector onto another vector
+     * @param vector - The vector to project onto
+     * @returns A new Vector2D representing the projection
+     */
+    project(vector: Vector2D): Vector2D;
+    /**
+     * Reflects this vector across a normal
+     * @param normal - The normal vector to reflect across
+     * @returns A new Vector2D representing the reflection
+     */
+    reflect(normal: Vector2D): Vector2D;
+    /**
+     * Linearly interpolates between this vector and another vector
+     * @param vector - The vector to interpolate towards
+     * @param t - The interpolation parameter (0-1)
+     * @returns A new Vector2D representing the interpolated vector
+     */
+    lerp(vector: Vector2D, t: number): Vector2D;
+    /**
+     * Limits the magnitude of this vector to a maximum value
+     * @param max - The maximum magnitude
+     * @returns A new Vector2D with limited magnitude
+     */
+    limit(max: number): Vector2D;
+    /**
+     * Checks if this vector is equal to another vector within a tolerance
+     * @param vector - The vector to compare with
+     * @param tolerance - The maximum difference allowed (default: 0.000001)
+     * @returns True if the vectors are equal within the tolerance
+     */
+    equals(vector: Vector2D, tolerance?: number): boolean;
+    /**
+     * Creates a copy of this vector
+     * @returns A new Vector2D with the same components
+     */
+    clone(): Vector2D;
+    /**
+     * Converts the vector to a string representation
+     * @returns A string representation of the vector
+     */
+    toString(): string;
+    /**
+     * Creates a vector pointing in a specific direction
+     * @param angle - The angle in radians
+     * @param magnitude - The length of the vector (default: 1)
+     * @returns A new Vector2D with the specified angle and magnitude
+     */
+    static fromAngle(angle: number, magnitude?: number): Vector2D;
+    /**
+     * Creates a random vector with the specified magnitude
+     * @param magnitude - The length of the vector (default: 1)
+     * @returns A new Vector2D with random direction and specified magnitude
+     */
+    static random(magnitude?: number): Vector2D;
+    /**
+     * Adds two vectors together
+     * @param v1 - The first vector
+     * @param v2 - The second vector
+     * @returns A new Vector2D representing the sum
+     */
+    static add(v1: Vector2D, v2: Vector2D): Vector2D;
+    /**
+     * Subtracts one vector from another
+     * @param v1 - The vector to subtract from
+     * @param v2 - The vector to subtract
+     * @returns A new Vector2D representing the difference
+     */
+    static subtract(v1: Vector2D, v2: Vector2D): Vector2D;
+    /**
+     * Calculates the distance between two vectors
+     * @param v1 - The first vector
+     * @param v2 - The second vector
+     * @returns The distance between the vectors
+     */
+    static distance(v1: Vector2D, v2: Vector2D): number;
+}
+
+declare const TWO_PI: number;
+
+declare class Camera extends Node {
+    zoom: number;
+    constructor(x?: number, y?: number, zoom?: number);
+    update(deltaTime: number): void;
+    transformCoordinates(position: Vector2D): Vector2D;
+}
+
+declare class InputManager extends Node {
+    private keyState;
+    private keyJustPressed;
+    private mouseState;
+    private mouseJustPressed;
+    constructor();
+    private setupListeners;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleMouseDown;
+    private handleMouseUp;
+    justPressed(keyOrButton: string | number): boolean;
+    isPressed(keyOrButton: string | number): boolean;
+    postUpdate(): void;
+}
+
+interface SceneOptions {
+    camera?: Camera;
+    inputManager?: InputManager;
+}
+interface Updatable {
+    update(deltaTime: number): void;
+}
+interface Drawable {
+    draw(ctx: CanvasRenderingContext2D): void;
+}
+declare class Scene extends Node {
+    camera: Camera;
+    inputManager: InputManager;
+    ctx: CanvasRenderingContext2D;
+    private lastTime;
+    private totalTime;
+    constructor(ctx: CanvasRenderingContext2D, opts?: SceneOptions);
+    addObject(object: Node): void;
+    setup(): void;
+    resizeCanvas(): void;
+    update(deltaTime: number): void;
+    draw(ctx: CanvasRenderingContext2D): void;
+    gameLoop(callback?: (deltaTime: number, totalTime: number) => void, targetFPS?: number): void;
+}
+
+interface NodeConfig {
+    id?: string;
+    pos?: Vector2D;
+}
+declare class Node {
+    id: string;
+    pos: Vector2D;
+    children: Node[];
+    scene?: Scene;
+    constructor(config?: NodeConfig);
+    addObject(object: Node): void;
+    removeObject(object: Node): void;
+    private generateID;
+}
+
+interface CircleConfig {
+    vel?: Vector2D;
+    size?: number;
+    friction?: number;
+    startsWithBoundingBox?: boolean;
+}
+declare class Circle extends Node {
+    vel: Vector2D;
+    size: number;
+    friction: number;
+    constructor(config?: CircleConfig);
+    draw(ctx: CanvasRenderingContext2D, selected?: boolean): void;
+}
+
+declare function getCanvas(id: string): HTMLCanvasElement;
+
+export { Camera, Circle, type CircleConfig, type Drawable, Node, type NodeConfig, Scene, type SceneOptions, TWO_PI, type Updatable, Vector2D, getCanvas };

package/dist/main.d.ts

@@ -0,0 +1,239 @@
+/**
+ * A 2D vector class for mathematical operations and physics calculations
+ */
+declare class Vector2D {
+    x: number;
+    y: number;
+    /**
+     * Creates a new Vector2D instance
+     * @param x - The x component of the vector
+     * @param y - The y component of the vector
+     */
+    constructor(x?: number, y?: number);
+    /**
+     * Adds another vector to this vector
+     * @param vector - The vector to add
+     * @param self - If true, modifies the current vector in place, otherwise returns a new vector
+     * @returns A new Vector2D representing the sum
+     */
+    add(vector: Vector2D, self?: boolean): Vector2D;
+    /**
+     * Subtracts another vector from this vector
+     * @param vector - The vector to subtract
+     * @param self - If true, modifies the current vector in place, otherwise returns a new vector
+     * @returns A new Vector2D representing the difference
+     */
+    subtract(vector: Vector2D, self?: boolean): Vector2D;
+    /**
+     * Multiplies this vector by a scalar value
+     * @param scalar - The scalar value to multiply by
+     * @returns A new Vector2D scaled by the input value
+     */
+    multiply(scalar: number): Vector2D;
+    /**
+     * Divides this vector by a scalar value
+     * @param scalar - The scalar value to divide by
+     * @throws {Error} If scalar is zero
+     * @returns A new Vector2D divided by the scalar value
+     */
+    divide(scalar: number): Vector2D;
+    /**
+     * Calculates the magnitude (length) of this vector
+     * @returns The magnitude of the vector
+     */
+    magnitude(): number;
+    /**
+     * Creates a normalized (unit) vector pointing in the same direction
+     * @returns A new Vector2D with magnitude 1 (or 0 if this vector is 0)
+     */
+    normalize(): Vector2D;
+    /**
+     * Calculates the dot product with another vector
+     * @param vector - The vector to calculate the dot product with
+     * @returns The dot product of the two vectors
+     */
+    dot(vector: Vector2D): number;
+    /**
+     * Calculates the 2D cross product with another vector
+     * @param vector - The vector to calculate the cross product with
+     * @returns The magnitude of the cross product
+     */
+    cross(vector: Vector2D): number;
+    /**
+     * Calculates the angle between this vector and another vector
+     * @param vector - The vector to calculate the angle with
+     * @returns The angle in radians between the two vectors
+     */
+    angle(vector: Vector2D): number;
+    /**
+     * Rotates the vector by a given angle
+     * @param angle - The angle to rotate by (in radians)
+     * @returns A new Vector2D rotated by the specified angle
+     */
+    rotate(angle: number): Vector2D;
+    /**
+     * Calculates the distance to another vector
+     * @param vector - The vector to calculate the distance to
+     * @returns The distance between the two vectors
+     */
+    distance(vector: Vector2D): number;
+    /**
+     * Projects this vector onto another vector
+     * @param vector - The vector to project onto
+     * @returns A new Vector2D representing the projection
+     */
+    project(vector: Vector2D): Vector2D;
+    /**
+     * Reflects this vector across a normal
+     * @param normal - The normal vector to reflect across
+     * @returns A new Vector2D representing the reflection
+     */
+    reflect(normal: Vector2D): Vector2D;
+    /**
+     * Linearly interpolates between this vector and another vector
+     * @param vector - The vector to interpolate towards
+     * @param t - The interpolation parameter (0-1)
+     * @returns A new Vector2D representing the interpolated vector
+     */
+    lerp(vector: Vector2D, t: number): Vector2D;
+    /**
+     * Limits the magnitude of this vector to a maximum value
+     * @param max - The maximum magnitude
+     * @returns A new Vector2D with limited magnitude
+     */
+    limit(max: number): Vector2D;
+    /**
+     * Checks if this vector is equal to another vector within a tolerance
+     * @param vector - The vector to compare with
+     * @param tolerance - The maximum difference allowed (default: 0.000001)
+     * @returns True if the vectors are equal within the tolerance
+     */
+    equals(vector: Vector2D, tolerance?: number): boolean;
+    /**
+     * Creates a copy of this vector
+     * @returns A new Vector2D with the same components
+     */
+    clone(): Vector2D;
+    /**
+     * Converts the vector to a string representation
+     * @returns A string representation of the vector
+     */
+    toString(): string;
+    /**
+     * Creates a vector pointing in a specific direction
+     * @param angle - The angle in radians
+     * @param magnitude - The length of the vector (default: 1)
+     * @returns A new Vector2D with the specified angle and magnitude
+     */
+    static fromAngle(angle: number, magnitude?: number): Vector2D;
+    /**
+     * Creates a random vector with the specified magnitude
+     * @param magnitude - The length of the vector (default: 1)
+     * @returns A new Vector2D with random direction and specified magnitude
+     */
+    static random(magnitude?: number): Vector2D;
+    /**
+     * Adds two vectors together
+     * @param v1 - The first vector
+     * @param v2 - The second vector
+     * @returns A new Vector2D representing the sum
+     */
+    static add(v1: Vector2D, v2: Vector2D): Vector2D;
+    /**
+     * Subtracts one vector from another
+     * @param v1 - The vector to subtract from
+     * @param v2 - The vector to subtract
+     * @returns A new Vector2D representing the difference
+     */
+    static subtract(v1: Vector2D, v2: Vector2D): Vector2D;
+    /**
+     * Calculates the distance between two vectors
+     * @param v1 - The first vector
+     * @param v2 - The second vector
+     * @returns The distance between the vectors
+     */
+    static distance(v1: Vector2D, v2: Vector2D): number;
+}
+
+declare const TWO_PI: number;
+
+declare class Camera extends Node {
+    zoom: number;
+    constructor(x?: number, y?: number, zoom?: number);
+    update(deltaTime: number): void;
+    transformCoordinates(position: Vector2D): Vector2D;
+}
+
+declare class InputManager extends Node {
+    private keyState;
+    private keyJustPressed;
+    private mouseState;
+    private mouseJustPressed;
+    constructor();
+    private setupListeners;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleMouseDown;
+    private handleMouseUp;
+    justPressed(keyOrButton: string | number): boolean;
+    isPressed(keyOrButton: string | number): boolean;
+    postUpdate(): void;
+}
+
+interface SceneOptions {
+    camera?: Camera;
+    inputManager?: InputManager;
+}
+interface Updatable {
+    update(deltaTime: number): void;
+}
+interface Drawable {
+    draw(ctx: CanvasRenderingContext2D): void;
+}
+declare class Scene extends Node {
+    camera: Camera;
+    inputManager: InputManager;
+    ctx: CanvasRenderingContext2D;
+    private lastTime;
+    private totalTime;
+    constructor(ctx: CanvasRenderingContext2D, opts?: SceneOptions);
+    addObject(object: Node): void;
+    setup(): void;
+    resizeCanvas(): void;
+    update(deltaTime: number): void;
+    draw(ctx: CanvasRenderingContext2D): void;
+    gameLoop(callback?: (deltaTime: number, totalTime: number) => void, targetFPS?: number): void;
+}
+
+interface NodeConfig {
+    id?: string;
+    pos?: Vector2D;
+}
+declare class Node {
+    id: string;
+    pos: Vector2D;
+    children: Node[];
+    scene?: Scene;
+    constructor(config?: NodeConfig);
+    addObject(object: Node): void;
+    removeObject(object: Node): void;
+    private generateID;
+}
+
+interface CircleConfig {
+    vel?: Vector2D;
+    size?: number;
+    friction?: number;
+    startsWithBoundingBox?: boolean;
+}
+declare class Circle extends Node {
+    vel: Vector2D;
+    size: number;
+    friction: number;
+    constructor(config?: CircleConfig);
+    draw(ctx: CanvasRenderingContext2D, selected?: boolean): void;
+}
+
+declare function getCanvas(id: string): HTMLCanvasElement;
+
+export { Camera, Circle, type CircleConfig, type Drawable, Node, type NodeConfig, Scene, type SceneOptions, TWO_PI, type Updatable, Vector2D, getCanvas };