feat(spine): Adds a Spine Package

packages/cache-buster/src/cacheBuster.ts

@@ -1,8 +1,5 @@
 import type { AssetPipe, Asset } from '@play-co/assetpack-core';
 import { createNewAssetAt, swapExt } from '@play-co/assetpack-core';
-import fs from 'fs-extra';
-
-import nodeCrc32 from '@node-rs/crc32';
 
 /**
  * Cache buster asset pipe. This pipe will add a hash to the end of the filename
@@ -28,26 +25,14 @@ export function cacheBuster(): AssetPipe
         },
         async transform(asset: Asset)
         {
-            const buffer = asset.buffer ?? fs.readFileSync(asset.path);
-
-            const hash = crc32(buffer);
+            const hash = asset.hash;
             const newFileName = swapExt(asset.filename, `-${hash}${asset.extension}`);
 
             const newAsset = createNewAssetAt(asset, newFileName);
 
-            // by attaching the buffer - we can avoid reading the file again
-            // and the final copy op will use the buffer, rather than the file path!
-            newAsset.buffer = buffer;
+            newAsset.buffer = asset.buffer;
 
             return [newAsset];
         }
     };
 }
-
-/** Calculate a CRC32 checksum. */
-export function crc32(input: string | Buffer): string
-{
-    const checksumHex = nodeCrc32.crc32(input).toString(16);
-
-    return Buffer.from(checksumHex, 'hex').toString('base64url');
-}

packages/cache-buster/test/cacheBuster.test.ts

@@ -1,7 +1,7 @@
-import { AssetPack, path } from '@play-co/assetpack-core';
-import { existsSync, readFileSync } from 'fs-extra';
+import { Asset, AssetPack, path } from '@play-co/assetpack-core';
+import { existsSync } from 'fs-extra';
 import { assetPath, createFolder, getInputDir, getOutputDir } from '../../../shared/test';
-import { cacheBuster, crc32 } from '../src';
+import { cacheBuster } from '../src';
 
 const pkg = 'cache-buster';
 
@@ -40,10 +40,10 @@ describe('CacheBuster', () =>
 
         const originalPath = path.joinSafe('.testInput', testName, 'ttf.ttf');
 
-        const buffer = readFileSync(originalPath);
-
-        const hash = crc32(buffer);
+        const asset = new Asset({
+            path: originalPath,
+        });
 
-        expect(existsSync(path.joinSafe('.testOutput', testName, `ttf-${hash}.ttf`))).toBe(true);
+        expect(existsSync(path.joinSafe('.testOutput', testName, `ttf-${asset.hash}.ttf`))).toBe(true);
     });
 });

packages/core/src/Asset.ts

@@ -1,6 +1,6 @@
 import { extractTagsFromFileName } from './utils/extractTagsFromFileName';
 import { getHash } from './utils/getHash';
-import fs from 'fs-extra';
+import { readFileSync } from 'fs-extra';
 import { Logger } from './logger/Logger';
 import { path } from './utils/path';
 
@@ -112,7 +112,7 @@ export class Asset
 
         if (!this._buffer)
         {
-            this._buffer = fs.readFileSync(this.path);
+            this._buffer = readFileSync(this.path);
         }
 
         return this._buffer;
@@ -132,7 +132,7 @@ export class Asset
             Logger.warn('[Assetpack] folders should not have hashes. Contact the developer of the Assetpack');
         }
 
-        this._hash ??= getHash(this.buffer ?? this.path);
+        this._hash ??= getHash(this.buffer);
 
         return this._hash;
     }

packages/core/src/index.ts

@@ -17,4 +17,5 @@ export * from './utils/stripTags';
 export * from './utils/merge';
 export * from './utils/path';
 export * from './utils/swapExt';
+export * from './utils/findAssetsWithFileName';
 

packages/core/src/utils/findAssetsWithFileName.ts

@@ -0,0 +1,30 @@
+import type { Asset } from '../Asset';
+
+export function findAssetsWithFileName(
+    test: (asset: Asset) => boolean,
+    asset: Asset,
+    searchTransform: boolean,
+    out: Asset[] = []
+): Asset[]
+{
+    if (test(asset))
+    {
+        out.push(asset);
+    }
+
+    for (let i = 0; i < asset.children.length; i++)
+    {
+        const child = asset.children[i];
+
+        findAssetsWithFileName(test, child, searchTransform, out);
+    }
+
+    for (let i = 0; i < asset.transformChildren.length; i++)
+    {
+        const transformChild = asset.transformChildren[i];
+
+        findAssetsWithFileName(test, transformChild, searchTransform, out);
+    }
+
+    return out;
+}

packages/manifest/src/pixiManifest.ts

@@ -3,7 +3,8 @@ import {
     type Asset,
     type AssetPipe,
     type PipeSystem,
-    path
+    path,
+    findAssetsWithFileName
 } from '@play-co/assetpack-core';
 
 import fs from 'fs-extra';
@@ -31,6 +32,36 @@ export interface PixiManifestOptions
     trimExtensions?: boolean;
 }
 
+// TODO EXPORT this out!
+export class AtlasView
+{
+    public rawAtlas: string;
+
+    constructor(buffer: Buffer)
+    {
+        this.rawAtlas = buffer.toString();
+    }
+
+    getTextures(): string[]
+    {
+        const regex = /^.+?(?:\.png|\.jpg|\.jpeg|\.webp|\.avif)$/gm;
+
+        const matches = this.rawAtlas.match(regex);
+
+        return matches as string[];
+    }
+
+    replaceTexture(filename: string, newFilename: string)
+    {
+        this.rawAtlas = this.rawAtlas.replace(filename, newFilename);
+    }
+
+    get buffer()
+    {
+        return Buffer.from(this.rawAtlas);
+    }
+}
+
 export function pixiManifest(_options: PixiManifestOptions = {}): AssetPipe<PixiManifestOptions>
 {
     const defaultOptions = {
@@ -45,6 +76,8 @@ export function pixiManifest(_options: PixiManifestOptions = {}): AssetPipe<Pixi
         defaultOptions,
         finish: async (asset: Asset, options, pipeSystem: PipeSystem) =>
         {
+            removeAtlasTextures(asset);
+
             const newFileName = path.dirname(options.output) === '.'
                 ? path.joinSafe(pipeSystem.outputPath, options.output) : options.output;
 
@@ -100,15 +133,19 @@ function collectAssets(
             {
                 bundleAssets.push({
                     alias: getShortNames(stripTags(path.relative(entryPath, `${asset.path}-${pageIndex}`)), options),
-                    src: pages.map((finalAsset) => path.relative(outputPath, finalAsset.path))
+                    src: pages
+                        .map((finalAsset) => path.relative(outputPath, finalAsset.path))
+                        .sort((a, b) => b.localeCompare(a))
                 });
             });
         }
         else
         {
             bundleAssets.push({
                 alias: getShortNames(stripTags(path.relative(entryPath, asset.path)), options),
-                src: finalAssets.map((finalAsset) => path.relative(outputPath, finalAsset.path))
+                src: finalAssets
+                    .map((finalAsset) => path.relative(outputPath, finalAsset.path))
+                    .sort((a, b) => b.localeCompare(a))
             });
         }
     }
@@ -117,6 +154,34 @@ function collectAssets(
     {
         collectAssets(child, options, outputPath, entryPath, bundles, localBundle);
     });
+
+    // for all assets.. check for atlas and remove them from the bundle..
+}
+
+function removeAtlasTextures(asset: Asset)
+{
+    // do a pass to remove what we don't want..
+
+    const atlasAssets = findAssetsWithFileName((asset) =>
+        asset.extension === '.atlas' && asset.transformChildren.length === 0, asset, true);
+
+    atlasAssets.forEach((atlasAsset) =>
+    {
+        const view = new AtlasView(atlasAsset.buffer);
+
+        const textureNames = view.getTextures();
+
+        textureNames.forEach((texture) =>
+        {
+            const textureAssets = findAssetsWithFileName((asset) =>
+                asset.filename === texture, asset, true);
+
+            textureAssets.forEach((textureAsset) =>
+            {
+                textureAsset.skip = true;
+            });
+        });
+    });
 }
 
 function getTexturePackedAssets(assets: Asset[])