minimojs 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/internal/AssetSystem.js

@@ -0,0 +1,281 @@
+/**
+ * Images and sounds, loaded by key. Both kinds share one queue, one progress
+ * count, one failure report, and one namespace of keys, so a game's loading
+ * screen and its retry cover every file it loads.
+ *
+ * @internal
+ */
+export class AssetSystem {
+    constructor(_soundLoader = null) {
+        this._soundLoader = _soundLoader;
+        /** @internal */
+        this._queuedImages = new Map();
+        /** @internal */
+        this._loadedImages = new Map();
+        /** @internal */
+        this._imageSources = new Map();
+        /** @internal */
+        this._imageVersions = new Map();
+        /**
+         * The asset file that declared each key, as the object passed to
+         * `loadAssets`. Keys are unique in the whole game, so a key belongs to
+         * exactly one asset file, or to `loadImage` and `createTexture`.
+         *
+         * @internal
+         */
+        this._assetFileByKey = new Map();
+        /** @internal */
+        this._registeredAssetFiles = new WeakSet();
+        /** @internal */
+        this._queuedSounds = new Map();
+        /** @internal */
+        this._loadedSounds = new Map();
+        /** @internal */
+        this._soundSources = new Map();
+    }
+    queueImage(key, src) {
+        const safeKey = key.trim();
+        const safeSrc = src.trim();
+        if (safeKey.length === 0) {
+            throw new Error("MinimoJS: Image keys must be non-empty strings.");
+        }
+        if (safeSrc.length === 0) {
+            throw new Error("MinimoJS: Image sources must be non-empty strings.");
+        }
+        this.refuseAssetFileKey(safeKey, "loadImage()");
+        this.refuseSoundKey(safeKey, "loadImage()");
+        this.enqueueImage(safeKey, safeSrc);
+    }
+    queueSound(key, src) {
+        const safeKey = key.trim();
+        const safeSrc = src.trim();
+        if (safeKey.length === 0) {
+            throw new Error("MinimoJS: Sound keys must be non-empty strings.");
+        }
+        if (safeSrc.length === 0) {
+            throw new Error("MinimoJS: Sound sources must be non-empty strings.");
+        }
+        this.refuseAssetFileKey(safeKey, "loadSound()");
+        if (this._imageSources.has(safeKey) || this._loadedImages.has(safeKey)) {
+            throw new Error(`MinimoJS: loadSound() cannot use the key "${safeKey}", which an image uses. Keys must be unique in the whole game.`);
+        }
+        this.enqueueSound(safeKey, safeSrc);
+    }
+    /**
+     * Registers a parsed asset file and queues its images. `source` is the
+     * object the game passed, which identifies the file, so loading the same
+     * file again, as a scene's `onPreload()` does on every entry, only queues
+     * images that are not loaded.
+     *
+     * Every key is checked before anything is queued, so a refused file
+     * registers nothing. Returns `true` the first time a file is registered.
+     */
+    registerAssetFile(file, source) {
+        for (const entry of file.assets) {
+            const owner = this._assetFileByKey.get(entry.key);
+            if (owner === undefined) {
+                if (this._imageSources.has(entry.key) || this._loadedImages.has(entry.key)) {
+                    throw new Error(`MinimoJS: Asset key "${entry.key}" is already registered with loadImage() or createTexture(). Keys must be unique in the whole game.`);
+                }
+                if (this._soundSources.has(entry.key)) {
+                    throw new Error(`MinimoJS: Asset key "${entry.key}" is already registered with loadSound(). Keys must be unique in the whole game.`);
+                }
+            }
+            else if (owner !== source) {
+                throw new Error(`MinimoJS: Asset key "${entry.key}" is declared by two asset files. Keys must be unique in the whole game.`);
+            }
+        }
+        for (const entry of file.assets) {
+            this._assetFileByKey.set(entry.key, source);
+            if (entry.type === "image") {
+                this.enqueueImage(entry.key, entry.src.trim());
+            }
+            else if (entry.type === "sound") {
+                this.enqueueSound(entry.key, entry.src.trim());
+            }
+        }
+        const isFirstRegistration = !this._registeredAssetFiles.has(source);
+        this._registeredAssetFiles.add(source);
+        return isFirstRegistration;
+    }
+    /** @internal */
+    enqueueImage(safeKey, safeSrc) {
+        const existingSrc = this._imageSources.get(safeKey);
+        if (existingSrc !== undefined && existingSrc !== safeSrc) {
+            throw new Error(`MinimoJS: Image key "${safeKey}" is already registered with a different source.`);
+        }
+        this._imageSources.set(safeKey, safeSrc);
+        this._queuedImages.set(safeKey, safeSrc);
+    }
+    /** @internal */
+    enqueueSound(safeKey, safeSrc) {
+        const existingSrc = this._soundSources.get(safeKey);
+        if (existingSrc !== undefined && existingSrc !== safeSrc) {
+            throw new Error(`MinimoJS: Sound key "${safeKey}" is already registered with a different source.`);
+        }
+        this._soundSources.set(safeKey, safeSrc);
+        if (!this._loadedSounds.has(safeKey)) {
+            this._queuedSounds.set(safeKey, safeSrc);
+        }
+    }
+    createTexture(key, width, height, painter) {
+        const safeKey = key.trim();
+        if (safeKey.length === 0) {
+            throw new Error("MinimoJS: Texture keys must be non-empty strings.");
+        }
+        if (typeof painter !== "function") {
+            throw new Error("MinimoJS: createTexture() requires a painter function.");
+        }
+        this.refuseAssetFileKey(safeKey, "createTexture()");
+        this.refuseSoundKey(safeKey, "createTexture()");
+        const canvas = document.createElement("canvas");
+        canvas.width = Math.max(1, Math.round(Number.isFinite(width) ? width : 1));
+        canvas.height = Math.max(1, Math.round(Number.isFinite(height) ? height : 1));
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+            throw new Error("MinimoJS: Could not acquire a texture rendering context.");
+        }
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        painter(ctx, canvas);
+        this._queuedImages.delete(safeKey);
+        this._imageSources.delete(safeKey);
+        this._loadedImages.set(safeKey, canvas);
+        this.bumpImageVersion(safeKey);
+        return canvas;
+    }
+    getImage(key) {
+        return this._loadedImages.get(key);
+    }
+    getImageVersion(key) {
+        return this._imageVersions.get(key) ?? 0;
+    }
+    hasImage(key) {
+        return this._loadedImages.has(key);
+    }
+    /** Returns a decoded sound, as the sound loader returned it, if it is loaded. */
+    getSound(key) {
+        return this._loadedSounds.get(key);
+    }
+    hasSound(key) {
+        return this._loadedSounds.has(key);
+    }
+    /** Counts the queued images and sounds that are not loaded yet. */
+    getQueuedAssetCount() {
+        let total = 0;
+        for (const key of this._queuedImages.keys()) {
+            if (!this._loadedImages.has(key)) {
+                total++;
+            }
+        }
+        for (const key of this._queuedSounds.keys()) {
+            if (!this._loadedSounds.has(key)) {
+                total++;
+            }
+        }
+        return total;
+    }
+    /**
+     * Loads every queued image and sound that is not loaded yet, settling all
+     * of them before returning instead of stopping at the first failure.
+     *
+     * Loaded files leave the queue; failed ones stay in it, so a retry loads
+     * only them. Returns the keys that failed, empty when all loaded.
+     */
+    async loadQueuedAssets(onProgress) {
+        const images = [...this._queuedImages.entries()].filter(([key]) => !this._loadedImages.has(key));
+        const sounds = [...this._queuedSounds.entries()].filter(([key]) => !this._loadedSounds.has(key));
+        const total = images.length + sounds.length;
+        let settled = 0;
+        const failed = [];
+        onProgress?.(0, total, null);
+        if (total === 0) {
+            this._queuedImages.clear();
+            this._queuedSounds.clear();
+            return failed;
+        }
+        const settle = (key) => {
+            settled += 1;
+            onProgress?.(settled, total, key);
+        };
+        await Promise.all([
+            ...images.map(async ([key, src]) => {
+                try {
+                    const image = await this.loadImage(src);
+                    this._loadedImages.set(key, image);
+                    this.bumpImageVersion(key);
+                    this._queuedImages.delete(key);
+                }
+                catch {
+                    failed.push(key);
+                }
+                settle(key);
+            }),
+            ...sounds.map(async ([key, src]) => {
+                try {
+                    if (!this._soundLoader) {
+                        throw new Error("MinimoJS: This game cannot load sounds.");
+                    }
+                    this._loadedSounds.set(key, await this._soundLoader(src));
+                    this._queuedSounds.delete(key);
+                }
+                catch {
+                    failed.push(key);
+                }
+                settle(key);
+            }),
+        ]);
+        for (const key of [...this._queuedImages.keys()]) {
+            if (this._loadedImages.has(key)) {
+                this._queuedImages.delete(key);
+            }
+        }
+        return failed;
+    }
+    /** Returns the source registered for an image or sound key, if any. */
+    getAssetSource(key) {
+        return this._imageSources.get(key) ?? this._soundSources.get(key);
+    }
+    /**
+     * Drops queued images and sounds that were not loaded, so a later load does
+     * not pick them up. Their keys may be registered again.
+     */
+    discardQueuedAssets() {
+        this._queuedImages.clear();
+        this._queuedSounds.clear();
+    }
+    /** @internal */
+    refuseSoundKey(safeKey, caller) {
+        if (this._soundSources.has(safeKey)) {
+            throw new Error(`MinimoJS: ${caller} cannot use the key "${safeKey}", which a sound uses. Keys must be unique in the whole game.`);
+        }
+    }
+    /** @internal */
+    refuseAssetFileKey(safeKey, caller) {
+        if (this._assetFileByKey.has(safeKey)) {
+            throw new Error(`MinimoJS: ${caller} cannot use the key "${safeKey}", which an asset file declares. Keys must be unique in the whole game.`);
+        }
+    }
+    /**
+     * Loads one image with a CORS request, as `fetch` loads sounds, so an image
+     * from another origin never taints the canvas and the game can still read
+     * its pixels or export it. A host that does not answer with CORS fails the
+     * image instead.
+     *
+     * @internal
+     */
+    loadImage(src) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.crossOrigin = "anonymous";
+            image.onload = () => resolve(image);
+            image.onerror = () => {
+                reject(new Error(`MinimoJS: Failed to load image "${src}".`));
+            };
+            image.src = src;
+        });
+    }
+    /** @internal */
+    bumpImageVersion(key) {
+        this._imageVersions.set(key, (this._imageVersions.get(key) ?? 0) + 1);
+    }
+}

package/dist/internal/BackgroundSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/BackgroundSystem.js

@@ -0,0 +1,26 @@
+/** @internal */
+export class BackgroundSystem {
+    constructor() {
+        /** @internal */
+        this._layers = [];
+    }
+    add(layer) {
+        this._layers.push(layer);
+        return layer;
+    }
+    destroyLayer(layer) {
+        const index = this._layers.indexOf(layer);
+        if (index !== -1) {
+            this._layers.splice(index, 1);
+        }
+    }
+    getLayers() {
+        return [...this._layers];
+    }
+    getMutableLayers() {
+        return this._layers;
+    }
+    clearAll() {
+        this._layers = [];
+    }
+}

package/dist/internal/CanvasSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/CanvasSystem.js

@@ -0,0 +1,51 @@
+/** @internal */
+export class CanvasSystem {
+    constructor(/** @internal */ canvas) {
+        this.canvas = canvas;
+        /** @internal */
+        this.onResize = () => this.applyResponsiveCanvasLayout();
+        /** @internal */
+        this.onViewportChange = () => this.applyResponsiveCanvasLayout();
+    }
+    initialize() {
+        const mountCanvas = () => {
+            if (document.body && !this.canvas.isConnected) {
+                document.body.appendChild(this.canvas);
+            }
+            this.applyResponsiveCanvasLayout();
+        };
+        if (document.body) {
+            mountCanvas();
+        }
+        else {
+            window.addEventListener("DOMContentLoaded", mountCanvas, { once: true });
+        }
+        window.addEventListener("resize", this.onResize);
+        window.visualViewport?.addEventListener("resize", this.onViewportChange);
+        window.visualViewport?.addEventListener("scroll", this.onViewportChange);
+    }
+    /** @internal */
+    applyResponsiveCanvasLayout() {
+        if (!document.body)
+            return;
+        const viewportW = Math.max(1, Math.floor(window.visualViewport?.width ??
+            window.innerWidth ??
+            document.documentElement.clientWidth ??
+            1));
+        const viewportH = Math.max(1, Math.floor(window.visualViewport?.height ??
+            window.innerHeight ??
+            document.documentElement.clientHeight ??
+            1));
+        document.body.style.margin = "0";
+        document.body.style.height = `${viewportH}px`;
+        document.body.style.minHeight = `${viewportH}px`;
+        document.body.style.display = "grid";
+        document.body.style.placeItems = "center";
+        document.body.style.touchAction = "manipulation";
+        document.body.style.overflow = "hidden";
+        const scale = Math.min(viewportW / this.canvas.width, viewportH / this.canvas.height);
+        const safeScale = Number.isFinite(scale) && scale > 0 ? scale : 1;
+        this.canvas.style.width = `${Math.floor(this.canvas.width * safeScale)}px`;
+        this.canvas.style.height = `${Math.floor(this.canvas.height * safeScale)}px`;
+    }
+}

package/dist/internal/DesignNamingCheck.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/DesignNamingCheck.js

@@ -0,0 +1,7 @@
+// A compile-time check, with no runtime code, that every property of a design
+// object, except `id` and `type`, exists on its runtime class under the same
+// name and with a compatible type (X-002). Designs use the runtime's names so
+// agents learn one vocabulary for code and files. The build fails when a
+// property is misnamed; a property that must be named differently would be
+// declared here as an explicit exception.
+export {};

package/dist/internal/ExplosionSystem.d.ts

@@ -0,0 +1 @@
+export {};