@jgengine/assets 0.11.0 → 0.13.0

package/dist/download.js

@@ -29,6 +29,37 @@ export function boundedExtractFilter(matches) {
         return true;
     };
 }
+const PACK_IMAGE_EXT = /\.(png|jpe?g|webp)$/i;
+/** Flatten a glTF image URI ("../Textures/color%20map.png") to its decoded basename. */
+function imageUriBasename(uri) {
+    const decoded = (() => {
+        try {
+            return decodeURIComponent(uri);
+        }
+        catch {
+            return uri;
+        }
+    })();
+    const clean = decoded.replace(/\\/g, "/");
+    return clean.split("/").pop() ?? clean;
+}
+/**
+ * Rewrite external image URIs to flat basenames so a model always finds its
+ * texture beside itself in the pack dir, no matter how the source archive
+ * nested it ("Textures/x.png", "../texture/x.png", "x.png" all become "x.png").
+ * Returns the basenames of every external image the model references.
+ */
+function normalizeGltfImageUris(json) {
+    const referenced = [];
+    for (const image of json.images ?? []) {
+        if (image.uri === undefined || image.uri.startsWith("data:"))
+            continue;
+        const base = imageUriBasename(image.uri);
+        image.uri = base;
+        referenced.push(base);
+    }
+    return referenced;
+}
 function resolveRelative(path, pageUrl) {
     try {
         return new URL(path, pageUrl).toString();
@@ -194,23 +225,7 @@ function dedupeByBasename(archive, pattern) {
     }
     return Array.from(byName, ([file, bytes]) => ({ file, bytes })).sort((a, b) => a.file.localeCompare(b.file));
 }
-/**
- * Pack a `.gltf` + optional external `.bin` into a single `.glb` so reindex /
- * the shell only ever deal in one-file models. Strips buffer `uri` fields so
- * the binary chunk is self-contained. External image URIs stay as-is (loaders
- * resolve relative to the catalog URL only for GLB-embedded images).
- * @internal
- */
-export function packGltfToGlb(gltfBytes, binBytes) {
-    const json = JSON.parse(new TextDecoder().decode(gltfBytes));
-    if (Array.isArray(json.buffers)) {
-        for (const buffer of json.buffers) {
-            delete buffer.uri;
-            if (binBytes !== undefined)
-                buffer.byteLength = binBytes.byteLength;
-        }
-    }
-    const jsonText = JSON.stringify(json);
+function buildGlb(jsonText, binBytes) {
     const jsonPad = (4 - (jsonText.length % 4)) % 4;
     const jsonChunk = new Uint8Array(jsonText.length + jsonPad);
     new TextEncoder().encodeInto(jsonText, jsonChunk);
@@ -239,22 +254,109 @@ export function packGltfToGlb(gltfBytes, binBytes) {
     }
     return out;
 }
+/** Parse a `.glb` container into its JSON document and optional BIN chunk. Returns null for non-glb bytes. */
+function parseGlb(bytes) {
+    if (bytes.byteLength < 20)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.getUint32(0, true) !== 0x46546c67)
+        return null;
+    let offset = 12;
+    let json;
+    let bin;
+    while (offset + 8 <= bytes.byteLength) {
+        const length = view.getUint32(offset, true);
+        const kind = view.getUint32(offset + 4, true);
+        const body = bytes.subarray(offset + 8, offset + 8 + length);
+        if (kind === 0x4e4f534a) {
+            try {
+                json = JSON.parse(new TextDecoder().decode(body));
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (kind === 0x004e4942) {
+            bin = body;
+        }
+        offset += 8 + length;
+    }
+    if (json === undefined)
+        return null;
+    return bin === undefined ? { json } : { json, bin };
+}
+/**
+ * External image basenames a packed `.glb` still references (its textures must
+ * sit beside it in the pack dir). Empty for self-contained models.
+ * @internal
+ */
+export function externalGlbImages(bytes) {
+    const chunks = parseGlb(bytes);
+    if (chunks === null)
+        return [];
+    return (chunks.json.images ?? [])
+        .map((image) => image.uri)
+        .filter((uri) => uri !== undefined && !uri.startsWith("data:"))
+        .map((uri) => imageUriBasename(uri));
+}
+/** Rewrite a native `.glb`'s external image URIs to flat basenames; returns the input untouched when nothing changes. */
+function normalizeGlbImageUris(bytes) {
+    const chunks = parseGlb(bytes);
+    if (chunks === null)
+        return { bytes, referenced: [] };
+    const before = JSON.stringify(chunks.json.images ?? []);
+    const referenced = normalizeGltfImageUris(chunks.json);
+    if (referenced.length === 0 || JSON.stringify(chunks.json.images ?? []) === before) {
+        return { bytes, referenced };
+    }
+    return { bytes: buildGlb(JSON.stringify(chunks.json), chunks.bin), referenced };
+}
 /**
- * Pull every GLB out of an archive. Also converts co-located `.gltf` + `.bin`
- * pairs (Quaternius Standard packs on OpenGameArt) into `.glb` so the catalog
- * stays one-file-per-model. GLB wins when both formats share a basename.
+ * Pack a `.gltf` + optional external `.bin` into a single `.glb` so reindex /
+ * the shell only ever deal in one-file models. Strips buffer `uri` fields so
+ * the binary chunk is self-contained; external image URIs are flattened to
+ * basenames so the pack ships each referenced texture beside the models
+ * (loaders resolve the relative URI against the model's own URL).
+ * @internal
+ */
+export function packGltfToGlb(gltfBytes, binBytes) {
+    const json = JSON.parse(new TextDecoder().decode(gltfBytes));
+    if (Array.isArray(json.buffers)) {
+        for (const buffer of json.buffers) {
+            delete buffer.uri;
+            if (binBytes !== undefined)
+                buffer.byteLength = binBytes.byteLength;
+        }
+    }
+    normalizeGltfImageUris(json);
+    return buildGlb(JSON.stringify(json), binBytes);
+}
+/**
+ * Pull every GLB out of an archive, plus the textures those models reference.
+ * Converts co-located `.gltf` + `.bin` pairs (Quaternius Standard packs on
+ * OpenGameArt, KayKit bits packs) into `.glb` so the catalog stays
+ * one-file-per-model; GLB wins when both formats share a basename. External
+ * image URIs are flattened to basenames and the matching archive images are
+ * returned for writing beside the models — a pulled pack renders textured, not
+ * as white clay (#1005).
   * @internal
   */
 export function extractGlbs(archive) {
     const entries = unzipSync(archive, {
-        filter: boundedExtractFilter((file) => /\.(glb|gltf|bin)$/i.test(file.name)),
+        filter: boundedExtractFilter((file) => /\.(glb|gltf|bin)$/i.test(file.name) || PACK_IMAGE_EXT.test(file.name)),
     });
     const byDirBase = new Map();
+    const imagesByBase = new Map();
     for (const [path, bytes] of Object.entries(entries)) {
         const parts = path.replace(/\\/g, "/").split("/");
         const file = parts.pop();
         if (file === undefined || file.length === 0)
             continue;
+        if (PACK_IMAGE_EXT.test(file)) {
+            if (!imagesByBase.has(file))
+                imagesByBase.set(file, bytes);
+            continue;
+        }
         const dir = parts.join("/");
         // KayKit ships some files as `name.gltf.glb` — strip both suffixes for a clean id.
         const base = file.replace(/\.gltf\.glb$/i, "").replace(/\.(glb|gltf|bin)$/i, "");
@@ -275,20 +377,32 @@ export function extractGlbs(archive) {
         byDirBase.set(key, slot);
     }
     const byName = new Map();
+    const referenced = new Set();
     for (const [key, slot] of byDirBase) {
         const base = key.split("\0")[1];
         const file = `${base}.glb`;
+        if (byName.has(file))
+            continue;
         if (slot.glb !== undefined) {
-            if (!byName.has(file))
-                byName.set(file, slot.glb);
+            const normalized = normalizeGlbImageUris(slot.glb);
+            byName.set(file, normalized.bytes);
+            for (const image of normalized.referenced)
+                referenced.add(image);
             continue;
         }
         if (slot.gltf !== undefined) {
-            if (!byName.has(file))
-                byName.set(file, packGltfToGlb(slot.gltf, slot.bin));
+            const packed = packGltfToGlb(slot.gltf, slot.bin);
+            byName.set(file, packed);
+            for (const image of externalGlbImages(packed))
+                referenced.add(image);
         }
     }
-    return Array.from(byName, ([file, bytes]) => ({ file, bytes })).sort((a, b) => a.file.localeCompare(b.file));
+    const models = Array.from(byName, ([file, bytes]) => ({ file, bytes })).sort((a, b) => a.file.localeCompare(b.file));
+    const images = Array.from(referenced)
+        .filter((file) => imagesByBase.has(file))
+        .map((file) => ({ file, bytes: imagesByBase.get(file) }))
+        .sort((a, b) => a.file.localeCompare(b.file));
+    return { models, images };
 }
 /** Pulls every SVG/PNG out of a sprite/icon-pack archive, deduped by basename regardless of nesting depth.
  * @internal
@@ -296,23 +410,6 @@ export function extractGlbs(archive) {
 export function extractSpriteFiles(archive) {
     return dedupeByBasename(archive, /\.(svg|png)$/i);
 }
-const TEXTURE_ENTRY = /(?:^|\/)(Textures\/[^/]+)$/i;
-/** @internal */
-export function extractTextures(archive) {
-    const entries = unzipSync(archive, {
-        filter: boundedExtractFilter((file) => TEXTURE_ENTRY.test(file.name)),
-    });
-    const byRel = new Map();
-    for (const [path, bytes] of Object.entries(entries)) {
-        const match = path.match(TEXTURE_ENTRY);
-        if (match === null)
-            continue;
-        const rel = match[1];
-        if (!byRel.has(rel))
-            byRel.set(rel, bytes);
-    }
-    return Array.from(byRel, ([file, bytes]) => ({ file, bytes })).sort((a, b) => a.file.localeCompare(b.file));
-}
 /** @internal */
 export async function sha256Hex(bytes) {
     const buffer = new ArrayBuffer(bytes.byteLength);