@combos-fun/engine 0.0.37 → 0.0.39

package/dist/engine.cjs.js

@@ -1001,7 +1001,7 @@ class Scene extends GameObject {
 }
 
 /** Generated at build from package.json */
-const version = "0.0.37";
+const version = "0.0.39";
 
 /**
  * Sent to `window.parent` after each `System.init` completes during `Game.addSystem`
@@ -1642,6 +1642,105 @@ class Progress extends EventEmitter__default.default {
     }
 }
 
+const SLOT_DEFAULT_TYPE = {
+    image: 'png',
+    json: 'json',
+    tex: 'tex',
+    ske: 'ske',
+    audio: 'audio',
+    video: 'video',
+};
+const EXT_TO_TYPE = {
+    png: 'png',
+    jpg: 'jpg',
+    jpeg: 'jpeg',
+    webp: 'webp',
+    json: 'json',
+    tex: 'tex',
+    ske: 'ske',
+    mp3: 'audio',
+    wav: 'audio',
+    aac: 'audio',
+    ogg: 'audio',
+    mp4: 'video',
+    webm: 'video',
+    glb: 'glb',
+    gltf: 'gltf',
+};
+function extensionOf(url) {
+    const path = url.split('?')[0].split('#')[0];
+    const dot = path.lastIndexOf('.');
+    if (dot < 0)
+        return '';
+    return path.slice(dot + 1).toLowerCase();
+}
+function typeFromUrl(url, slot) {
+    return EXT_TO_TYPE[extensionOf(url)] || SLOT_DEFAULT_TYPE[slot] || 'png';
+}
+function defaultSlotForResourceType(resourceType) {
+    if (resourceType === 'AUDIO')
+        return 'audio';
+    if (resourceType === 'VIDEO')
+        return 'video';
+    return 'image';
+}
+function wrapSlot(slot, value, resourceName) {
+    if (typeof value === 'string') {
+        const url = value.trim();
+        if (!url) {
+            throw missingUrlError(resourceName, slot);
+        }
+        return { type: typeFromUrl(url, slot), url };
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Resource "${resourceName}" src.${slot} must be a url string or { type, url }.`);
+    }
+    const slotValue = value;
+    if (slotValue.type === 'data') {
+        return slotValue;
+    }
+    const url = typeof slotValue.url === 'string' ? slotValue.url.trim() : '';
+    if (!url) {
+        throw missingUrlError(resourceName, slot);
+    }
+    return {
+        ...slotValue,
+        type: slotValue.type || typeFromUrl(url, slot),
+        url,
+    };
+}
+function missingUrlError(resourceName, slot) {
+    return new Error(`Resource "${resourceName}" src.${slot}.url is required. ` +
+        `Use { type, url } (e.g. { type: "webp", url: "https://..." }). ` +
+        `A flat path string is also accepted and will be normalized.`);
+}
+/**
+ * Accept the documented `{ type, url }` slots, plus the common guesses
+ * `src: "file.png"` and `src: { image: "a.webp", json: "a.json" }`.
+ */
+function normalizeResourceSrc(src, resourceType, resourceName = '(unnamed)') {
+    if (src == null) {
+        throw new Error(`Resource "${resourceName}" src is required.`);
+    }
+    if (typeof src === 'string') {
+        const slot = defaultSlotForResourceType(resourceType);
+        return { [slot]: wrapSlot(slot, src, resourceName) };
+    }
+    if (typeof src !== 'object' || Array.isArray(src)) {
+        throw new Error(`Resource "${resourceName}" src must be a url string or a slot object.`);
+    }
+    const out = {};
+    for (const [slot, value] of Object.entries(src)) {
+        if (value == null)
+            continue;
+        out[slot] = wrapSlot(slot, value, resourceName);
+    }
+    if (Object.keys(out).length === 0) {
+        throw new Error(`Resource "${resourceName}" src has no loadable slots.`);
+    }
+    return out;
+}
+
 const resourceLoader = {
     AbstractLoadStrategy: resourceLoader$1.AbstractLoadStrategy,
     AudioLoadStrategy: resourceLoader$1.AudioLoadStrategy,
@@ -1656,6 +1755,102 @@ const resourceLoader = {
     ResourceState: resourceLoader$1.ResourceState
 };
 
+function isFrameMap(frames) {
+    return !!frames && typeof frames === 'object' && !Array.isArray(frames);
+}
+function frameFromPackedItem(item) {
+    const frame = item.frame;
+    if (!frame || typeof frame !== 'object')
+        return null;
+    return {
+        ...item,
+        frame: frame,
+        rotated: Boolean(item.rotated),
+        trimmed: Boolean(item.trimmed),
+        spriteSourceSize: item.spriteSourceSize,
+        sourceSize: item.sourceSize,
+    };
+}
+function collectArrayFrames(list, frames, animations) {
+    for (const raw of list) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const item = raw;
+        const name = String(item.filename || item.name || '');
+        if (!name)
+            continue;
+        const packed = frameFromPackedItem(item);
+        if (!packed)
+            continue;
+        frames[name] = packed;
+        const slash = name.lastIndexOf('/');
+        if (slash > 0) {
+            const anim = name.slice(0, slash);
+            if (!animations[anim])
+                animations[anim] = [];
+            if (!animations[anim].includes(name))
+                animations[anim].push(name);
+        }
+    }
+}
+/**
+ * Pixi `Spritesheet` reads `data.meta.scale` and a name→frame `frames` map.
+ * TexturePacker multi-atlas (`textures[].frames` as an array) is accepted and
+ * rewritten to that hash. Always returns a `meta.scale` so construction cannot
+ * throw `Cannot read properties of undefined (reading 'scale')`.
+ */
+function normalizeSpritesheetData(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return { frames: {}, animations: {}, meta: { scale: 1 } };
+    }
+    const json = raw;
+    if (isFrameMap(json.frames)) {
+        return {
+            ...json,
+            frames: json.frames,
+            animations: { ...(json.animations || {}) },
+            meta: { scale: 1, ...(json.meta || {}) },
+        };
+    }
+    const frames = {};
+    const animations = { ...(json.animations || {}) };
+    if (Array.isArray(json.textures)) {
+        for (const sheet of json.textures) {
+            if (!sheet || typeof sheet !== 'object')
+                continue;
+            if (Array.isArray(sheet.frames)) {
+                collectArrayFrames(sheet.frames, frames, animations);
+            }
+        }
+        const first = json.textures[0] || {};
+        const scale = first.scale ?? json.meta?.scale ?? 1;
+        return {
+            frames,
+            animations,
+            meta: {
+                scale: typeof scale === 'number' || typeof scale === 'string' ? scale : 1,
+                image: typeof first.image === 'string' ? first.image : undefined,
+                size: first.size,
+                format: first.format,
+                ...(json.meta || {}),
+            },
+        };
+    }
+    if (Array.isArray(json.frames)) {
+        collectArrayFrames(json.frames, frames, animations);
+        return {
+            frames,
+            animations,
+            meta: { scale: 1, ...(json.meta || {}) },
+        };
+    }
+    return {
+        frames: {},
+        animations,
+        meta: { scale: 1, ...(json.meta || {}) },
+    };
+}
+
 /** Resource type */
 exports.RESOURCE_TYPE = void 0;
 (function (RESOURCE_TYPE) {
@@ -1733,8 +1928,11 @@ class Resource extends EventEmitter__default.default {
                 console.warn(res.name + ' was already added');
                 continue;
             }
-            this.resourcesMap[res.name] = res;
-            this.resourcesMap[res.name].data = {};
+            this.resourcesMap[res.name] = {
+                ...res,
+                src: normalizeResourceSrc(res.src, String(res.type), res.name),
+                data: {},
+            };
         }
     }
     /** dd resource preprocesser*/
@@ -1823,6 +2021,7 @@ class Resource extends EventEmitter__default.default {
             for (const handler of this.preProcessResourceHandlers) {
                 handler(res);
             }
+            res.src = normalizeResourceSrc(res.src, String(res.type), res.name);
             for (const key in res.src) {
                 const resourceType = res.src[key].type;
                 if (resourceType === 'data') {
@@ -1949,6 +2148,8 @@ exports.componentObserver = componentObserver;
 exports.decorators = decorators;
 exports.isAllowedMessageOrigin = isAllowedMessageOrigin;
 exports.mergeAllowedMessageOrigins = mergeAllowedMessageOrigins;
+exports.normalizeResourceSrc = normalizeResourceSrc;
+exports.normalizeSpritesheetData = normalizeSpritesheetData;
 exports.parseSetPlayingMessage = parseSetPlayingMessage;
 exports.postParentGameReady = postParentGameReady;
 exports.postParentGameState = postParentGameState;