fruta 0.0.4 → 0.1.0

package/dist/render/create/ShapeCreator.d.ts

@@ -0,0 +1,49 @@
+import CanvasTarget from './canvasTarget';
+export default class ShapeCreator extends CanvasTarget {
+    fillStyleShape(style: string | CanvasGradient | CanvasPattern): this;
+    drawRectShape(clear?: [number, number, number, number], fill?: [number, number, number, number], stroke?: [number, number, number, number]): this;
+    roundRectShape(x: number, y: number, width: number, height: number, radius: number | number[]): this;
+    startShape(): this;
+    strokeShape(path?: Path2D): this;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    fillShape(fillRule?: CanvasFillRule): this;
+    arcShape(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+    path2DShape(path?: Path2D | string): Path2D;
+    domMatrixShape(): DOMMatrix;
+    addPathShape(callerPath: Path2D, path: Path2D, transform?: DOMMatrix2DInit): Path2D;
+    ellipseShape(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
+    createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+    addColorStop(gradient: CanvasGradient, stops: Array<{
+        color: string;
+    }>): this;
+    createPattern(image: CanvasImageSource, repetition?: string | null): CanvasPattern | null;
+    lineCapShape(style: CanvasLineCap): this;
+    lineJoinShape(style: CanvasLineJoin): this;
+    lineWidthShape(width: number): this;
+    miterLimitShape(limit: number): this;
+    shadowBlurOfShape(size: number): this;
+    shadowColorOfShape(style: string): this;
+    shadowOffSetXY(x: number, y: number): this;
+    strokeStyle(style: string | CanvasGradient | CanvasPattern): this;
+    scaleShape(x: number, y: number): this;
+    rotateShape(angle: number): this;
+    translateShape(x: number, y: number): this;
+    transformShape(a: number, b: number, c: number, d: number, e: number, f: number): this;
+    setTransformShape(a: number, b: number, c: number, d: number, e: number, f: number): this;
+    globalAlpha(alpha: number): this;
+    globalCompositeOperation(composition: GlobalCompositeOperation): this;
+    clipShape(): this;
+    shadowColor(color: string): this;
+    createImage(config: {
+        src: string;
+        img: number[];
+    }): this;
+    createImageData(sw: number, sh: number): ImageData;
+    getImgData(sx: number, sy: number, sw: number, sh: number): ImageData;
+    putImageData(imageData: ImageData, dx: number, dy: number): this;
+}

package/dist/render/create/canvasTarget.d.ts

@@ -0,0 +1,5 @@
+export default class CanvasTarget {
+    readonly canvas: HTMLCanvasElement;
+    readonly context: CanvasRenderingContext2D;
+    constructor(canvas: HTMLCanvasElement, context: CanvasRenderingContext2D);
+}

package/dist/render/shaders.d.ts

@@ -0,0 +1,29 @@
+export declare const Shaders: {
+    grayscale: string;
+    invert: string;
+    sepia: string;
+    tint: string;
+    brightness: string;
+    posterize: string;
+    threshold: string;
+    scanlines: string;
+    crt: string;
+    vhs: string;
+    pixelate: string;
+    noise: string;
+    glitch: string;
+    chromatic: string;
+    wave: string;
+    fisheye: string;
+    mirror: string;
+    shockwave: string;
+    blur: string;
+    sharpen: string;
+    bloom: string;
+    dream: string;
+    edge: string;
+    vignette: string;
+    nightvision: string;
+};
+export type ShaderName = keyof typeof Shaders;
+export declare const ShaderDefaults: Partial<Record<ShaderName, Record<string, number | number[]>>>;

package/dist/render/webgl.d.ts

@@ -0,0 +1,67 @@
+export interface QuadOptions {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    rotation?: number;
+    color?: string | [number, number, number, number];
+    alpha?: number;
+    u0?: number;
+    v0?: number;
+    u1?: number;
+    v1?: number;
+}
+export declare class WebGLBatch {
+    readonly canvas: HTMLCanvasElement;
+    private gl;
+    private prog;
+    private buf;
+    private data;
+    private count;
+    private textures;
+    private white;
+    private currentTex;
+    private loc;
+    constructor(canvas: HTMLCanvasElement);
+    private makeTexture;
+    texture(name: string, source: TexImageSource): void;
+    getTexture(name: string): {
+        tex: WebGLTexture;
+        w: number;
+        h: number;
+    } | null;
+    removeTexture(name: string): void;
+    get whiteTexture(): WebGLTexture;
+    pushQuad(tex: WebGLTexture, c: [number, number, number, number, number, number, number, number], uv: [number, number, number, number], r: number, g: number, b: number, a: number): void;
+    resize(w: number, h: number): void;
+    clear(r?: number, g?: number, b?: number, a?: number): void;
+    rect(o: QuadOptions): void;
+    sprite(name: string, o: QuadOptions): void;
+    private quad;
+    flush(): void;
+}
+export type Uniforms = Record<string, number | [number, number] | [number, number, number]>;
+export declare class PostFX {
+    private readonly canvas;
+    private gl;
+    private fbo;
+    private tex;
+    private quad;
+    private w;
+    private h;
+    private programs;
+    private current;
+    constructor(canvas: HTMLCanvasElement);
+    private resize;
+    setEffect(fragment: string): void;
+    begin(): void;
+    end(uniforms: Uniforms, time: number): void;
+}
+export declare class Shader {
+    readonly canvas: HTMLCanvasElement;
+    private gl;
+    private prog;
+    private buf;
+    constructor(canvas: HTMLCanvasElement, fragment: string);
+    draw(time: number, uniforms?: Record<string, number | [number, number]>): void;
+}

package/dist/renderer.d.ts

@@ -0,0 +1,42 @@
+export interface Drawer {
+    rect(o: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        fill?: string;
+        rotation?: number;
+        radius?: number;
+        alpha?: number;
+    }): unknown;
+    circle(o: {
+        x: number;
+        y: number;
+        r: number;
+        fill?: string;
+        alpha?: number;
+    }): unknown;
+    ellipse(o: {
+        x: number;
+        y: number;
+        rx: number;
+        ry: number;
+        rotation?: number;
+        fill?: string;
+        alpha?: number;
+    }): unknown;
+    sprite(name: string, o: {
+        x: number;
+        y: number;
+        w?: number;
+        h?: number;
+        frame?: number;
+        frameW?: number;
+        frameH?: number;
+        cols?: number;
+        rotation?: number;
+        flipX?: boolean;
+        anchor?: 'topleft' | 'center';
+        alpha?: number;
+    }): unknown;
+}

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+export interface FrutaConfig {
+    canvas?: HTMLCanvasElement | string;
+    width?: number;
+    height?: number;
+    background?: string;
+    clear?: boolean;
+    mount?: HTMLElement | string;
+    renderer?: 'canvas' | 'webgl';
+}

package/dist/utils/logStyle.d.ts

@@ -0,0 +1 @@
+export declare const consoleStyle: (message: string) => void;

package/dist/world/camera.d.ts

@@ -0,0 +1,24 @@
+export declare class Camera {
+    private readonly canvas;
+    private readonly ctx;
+    x: number;
+    y: number;
+    zoom: number;
+    private shakeAmt;
+    private shakeLeft;
+    private shakeDur;
+    constructor(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D);
+    shake(strength: number, duration?: number): void;
+    tick(dt: number): void;
+    follow(target: {
+        x: number;
+        y: number;
+    }, smooth?: number): void;
+    clamp(minX: number, minY: number, maxX: number, maxY: number): void;
+    begin(): void;
+    end(): void;
+    screenToWorld(px: number, py: number): {
+        x: number;
+        y: number;
+    };
+}

package/dist/world/entities.d.ts

@@ -0,0 +1,45 @@
+import type { Drawer } from '../renderer';
+export interface EntitySpec {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    vx?: number;
+    vy?: number;
+    gravity?: number;
+    sprite?: string;
+    shape?: 'rect' | 'circle';
+    color?: string;
+    r?: number;
+    radius?: number;
+    rotation?: number;
+    flipX?: boolean;
+    frame?: number;
+    frameW?: number;
+    frameH?: number;
+    cols?: number;
+    anchor?: 'topleft' | 'center';
+    bounds?: 'bounce' | 'wrap';
+    update?: (self: Entity, dt: number, time: number) => void;
+    [key: string]: unknown;
+}
+export type Entity = EntitySpec & {
+    w: number;
+    h: number;
+    vx: number;
+    vy: number;
+    alive: boolean;
+    remove(): void;
+};
+export declare class Entities {
+    private readonly app;
+    private list;
+    constructor(app: Drawer);
+    get count(): number;
+    add(spec: EntitySpec): Entity;
+    update(dt: number, time: number, bw?: number, bh?: number): void;
+    private edges;
+    draw(): void;
+    all(): Entity[];
+    clear(): void;
+}

package/dist/world/particles.d.ts

@@ -0,0 +1,42 @@
+export interface BurstOptions {
+    x: number;
+    y: number;
+    count?: number;
+    color?: string | string[];
+    speed?: number | [number, number];
+    spread?: number;
+    direction?: number;
+    life?: number;
+    size?: number;
+    gravity?: number;
+    fade?: boolean;
+}
+export interface EmitterOptions extends BurstOptions {
+    rate?: number;
+}
+export interface Emitter {
+    x: number;
+    y: number;
+    active: boolean;
+    stop(): void;
+}
+export declare class Particles {
+    private list;
+    private emitters;
+    get count(): number;
+    get busy(): boolean;
+    emit(opts: EmitterOptions): Emitter;
+    burst(o: BurstOptions): void;
+    update(dt: number): void;
+    draw(ctx: CanvasRenderingContext2D): void;
+    drawWith(d: {
+        circle(o: {
+            x: number;
+            y: number;
+            r: number;
+            fill?: string;
+            alpha?: number;
+        }): unknown;
+    }): void;
+    clear(): void;
+}

package/dist/world/tilemap.d.ts

@@ -0,0 +1,44 @@
+import type { Drawer } from '../renderer';
+import { type Cell } from '../math/pathfind';
+export interface TileDef {
+    solid?: boolean;
+    color?: string;
+    sprite?: string;
+    frame?: number;
+}
+export interface Body {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    vx: number;
+    vy: number;
+    onGround?: boolean;
+}
+export interface TilemapConfig {
+    data: string[];
+    size: number;
+    tiles: Record<string, TileDef>;
+    bevel?: boolean;
+}
+export declare class Tilemap {
+    private readonly app;
+    readonly size: number;
+    private grid;
+    private defs;
+    private bevel;
+    constructor(config: TilemapConfig, app: Drawer);
+    get cols(): number;
+    get rows(): number;
+    get width(): number;
+    get height(): number;
+    at(tx: number, ty: number): string;
+    set(tx: number, ty: number, char: string): void;
+    isSolid(tx: number, ty: number): boolean;
+    path(start: Cell, goal: Cell, opts?: {
+        diagonal?: boolean;
+    }): Cell[] | null;
+    draw(): void;
+    move(body: Body, dt: number): void;
+    private resolve;
+}

package/dist/world/timers.d.ts

@@ -0,0 +1,11 @@
+export interface TimerHandle {
+    cancel(): void;
+}
+export declare class Timers {
+    private list;
+    get count(): number;
+    after(seconds: number, fn: () => void): TimerHandle;
+    every(seconds: number, fn: () => void): TimerHandle;
+    update(dt: number): void;
+    clear(): void;
+}

package/package.json

@@ -1,37 +1,37 @@
 {
-    "name": "fruta",
-    "version": "0.0.4",
-    "description": "Intuitive Video Game Library Aimed at HTML5 Development.",
-    "browser": "./src/core/fruta.js",
-    "scripts": {
-        "build": "webpack --mode=production --node-env=production",
-        "build:dev": "webpack --mode=development",
-        "build:prod": "webpack --mode=production --node-env=production",
-        "watch": "webpack --watch",
-        "serve": "webpack serve"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/karttofer/fruitjs"
-    },
-    "keywords": [
-        "WebGL",
-        "2d",
-        "canvas",
-        "HTML5",
-        "javascript",
-        "game"
-    ],
-    "author": "Jhornan Colina <jhornancolina@gmail.com>",
-    "license": "MIT",
-    "devDependencies": {
-        "@babel/core": "^7.22.1",
-        "@babel/preset-env": "^7.22.4",
-        "babel-loader": "^9.1.2",
-        "html-webpack-plugin": "^5.5.1",
-        "prettier": "^2.8.8",
-        "webpack": "^5.86.0",
-        "webpack-cli": "^5.1.4",
-        "webpack-dev-server": "^4.15.0"
+  "name": "fruta",
+  "version": "0.1.0",
+  "description": "Tiny, semantic 2D graphics & game engine for the web (Canvas2D + WebGL). TypeScript-first, framework-friendly. Physics, pathfinding, pooling, spatial hashing, bézier + hex math.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/fruta.js",
+  "module": "./dist/fruta.js",
+  "types": "./dist/fruta.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/fruta.d.ts",
+      "import": "./dist/fruta.js"
     }
-}
+  },
+  "files": ["dist"],
+  "scripts": {
+    "gensrc": "bun run playground/gensrc.ts",
+    "dev": "bun run gensrc && bun ./index.html",
+    "build": "rm -rf dist && bun run build:types && bun run build:js",
+    "build:types": "tsc",
+    "build:js": "bun build ./src/core/fruta.ts --outfile dist/fruta.js --target browser --format esm --minify",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/karttofer/fruitjs"
+  },
+  "keywords": ["WebGL", "2d", "canvas", "HTML5", "javascript", "typescript", "game", "graphics"],
+  "author": "Jhornan Colina <jhornancolina@gmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.4.5"
+  }
+}