@haiyue/extensions 0.1.0

package/dist/chunks/SpineAssetParser-BSDmPge1.js

@@ -0,0 +1,378 @@
+import { EngineError, EngineErrorCode } from '@haiyue/engine';
+import { ErrorRecovery, ErrorDomain } from '@haiyue/engine/core';
+
+function parseAtlas(text) {
+    const regions = new Map();
+    const lines = text.split(/\r?\n/);
+    let page = '';
+    for (let i = 0; i < lines.length; i++) {
+        const sourceLine = lines[i];
+        if (sourceLine === undefined)
+            continue;
+        const line = sourceLine.trim();
+        if (!line)
+            continue;
+        if (!line.includes(':')) {
+            const next = lines[i + 1]?.trim() ?? '';
+            if (next.startsWith('size:') || next.startsWith('format:') || next.startsWith('filter:') || next.startsWith('repeat:')) {
+                page = line;
+                continue;
+            }
+            const name = line;
+            const region = {
+                name,
+                page,
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1,
+                originalWidth: 0,
+                originalHeight: 0,
+                offsetX: 0,
+                offsetY: 0,
+                rotate: 0,
+            };
+            while (i + 1 < lines.length) {
+                const propertyLine = lines[i + 1];
+                if (propertyLine === undefined || !propertyLine.includes(':'))
+                    break;
+                i++;
+                const separator = propertyLine.indexOf(':');
+                const key = propertyLine.slice(0, separator).trim();
+                const raw = propertyLine.slice(separator + 1).trim();
+                const nums = raw.split(',').map(Number);
+                const numberAt = (index, fallback) => {
+                    const value = nums[index];
+                    return value !== undefined && Number.isFinite(value) ? value : fallback;
+                };
+                if (key === 'rotate')
+                    region.rotate = raw === 'true' ? 90 : raw === 'false' ? 0 : Number(raw) || 0;
+                if (key === 'bounds') {
+                    region.x = numberAt(0, region.x);
+                    region.y = numberAt(1, region.y);
+                    region.width = numberAt(2, region.width);
+                    region.height = numberAt(3, region.height);
+                }
+                if (key === 'xy') {
+                    region.x = numberAt(0, region.x);
+                    region.y = numberAt(1, region.y);
+                }
+                if (key === 'size') {
+                    region.width = numberAt(0, region.width);
+                    region.height = numberAt(1, region.height);
+                }
+                if (key === 'orig') {
+                    region.originalWidth = numberAt(0, region.originalWidth);
+                    region.originalHeight = numberAt(1, region.originalHeight);
+                }
+                if (key === 'offsets') {
+                    region.offsetX = numberAt(0, region.offsetX);
+                    region.offsetY = numberAt(1, region.offsetY);
+                    region.originalWidth = numberAt(2, region.originalWidth);
+                    region.originalHeight = numberAt(3, region.originalHeight);
+                }
+                if (key === 'offset') {
+                    region.offsetX = numberAt(0, region.offsetX);
+                    region.offsetY = numberAt(1, region.offsetY);
+                }
+            }
+            if (!region.originalWidth && !region.originalHeight) {
+                region.originalWidth = region.width;
+                region.originalHeight = region.height;
+            }
+            regions.set(name, region);
+        }
+    }
+    return regions;
+}
+function resolveAtlasPageImageUrl(options, atlas, page) {
+    const mapped = options.imageUrls[page] ?? options.imageUrls[page.split('/').pop() ?? page];
+    if (mapped)
+        return mapped;
+    if (options.imageUrl && (!page || atlasPageCount(atlas) <= 1))
+        return options.imageUrl;
+    if (!page) {
+        if (options.imageUrl)
+            return options.imageUrl;
+        throw new EngineError(EngineErrorCode.AssetInvalidData, 'Spine imageUrl is required when atlas has no page.', {
+            domain: ErrorDomain.Component,
+            recovery: ErrorRecovery.ReleaseResource,
+            context: { atlasUrl: options.atlasUrl, resourceType: 'skeleton/spine-atlas' },
+            path: 'spine.atlas.pages',
+        });
+    }
+    return new URL(page, options.atlasUrl || window.location.href).href;
+}
+function atlasPageCount(atlas) {
+    return new Set(Array.from(atlas.values()).map(region => region.page).filter(Boolean)).size;
+}
+
+function normalizeSpineData(input) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw invalidSpineData('Spine JSON root must be an object.', 'spine');
+    }
+    const record = input;
+    if (!Array.isArray(record.bones))
+        throw invalidSpineData('Spine JSON bones must be an array.', 'spine.bones');
+    if (!Array.isArray(record.slots))
+        throw invalidSpineData('Spine JSON slots must be an array.', 'spine.slots');
+    for (const [index, bone] of record.bones.entries()) {
+        if (typeof bone !== 'object' || bone === null || typeof bone.name !== 'string') {
+            throw invalidSpineData(`Spine bone ${index} must include a string name.`, `spine.bones[${index}].name`);
+        }
+    }
+    for (const [index, slot] of record.slots.entries()) {
+        if (typeof slot !== 'object' || slot === null || typeof slot.name !== 'string') {
+            throw invalidSpineData(`Spine slot ${index} must include a string name.`, `spine.slots[${index}].name`);
+        }
+    }
+    return normalizeValidatedSpineData(record);
+}
+// Spine JSON is an open, version-dependent third-party schema. Dynamic access is
+// intentionally confined to this normalization adapter; domain code consumes SpineData.
+function normalizeValidatedSpineData(input) {
+    const skins = {};
+    const skinConstraints = {};
+    if (Array.isArray(input.skins)) {
+        for (const skin of input.skins) {
+            const name = skin.name || 'default';
+            skins[name] = normalizeSkinAttachments(skin.attachments);
+            skinConstraints[name] = {
+                ik: skin.ik ?? [],
+                transform: skin.transform ?? [],
+                path: skin.path ?? [],
+                slider: skin.slider ?? skin.sliders ?? [],
+            };
+        }
+    }
+    else {
+        for (const [name, attachments] of Object.entries(input.skins ?? {})) {
+            skins[name] = normalizeSkinAttachments(attachments);
+        }
+        for (const name of Object.keys(skins))
+            skinConstraints[name] = { ik: [], transform: [], path: [], slider: [] };
+    }
+    resolveLinkedMeshes(skins);
+    const constraints = Array.isArray(input.constraints)
+        ? input.constraints.map((constraint, index) => ({ ...constraint, __order: index }))
+        : null;
+    const ikConstraints = constraints
+        ? constraints.filter(constraint => constraint.type === 'ik')
+        : (input.ik ?? []);
+    const transformConstraints = constraints
+        ? constraints.filter(constraint => constraint.type === 'transform')
+        : (input.transform ?? []);
+    const pathConstraints = constraints
+        ? constraints.filter(constraint => constraint.type === 'path')
+        : (input.path ?? []);
+    const sliderConstraints = constraints
+        ? constraints.filter(constraint => constraint.type === 'slider')
+        : (input.sliders ?? input.slider ?? []);
+    return {
+        bones: (input.bones ?? []).map(bone => ({
+            name: bone.name,
+            ...(bone.parent === undefined ? {} : { parent: bone.parent }),
+            ...(bone.inherit === undefined ? {} : { inherit: bone.inherit }),
+            x: bone.x ?? 0,
+            y: bone.y ?? 0,
+            rotation: bone.rotation ?? 0,
+            shearX: bone.shearX ?? 0,
+            shearY: bone.shearY ?? 0,
+            scaleX: bone.scaleX ?? 1,
+            scaleY: bone.scaleY ?? 1,
+            length: bone.length ?? 0,
+        })),
+        ik: ikConstraints.map((constraint, index) => ({
+            name: constraint.name,
+            order: constraint.order ?? constraint.__order ?? index,
+            skin: constraint.skin ?? false,
+            bones: constraint.bones ?? [],
+            target: constraint.target ?? constraint.source ?? '',
+            mix: constraint.mix ?? 1,
+            softness: constraint.softness ?? 0,
+            bendPositive: constraint.bendPositive ?? true,
+        })),
+        transform: transformConstraints.map((constraint, index) => ({
+            name: constraint.name,
+            order: constraint.order ?? constraint.__order ?? index,
+            skin: constraint.skin ?? false,
+            bones: constraint.bones ?? [],
+            target: constraint.target ?? constraint.source ?? '',
+            rotation: constraint.rotation ?? 0,
+            x: constraint.x ?? 0,
+            y: constraint.y ?? 0,
+            scaleX: constraint.scaleX ?? 0,
+            scaleY: constraint.scaleY ?? 0,
+            shearY: constraint.shearY ?? 0,
+            ...normalizeTransformMixes(constraint),
+            localSource: constraint.localSource ?? false,
+            localTarget: constraint.localTarget ?? false,
+            additive: constraint.additive ?? false,
+        })),
+        path: pathConstraints.map((constraint, index) => ({
+            name: constraint.name,
+            order: constraint.order ?? constraint.__order ?? index,
+            skin: constraint.skin ?? false,
+            bones: constraint.bones ?? [],
+            slot: constraint.slot ?? '',
+            position: constraint.position ?? 0,
+            spacing: constraint.spacing ?? 0,
+            mixRotate: constraint.mixRotate ?? 1,
+            mixX: constraint.mixX ?? 1,
+            mixY: constraint.mixY ?? constraint.mixX ?? 1,
+            positionMode: constraint.positionMode ?? 'percent',
+            spacingMode: constraint.spacingMode ?? 'length',
+            rotateMode: constraint.rotateMode ?? 'tangent',
+            offsetRotation: constraint.rotation ?? 0,
+        })),
+        sliders: sliderConstraints.map((constraint, index) => ({
+            name: constraint.name,
+            order: constraint.order ?? constraint.__order ?? index,
+            skin: constraint.skin ?? false,
+            animation: constraint.animation ?? '',
+            ...(constraint.bone === undefined ? {} : { bone: constraint.bone }),
+            property: constraint.property ?? 'rotate',
+            scale: constraint.scale ?? 1,
+            offset: constraint.offset ?? 0,
+            loop: constraint.loop ?? false,
+            local: constraint.local ?? false,
+            mix: constraint.mix ?? 1,
+        })),
+        slots: (input.slots ?? []).map(slot => {
+            const color = parseColor(slot.color);
+            return {
+                name: slot.name,
+                bone: slot.bone,
+                ...(slot.attachment === undefined ? {} : { attachment: slot.attachment }),
+                ...(color === undefined ? {} : { color }),
+                blend: slot.blend ?? 'normal',
+            };
+        }),
+        skins,
+        skinConstraints,
+        animations: input.animations ?? {},
+    };
+}
+function invalidSpineData(message, path) {
+    return new EngineError(EngineErrorCode.AssetInvalidData, message, {
+        domain: ErrorDomain.Component,
+        recovery: ErrorRecovery.ReleaseResource,
+        context: { resourceType: 'skeleton/spine' },
+        path,
+    });
+}
+function parseColor(value) {
+    if (!value || value.length < 8)
+        return undefined;
+    return [
+        parseInt(value.slice(0, 2), 16) / 255,
+        parseInt(value.slice(2, 4), 16) / 255,
+        parseInt(value.slice(4, 6), 16) / 255,
+        parseInt(value.slice(6, 8), 16) / 255,
+    ];
+}
+function resolveLinkedMeshes(skins) {
+    for (const [skinName, skin] of Object.entries(skins)) {
+        for (const [slotName, attachments] of Object.entries(skin)) {
+            for (const [attachmentName, attachment] of Object.entries(attachments)) {
+                if (attachment.type !== 'linkedmesh')
+                    continue;
+                const sourceSkinName = attachment.skin ?? skinName;
+                const sourceName = attachment.source ?? attachmentName;
+                const source = skins[sourceSkinName]?.[slotName]?.[sourceName] ?? skins.default?.[slotName]?.[sourceName];
+                if (!source)
+                    continue;
+                attachments[attachmentName] = {
+                    ...source,
+                    ...attachment,
+                    type: source.type ?? 'mesh',
+                    ...(source.uvs === undefined ? {} : { uvs: source.uvs }),
+                    ...(source.triangles === undefined ? {} : { triangles: source.triangles }),
+                    ...(source.vertices === undefined ? {} : { vertices: source.vertices }),
+                    ...(source.vertexCount === undefined ? {} : { vertexCount: source.vertexCount }),
+                };
+            }
+        }
+    }
+}
+function normalizeSkinAttachments(attachments) {
+    const normalized = {};
+    for (const [slotName, slotAttachments] of Object.entries(attachments ?? {})) {
+        normalized[slotName] = {};
+        for (const [attachmentName, attachment] of Object.entries(slotAttachments ?? {})) {
+            const { color: rawColor, ...attachmentFields } = attachment;
+            const color = typeof rawColor === 'string' ? parseColor(rawColor) : rawColor;
+            normalized[slotName][attachmentName] = {
+                ...attachmentFields,
+                name: attachment.name ?? attachmentName,
+                path: attachment.path ?? attachment.name ?? attachmentName,
+                x: attachment.x ?? 0,
+                y: attachment.y ?? 0,
+                rotation: attachment.rotation ?? 0,
+                scaleX: attachment.scaleX ?? 1,
+                scaleY: attachment.scaleY ?? 1,
+                width: attachment.width ?? 0,
+                height: attachment.height ?? 0,
+                ...(color === undefined ? {} : { color }),
+            };
+        }
+    }
+    return normalized;
+}
+function normalizeTransformMixes(constraint) {
+    const targets = getTransformPropertyTargets(constraint.properties);
+    if (!targets) {
+        return {
+            mixRotate: constraint.mixRotate ?? 1,
+            mixX: constraint.mixX ?? 1,
+            mixY: constraint.mixY ?? constraint.mixX ?? 1,
+            mixScaleX: constraint.mixScaleX ?? 1,
+            mixScaleY: constraint.mixScaleY ?? constraint.mixScaleX ?? 1,
+            mixShearY: constraint.mixShearY ?? 1,
+        };
+    }
+    return {
+        mixRotate: targets.rotate ? constraint.mixRotate ?? 1 : 0,
+        mixX: targets.x ? constraint.mixX ?? 1 : 0,
+        mixY: targets.y ? constraint.mixY ?? constraint.mixX ?? 1 : 0,
+        mixScaleX: targets.scaleX ? constraint.mixScaleX ?? 1 : 0,
+        mixScaleY: targets.scaleY ? constraint.mixScaleY ?? constraint.mixScaleX ?? 1 : 0,
+        mixShearY: targets.shearY ? constraint.mixShearY ?? 1 : 0,
+    };
+}
+function getTransformPropertyTargets(properties) {
+    if (!properties || typeof properties !== 'object')
+        return null;
+    const targets = { rotate: false, x: false, y: false, scaleX: false, scaleY: false, shearY: false };
+    let hasTarget = false;
+    for (const from of Object.values(properties)) {
+        if (!from || typeof from !== 'object')
+            continue;
+        const to = from.to;
+        if (!to || typeof to !== 'object')
+            continue;
+        for (const name of Object.keys(to)) {
+            if (name in targets) {
+                targets[name] = true;
+                hasTarget = true;
+            }
+        }
+    }
+    return hasTarget ? targets : null;
+}
+
+const SPINE_ASSET_PARSER = Object.freeze({
+    type: 'skeleton/spine',
+    parse(input, _context) {
+        return {
+            data: normalizeSpineData(input.json),
+            regions: [...parseAtlas(input.atlasText).entries()],
+        };
+    },
+});
+function parseSpineAssetPayload(input) {
+    return SPINE_ASSET_PARSER.parse(input, { source: 'spine' });
+}
+
+export { SPINE_ASSET_PARSER as S, parseSpineAssetPayload as a, normalizeSpineData as n, parseAtlas as p, resolveAtlasPageImageUrl as r };
+//# sourceMappingURL=SpineAssetParser-BSDmPge1.js.map