@bloopjs/bloop 0.0.19 → 0.0.21

package/test/inputs.test.ts

@@ -1,227 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { Key, MouseButton } from "@bloopjs/engine";
-import { Bloop } from "../src/bloop";
-import { mount } from "../src/runtime";
-
-describe("inputs", () => {
-  it("runs a single system", async () => {
-    const bloop = Bloop.create();
-    let count = 0;
-
-    bloop.system("test", {
-      update() {
-        count++;
-      },
-    });
-
-    const { runtime } = await mount(bloop);
-    runtime.step();
-
-    expect(count).toEqual(1);
-  });
-
-  it("routes keydown event", async () => {
-    const bloop = Bloop.create();
-    let receivedKey: Key | null = null;
-    let called = false;
-    bloop.system("input", {
-      keydown({ event }) {
-        receivedKey = event.key;
-        called = true;
-      },
-    });
-
-    const { runtime } = await mount(bloop);
-    runtime.emit.keydown("Space");
-    runtime.step();
-
-    expect(called).toBe(true);
-    expect(receivedKey!).toEqual("Space");
-  });
-
-  it("routes all input events", async () => {
-    const bloop = Bloop.create();
-
-    const events = {
-      keydown: null as Key | null,
-      keyup: null as Key | null,
-
-      mousemove: null as { x: number; y: number } | null,
-      mousedown: null as MouseButton | null,
-      mouseup: null as MouseButton | null,
-      mousewheel: null as { x: number; y: number } | null,
-    };
-
-    bloop.system("input", {
-      keydown({ event }) {
-        events.keydown = event.key;
-      },
-      keyup({ event }) {
-        events.keyup = event.key;
-      },
-      mousemove({ event }) {
-        events.mousemove = { x: event.x, y: event.y };
-      },
-      mousedown({ event }) {
-        events.mousedown = event.button;
-      },
-      mouseup({ event }) {
-        events.mouseup = event.button;
-      },
-      mousewheel({ event }) {
-        events.mousewheel = event;
-      },
-    });
-
-    const { runtime } = await mount(bloop);
-
-    runtime.emit.keydown("Space");
-    runtime.emit.mousedown("Left");
-    runtime.emit.mousemove(100, 150);
-    runtime.emit.mousewheel(1, 2);
-
-    runtime.step();
-
-    expect(events.keydown).toEqual("Space");
-    expect(events.mousemove).toEqual({ x: 100, y: 150 });
-    expect(events.mousedown).toEqual("Left");
-    expect(events.mousewheel).toEqual({ x: 1, y: 2 });
-
-    runtime.emit.keyup("Space");
-    runtime.emit.mouseup("Left");
-    runtime.emit.mousemove(3, 4);
-
-    runtime.step();
-
-    expect(events.keyup).toEqual("Space");
-    expect(events.mouseup).toEqual("Left");
-    expect(events.mousemove).toEqual({ x: 3, y: 4 });
-  });
-
-  it("exposes keyboard context", async () => {
-    const bloop = Bloop.create({
-      bag: {
-        down: null as boolean | null,
-        held: null as boolean | null,
-        up: null as boolean | null,
-      },
-    });
-
-    bloop.system("key state", {
-      update({ inputs, bag }) {
-        bag.down = inputs.keys.backquote.down;
-        bag.held = inputs.keys.backquote.held;
-        bag.up = inputs.keys.backquote.up;
-      },
-    });
-
-    const { runtime } = await mount(bloop);
-
-    // Initial state
-    runtime.step();
-    expect(bloop.bag).toEqual({
-      down: false,
-      held: false,
-      up: false,
-    });
-
-    // down and held are both true on the first frame of a key down
-    runtime.emit.keydown("Backquote");
-    runtime.step();
-    expect(bloop.bag).toEqual({
-      down: true,
-      held: true,
-      up: false,
-    });
-
-    // held remains true, down goes false
-    runtime.step();
-    expect(bloop.bag).toEqual({
-      down: false,
-      held: true,
-      up: false,
-    });
-
-    // on key up, up is true, held and down are false
-    runtime.emit.keyup("Backquote");
-    runtime.step();
-    expect(bloop.bag).toEqual({
-      down: false,
-      held: false,
-      up: true,
-    });
-  });
-
-  it("exposes mouse context", async () => {
-    const bloop = Bloop.create({
-      bag: {
-        down: null as boolean | null,
-        held: null as boolean | null,
-        up: null as boolean | null,
-        position: null as { x: number; y: number } | null,
-        wheel: null as { x: number; y: number } | null,
-      },
-    });
-
-    bloop.system("mouse state", {
-      update({ inputs, bag }) {
-        bag.down = inputs.mouse.left.down;
-        bag.held = inputs.mouse.left.held;
-        bag.up = inputs.mouse.left.up;
-        bag.position = { x: inputs.mouse.x, y: inputs.mouse.y };
-        bag.wheel = inputs.mouse.wheel;
-      },
-    });
-
-    const { runtime } = await mount(bloop);
-
-    // Initial state
-    runtime.step();
-    expect(bloop.bag).toEqual({
-      down: false,
-      held: false,
-      up: false,
-      position: { x: 0, y: 0 },
-      wheel: { x: 0, y: 0 },
-    });
-
-    // down and held are both true on the first frame of a key down
-    runtime.emit.mousedown("Left");
-    runtime.step();
-    expect(bloop.bag).toMatchObject({
-      down: true,
-      held: true,
-      up: false,
-    });
-
-    runtime.emit.mousemove(123, 456);
-    runtime.step();
-    expect(bloop.bag).toMatchObject({
-      down: false,
-      held: true,
-      up: false,
-      position: { x: 123, y: 456 },
-    });
-
-    runtime.emit.mousewheel(5, -3);
-    runtime.step();
-    expect(bloop.bag).toMatchObject({
-      down: false,
-      held: true,
-      up: false,
-      position: { x: 123, y: 456 },
-      wheel: { x: 5, y: -3 },
-    });
-
-    runtime.emit.mouseup("Left");
-    runtime.step();
-    expect(bloop.bag).toMatchObject({
-      down: false,
-      held: false,
-      up: true,
-    });
-  });
-
-  it.skip("handles multiple frames between accumulated inputs", async () => {});
-  it.skip("handles down and up between frames", async () => {});
-});

package/test/runtime.test.ts

@@ -1,298 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  KeyboardContext,
-  type KeyState,
-  MOUSE_OFFSET,
-  MouseContext,
-} from "@bloopjs/engine";
-import { mount } from "../src/runtime";
-import { assert } from "../src/util";
-
-it("hello wasm", async () => {
-  let count = 0;
-  const { wasm } = await mount({
-    systemsCallback() {
-      count++;
-    },
-    setBuffer() {},
-  });
-
-  wasm.step(16);
-  expect(count).toBe(1);
-});
-
-describe("time", () => {
-  it("injects frame and dt", async () => {
-    const { runtime } = await mount({
-      systemsCallback() {},
-      setBuffer() {},
-    });
-
-    runtime.step(16);
-    expect(runtime.time.frame).toEqual(1);
-    expect(runtime.time.dt).toEqual(0.016);
-  });
-
-  it("exposes time context pointer in system callback", async () => {
-    let called = false;
-    const { runtime } = await mount({
-      systemsCallback(_handle, ptr) {
-        called = true;
-        const dataView = new DataView(runtime.buffer, ptr);
-        const timeCtxPtr = dataView.getUint32(0, true);
-        const timeDataView = new DataView(runtime.buffer, timeCtxPtr);
-        const frame = timeDataView.getUint32(0, true);
-        const dt = timeDataView.getUint32(4, true);
-        expect(frame).toEqual(0);
-        expect(dt).toEqual(16);
-      },
-      setBuffer() {},
-    });
-    runtime.step(16);
-
-    expect(called).toEqual(true);
-  });
-});
-
-describe("snapshots", () => {
-  it("can capture time to a snapshot", async () => {
-    const { runtime } = await mount({
-      systemsCallback() {},
-      setBuffer() {},
-    });
-
-    runtime.step(16);
-    runtime.step(16);
-    expect(runtime.time.frame).toEqual(2);
-    expect(runtime.time.dt).toEqual(0.016);
-
-    const snapshot = runtime.snapshot();
-
-    runtime.step(16);
-    expect(runtime.time.frame).toEqual(3);
-
-    runtime.restore(snapshot);
-    expect(runtime.time.frame).toEqual(2);
-
-    runtime.step(16);
-    expect(runtime.time.frame).toEqual(3);
-  });
-});
-
-describe("inputs", () => {
-  it("updates input context in response to keyboard events", async () => {
-    let called = false;
-    const states: KeyState[] = [];
-
-    const { runtime } = await mount({
-      systemsCallback(_handle, ptr) {
-        const dataView = new DataView(runtime.buffer, ptr);
-        const inputCtxPtr = dataView.getUint32(4, true);
-        const inputDataView = new DataView(runtime.buffer, inputCtxPtr);
-
-        const keyboardContext = new KeyboardContext(inputDataView);
-        states.push(keyboardContext.digit8);
-
-        called = true;
-      },
-      setBuffer() {},
-    });
-
-    runtime.emit.keydown("Digit8");
-    runtime.step();
-    runtime.step();
-    runtime.emit.keyup("Digit8");
-    runtime.step();
-    expect(called).toEqual(true);
-
-    expect(states[0]).toEqual({
-      down: true,
-      held: true,
-      up: false,
-    });
-
-    expect(states[1]).toEqual({
-      down: false,
-      held: true,
-      up: false,
-    });
-
-    expect(states[2]).toEqual({
-      down: false,
-      held: false,
-      up: true,
-    });
-  });
-
-  it("updates input context in response to mouse events", async () => {
-    let called = false;
-    type MouseState = {
-      x: number;
-      y: number;
-      wheelX: number;
-      wheelY: number;
-      left: KeyState;
-    };
-    const states: MouseState[] = [];
-
-    const { runtime } = await mount({
-      systemsCallback(_handle, ptr) {
-        const dataView = new DataView(runtime.buffer, ptr);
-        const inputCtxPtr = dataView.getUint32(4, true);
-        const inputDataView = new DataView(runtime.buffer, inputCtxPtr);
-
-        const dv = new DataView(
-          inputDataView.buffer,
-          inputDataView.byteOffset + MOUSE_OFFSET,
-        );
-        const mouseContext = new MouseContext(dv);
-
-        states.push({
-          x: mouseContext.x,
-          y: mouseContext.y,
-          left: mouseContext.left,
-          wheelX: mouseContext.wheelX,
-          wheelY: mouseContext.wheelY,
-        });
-
-        called = true;
-      },
-      setBuffer() {},
-    });
-
-    runtime.emit.mousedown("Left");
-    runtime.step();
-
-    runtime.emit.mousemove(123, 456);
-    runtime.emit.mousewheel(789, 101);
-    runtime.step();
-
-    runtime.emit.mouseup("Left");
-    runtime.step();
-
-    expect(called).toEqual(true);
-
-    expect(states[0]).toMatchObject({
-      left: {
-        down: true,
-        held: true,
-        up: false,
-      },
-    });
-
-    expect(states[1]).toMatchObject({
-      left: {
-        down: false,
-        held: true,
-        up: false,
-      },
-      x: 123,
-      y: 456,
-      wheelX: 789,
-      wheelY: 101,
-    });
-
-    expect(states[2]).toMatchObject({
-      left: {
-        down: false,
-        held: false,
-        up: true,
-      },
-    });
-  });
-
-  it("updates platform events with input events", async () => {
-    let called = false;
-    const { runtime } = await mount({
-      systemsCallback(_handle, ptr) {
-        const dataView = new DataView(runtime.buffer, ptr);
-        const eventsPtr = dataView.getUint32(8, true);
-        const eventsDataView = new DataView(runtime.buffer, eventsPtr);
-        const eventCount = eventsDataView.getUint32(0, true);
-        expect(eventCount).toEqual(1);
-        // kind = 1 byte + 3 bytes padding
-        // payload = 8 bytes
-        const typeOffset = 4;
-        const payloadOffset = 7;
-        const eventType = eventsDataView.getUint8(typeOffset + 0);
-        const eventPayload = eventsDataView.getUint8(payloadOffset + 1);
-        expect(eventCount).toEqual(1);
-        expect(eventType).toEqual(1);
-        expect(eventPayload).toEqual(3); // KeyCode for BracketLeft
-        called = true;
-      },
-      setBuffer() {},
-    });
-
-    runtime.emit.keydown("BracketLeft");
-    runtime.step();
-    expect(called).toEqual(true);
-  });
-});
-
-describe("tapes", () => {
-  describe("engine snapshot", () => {
-    it("saves and restores time context", async () => {
-      const { runtime } = await mount({
-        systemsCallback() {},
-        setBuffer() {},
-      });
-
-      const snapshot = runtime.snapshot();
-      expect(runtime.time.frame).toEqual(0);
-      runtime.step();
-      expect(runtime.time.frame).toEqual(1);
-      runtime.step();
-      expect(runtime.time.frame).toEqual(2);
-      runtime.restore(snapshot);
-
-      expect(runtime.time.frame).toEqual(0);
-    });
-  });
-
-  describe("caller payload", () => {
-    it("can capture and restore arbitrary payloads", async () => {
-      let called = false;
-      const { runtime } = await mount({
-        startRecording: false,
-        systemsCallback() {},
-        setBuffer() {},
-        serialize() {
-          return {
-            write(buffer, ptr) {
-              const data = new Uint8Array(buffer, ptr, 1);
-              data[0] = 66;
-            },
-            size: 1,
-          };
-        },
-        deserialize(buffer, ptr, length) {
-          called = true;
-          const data = new Uint8Array(buffer, ptr, length);
-          expect(data.byteLength).toBe(1);
-          expect(length).toEqual(1);
-          expect(data[0]).toBe(66);
-        },
-      });
-
-      const snapshot = runtime.snapshot();
-      runtime.restore(snapshot);
-      expect(called).toEqual(true);
-    });
-  });
-});
-
-function toHexString(bytes: DataView | Uint8Array, length?: number): string {
-  const dv =
-    bytes instanceof DataView
-      ? bytes
-      : new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  length ??= dv.byteLength;
-
-  let hexString = "";
-  for (let i = 0; i < length; i++) {
-    const byte = dv.getUint8(i);
-    hexString += `${byte.toString(16).padStart(2, "0")} `;
-  }
-  return hexString.trim();
-}

package/test/tape.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { Bloop } from "../src/bloop";
-import { mount } from "../src/runtime";
-
-describe("tapes", () => {
-  describe("snapshots", () => {
-    it("can snapshot the bag", async () => {
-      const bloop = Bloop.create({
-        bag: {
-          cool: 42,
-        },
-      });
-
-      bloop.system("inc", {
-        update({ bag }) {
-          bag.cool++;
-        },
-      });
-
-      const { runtime } = await mount(bloop);
-      runtime.step();
-
-      expect(bloop.bag.cool).toEqual(43);
-      const snapshot = runtime.snapshot();
-
-      runtime.step();
-      expect(bloop.bag.cool).toEqual(44);
-
-      runtime.restore(snapshot);
-      expect(bloop.bag.cool).toEqual(43);
-    });
-
-    it("can snapshot the bag on frame 0", async () => {
-      const bloop = Bloop.create({
-        bag: {
-          score: 10,
-        },
-      });
-
-      const { runtime } = await mount(bloop);
-      const snapshot = runtime.snapshot();
-      runtime.restore(snapshot);
-      expect(bloop.bag.score).toEqual(10);
-    });
-
-    it("snapshots time", async () => {
-      const bloop = Bloop.create();
-
-      const timeCheck = {
-        dt: 0,
-        time: 0,
-        frame: 0,
-      };
-
-      bloop.system("timeCheck", {
-        update({ time }) {
-          timeCheck.dt = time.dt;
-          timeCheck.time = time.time;
-          timeCheck.frame = time.frame;
-        },
-      });
-
-      const { runtime } = await mount(bloop);
-
-      runtime.step();
-
-      expect(timeCheck.dt).toBeCloseTo(0.016);
-      expect(timeCheck.time).toBeCloseTo(0.016);
-      expect(timeCheck.frame).toEqual(0);
-      expect(bloop.context.time.frame).toEqual(1);
-
-      // const snapshot = bloop.snapshot();
-      const snapshot = runtime.snapshot();
-
-      runtime.step();
-      expect(timeCheck.dt).toBeCloseTo(0.016);
-      expect(timeCheck.time).toBeCloseTo(0.016 * 2);
-      expect(timeCheck.frame).toEqual(1);
-      expect(bloop.context.time.frame).toEqual(2);
-
-      runtime.restore(snapshot);
-      expect(bloop.context.time.frame).toEqual(1);
-      runtime.step();
-
-      expect(timeCheck.dt).toBeCloseTo(0.016);
-      expect(timeCheck.time).toBeCloseTo(0.016 * 2);
-      expect(bloop.context.time.frame).toEqual(2);
-    });
-  });
-
-  describe("playback", () => {
-    it("can step back", async () => {
-      const bloop = Bloop.create({
-        bag: {
-          clicks: 0,
-        },
-      });
-
-      bloop.system("countClicks", {
-        update({ bag, inputs }) {
-          if (inputs.mouse.left.down) {
-            bag.clicks++;
-          }
-        },
-      });
-
-      const { runtime } = await mount(bloop);
-
-      runtime.emit.mousedown("Left");
-      runtime.step();
-      expect(bloop.context.time.frame).toEqual(1);
-      expect(bloop.bag.clicks).toEqual(1);
-
-      runtime.emit.mouseup("Left");
-      runtime.step();
-      expect(bloop.context.time.frame).toEqual(2);
-      expect(bloop.bag.clicks).toEqual(1);
-
-      runtime.stepBack();
-      expect(bloop.context.time.frame).toEqual(1);
-      expect(bloop.bag.clicks).toEqual(1);
-
-      runtime.stepBack();
-      expect(bloop.context.time.frame).toEqual(0);
-      expect(bloop.bag.clicks).toEqual(0);
-    });
-  });
-});

package/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false,
-
-    // Declarations
-    "emitDeclarationOnly": true,
-    "declaration": true,
-    "outDir": "dist",
-  },
-  "include": ["src", "test"]
-}