Merge branch 'feat/watch-on-complete' of https://github.com/pixijs/assetpack into feat/watch-on-complete

Author: GoodBoyDigital

packages/assetpack/src/core/AssetPack.ts

@@ -9,7 +9,8 @@ import { generateCacheName } from './utils/generateCacheName.js';
 import { path } from './utils/path.js';
 import { promiseAllConcurrent } from './utils/promiseAllConcurrent.js';
 
-import type { Asset, TransformStats } from './Asset.js';
+import type { Asset } from './Asset.js';
+import type { CachedAsset } from './AssetCache.js';
 import type { AssetPackConfig } from './config.js';
 import type { AssetPipe } from './pipes/AssetPipe.js';
 import type { AssetSettings } from './pipes/PipeSystem.js';
@@ -58,7 +59,8 @@ export class AssetPack
         const { pipes, cache, cacheLocation } = this.config;
 
         AssetCache.location = cacheLocation!;
-        let assetCache: AssetCache | undefined;
+        let assetCacheData: Record<string, CachedAsset> | null = null;
+        let assetCache: AssetCache | null = null;
 
         // if there is no cache, lets just go ahead and remove the output folder
         // and the cached info folder
@@ -77,7 +79,9 @@ export class AssetPack
 
             // read the cache data, this will be used to restore the asset graph
             // by the AssetWatcher
-            if (assetCache.exists())
+            assetCacheData = assetCache.read();
+
+            if (assetCacheData)
             {
                 Logger.info('[AssetPack] cache found.');
             }
@@ -112,7 +116,7 @@ export class AssetPack
         // so it can be restored even if the process is terminated
         this._assetWatcher = new AssetWatcher({
             entryPath: this._entryPath,
-            assetCache,
+            assetCacheData,
             ignore: this.config.ignore,
             assetSettingsData: this.config.assetSettings as AssetSettings[] || [],
             onUpdate: async (root: Asset) =>
@@ -175,7 +179,7 @@ export class AssetPack
      * @param onComplete - optional callback that will be called after each time asset pack has finished transforming the assets
      * @returns a promise that will resolve when the first time asset pack has finished transforming the assets
      */
-    public watch(onComplete: (root: Asset) => void)
+    public watch(onComplete?: (root: Asset) => void)
     {
         this._onWatchTransformComplete = onComplete;
 
@@ -194,11 +198,6 @@ export class AssetPack
         return this._assetWatcher.stop();
     }
 
-    public get rootAsset()
-    {
-        return this._assetWatcher.root;
-    }
-
     private async _transform(asset: Asset)
     {
         await this._pipeSystem.start(asset);
@@ -214,25 +213,11 @@ export class AssetPack
             {
                 if (asset.skip) return;
 
-                const stats = asset.stats = {
-                    date: Date.now(),
-                    duration: 0,
-                    success: true,
-                } as TransformStats;
-
-                const now = performance.now();
-
                 await this._pipeSystem.transform(asset).catch((e) =>
                 {
-                    stats.success = false;
-                    stats.error = e.message;
-
                     // eslint-disable-next-line max-len
                     Logger.error(`[AssetPack] Transform failed:\ntransform: ${e.name}\nasset:${asset.path}\nerror:${e.message}`);
                 });
-
-                stats.duration = performance.now() - now;
-
                 index++;
 
                 const percent = Math.round((index / assetsToTransform.length) * 100);

packages/assetpack/test/core/Assetpack.test.ts

@@ -352,115 +352,6 @@ describe('Core', () =>
         expect(rootAsset.settings).toBeUndefined();
     });
 
-    it('should generate correct stats', async () =>
-    {
-        const testName = 'core-stats';
-        const inputDir = `${getInputDir(pkg, testName)}/`;
-        const outputDir = getOutputDir(pkg, testName);
-
-        fs.removeSync(inputDir);
-
-        createFolder(
-            pkg,
-            {
-                name: testName,
-                files: [{
-                    name: 'json.json',
-                    content: assetPath('json/json.json'),
-                }],
-                folders: [],
-            });
-
-        const assetpack = new AssetPack({
-            entry: inputDir, cacheLocation: getCacheDir(pkg, testName),
-            output: outputDir,
-            cache: false
-        });
-
-        await assetpack.run();
-
-        const stats = assetpack.rootAsset.children[0].stats!;
-
-        expect(stats.date).toBeGreaterThan(0);
-        expect(stats.duration).toBeGreaterThan(0);
-        expect(stats.success).toBe(true);
-    });
-
-    it('should generate correct stats when cacheing', async () =>
-    {
-        const testName = 'core-stats-cache';
-        const inputDir = `${getInputDir(pkg, testName)}/`;
-        const outputDir = getOutputDir(pkg, testName);
-
-        fs.removeSync(inputDir);
-
-        createFolder(
-            pkg,
-            {
-                name: testName,
-                files: [{
-                    name: 'json.json',
-                    content: assetPath('json/json.json'),
-                }],
-                folders: [],
-            });
-
-        const testFile = join(inputDir, 'json.json');
-
-        const assetpack = new AssetPack({
-            entry: inputDir, cacheLocation: getCacheDir(pkg, testName),
-            output: outputDir,
-            cache: true
-        });
-
-        fs.writeJSONSync(testFile, { nice: `old value!` });
-
-        await assetpack.run();
-
-        const stats = assetpack.rootAsset.children[0].stats!;
-
-        expect(stats.date).toBeGreaterThan(0);
-        expect(stats.duration).toBeGreaterThan(0);
-        expect(stats.success).toBe(true);
-
-        //
-
-        const date = stats.date;
-
-        await assetpack.run();
-
-        // // should maintain the same stats..
-        const stats2 = assetpack.rootAsset.children[0].stats!;
-
-        expect(stats2.date).toBe(date);
-        expect(stats2.duration).toBe(stats.duration);
-        expect(stats2.success).toBe(true);
-
-        fs.writeJSONSync(testFile, { nice: 'new value!' });
-
-        await assetpack.run();
-
-        const stats3 = assetpack.rootAsset.children[0].stats!;
-
-        expect(stats3.date).toBeGreaterThan(stats.date);
-        expect(stats3.success).toBe(true);
-    });
-
-    it('should return the root asset', () =>
-    {
-        const testName = 'root-asset';
-        const inputDir = getInputDir(pkg, testName);
-        const outputDir = getOutputDir(pkg, testName);
-
-        const assetpack = new AssetPack({
-            entry: inputDir, cacheLocation: getCacheDir(pkg, testName),
-            output: outputDir,
-            cache: false
-        });
-
-        expect(assetpack.rootAsset).toBeDefined();
-    });
-
     it('should call onComplete when the asset pack run is complete when watching', async () =>
     {
         const testName = 'watch-onComplete';