@whatever-engine/api 0.1.1-3 → 0.2.0

package/dist/index.js

@@ -0,0 +1,600 @@
+// src/ipc.ts
+import { createInterface } from "node:readline";
+
+// src/shared.ts
+var _handlers = new Map;
+var _fileCallbacks = new Map;
+var _modListCallbacks = new Map;
+var _modGetCallbacks = new Map;
+var _msgCallbacks = new Map;
+var _entityCallbacks = new Map;
+var _entityListCallbacks = new Map;
+var _componentGetCallbacks = new Map;
+var _componentQueryCallbacks = new Map;
+var _counter = { n: 0 };
+function nextReqId() {
+  return String(++_counter.n);
+}
+function _send(msg) {
+  process.stdout.write(JSON.stringify(msg) + `
+`);
+}
+var _EVENT_SUBSCRIBE = {
+  init: "Init",
+  exit: "Shutdown",
+  tick: "Tick"
+};
+
+// src/components/console.ts
+var _cmdHandlers = new Map;
+var _cmdArgSpecs = new Map;
+function _specToInternal(spec, pathPrefix) {
+  const path = pathPrefix ? `${pathPrefix}.${spec.name}` : spec.name;
+  const mappedArgs = (spec.args ?? []).map((a) => ({
+    name: a.name,
+    type: a.type,
+    required: a.required ?? false,
+    description: a.description ?? ""
+  }));
+  if (spec.handler) {
+    _cmdHandlers.set(path, spec.handler);
+    _cmdArgSpecs.set(path, mappedArgs);
+  }
+  return {
+    name: spec.name,
+    description: spec.description ?? "",
+    subcommands: (spec.subcommands ?? []).map((s) => _specToInternal(s, path)),
+    args: mappedArgs,
+    has_handler: !!spec.handler
+  };
+}
+async function _handleCommandInvoke(msg) {
+  const handlerKey = msg.command_path.join(".");
+  const handler = _cmdHandlers.get(handlerKey);
+  const argSpecs = _cmdArgSpecs.get(handlerKey) ?? [];
+  const argsRecord = {};
+  msg.args.forEach((v, i) => {
+    const name = argSpecs[i]?.name ?? String(i);
+    argsRecord[name] = v;
+  });
+  if (!handler) {
+    _send({ type: "CommandResponse", request_id: msg.request_id, output: [], error: `no handler registered for '${handlerKey}'` });
+    return;
+  }
+  try {
+    const result = await handler(argsRecord);
+    const lines = Array.isArray(result) ? result : [result];
+    _send({ type: "CommandResponse", request_id: msg.request_id, output: lines, error: null });
+  } catch (error) {
+    const message = error instanceof Error ? error.message + `
+` + error.stack : String(error);
+    _send({ type: "CommandResponse", request_id: msg.request_id, output: [], error: message });
+  }
+}
+var Console = {
+  register(spec) {
+    if (!/^[a-z_]+$/.test(spec.name)) {
+      throw new Error(`Console.register: command name '${spec.name}' must match [a-z_]+`);
+    }
+    const internal = _specToInternal(spec, "");
+    _send({
+      type: "RegisterCommand",
+      name: internal.name,
+      description: internal.description,
+      subcommands: internal.subcommands,
+      args: internal.args,
+      has_handler: internal.has_handler
+    });
+  }
+};
+
+// src/ipc.ts
+function _dispatch(msg) {
+  if (msg.type === "CommandInvoke") {
+    _handleCommandInvoke(msg);
+    return;
+  }
+  if (msg.type === "Tick") {
+    const handlers = _handlers.get("tick");
+    const promises = [];
+    if (handlers) {
+      for (const fn_ of handlers) {
+        const r = fn_(msg);
+        if (r instanceof Promise)
+          promises.push(r);
+      }
+    }
+    Promise.all(promises).then(() => process.stdout.write(JSON.stringify({ type: "TickDone", tick_number: msg.tick_number }) + `
+`));
+    return;
+  }
+  if (msg.type === "FileResponse") {
+    const cb = _fileCallbacks.get(msg.request_id);
+    if (cb) {
+      _fileCallbacks.delete(msg.request_id);
+      msg.error ? cb.reject(new Error(msg.error)) : cb.resolve(msg.data_base64);
+    }
+    return;
+  }
+  if (msg.type === "ModListResponse") {
+    const cb = _modListCallbacks.get(msg.request_id);
+    if (cb) {
+      _modListCallbacks.delete(msg.request_id);
+      cb.resolve(msg.mods);
+    }
+    return;
+  }
+  if (msg.type === "ModGetResponse") {
+    const cb = _modGetCallbacks.get(msg.request_id);
+    if (cb) {
+      _modGetCallbacks.delete(msg.request_id);
+      msg.error ? cb.reject(new Error(msg.error)) : cb.resolve(msg.manifest);
+    }
+    return;
+  }
+  if (msg.type === "ModMessageReplyDelivered") {
+    const cb = _msgCallbacks.get(msg.request_id);
+    if (cb) {
+      _msgCallbacks.delete(msg.request_id);
+      cb.resolve(msg.payload);
+    }
+    return;
+  }
+  if (msg.type === "ModMessageReceived") {
+    const handlers = _handlers.get("mod_message");
+    if (handlers) {
+      const payload = {
+        source_mod_id: msg.source_mod_id,
+        message: msg.payload,
+        ...msg.request_id !== null && { request_id: msg.request_id }
+      };
+      for (const fn_ of handlers)
+        fn_(payload);
+    }
+    return;
+  }
+  if (msg.type === "EntityCreated") {
+    const cb = _entityCallbacks.get(msg.request_id);
+    if (cb) {
+      _entityCallbacks.delete(msg.request_id);
+      cb.resolve(msg.entity_id);
+    }
+    return;
+  }
+  if (msg.type === "EntityListResponse") {
+    const cb = _entityListCallbacks.get(msg.request_id);
+    if (cb) {
+      _entityListCallbacks.delete(msg.request_id);
+      cb.resolve(msg.entity_ids);
+    }
+    return;
+  }
+  if (msg.type === "ComponentGetResponse") {
+    const cb = _componentGetCallbacks.get(msg.request_id);
+    if (cb) {
+      _componentGetCallbacks.delete(msg.request_id);
+      msg.error ? cb.reject(new Error(msg.error)) : cb.resolve(msg.data);
+    }
+    return;
+  }
+  if (msg.type === "ComponentQueryResponse") {
+    const cb = _componentQueryCallbacks.get(msg.request_id);
+    if (cb) {
+      _componentQueryCallbacks.delete(msg.request_id);
+      cb.resolve(msg.results);
+    }
+    return;
+  }
+  for (const [event, msgType] of Object.entries(_EVENT_SUBSCRIBE)) {
+    if (msg.type !== msgType)
+      continue;
+    const handlers = _handlers.get(event);
+    if (handlers) {
+      for (const fn_ of handlers)
+        fn_(msg);
+    }
+    if (event === "exit") {
+      process.exit(msg.exit_code);
+    }
+  }
+}
+var _rl = createInterface({ input: process.stdin, terminal: false });
+_rl.on("line", (line) => {
+  try {
+    _dispatch(JSON.parse(line));
+  } catch {}
+});
+_rl.on("close", () => process.exit(0));
+
+// src/components/engine.ts
+var Engine = {
+  on(event, handler) {
+    if (!_handlers.has(event))
+      _handlers.set(event, new Set);
+    _handlers.get(event).add(handler);
+    const msgType = _EVENT_SUBSCRIBE[event];
+    if (msgType)
+      _send({ type: "Subscribe", events: [msgType] });
+  },
+  log(level, message) {
+    _send({ type: "Log", level, message });
+  },
+  setTickRate(ticks_per_second) {
+    _send({ type: "SetTickRate", ticks_per_second });
+  }
+};
+// src/components/window.ts
+var Window = {
+  setTitle(title) {
+    _send({ type: "SetWindowTitle", title });
+  }
+};
+// src/components/file.ts
+var File = {
+  write(path, data) {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _fileCallbacks.set(request_id, { resolve: () => resolve(), reject });
+      _send({ type: "FileWrite", request_id, path, data_base64: Buffer.from(data, "utf8").toString("base64") });
+    });
+  },
+  read(path) {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _fileCallbacks.set(request_id, {
+        resolve: (b64) => resolve(Buffer.from(b64, "base64").toString("utf8")),
+        reject
+      });
+      _send({ type: "FileRead", request_id, path });
+    });
+  },
+  delete(path) {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _fileCallbacks.set(request_id, { resolve: () => resolve(), reject });
+      _send({ type: "FileDelete", request_id, path });
+    });
+  }
+};
+// src/components/ecs.ts
+var BuiltInComponents;
+((BuiltInComponents) => {
+  BuiltInComponents.TRANSFORM_ID = "core:transform";
+  BuiltInComponents.SPRITE_RENDERER_ID = "core:sprite_renderer";
+
+  class Transform {
+    id = BuiltInComponents.TRANSFORM_ID;
+    position;
+    rotation;
+    scale;
+    constructor(init = {}) {
+      this.position = init.position ?? [0, 0, 0];
+      this.rotation = init.rotation ?? [0, 0, 0, 1];
+      this.scale = init.scale ?? [1, 1, 1];
+    }
+    getX() {
+      return this.position[0];
+    }
+    setX(x) {
+      this.position[0] = x;
+      return this;
+    }
+    addX(x) {
+      this.position[0] += x;
+      return this;
+    }
+    getY() {
+      return this.position[1];
+    }
+    setY(y) {
+      this.position[1] = y;
+      return this;
+    }
+    addY(y) {
+      this.position[1] += y;
+      return this;
+    }
+    getZ() {
+      return this.position[2];
+    }
+    setZ(z) {
+      this.position[2] = z;
+      return this;
+    }
+    addZ(z) {
+      this.position[2] += z;
+      return this;
+    }
+    getPosition() {
+      return [this.position[0], this.position[1], this.position[2]];
+    }
+    setPosition(x, y, z) {
+      this.position = [x, y, z];
+      return this;
+    }
+    getScaleX() {
+      return this.scale[0];
+    }
+    setScaleX(x) {
+      this.scale[0] = x;
+      return this;
+    }
+    getScaleY() {
+      return this.scale[1];
+    }
+    setScaleY(y) {
+      this.scale[1] = y;
+      return this;
+    }
+    getScaleZ() {
+      return this.scale[2];
+    }
+    setScaleZ(z) {
+      this.scale[2] = z;
+      return this;
+    }
+    getScale() {
+      return [this.scale[0], this.scale[1], this.scale[2]];
+    }
+    setScale(x, y, z) {
+      this.scale = [x, y, z];
+      return this;
+    }
+    setScaleUniform(s) {
+      this.scale = [s, s, s];
+      return this;
+    }
+    distance(other) {
+      const dx = this.position[0] - other.position[0];
+      const dy = this.position[1] - other.position[1];
+      const dz = this.position[2] - other.position[2];
+      return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    getRotation() {
+      return [this.rotation[0], this.rotation[1], this.rotation[2], this.rotation[3]];
+    }
+    setRotation(x, y, z, w) {
+      this.rotation = [x, y, z, w];
+      return this;
+    }
+    getEulerRadians() {
+      const [qx, qy, qz, qw] = this.rotation;
+      const rx = Math.atan2(2 * (qw * qx + qy * qz), 1 - 2 * (qx * qx + qy * qy));
+      const sinPitch = Math.max(-1, Math.min(1, 2 * (qw * qy - qz * qx)));
+      const ry = Math.asin(sinPitch);
+      const rz = Math.atan2(2 * (qw * qz + qx * qy), 1 - 2 * (qy * qy + qz * qz));
+      return [rx, ry, rz];
+    }
+    setEulerRadians(rx, ry, rz) {
+      const cx = Math.cos(rx / 2), sx = Math.sin(rx / 2);
+      const cy = Math.cos(ry / 2), sy = Math.sin(ry / 2);
+      const cz = Math.cos(rz / 2), sz = Math.sin(rz / 2);
+      this.rotation = [
+        sx * cy * cz - cx * sy * sz,
+        cx * sy * cz + sx * cy * sz,
+        cx * cy * sz - sx * sy * cz,
+        cx * cy * cz + sx * sy * sz
+      ];
+      return this;
+    }
+    getEulerDegrees() {
+      const r = this.getEulerRadians();
+      return [r[0] * 180 / Math.PI, r[1] * 180 / Math.PI, r[2] * 180 / Math.PI];
+    }
+    setEulerDegrees(x, y, z) {
+      return this.setEulerRadians(x * Math.PI / 180, y * Math.PI / 180, z * Math.PI / 180);
+    }
+    rotateX(degrees) {
+      const r = degrees * Math.PI / 180;
+      const s = Math.sin(r / 2), c = Math.cos(r / 2);
+      return this._leftMultiply(s, 0, 0, c);
+    }
+    rotateY(degrees) {
+      const r = degrees * Math.PI / 180;
+      const s = Math.sin(r / 2), c = Math.cos(r / 2);
+      return this._leftMultiply(0, s, 0, c);
+    }
+    rotateZ(degrees) {
+      const r = degrees * Math.PI / 180;
+      const s = Math.sin(r / 2), c = Math.cos(r / 2);
+      return this._leftMultiply(0, 0, s, c);
+    }
+    _leftMultiply(ax, ay, az, aw) {
+      const [bx, by, bz, bw] = this.rotation;
+      this.rotation = [
+        aw * bx + ax * bw + ay * bz - az * by,
+        aw * by - ax * bz + ay * bw + az * bx,
+        aw * bz + ax * by - ay * bx + az * bw,
+        aw * bw - ax * bx - ay * by - az * bz
+      ];
+      return this;
+    }
+  }
+  BuiltInComponents.Transform = Transform;
+
+  class SpriteRenderer {
+    id = BuiltInComponents.SPRITE_RENDERER_ID;
+    texture;
+    z_index;
+    constructor(init = {}) {
+      this.texture = init.texture ?? "";
+      this.z_index = init.z_index ?? 0;
+    }
+    getTexture() {
+      return this.texture;
+    }
+    setTexture(texture) {
+      this.texture = texture;
+      return this;
+    }
+    getZIndex() {
+      return this.z_index;
+    }
+    setZIndex(z) {
+      this.z_index = z;
+      return this;
+    }
+  }
+  BuiltInComponents.SpriteRenderer = SpriteRenderer;
+})(BuiltInComponents ||= {});
+var _componentHydrators = {
+  "core:transform": (data) => new BuiltInComponents.Transform(data),
+  "core:sprite_renderer": (data) => new BuiltInComponents.SpriteRenderer(data)
+};
+function _setComponentImpl(entity_id, component_type, data) {
+  const { id: _id, ...rest } = data;
+  _send({ type: "ComponentSet", entity_id, component_type, data: rest });
+}
+function _getComponentImpl(entity_id, component_type) {
+  return new Promise((resolve, reject) => {
+    const request_id = nextReqId();
+    _componentGetCallbacks.set(request_id, { resolve, reject });
+    _send({ type: "ComponentGet", request_id, entity_id, component_type });
+  }).then((data) => {
+    if (data === null)
+      return null;
+    const hydrator = _componentHydrators[component_type];
+    return hydrator ? hydrator(data) : data;
+  });
+}
+
+class Entity {
+  id;
+  constructor(id) {
+    this.id = id;
+  }
+  destroy() {
+    _send({ type: "EntityDestroy", entity_id: this.id });
+  }
+  setComponent(component_type, data) {
+    _setComponentImpl(this.id, component_type, data);
+  }
+  removeComponent(component_type) {
+    _send({ type: "ComponentRemove", entity_id: this.id, component_type });
+  }
+  getComponent(component_type) {
+    return _getComponentImpl(this.id, component_type);
+  }
+  async move(position) {
+    const existing = await this.getComponent("core:transform");
+    this.setComponent("core:transform", {
+      position,
+      rotation: existing?.rotation ?? [0, 0, 0, 1],
+      scale: existing?.scale ?? [1, 1, 1]
+    });
+  }
+}
+var Scene = {
+  createEntity() {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _entityCallbacks.set(request_id, { resolve: (id) => resolve(new Entity(id)), reject });
+      _send({ type: "EntityCreate", request_id });
+    });
+  },
+  destroyEntity(entity_id) {
+    _send({ type: "EntityDestroy", entity_id });
+  },
+  listEntities() {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _entityListCallbacks.set(request_id, { resolve: (ids) => resolve(ids.map((id) => new Entity(id))), reject });
+      _send({ type: "EntityListRequest", request_id });
+    });
+  },
+  setComponent: _setComponentImpl,
+  removeComponent(entity_id, component_type) {
+    _send({ type: "ComponentRemove", entity_id, component_type });
+  },
+  getComponent: _getComponentImpl,
+  query(component_types) {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _componentQueryCallbacks.set(request_id, {
+        resolve: (results) => resolve(results.map((r) => ({
+          entity: new Entity(r.entity_id),
+          components: Object.fromEntries(Object.entries(r.components).map(([k, v]) => {
+            const hydrator = _componentHydrators[k];
+            return [k, hydrator ? hydrator(v) : v];
+          }))
+        }))),
+        reject
+      });
+      _send({ type: "ComponentQuery", request_id, component_types });
+    });
+  },
+  async spawnSprite(texture, position, scale = [1, 1, 1]) {
+    const entity = await Scene.createEntity();
+    entity.setComponent("core:transform", { position, rotation: [0, 0, 0, 1], scale });
+    entity.setComponent("core:sprite_renderer", { texture, z_index: 0 });
+    return entity;
+  },
+  async moveEntity(entity_id, position) {
+    const existing = await Scene.getComponent(entity_id, "core:transform");
+    Scene.setComponent(entity_id, "core:transform", {
+      position,
+      rotation: existing?.rotation ?? [0, 0, 0, 1],
+      scale: existing?.scale ?? [1, 1, 1]
+    });
+  }
+};
+// src/components/mods.ts
+var Mods = {
+  list() {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _modListCallbacks.set(request_id, { resolve, reject });
+      _send({ type: "ModListRequest", request_id });
+    });
+  },
+  get(id) {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      _modGetCallbacks.set(request_id, { resolve, reject });
+      _send({ type: "ModGetRequest", request_id, mod_id: id });
+    });
+  }
+};
+var Message = {
+  sendAndForget(id, message) {
+    _send({ type: "ModMessageSend", target_mod_id: id, request_id: null, payload: message });
+  },
+  send(id, message, timeout) {
+    return new Promise((resolve, reject) => {
+      const request_id = nextReqId();
+      const timer = setTimeout(() => {
+        _msgCallbacks.delete(request_id);
+        reject(new Error(`Message to '${id}' timed out after ${timeout}ms`));
+      }, timeout);
+      _msgCallbacks.set(request_id, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        reject
+      });
+      _send({ type: "ModMessageSend", target_mod_id: id, request_id, payload: message });
+    });
+  },
+  registerMessageHandler(handler) {
+    Engine.on("mod_message", (payload) => {
+      const result = handler(payload);
+      if (payload.request_id !== undefined && result !== null) {
+        _send({ type: "ModMessageReply", request_id: payload.request_id, payload: result });
+      }
+    });
+  }
+};
+export {
+  Window,
+  Scene,
+  Mods,
+  Message,
+  File,
+  Entity,
+  Engine,
+  Console,
+  BuiltInComponents
+};
+// With love from the Whatever team <3
+// https://github.com/MesterMan03/Whatever

package/package.json

@@ -3,20 +3,21 @@
   "author": "Mester",
   "license": "Apache-2.0",
   "description": "TypeScript scripting API for Whatever Engine mods",
-  "version": "0.1.1-3",
-  "module": "./index.ts",
-  "types": "./index.d.ts",
+  "version": "0.2.0",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "bun": "./index.ts",
-      "types": "./index.d.ts"
-    }
+    ".": "./dist/index.js"
   },
   "scripts": {
-    "build:types": "tsc"
+    "build:bundle": "bun build src/index.ts --outfile dist/index.js --external=node --target=node --footer=\"// With love from the Whatever team <3\n// https://github.com/MesterMan03/Whatever\"",
+    "build:types": "dts-bundle-generator --project tsconfig.dts.json --out-file dist/index.d.ts src/index.ts",
+    "build": "bun run build:bundle && bun run build:types",
+    "prepublishOnly": "bun run build"
   },
   "devDependencies": {
     "@types/node": "^22",
+    "dts-bundle-generator": "^9.5.1",
     "typescript": "^5"
   },
   "publishConfig": {
@@ -26,5 +27,8 @@
     "type": "git",
     "url": "git+https://github.com/MesterMan03/Whatever.git",
     "directory": "runtime"
-  }
+  },
+  "files": [
+    "dist"
+  ]
 }