@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/assets/SvgSource.js

@@ -1,22 +0,0 @@
-import { resolve } from './paths.js';
-import { sanitizeSvg } from './svg.js';
-/** Shared source loading for SVG parts and skeletal artwork, including compiled data URIs. */
-export async function readSvgSource(source) {
-    if (source.trimStart().startsWith('<'))
-        return sanitizeSvg(source);
-    const url = resolve(source);
-    if (url.startsWith('data:')) {
-        const comma = url.indexOf(',');
-        if (comma < 0)
-            throw new Error(`invalid SVG data URI for ${source}`);
-        const text = /;base64/i.test(url.slice(0, comma))
-            ? new TextDecoder().decode(Uint8Array.from(atob(url.slice(comma + 1)), (c) => c.charCodeAt(0)))
-            : decodeURIComponent(url.slice(comma + 1));
-        return sanitizeSvg(text);
-    }
-    const response = await fetch(url);
-    if (!response.ok)
-        throw new Error(`SVG failed to load ${source}: ${response.status}`);
-    return sanitizeSvg(await response.text());
-}
-//# sourceMappingURL=SvgSource.js.map

package/dist/assets/SvgSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SvgSource.js","sourceRoot":"","sources":["../../src/assets/SvgSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,8FAA8F;AAC9F,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc;IACjD,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC;IACnE,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,KAAK,GAAG,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,MAAM,EAAE,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAChD,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/F,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5C,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IACD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,CAAC,QAAQ,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,MAAM,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACtF,OAAO,WAAW,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;AAC3C,CAAC"}

package/dist/assets/binary.d.ts

@@ -1,52 +0,0 @@
-import { type AssetProgress } from './paths.ts';
-/**
- * Raw asset bytes, cached and progress-reported the same way `loader.ts`'s texture cache is -
- * but renderer-free, so a Babylon-only game (or anything else that just wants an
- * `ArrayBuffer`) gets the same `load`/`isLoaded`/`release` shape a 2D game's textures already
- * have, without pulling Pixi in. `Vox.parseVox` is the direct beneficiary: it takes an
- * `ArrayBuffer` a game previously had to fetch and cache by hand.
- *
- * Kept out of `loader.ts` itself for the same reason `paths.ts` is its own file: `loader.ts`
- * is allowed to know about Pixi, `three-d` is allowed to know about Babylon, but neither
- * should have to import the other's renderer just to share a byte cache.
- *
- * @example
- * ```ts
- * import { loadBinary, getBinary } from '@datamoc/mw_games/assets';
- * import { parseVox, createVoxModel3D } from '@datamoc/mw_games/3d';
- *
- * await loadBinary(['models/rock.vox']);
- * const model = parseVox(getBinary('models/rock.vox'));
- * ```
- */
-export interface LoadBinaryOptions {
-    /** overrides the fetch used to load bytes; defaults to `globalThis.fetch` */
-    fetch?: typeof globalThis.fetch;
-}
-/** Loads and caches raw bytes for every path not already cached; a path already loaded is a no-op. */
-export declare function loadBinary(paths: string[], onProgress?: AssetProgress, options?: LoadBinaryOptions): Promise<void>;
-/** a loaded asset's raw bytes, by the same path it was loaded with */
-export declare function getBinary(path: string): ArrayBuffer;
-/**
- * true once `loadBinary` has resolved for this path and it has not since been `releaseBinary`d
- *
- * @example
- * ```ts
- * import { isBinaryLoaded } from '@datamoc/mw_games/assets';
- *
- * console.log(isBinaryLoaded('models/rock.vox')); // false until loadBinary resolves for it
- * ```
- */
-export declare function isBinaryLoaded(path: string): boolean;
-/**
- * Frees cached bytes; a path never loaded (or already released) is silently skipped.
- *
- * @example
- * ```ts
- * import { releaseBinary } from '@datamoc/mw_games/assets';
- *
- * releaseBinary(['models/rock.vox']); // frees the cached bytes once the model is placed
- * ```
- */
-export declare function releaseBinary(paths: string[]): void;
-//# sourceMappingURL=binary.d.ts.map

package/dist/assets/binary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../src/assets/binary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,iBAAiB;IACjC,6EAA6E;IAC7E,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CAChC;AAID,sGAAsG;AACtG,wBAAsB,UAAU,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,CAAC,EAAE,aAAa,EAC1B,OAAO,GAAE,iBAAsB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAInD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAEnD"}

package/dist/assets/binary.js

@@ -1,57 +0,0 @@
-import { resolve } from './paths.js';
-const cache = new Map();
-/** Loads and caches raw bytes for every path not already cached; a path already loaded is a no-op. */
-export async function loadBinary(paths, onProgress, options = {}) {
-    const doFetch = options.fetch ?? globalThis.fetch;
-    if (!doFetch)
-        throw new Error('fetch is unavailable; provide LoadBinaryOptions.fetch');
-    const pending = paths.filter((path) => !cache.has(path));
-    if (pending.length === 0) {
-        onProgress?.(1);
-        return;
-    }
-    let done = 0;
-    await Promise.all(pending.map(async (path) => {
-        const response = await doFetch(resolve(path));
-        if (!response.ok)
-            throw new Error(`failed to load binary asset "${path}": ${response.status}`);
-        cache.set(path, await response.arrayBuffer());
-        done++;
-        onProgress?.(done / pending.length);
-    }));
-}
-/** a loaded asset's raw bytes, by the same path it was loaded with */
-export function getBinary(path) {
-    const data = cache.get(path);
-    if (!data)
-        throw new Error(`binary asset "${path}" has not been loaded - pass it to loadBinary() first`);
-    return data;
-}
-/**
- * true once `loadBinary` has resolved for this path and it has not since been `releaseBinary`d
- *
- * @example
- * ```ts
- * import { isBinaryLoaded } from '@datamoc/mw_games/assets';
- *
- * console.log(isBinaryLoaded('models/rock.vox')); // false until loadBinary resolves for it
- * ```
- */
-export function isBinaryLoaded(path) {
-    return cache.has(path);
-}
-/**
- * Frees cached bytes; a path never loaded (or already released) is silently skipped.
- *
- * @example
- * ```ts
- * import { releaseBinary } from '@datamoc/mw_games/assets';
- *
- * releaseBinary(['models/rock.vox']); // frees the cached bytes once the model is placed
- * ```
- */
-export function releaseBinary(paths) {
-    for (const path of paths)
-        cache.delete(path);
-}
-//# sourceMappingURL=binary.js.map

package/dist/assets/binary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary.js","sourceRoot":"","sources":["../../src/assets/binary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAsB,MAAM,YAAY,CAAC;AA4BzD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAuB,CAAC;AAE7C,sGAAsG;AACtG,MAAM,CAAC,KAAK,UAAU,UAAU,CAC/B,KAAe,EACf,UAA0B,EAC1B,OAAO,GAAsB,EAAE;IAE/B,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAC;IAClD,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAEvF,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACzD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,OAAO;IACR,CAAC;IAED,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,MAAM,OAAO,CAAC,GAAG,CAChB,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,MAAM,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QAC/F,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;QAC9C,IAAI,EAAE,CAAC;QACP,UAAU,EAAE,CAAC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC,CAAC,CACF,CAAC;AACH,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,SAAS,CAAC,IAAY;IACrC,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,iBAAiB,IAAI,uDAAuD,CAAC,CAAC;IACzG,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IAC1C,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACxB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,KAAe;IAC5C,KAAK,MAAM,IAAI,IAAI,KAAK;QAAE,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC"}

package/dist/assets/index.d.ts

@@ -1,27 +0,0 @@
-/**
- * The `file://` story, split by how renderer-specific each piece is.
- *
- * `paths.ts` resolves an asset path against the compiled `data:` URI map (or the dev server)
- * and needs no renderer at all; `binary.ts` caches raw bytes the same renderer-free way, for
- * anything (`three-d`'s VOX loader, most directly) that wants an `ArrayBuffer` rather than a
- * decoded texture; `loader.ts` fetches and decodes textures through Pixi specifically. This
- * barrel exposes all three, so `import { load, resolve } from '@datamoc/mw_games/assets'` is
- * unchanged - but a game rendering through something else imports
- * `@datamoc/mw_games/assets/paths` or `@datamoc/mw_games/assets/binary` instead and pays
- * nothing for Pixi.
- */
-export { setBase, setAssetMap, isCompiled, paths, has, resolve } from './paths.ts';
-export type { AssetProgress } from './paths.ts';
-export { load, texture, get, isLoaded, release } from './loader.ts';
-export type { LoadAssetsOptions } from './loader.ts';
-export { loadBinary, getBinary, isBinaryLoaded, releaseBinary } from './binary.ts';
-export { sanitizeSvg, svgScaleVariants, svgDataUri, splitSvgGroups } from './svg.ts';
-export type { ScaleVariant, SvgVariant } from './svg.ts';
-export type { LoadBinaryOptions } from './binary.ts';
-export { AssetStream } from './Streaming.ts';
-export type { AssetBundle, AssetStreamOptions } from './Streaming.ts';
-export { fetchWithByteProgress } from './ByteProgress.ts';
-export type { ByteProgress, OnByteProgress } from './ByteProgress.ts';
-export { loadSvgParts, releaseSvgParts } from './SvgParts.ts';
-export type { SvgPartsOptions } from './SvgParts.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/assets/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/assets/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACnF,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACpE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACrF,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/assets/index.js

@@ -1,20 +0,0 @@
-/**
- * The `file://` story, split by how renderer-specific each piece is.
- *
- * `paths.ts` resolves an asset path against the compiled `data:` URI map (or the dev server)
- * and needs no renderer at all; `binary.ts` caches raw bytes the same renderer-free way, for
- * anything (`three-d`'s VOX loader, most directly) that wants an `ArrayBuffer` rather than a
- * decoded texture; `loader.ts` fetches and decodes textures through Pixi specifically. This
- * barrel exposes all three, so `import { load, resolve } from '@datamoc/mw_games/assets'` is
- * unchanged - but a game rendering through something else imports
- * `@datamoc/mw_games/assets/paths` or `@datamoc/mw_games/assets/binary` instead and pays
- * nothing for Pixi.
- */
-export { setBase, setAssetMap, isCompiled, paths, has, resolve } from './paths.js';
-export { load, texture, get, isLoaded, release } from './loader.js';
-export { loadBinary, getBinary, isBinaryLoaded, releaseBinary } from './binary.js';
-export { sanitizeSvg, svgScaleVariants, svgDataUri, splitSvgGroups } from './svg.js';
-export { AssetStream } from './Streaming.js';
-export { fetchWithByteProgress } from './ByteProgress.js';
-export { loadSvgParts, releaseSvgParts } from './SvgParts.js';
-//# sourceMappingURL=index.js.map

package/dist/assets/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/assets/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAGnF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAGpE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAIrF,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/assets/loader.d.ts

@@ -1,70 +0,0 @@
-import { Texture } from 'pixi.js';
-import { type AssetProgress } from './paths.ts';
-/**
- * Actually fetching and decoding assets, which is the half that needs Pixi.
- *
- * Split from `paths.ts` so path resolution stays renderer-free: a game rendering through
- * something other than Pixi (`mwg/3d` on Babylon) resolves paths through the same compiled
- * asset map and hands the fetch to its own loader, rather than importing this file at all.
- *
- * @example
- * ```ts
- * import { load, texture, isLoaded, release } from '@datamoc/mw_games/assets';
- *
- * await load(['tiles.png', 'data/level1.json']);
- * const tilesTexture = texture('tiles.png');
- * console.log(isLoaded('tiles.png')); // true
- *
- * await release(['tiles.png']); // frees the GPU texture once a zone is left for good
- * ```
- */
-export interface LoadAssetsOptions {
-    /** item 135's `LoadQueue`/`LoadingScreen` seam: 0 to 1 across the batch */
-    onProgress?: AssetProgress;
-    /**
-     * Rasterize vector sources (SVG, item 15) at this multiple of their intrinsic size.
-     * An SVG loaded once is a bitmap from then on, so a game that zooms in either asks for
-     * a bigger rasterization here or ships a soft texture; `2` doubles both dimensions, so
-     * the texture is crisp up to 2x zoom. Raster formats ignore it. Omit for the loader's
-     * own default, which is the SVG's intrinsic size.
-     */
-    resolution?: number;
-    /**
-     * Paths a game can do without - a portrait variant, an optional decal - loaded separately
-     * from the rest of the batch so one missing file never aborts every other asset the batch
-     * was loading. A path in here that fails to load is simply left unloaded: `isLoaded` reports
-     * `false` for it and `texture`'s fallback argument (or `get`'s) is what a caller reads
-     * instead, rather than every caller writing its own try/catch around `load()`.
-     */
-    optional?: readonly string[];
-    /** called once per `optional` path that failed to load, with whatever `Assets.load` threw */
-    onMissing?: (path: string, error: unknown) => void;
-}
-/**
- * Loads assets by path, giving each one an alias equal to its path.
- *
- * Load everything a scene needs before creating it; afterwards `texture()` is synchronous,
- * so game code never has to await in the middle of building a scene. Pass `onProgress` alone
- * (the original signature) or a `LoadAssetsOptions` object for the resolution option.
- */
-export declare function load(paths: string[], options?: AssetProgress | LoadAssetsOptions): Promise<void>;
-/**
- * A loaded texture, by the same path it was loaded with. `fallback` is what an `optional`
- * `load()` path was for: pass it (typically `Texture.EMPTY`) to get that back instead of a
- * throw when the path never loaded, rather than every caller writing its own `isLoaded` guard.
- */
-export declare function texture(path: string, fallback?: Texture): Texture;
-/** a loaded asset of any other kind, such as parsed JSON; `fallback` behaves as it does on `texture` */
-export declare function get<T>(path: string, fallback?: T): T;
-/** true once `load` has resolved for this path and it has not since been `release`d */
-export declare function isLoaded(path: string): boolean;
-/**
- * Frees assets `load` brought in, destroying any texture among them so it stops holding GPU
- * memory. For a game with many discrete zones - each with its own tileset or sprite sheet -
- * this is the counterpart to `world.World.unload`: that drops a map's own state, this drops
- * the assets it pointed at, once a game decides the player has left an area for good. A path
- * never loaded (or already released) is silently skipped rather than treated as an error,
- * since a game unloading a zone it may or may not have visited shouldn't have to check first.
- */
-export declare function release(paths: string[]): Promise<void>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/assets/loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/assets/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAW,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,iBAAiB;IACjC,2EAA2E;IAC3E,UAAU,CAAC,EAAE,aAAa,CAAC;IAE3B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE7B,6FAA6F;IAC7F,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnD;AA0BD;;;;;;GAMG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,aAAa,GAAG,iBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD1G;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAMjE;AAED,wGAAwG;AACxG,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAMpD;AAED,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5D"}

package/dist/assets/loader.js

@@ -1,115 +0,0 @@
-import { Assets, Texture } from 'pixi.js';
-import { resolve } from './paths.js';
-/**
- * `data:` URI MIME type to the format token Pixi's resolver expects - the authoritative source
- * when it is available, since a compiled asset's embedded bytes can differ from what its path's
- * extension suggests (`tools/compile-resources.mjs`'s `toWebp` option, item 350, compiles a
- * `sprite.png` path into `image/webp` bytes when that is smaller, keeping the `.png` key so
- * `load('sprite.png')` still works the same in dev and built modes).
- */
-const MIME_TO_FORMAT = {
-    'image/png': 'png',
-    'image/jpeg': 'jpg',
-    'image/webp': 'webp',
-    'image/gif': 'gif',
-    'image/svg+xml': 'svg',
-};
-/**
- * Loads assets by path, giving each one an alias equal to its path.
- *
- * Load everything a scene needs before creating it; afterwards `texture()` is synchronous,
- * so game code never has to await in the middle of building a scene. Pass `onProgress` alone
- * (the original signature) or a `LoadAssetsOptions` object for the resolution option.
- */
-export async function load(paths, options = {}) {
-    const { onProgress, resolution, optional, onMissing } = typeof options === 'function'
-        ? { onProgress: options, resolution: undefined, optional: undefined, onMissing: undefined }
-        : options;
-    const optionalPaths = new Set(optional ?? []);
-    const pending = paths.filter((path) => !Assets.cache.has(path));
-    const requiredPending = pending.filter((path) => !optionalPaths.has(path));
-    const optionalPending = pending.filter((path) => optionalPaths.has(path));
-    const add = (path) => {
-        const src = resolve(path);
-        const descriptor = { alias: path, src };
-        if (resolution !== undefined)
-            descriptor.data = { resolution };
-        //a compiled build's `src` is a `data:` URI, which carries no extension for Pixi's
-        //resolver to pick a parser from - `path` still does, so it is supplied explicitly
-        //instead of a game having to pass its own {src, parser} descriptor to Assets directly.
-        //The URI's own MIME type is tried first, not just `path`'s extension: `toWebp` (item
-        //350) can compile a `sprite.png` path into `data:image/webp;...` bytes when that is
-        //smaller, and the *key* deliberately stays "sprite.png" so dev and built modes agree -
-        //trusting only the stale `.png` extension here would tell Pixi's resolver to run the
-        //PNG parser over WebP bytes.
-        if (src.startsWith('data:')) {
-            const mime = /^data:([^;,]+)/.exec(src)?.[1];
-            const extension = (mime && MIME_TO_FORMAT[mime]) ?? /\.([a-z0-9]+)$/i.exec(path)?.[1];
-            if (extension)
-                descriptor.format = extension;
-        }
-        Assets.add(descriptor);
-    };
-    if (optionalPending.length === 0 && requiredPending.length === 0) {
-        onProgress?.(1);
-        return;
-    }
-    for (const path of requiredPending)
-        add(path);
-    const requiredLoad = requiredPending.length > 0 ? Assets.load(requiredPending, onProgress) : Promise.resolve();
-    //loaded one at a time and never rejected past this function: one missing optional asset
-    //must never take the required batch (or any other optional path) down with it
-    const optionalLoads = optionalPending.map(async (path) => {
-        add(path);
-        try {
-            await Assets.load(path);
-        }
-        catch (error) {
-            onMissing?.(path, error);
-        }
-    });
-    await Promise.all([requiredLoad, ...optionalLoads]);
-    if (optionalPending.length > 0 && requiredPending.length === 0)
-        onProgress?.(1);
-}
-/**
- * A loaded texture, by the same path it was loaded with. `fallback` is what an `optional`
- * `load()` path was for: pass it (typically `Texture.EMPTY`) to get that back instead of a
- * throw when the path never loaded, rather than every caller writing its own `isLoaded` guard.
- */
-export function texture(path, fallback) {
-    if (!Assets.cache.has(path)) {
-        if (fallback !== undefined)
-            return fallback;
-        throw new Error(`texture "${path}" has not been loaded - pass it to load() first`);
-    }
-    return Assets.get(path);
-}
-/** a loaded asset of any other kind, such as parsed JSON; `fallback` behaves as it does on `texture` */
-export function get(path, fallback) {
-    if (!Assets.cache.has(path)) {
-        if (fallback !== undefined)
-            return fallback;
-        throw new Error(`asset "${path}" has not been loaded - pass it to load() first`);
-    }
-    return Assets.get(path);
-}
-/** true once `load` has resolved for this path and it has not since been `release`d */
-export function isLoaded(path) {
-    return Assets.cache.has(path);
-}
-/**
- * Frees assets `load` brought in, destroying any texture among them so it stops holding GPU
- * memory. For a game with many discrete zones - each with its own tileset or sprite sheet -
- * this is the counterpart to `world.World.unload`: that drops a map's own state, this drops
- * the assets it pointed at, once a game decides the player has left an area for good. A path
- * never loaded (or already released) is silently skipped rather than treated as an error,
- * since a game unloading a zone it may or may not have visited shouldn't have to check first.
- */
-export async function release(paths) {
-    const loaded = paths.filter((path) => Assets.cache.has(path));
-    if (loaded.length === 0)
-        return;
-    await Assets.unload(loaded);
-}
-//# sourceMappingURL=loader.js.map

package/dist/assets/loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../src/assets/loader.ts"],"names":[],"mappings":"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"}

package/dist/assets/paths.d.ts

@@ -1,73 +0,0 @@
-/**
- * Where a game's assets come from, as pure path arithmetic.
- *
- * In a built game, `tools/compile-resources` has already turned every asset into a `data:`
- * URI inside a script that runs before the game does. `resolve` then hands back that URI
- * instead of a path, which is what lets the page work from `file://`: see the tool for
- * why plain files next to the page do not.
- *
- * During development there is no compiled bundle, so paths are used as they are and the
- * dev server serves them. Game code says `load('tiles.png')` either way.
- *
- * Kept separate from `loader.ts` because none of this needs a renderer. Resolving a path is
- * string-and-map work; only actually fetching and decoding an asset needs Pixi's loader. That
- * split is what lets `mwg/3d` resolve a `.glb` path through the same compiled-asset map every
- * 2D game uses while handing the fetch to Babylon, without a Babylon-only game importing
- * Pixi at all - which it did, transitively, purely because these two halves shared a file.
- *
- * @example
- * ```ts
- * import { setBase, isCompiled, paths, resolve } from '@datamoc/mw_games/assets/paths';
- *
- * setBase('assets/'); // dev-server mode; a compiled build ignores this
- *
- * if (isCompiled()) console.log('every compiled path:', paths());
- * const url = resolve('tiles.png'); // a data: URI in a compiled build, 'assets/tiles.png' in dev
- * ```
- */
-declare global {
-    interface Window {
-        __MWG_ASSETS__?: Record<string, string>;
-    }
-}
-/** points dev-mode lookups at the folder assets are served from */
-export declare function setBase(path: string): void;
-/**
- * Hands `resolve`/`has`/`paths` a game's own path-to-URI map, in place of
- * `tools/compile-resources`'s `window.__MWG_ASSETS__` convention.
- *
- * A game bundled by its own tool (Vite, say) that compiles its assets into `data:` URIs a
- * different way still wants `resolve`'s single lookup and `isCompiled`'s dev/build branch,
- * without also adopting `window.__MWG_ASSETS__` as the wire format. Passing the map here
- * makes this file agnostic to *how* the map was built, only to its shape - `{ path: uri }`,
- * the same shape `window.__MWG_ASSETS__` already is. `undefined` reverts to reading
- * `window.__MWG_ASSETS__` (or dev-server mode, if that is unset too).
- *
- * @example
- * ```ts
- * import { setAssetMap, isCompiled, resolve } from '@datamoc/mw_games/assets/paths';
- *
- * setAssetMap({ 'tiles.png': 'data:image/png;base64,...' });
- * console.log(isCompiled()); // true
- * console.log(resolve('tiles.png')); // the data: URI handed in above
- *
- * setAssetMap(undefined); // back to window.__MWG_ASSETS__ / dev-server mode
- * ```
- */
-export declare function setAssetMap(map: Record<string, string> | undefined): void;
-/** true when running against a compiled bundle rather than a dev server */
-export declare function isCompiled(): boolean;
-export declare function paths(): string[];
-export declare function has(path: string): boolean;
-/** an asset path resolved to something the browser can actually load */
-export declare function resolve(path: string): string;
-/**
- * 0 (started) to 1 (complete) - a count of assets finished, not a byte count. Pixi's own
- * loaders do not expose bytes transferred across every asset type uniformly, so this reports
- * what is actually available rather than a byte figure it cannot back with a real number.
- *
- * Lives here rather than with the loader so `Streaming.ts` can name it without either file
- * importing the other's module barrel, which is what made these two a cycle before.
- */
-export type AssetProgress = (fraction: number) => void;
-//# sourceMappingURL=paths.d.ts.map

package/dist/assets/paths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/assets/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,MAAM;QACf,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACxC;CACD;AAKD,mEAAmE;AACnE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE1C;AAKD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAAG,IAAI,CAEzE;AAOD,2EAA2E;AAC3E,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED,wBAAgB,KAAK,IAAI,MAAM,EAAE,CAEhC;AAED,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGzC;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAa5C;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC"}

package/dist/assets/paths.js

@@ -1,91 +0,0 @@
-/**
- * Where a game's assets come from, as pure path arithmetic.
- *
- * In a built game, `tools/compile-resources` has already turned every asset into a `data:`
- * URI inside a script that runs before the game does. `resolve` then hands back that URI
- * instead of a path, which is what lets the page work from `file://`: see the tool for
- * why plain files next to the page do not.
- *
- * During development there is no compiled bundle, so paths are used as they are and the
- * dev server serves them. Game code says `load('tiles.png')` either way.
- *
- * Kept separate from `loader.ts` because none of this needs a renderer. Resolving a path is
- * string-and-map work; only actually fetching and decoding an asset needs Pixi's loader. That
- * split is what lets `mwg/3d` resolve a `.glb` path through the same compiled-asset map every
- * 2D game uses while handing the fetch to Babylon, without a Babylon-only game importing
- * Pixi at all - which it did, transitively, purely because these two halves shared a file.
- *
- * @example
- * ```ts
- * import { setBase, isCompiled, paths, resolve } from '@datamoc/mw_games/assets/paths';
- *
- * setBase('assets/'); // dev-server mode; a compiled build ignores this
- *
- * if (isCompiled()) console.log('every compiled path:', paths());
- * const url = resolve('tiles.png'); // a data: URI in a compiled build, 'assets/tiles.png' in dev
- * ```
- */
-/** the base for dev-mode paths, when assets are served rather than compiled in */
-let base = '';
-/** points dev-mode lookups at the folder assets are served from */
-export function setBase(path) {
-    base = path.endsWith('/') || path === '' ? path : path + '/';
-}
-/** a path-to-URI map handed in directly, taking priority over `window.__MWG_ASSETS__` */
-let assetMap;
-/**
- * Hands `resolve`/`has`/`paths` a game's own path-to-URI map, in place of
- * `tools/compile-resources`'s `window.__MWG_ASSETS__` convention.
- *
- * A game bundled by its own tool (Vite, say) that compiles its assets into `data:` URIs a
- * different way still wants `resolve`'s single lookup and `isCompiled`'s dev/build branch,
- * without also adopting `window.__MWG_ASSETS__` as the wire format. Passing the map here
- * makes this file agnostic to *how* the map was built, only to its shape - `{ path: uri }`,
- * the same shape `window.__MWG_ASSETS__` already is. `undefined` reverts to reading
- * `window.__MWG_ASSETS__` (or dev-server mode, if that is unset too).
- *
- * @example
- * ```ts
- * import { setAssetMap, isCompiled, resolve } from '@datamoc/mw_games/assets/paths';
- *
- * setAssetMap({ 'tiles.png': 'data:image/png;base64,...' });
- * console.log(isCompiled()); // true
- * console.log(resolve('tiles.png')); // the data: URI handed in above
- *
- * setAssetMap(undefined); // back to window.__MWG_ASSETS__ / dev-server mode
- * ```
- */
-export function setAssetMap(map) {
-    assetMap = map;
-}
-function compiled() {
-    if (assetMap)
-        return assetMap;
-    return typeof window === 'undefined' ? undefined : window.__MWG_ASSETS__;
-}
-/** true when running against a compiled bundle rather than a dev server */
-export function isCompiled() {
-    return compiled() !== undefined;
-}
-export function paths() {
-    return Object.keys(compiled() ?? {});
-}
-export function has(path) {
-    const map = compiled();
-    return map ? path in map : true;
-}
-/** an asset path resolved to something the browser can actually load */
-export function resolve(path) {
-    //already a loadable URL (a synthesized tone, a canvas blob): nothing to look up
-    if (/^(data|blob):/.test(path))
-        return path;
-    const map = compiled();
-    if (!map)
-        return base + path;
-    const found = map[path];
-    if (found === undefined) {
-        throw new Error(`asset "${path}" is not in this build - check it is under the folder passed to compile-resources`);
-    }
-    return found;
-}
-//# sourceMappingURL=paths.js.map

package/dist/assets/paths.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../src/assets/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAQH,kFAAkF;AAClF,IAAI,IAAI,GAAG,EAAE,CAAC;AAEd,mEAAmE;AACnE,MAAM,UAAU,OAAO,CAAC,IAAY;IACnC,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC;AAC9D,CAAC;AAED,yFAAyF;AACzF,IAAI,QAA4C,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,WAAW,CAAC,GAAuC;IAClE,QAAQ,GAAG,GAAG,CAAC;AAChB,CAAC;AAED,SAAS,QAAQ;IAChB,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,OAAO,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC;AAC1E,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,UAAU;IACzB,OAAO,QAAQ,EAAE,KAAK,SAAS,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,KAAK;IACpB,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,GAAG,CAAC,IAAY;IAC/B,MAAM,GAAG,GAAG,QAAQ,EAAE,CAAC;IACvB,OAAO,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AACjC,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,OAAO,CAAC,IAAY;IACnC,gFAAgF;IAChF,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,MAAM,GAAG,GAAG,QAAQ,EAAE,CAAC;IACvB,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,GAAG,IAAI,CAAC;IAE7B,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACxB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACd,UAAU,IAAI,mFAAmF,CACjG,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC"}