@datamoc/mw_games 0.15.0 → 0.17.0

package/tools/vendored/rgssad-wasm/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "rgssad-wasm",
+  "version": "0.0.0",
+  "type": "module",
+  "files": [
+    "rgssad_wasm_bg.wasm",
+    "rgssad_wasm.js",
+    "rgssad_wasm_bg.js",
+    "rgssad_wasm.d.ts"
+  ],
+  "module": "rgssad_wasm.js",
+  "types": "rgssad_wasm.d.ts",
+  "sideEffects": [
+    "./rgssad_wasm.js",
+    "./snippets/*"
+  ]
+}

package/tools/vendored/rgssad-wasm/rgssad_wasm.d.ts

@@ -0,0 +1,41 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* An Archive Reader
+*/
+export class Reader {
+  free(): void;
+/**
+* Make a new [`Reader`].
+*
+* Accepts either an [`Uint8Array`] or an [`ArrayBuffer`].
+* @param {any} value
+*/
+  constructor(value: any);
+/**
+* Get the next entry.
+*
+* # Arguments
+* Takes a function as an argument.
+* This function gets the file name and size as arguments.
+* If this function returns true, it is skipped.
+* If this function is absent, the entry is not skipped.
+* @param {Function | undefined} skip
+* @returns {ReaderEntry | undefined}
+*/
+  readEntry(skip?: Function): ReaderEntry | undefined;
+}
+/**
+* An entry from a [`Reader`].
+*/
+export class ReaderEntry {
+  free(): void;
+/**
+* Get the file data
+*/
+  readonly data: Uint8Array;
+/**
+* Get the file name.
+*/
+  readonly fileName: string;
+}

package/tools/vendored/rgssad-wasm/rgssad_wasm.js

@@ -0,0 +1,6 @@
+import * as wasm from "./rgssad_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./rgssad_wasm_bg.js";
+__wbg_set_wasm(wasm);
+export * from "./rgssad_wasm_bg.js";
+
+wasm.__wbindgen_start();

package/tools/vendored/rgssad-wasm/rgssad_wasm_bg.js

@@ -0,0 +1,399 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
+
+let cachedTextEncoder = new lTextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__wbindgen_export_3(idx);
+    return value;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__wbindgen_export_4();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_export_5(idx);
+    }
+}
+/**
+* An Archive Reader
+*/
+export class Reader {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Reader.prototype);
+        obj.__wbg_ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_reader_free(ptr);
+    }
+    /**
+    * Make a new [`Reader`].
+    *
+    * Accepts either an [`Uint8Array`] or an [`ArrayBuffer`].
+    * @param {any} value
+    */
+    constructor(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.reader_new(retptr, value);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeFromExternrefTable0(r1);
+            }
+            return Reader.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get the next entry.
+    *
+    * # Arguments
+    * Takes a function as an argument.
+    * This function gets the file name and size as arguments.
+    * If this function returns true, it is skipped.
+    * If this function is absent, the entry is not skipped.
+    * @param {Function | undefined} skip
+    * @returns {ReaderEntry | undefined}
+    */
+    readEntry(skip) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.reader_readEntry(retptr, this.__wbg_ptr, isLikeNone(skip) ? 0 : addToExternrefTable0(skip));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeFromExternrefTable0(r1);
+            }
+            return r0 === 0 ? undefined : ReaderEntry.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+/**
+* An entry from a [`Reader`].
+*/
+export class ReaderEntry {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ReaderEntry.prototype);
+        obj.__wbg_ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_readerentry_free(ptr);
+    }
+    /**
+    * Get the file name.
+    * @returns {string}
+    */
+    get fileName() {
+        const ret = wasm.readerentry_fileName(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+    * Get the file data
+    * @returns {Uint8Array}
+    */
+    get data() {
+        const ret = wasm.readerentry_data(this.__wbg_ptr);
+        return ret;
+    }
+}
+
+export function __wbindgen_debug_string(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbg_instanceof_Uint8Array_d8d9cb2b8e8ac1d4(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+export function __wbg_instanceof_ArrayBuffer_39ac22089b74fddb(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+export function __wbg_new_8125e318e6245eed(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+export function __wbindgen_error_new(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbindgen_string_new(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_number_new(arg0) {
+    const ret = arg0;
+    return ret;
+};
+
+export function __wbg_call_4c92f6aec1e1d6e6() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments) };
+
+export function __wbindgen_is_falsy(arg0) {
+    const ret = !arg0;
+    return ret;
+};
+
+export function __wbg_newwithlength_e5d69174d6984cd7(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+};
+
+export function __wbg_length_72e2208bbc0efc61(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+export function __wbindgen_memory() {
+    const ret = wasm.memory;
+    return ret;
+};
+
+export function __wbg_buffer_085ec1f694018c4f(arg0) {
+    const ret = arg0.buffer;
+    return ret;
+};
+
+export function __wbg_newwithbyteoffsetandlength_6da8e527659b86aa(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+export function __wbg_set_5cf90238115182c3(arg0, arg1, arg2) {
+    arg0.set(arg1, arg2 >>> 0);
+};
+
+export function __wbindgen_throw(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_export_2;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+

package/tools/vendored/rgssad-wasm/rgssad_wasm_bg.wasm.d.ts

@@ -0,0 +1,17 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export function __wbg_reader_free(a: number): void;
+export function reader_new(a: number, b: number): void;
+export function reader_readEntry(a: number, b: number, c: number): void;
+export function __wbg_readerentry_free(a: number): void;
+export function readerentry_fileName(a: number): number;
+export function readerentry_data(a: number): number;
+export function __wbindgen_export_0(a: number, b: number): number;
+export function __wbindgen_export_1(a: number, b: number, c: number, d: number): number;
+export const __wbindgen_export_2: WebAssembly.Table;
+export function __wbindgen_add_to_stack_pointer(a: number): number;
+export function __wbindgen_export_3(a: number): void;
+export function __wbindgen_export_4(): number;
+export function __wbindgen_export_5(a: number): void;
+export function __wbindgen_start(): void;

package/tools/vite.d.mts

@@ -0,0 +1,17 @@
+import type { EmitPageOptions } from './emit-page.mjs';
+
+export interface MwgPageOptions extends Omit<EmitPageOptions, 'dist' | 'assets'> {
+	/** the asset source folder, relative to the vite root; served in dev and compiled in the build. Default `'assets'`, `false` for none */
+	assets?: string | false;
+	/** write `sbom.cdx.json`, the CycloneDX SBOM of what the build ships; default true */
+	sbom?: boolean;
+}
+
+/** the vite plugin that makes `vite build` alone write a page that opens from `file://` */
+export function mwgPage(options?: MwgPageOptions): {
+	name: string;
+	config(): Record<string, unknown>;
+	configResolved(config: { root: string; command: string; build: { outDir: string } }): void;
+	generateBundle(options: unknown, bundle: Record<string, { type: string; modules?: Record<string, unknown> }>): void;
+	closeBundle(this: { meta?: { watchMode?: boolean } }): Promise<void>;
+};

package/tools/vite.mjs

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { basename, join, resolve } from 'node:path';
+import { emitPage } from './emit-page.mjs';
+import { buildArtifactSbom, serialize, shippedFiles } from './sbom.mjs';
+
+/**
+ * The vite side of a `file://` game in one plugin: `plugins: [mwgPage()]` and `vite build` alone
+ * writes a folder that opens by double-clicking, the build every example here uses.
+ *
+ * It sets the configuration that target needs (a classic IIFE bundle named `game.js`, relative
+ * urls through `base: './'`, no inlined or copied assets since they are compiled instead) and
+ * serves `assets` (default `'assets'`, `false` for none) as the public folder, so an asset path reads the same in `vite` dev as in the
+ * build. At the end of the build it runs `emitPage` over the output folder with the same
+ * options. A setting the game's own config gives explicitly still wins, since vite merges a
+ * plugin's `config` result under the user's.
+ *
+ * It also writes `sbom.cdx.json` into the output folder (`sbom: false` to skip it): a CycloneDX
+ * SBOM of what this build ships, the npm packages whose modules reached the bundle, from vite's
+ * own module graph, and every shipped file with its SHA-256. That is the inventory a player's
+ * copy actually contains, which a lockfile SBOM (`mwg-sbom`) cannot give: the lockfile lists
+ * vite and TypeScript, and cannot tell which dependencies tree-shaking kept.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import { mwgPage } from '@datamoc/mw_games/tools/vite';
+ *
+ * export default defineConfig({ plugins: [mwgPage({ assets: 'assets', singleFile: true })] });
+ * ```
+ */
+export function mwgPage(options = {}) {
+	const assets = options.assets ?? 'assets';
+	let root = process.cwd();
+	let outDir = 'dist';
+	let building = false;
+	const modules = new Set();
+	return {
+		name: 'mwg-page',
+		config() {
+			return {
+				base: './',
+				publicDir: assets || false,
+				build: {
+					target: 'es2022',
+					assetsInlineLimit: 0,
+					copyPublicDir: false,
+					//emitPage writes real .gz/.br files, so vite need not estimate them in memory
+					reportCompressedSize: false,
+					rollupOptions: {
+						output: { format: 'iife', entryFileNames: 'game.js', assetFileNames: '[name][extname]' },
+					},
+				},
+			};
+		},
+		generateBundle(_options, bundle) {
+			for (const chunk of Object.values(bundle))
+				if (chunk.type === 'chunk') for (const id of Object.keys(chunk.modules)) modules.add(id);
+		},
+		configResolved(config) {
+			root = config.root;
+			outDir = config.build.outDir;
+			building = config.command === 'build';
+		},
+		async closeBundle() {
+			//vite also closes the bundle when a dev server stops; only a real build is finished
+			if (!building || this.meta?.watchMode) return;
+			const { assets: _assets, sbom = true, ...emitOptions } = options;
+			const source = assets ? resolve(root, assets) : undefined;
+			const dist = resolve(root, outDir);
+			await emitPage({ ...emitOptions, dist, assets: source && existsSync(source) ? source : undefined });
+			if (sbom) {
+				const manifest = join(root, 'package.json');
+				const packageJson = existsSync(manifest)
+					? JSON.parse(readFileSync(manifest, 'utf8'))
+					: { name: basename(root), version: '0.0.0' };
+				const bom = buildArtifactSbom({ packageJson, modules: [...modules], files: await shippedFiles(dist) });
+				await writeFile(join(dist, 'sbom.cdx.json'), serialize(bom), 'utf8');
+			}
+		},
+	};
+}