js-game-zero 0.0.0-stage → 0.3.0

package/dist/host.js

@@ -0,0 +1,435 @@
+/*!
+ * js-game-zero 0.3.0
+ * https://github.com/Leaf-Learning/js-game-zero
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Taha Rafiq
+ * Copyright (c) 2001 Robert Penner (easing equations)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import {
+  Actor,
+  AudioUnlockState,
+  BrowserSoundAsset,
+  InputDispatcher,
+  MusicPlayer,
+  Rect,
+  ToneGenerator,
+  ZRect,
+  assetUrl,
+  audioUnlock,
+  buttonsFromBrowserButtons,
+  clampVolume,
+  collectRuntimeDiagnostics,
+  createAssetLoaders,
+  createBrowserSoundAsset,
+  createFontLoader,
+  createImageLoader,
+  createInputDispatcher,
+  createLocalStorageAdapter,
+  createMusicLoader,
+  createMusicPlayer,
+  createSeededRandom,
+  createSoundLoader,
+  createStorage,
+  createToneGenerator,
+  dispatchHook,
+  drawnOn,
+  fitTextboxFontSize,
+  getParameterNames,
+  getScreen,
+  getSourceInspector,
+  layoutText,
+  loadImages,
+  mapBrowserKeyEvent,
+  mapBrowserMouseButton,
+  mapBrowserMouseEvent,
+  mapBrowserWheelEvent,
+  normalizeColor,
+  normalizeWaveform,
+  noteToFrequency,
+  parseToneFrequency,
+  setScreen,
+  validateAssetName
+} from "./chunk-brk0rjcy.js";
+
+// packages/js-game-zero/src/inspection.ts
+var MAX_DEPTH = 6;
+var MAX_COLLECTION_SIZE = 100;
+var MAX_STRING_LENGTH = 1e4;
+function serializeGameValue(value) {
+  return serialize(value, 0, new WeakSet);
+}
+function serialize(value, depth, ancestors) {
+  if (value === null || typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    return value.length <= MAX_STRING_LENGTH ? value : `${value.slice(0, MAX_STRING_LENGTH)}…`;
+  }
+  if (typeof value === "number") {
+    if (Number.isNaN(value))
+      return tagged("Number", { value: "NaN" });
+    if (value === Infinity)
+      return tagged("Number", { value: "Infinity" });
+    if (value === -Infinity)
+      return tagged("Number", { value: "-Infinity" });
+    if (Object.is(value, -0))
+      return tagged("Number", { value: "-0" });
+    return value;
+  }
+  if (value === undefined)
+    return tagged("Undefined");
+  if (typeof value === "bigint") {
+    return tagged("BigInt", { value: String(value) });
+  }
+  if (typeof value === "symbol") {
+    return tagged("Symbol", { value: value.description ?? "" });
+  }
+  if (typeof value === "function") {
+    return tagged("Function", { name: value.name || "anonymous" });
+  }
+  if (depth >= MAX_DEPTH)
+    return tagged("Truncated", { reason: "depth" });
+  if (ancestors.has(value))
+    return tagged("Circular");
+  ancestors.add(value);
+  try {
+    if (value instanceof Actor)
+      return serializeActor(value, depth, ancestors);
+    if (value instanceof ZRect)
+      return serializeRect(value, "ZRect");
+    if (value instanceof Rect)
+      return serializeRect(value, "Rect");
+    if (value instanceof Date) {
+      return tagged("Date", {
+        value: Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
+      });
+    }
+    if (value instanceof Error) {
+      return tagged("Error", { name: value.name, message: value.message });
+    }
+    if (Array.isArray(value)) {
+      const items = value.slice(0, MAX_COLLECTION_SIZE).map((item) => serialize(item, depth + 1, ancestors));
+      if (value.length > MAX_COLLECTION_SIZE) {
+        items.push(tagged("Truncated", {
+          reason: "collection",
+          omitted: value.length - MAX_COLLECTION_SIZE
+        }));
+      }
+      return items;
+    }
+    if (value instanceof Set) {
+      return tagged("Set", {
+        values: serializeCollection([...value], depth, ancestors),
+        size: value.size
+      });
+    }
+    if (value instanceof Map) {
+      const entries = [...value.entries()].slice(0, MAX_COLLECTION_SIZE).map(([key, item]) => [
+        serialize(key, depth + 1, ancestors),
+        serialize(item, depth + 1, ancestors)
+      ]);
+      return tagged("Map", {
+        entries,
+        size: value.size,
+        ...value.size > MAX_COLLECTION_SIZE ? { omitted: value.size - MAX_COLLECTION_SIZE } : {}
+      });
+    }
+    return serializeObject(value, depth, ancestors);
+  } finally {
+    ancestors.delete(value);
+  }
+}
+var actorInternalKeys = new Set([
+  "loader",
+  "screen",
+  "_image",
+  "_surface",
+  "_pos",
+  "_anchor",
+  "_angle",
+  "_opacity",
+  "_scale",
+  "_native",
+  "sizeSource",
+  "positionSource",
+  "imageLoadPromise",
+  "_images",
+  "_fps",
+  "_loop",
+  "animationStart",
+  "clockSource"
+]);
+function serializeActor(actor, depth, ancestors) {
+  let rect = null;
+  try {
+    rect = actor.rect();
+  } catch {}
+  const properties = {};
+  for (const key of Object.keys(actor).sort()) {
+    if (actorInternalKeys.has(key))
+      continue;
+    properties[key] = readProperty(actor, key, depth + 1, ancestors);
+  }
+  return tagged("Actor", {
+    image: actor.image,
+    pos: actor.pos,
+    x: actor.x,
+    y: actor.y,
+    width: safeNumber(() => actor.width),
+    height: safeNumber(() => actor.height),
+    angle: actor.angle,
+    opacity: actor.opacity,
+    scale: actor.scale,
+    anchor: [...actor.anchor],
+    rect: rect ? serializeRect(rect, "Rect") : null,
+    properties
+  });
+}
+function serializeRect(rect, type) {
+  return tagged(type, {
+    left: rect.left,
+    top: rect.top,
+    right: rect.right,
+    bottom: rect.bottom,
+    width: rect.width,
+    height: rect.height,
+    center: [...rect.center]
+  });
+}
+function serializeObject(value, depth, ancestors) {
+  const output = {};
+  const keys = Object.keys(value).sort();
+  for (const key of keys.slice(0, MAX_COLLECTION_SIZE)) {
+    output[key] = readProperty(value, key, depth + 1, ancestors);
+  }
+  if (keys.length > MAX_COLLECTION_SIZE) {
+    output.$truncated = tagged("Truncated", {
+      reason: "collection",
+      omitted: keys.length - MAX_COLLECTION_SIZE
+    });
+  }
+  const prototype = Object.getPrototypeOf(value);
+  const constructorName = prototype?.constructor?.name;
+  if (prototype !== Object.prototype && prototype !== null && typeof constructorName === "string" && constructorName !== "Object") {
+    return tagged(constructorName || "Object", { properties: output });
+  }
+  return output;
+}
+function readProperty(value, key, depth, ancestors) {
+  try {
+    return serialize(Reflect.get(value, key), depth, ancestors);
+  } catch (error) {
+    return tagged("Unreadable", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function serializeCollection(values, depth, ancestors) {
+  const serialized = values.slice(0, MAX_COLLECTION_SIZE).map((value) => serialize(value, depth + 1, ancestors));
+  if (values.length > MAX_COLLECTION_SIZE) {
+    serialized.push(tagged("Truncated", {
+      reason: "collection",
+      omitted: values.length - MAX_COLLECTION_SIZE
+    }));
+  }
+  return serialized;
+}
+function safeNumber(read) {
+  try {
+    return serializeGameValue(read());
+  } catch {
+    return tagged("Unavailable");
+  }
+}
+function tagged(type, fields = {}) {
+  return { $type: type, ...fields };
+}
+var identifier = /^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/u;
+var unsafeProperties = new Set(["__proto__", "prototype", "constructor"]);
+function parseStatePath(source) {
+  const invalid = () => {
+    throw new TypeError(`Invalid state path: ${JSON.stringify(source)}. Use a binding with .name and [index] after it, such as player.x or fish[0].y.`);
+  };
+  if (typeof source !== "string")
+    invalid();
+  const bindingMatch = identifier.exec(source);
+  if (!bindingMatch)
+    invalid();
+  const binding = bindingMatch[0];
+  const segments = [];
+  let cursor = binding.length;
+  while (cursor < source.length) {
+    if (source[cursor] === ".") {
+      const match = identifier.exec(source.slice(cursor + 1));
+      if (!match)
+        invalid();
+      if (unsafeProperties.has(match[0]))
+        invalid();
+      segments.push(match[0]);
+      cursor += match[0].length + 1;
+      continue;
+    }
+    if (source[cursor] === "[") {
+      const end = source.indexOf("]", cursor + 1);
+      if (end === -1)
+        invalid();
+      const raw = source.slice(cursor + 1, end);
+      if (!/^\d+$/.test(raw))
+        invalid();
+      const index = Number(raw);
+      if (!Number.isSafeInteger(index))
+        invalid();
+      segments.push(index);
+      cursor = end + 1;
+      continue;
+    }
+    invalid();
+  }
+  if (unsafeProperties.has(binding))
+    invalid();
+  return { source, binding, segments };
+}
+var DRAWN = "$drawn";
+function createGameInspector(source, screen) {
+  const read = (path) => {
+    const parsed = typeof path === "string" ? parseStatePath(path) : path;
+    let value = parsed.binding === DRAWN && screen ? drawnOn(screen) : source.read(parsed.binding);
+    for (const segment of parsed.segments) {
+      if (value === null || typeof value !== "object" && typeof value !== "function") {
+        throw new TypeError(`Cannot read ${parsed.source}: ${String(segment)} has no parent value.`);
+      }
+      value = Reflect.get(value, segment);
+    }
+    return value;
+  };
+  return {
+    bindings: () => source.bindings(),
+    functions: () => source.functions(),
+    read,
+    inspect(path) {
+      if (path !== undefined)
+        return serializeGameValue(read(path));
+      const snapshot = {};
+      for (const binding of source.bindings()) {
+        try {
+          snapshot[binding] = serializeGameValue(source.read(binding));
+        } catch (error) {
+          snapshot[binding] = serializeGameValue(error);
+        }
+      }
+      return snapshot;
+    }
+  };
+}
+var hostInspectors = new WeakMap;
+function getGameInspector(handle) {
+  const source = getSourceInspector(handle);
+  if (!source)
+    return null;
+  let inspector = hostInspectors.get(source);
+  if (!inspector) {
+    inspector = createGameInspector(source, handle.screen);
+    hostInspectors.set(source, inspector);
+  }
+  return inspector;
+}
+
+// packages/js-game-zero/src/host.ts
+var assetUrl2 = assetUrl;
+var audioUnlock2 = audioUnlock;
+var buttonsFromBrowserButtons2 = buttonsFromBrowserButtons;
+var clampVolume2 = clampVolume;
+var collectRuntimeDiagnostics2 = collectRuntimeDiagnostics;
+var createAssetLoaders2 = createAssetLoaders;
+var createBrowserSoundAsset2 = createBrowserSoundAsset;
+var createFontLoader2 = createFontLoader;
+var createImageLoader2 = createImageLoader;
+var createInputDispatcher2 = createInputDispatcher;
+var createLocalStorageAdapter2 = createLocalStorageAdapter;
+var createSeededRandom2 = createSeededRandom;
+var createMusicLoader2 = createMusicLoader;
+var createMusicPlayer2 = createMusicPlayer;
+var createSoundLoader2 = createSoundLoader;
+var createStorage2 = createStorage;
+var createToneGenerator2 = createToneGenerator;
+var dispatchHook2 = dispatchHook;
+var fitTextboxFontSize2 = fitTextboxFontSize;
+var getParameterNames2 = getParameterNames;
+var getGameInspector2 = getGameInspector;
+var getScreen2 = getScreen;
+var layoutText2 = layoutText;
+var loadImages2 = loadImages;
+var mapBrowserKeyEvent2 = mapBrowserKeyEvent;
+var mapBrowserMouseButton2 = mapBrowserMouseButton;
+var mapBrowserMouseEvent2 = mapBrowserMouseEvent;
+var mapBrowserWheelEvent2 = mapBrowserWheelEvent;
+var normalizeColor2 = normalizeColor;
+var normalizeWaveform2 = normalizeWaveform;
+var parseStatePath2 = parseStatePath;
+var noteToFrequency2 = noteToFrequency;
+var parseToneFrequency2 = parseToneFrequency;
+var serializeGameValue2 = serializeGameValue;
+var setScreen2 = setScreen;
+var validateAssetName2 = validateAssetName;
+export {
+  validateAssetName2 as validateAssetName,
+  setScreen2 as setScreen,
+  serializeGameValue2 as serializeGameValue,
+  parseToneFrequency2 as parseToneFrequency,
+  parseStatePath2 as parseStatePath,
+  noteToFrequency2 as noteToFrequency,
+  normalizeWaveform2 as normalizeWaveform,
+  normalizeColor2 as normalizeColor,
+  mapBrowserWheelEvent2 as mapBrowserWheelEvent,
+  mapBrowserMouseEvent2 as mapBrowserMouseEvent,
+  mapBrowserMouseButton2 as mapBrowserMouseButton,
+  mapBrowserKeyEvent2 as mapBrowserKeyEvent,
+  loadImages2 as loadImages,
+  layoutText2 as layoutText,
+  getScreen2 as getScreen,
+  getParameterNames2 as getParameterNames,
+  getGameInspector2 as getGameInspector,
+  fitTextboxFontSize2 as fitTextboxFontSize,
+  dispatchHook2 as dispatchHook,
+  createToneGenerator2 as createToneGenerator,
+  createStorage2 as createStorage,
+  createSoundLoader2 as createSoundLoader,
+  createSeededRandom2 as createSeededRandom,
+  createMusicPlayer2 as createMusicPlayer,
+  createMusicLoader2 as createMusicLoader,
+  createLocalStorageAdapter2 as createLocalStorageAdapter,
+  createInputDispatcher2 as createInputDispatcher,
+  createImageLoader2 as createImageLoader,
+  createFontLoader2 as createFontLoader,
+  createBrowserSoundAsset2 as createBrowserSoundAsset,
+  createAssetLoaders2 as createAssetLoaders,
+  collectRuntimeDiagnostics2 as collectRuntimeDiagnostics,
+  clampVolume2 as clampVolume,
+  buttonsFromBrowserButtons2 as buttonsFromBrowserButtons,
+  audioUnlock2 as audioUnlock,
+  assetUrl2 as assetUrl,
+  ToneGenerator,
+  MusicPlayer,
+  InputDispatcher,
+  BrowserSoundAsset,
+  AudioUnlockState
+};