ttmg-pack 0.4.4 → 0.4.5

package/__TEST__/tests/runner.js

@@ -0,0 +1,102 @@
+const fs = require('fs');
+const path = require('path');
+
+const tests = [];
+const describeStack = [];
+let currentDescribe = null;
+
+function describe(name, fn) {
+  const suite = { name, tests: [], children: [] };
+  if (currentDescribe) {
+    currentDescribe.children.push(suite);
+  } else {
+    tests.push(suite);
+  }
+  describeStack.push(currentDescribe);
+  currentDescribe = suite;
+  try {
+    fn();
+  } finally {
+    currentDescribe = describeStack.pop();
+  }
+}
+
+function it(name, fn) {
+  if (!currentDescribe) {
+    throw new Error('it() must be called inside describe()');
+  }
+  currentDescribe.tests.push({ name, fn });
+}
+
+let passed = 0;
+let failed = 0;
+
+async function runSuite(suite, indent = 0) {
+  console.log(`${'  '.repeat(indent)}${suite.name}`);
+  for (const test of suite.tests) {
+    try {
+      if (test.fn.constructor.name === 'AsyncFunction') {
+        await test.fn();
+      } else {
+        test.fn();
+      }
+      console.log(`${'  '.repeat(indent + 1)}✓ ${test.name}`);
+      passed++;
+    } catch (error) {
+      console.log(`${'  '.repeat(indent + 1)}✗ ${test.name}`);
+      console.log(`${'  '.repeat(indent + 2)}${error.message}`);
+      if (error.stack) {
+        console.log(`${'  '.repeat(indent + 2)}${error.stack.split('\n').slice(1).join('\n' + '  '.repeat(indent + 2))}`);
+      }
+      failed++;
+    }
+  }
+  for (const child of suite.children) {
+    await runSuite(child, indent + 1);
+  }
+}
+
+async function runTests() {
+  console.log('========================================');
+  console.log('Running unit tests');
+  console.log('========================================\n');
+
+  const testFiles = [
+    'utils/getMd5.test.js',
+    'utils/Deferred.test.js',
+    'utils/getGameEngine.test.js',
+    'utils/getSubpackagesConfig.test.js',
+    'utils/getIndependentPackagesConfig.test.js',
+    'utils/asyncPool.test.js',
+    'utils/unity.test.js',
+    'utils/getCheckConfig.test.js',
+    'libs/checkProject.test.js'
+  ];
+
+  for (const file of testFiles) {
+    const testPath = path.join(__dirname, file);
+    if (fs.existsSync(testPath)) {
+      console.log(`Loading tests from: ${file}`);
+      require(testPath);
+    }
+  }
+
+  console.log('\n');
+
+  for (const suite of tests) {
+    await runSuite(suite);
+  }
+
+  console.log('\n========================================');
+  console.log('Test Summary:');
+  console.log(`  Passed: ${passed}`);
+  console.log(`  Failed: ${failed}`);
+  console.log('========================================');
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+global.describe = describe;
+global.it = it;
+
+runTests();

package/__TEST__/tests/utils/Deferred.test.js

@@ -0,0 +1,69 @@
+const assert = require('assert');
+const { Deferred } = require('../../../dist/utils/Deferred');
+
+describe('Deferred', function() {
+  it('should create a deferred object with promise', function() {
+    const deferred = new Deferred();
+    assert(deferred.promise instanceof Promise);
+    assert.strictEqual(typeof deferred.resolve, 'function');
+    assert.strictEqual(typeof deferred.reject, 'function');
+  });
+
+  it('should resolve successfully', async function() {
+    const deferred = new Deferred();
+    const testValue = 'success';
+    
+    setTimeout(() => deferred.resolve(testValue), 10);
+    
+    const result = await deferred.promise;
+    assert.strictEqual(result, testValue);
+  });
+
+  it('should reject with error', async function() {
+    const deferred = new Deferred();
+    const testError = new Error('test error');
+    
+    setTimeout(() => deferred.reject(testError), 10);
+    
+    try {
+      await deferred.promise;
+      assert.fail('Promise should have rejected');
+    } catch (error) {
+      assert.strictEqual(error, testError);
+    }
+  });
+
+  it('should support then method', async function() {
+    const deferred = new Deferred();
+    const testValue = 'test';
+    
+    setTimeout(() => deferred.resolve(testValue), 10);
+    
+    const result = await deferred.then(val => val.toUpperCase());
+    assert.strictEqual(result, 'TEST');
+  });
+
+  it('should support catch method', async function() {
+    const deferred = new Deferred();
+    const testError = new Error('catch me');
+    
+    setTimeout(() => deferred.reject(testError), 10);
+    
+    const caught = await deferred.catch(err => err.message);
+    assert.strictEqual(caught, 'catch me');
+  });
+
+  it('should handle resolve called multiple times', async function() {
+    const deferred = new Deferred();
+    let resolveCount = 0;
+    
+    deferred.promise.then(() => resolveCount++);
+    
+    deferred.resolve('first');
+    deferred.resolve('second');
+    
+    await new Promise(resolve => setTimeout(resolve, 10));
+    
+    assert.strictEqual(resolveCount, 1);
+  });
+});

package/__TEST__/tests/utils/asyncPool.test.js

@@ -0,0 +1,48 @@
+const assert = require('assert');
+const { asyncPool } = require('../../../dist/utils/asyncPool');
+
+describe('asyncPool', function() {
+  it('should execute all tasks with pool limit', async function() {
+    const tasks = [1, 2, 3, 4, 5];
+    const results = [];
+    
+    const iteratorFn = async (item) => {
+      await new Promise(resolve => setTimeout(resolve, 10));
+      results.push(item);
+      return item * 2;
+    };
+    
+    const finalResults = await asyncPool(2, tasks, iteratorFn);
+    
+    assert.deepStrictEqual(finalResults, [2, 4, 6, 8, 10]);
+    assert.strictEqual(results.length, 5);
+  });
+
+  it('should handle empty array', async function() {
+    const results = await asyncPool(5, [], async () => {});
+    assert.deepStrictEqual(results, []);
+  });
+
+  it('should handle pool limit larger than array length', async function() {
+    const tasks = [1, 2, 3];
+    const iteratorFn = async (item) => item;
+    
+    const results = await asyncPool(10, tasks, iteratorFn);
+    assert.deepStrictEqual(results, [1, 2, 3]);
+  });
+
+  it('should propagate errors', async function() {
+    const tasks = [1, 2, 3];
+    const iteratorFn = async (item) => {
+      if (item === 2) throw new Error('Test error');
+      return item;
+    };
+    
+    try {
+      await asyncPool(2, tasks, iteratorFn);
+      assert.fail('Should have thrown an error');
+    } catch (error) {
+      assert.strictEqual(error.message, 'Test error');
+    }
+  });
+});

package/__TEST__/tests/utils/getCheckConfig.test.js

@@ -0,0 +1,24 @@
+const assert = require('assert');
+const path = require('path');
+const { getCheckConfig } = require('../../../dist/utils/getCheckConfig');
+const { GAME_PKG_SIZE_LIMIT } = require('../../../dist/constants');
+
+const fixturesPath = path.join(__dirname, '../fixtures');
+
+describe('getCheckConfig', function() {
+  it('should return unity config for unity engine', function() {
+    const config = getCheckConfig({
+      entry: path.join(fixturesPath, 'game-unity')
+    });
+    assert.strictEqual(config.pkgSizeLimit, GAME_PKG_SIZE_LIMIT.unity.project);
+  });
+
+  it('should return default config for non-unity engine', function() {
+    const config = getCheckConfig({
+      entry: path.join(fixturesPath, 'game-cocos')
+    });
+    assert.strictEqual(config.pkgSizeLimit, 30 * 1024 * 1024);
+    assert.strictEqual(config.mainPkgSizeLimit, 4 * 1024 * 1024);
+    assert.strictEqual(config.independentSubPkgSizeLimit, 4 * 1024 * 1024);
+  });
+});

package/__TEST__/tests/utils/getGameEngine.test.js

@@ -0,0 +1,32 @@
+const assert = require('assert');
+const path = require('path');
+const { getGameEngine } = require('../../../dist/utils/getGameEngine');
+
+const fixturesPath = path.join(__dirname, '../fixtures');
+
+describe('getGameEngine', function() {
+  it('should return unity when gameEngine is unity', function() {
+    const result = getGameEngine(path.join(fixturesPath, 'game-unity'));
+    assert.strictEqual(result, 'unity');
+  });
+
+  it('should return cocos when gameEngine is cocos', function() {
+    const result = getGameEngine(path.join(fixturesPath, 'game-cocos'));
+    assert.strictEqual(result, 'cocos');
+  });
+
+  it('should return unknown when game.json does not exist', function() {
+    const result = getGameEngine(path.join(fixturesPath, 'game-no-config'));
+    assert.strictEqual(result, 'unknown');
+  });
+
+  it('should return unknown when game.json has invalid JSON', function() {
+    const result = getGameEngine(path.join(fixturesPath, 'game-invalid-json'));
+    assert.strictEqual(result, 'unknown');
+  });
+
+  it('should return unknown when game.json does not have gameEngine field', function() {
+    const result = getGameEngine(path.join(fixturesPath, 'game-no-engine'));
+    assert.strictEqual(result, 'unknown');
+  });
+});

package/__TEST__/tests/utils/getIndependentPackagesConfig.test.js

@@ -0,0 +1,27 @@
+const assert = require('assert');
+const path = require('path');
+const { getIndependentPackagesConfig } = require('../../../dist/utils/getIndependentPackagesConfig');
+
+const fixturesPath = path.join(__dirname, '../fixtures');
+
+describe('getIndependentPackagesConfig', function() {
+  it('should return independent subpackages', function() {
+    const result = getIndependentPackagesConfig(path.join(fixturesPath, 'game-unity'));
+    assert(Array.isArray(result));
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].name, 'sub2');
+    assert.strictEqual(result[0].independent, true);
+  });
+
+  it('should return empty array when game.json does not exist', function() {
+    const result = getIndependentPackagesConfig(path.join(fixturesPath, 'game-no-config'));
+    assert(Array.isArray(result));
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('should return empty array when game.json has invalid JSON', function() {
+    const result = getIndependentPackagesConfig(path.join(fixturesPath, 'game-invalid-json'));
+    assert(Array.isArray(result));
+    assert.strictEqual(result.length, 0);
+  });
+});

package/__TEST__/tests/utils/getMd5.test.js

@@ -0,0 +1,31 @@
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const { getMd5 } = require('../../../dist/utils/getMd5');
+
+describe('getMd5', function() {
+  it('should return correct MD5 hash for string input', function() {
+    const testStr = 'hello world';
+    const expected = '5eb63bbbe01eeed093cb22bb8f5acdc3';
+    const result = getMd5(testStr);
+    assert.strictEqual(result, expected);
+  });
+
+  it('should return consistent hash for same input', function() {
+    const testStr = 'test string';
+    const result1 = getMd5(testStr);
+    const result2 = getMd5(testStr);
+    assert.strictEqual(result1, result2);
+  });
+
+  it('should return different hash for different input', function() {
+    const result1 = getMd5('string1');
+    const result2 = getMd5('string2');
+    assert.notStrictEqual(result1, result2);
+  });
+
+  it('should handle empty string', function() {
+    const result = getMd5('');
+    assert.strictEqual(result, 'd41d8cd98f00b204e9800998ecf8427e');
+  });
+});

package/__TEST__/tests/utils/getSubpackagesConfig.test.js

@@ -0,0 +1,26 @@
+const assert = require('assert');
+const path = require('path');
+const { getSubpackagesConfig } = require('../../../dist/utils/getSubpackagesConfig');
+
+const fixturesPath = path.join(__dirname, '../fixtures');
+
+describe('getSubpackagesConfig', function() {
+  it('should return non-independent subpackages', function() {
+    const result = getSubpackagesConfig(path.join(fixturesPath, 'game-unity'));
+    assert(Array.isArray(result));
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].name, 'sub1');
+  });
+
+  it('should return empty array when game.json does not exist', function() {
+    const result = getSubpackagesConfig(path.join(fixturesPath, 'game-no-config'));
+    assert(Array.isArray(result));
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('should return empty array when game.json has invalid JSON', function() {
+    const result = getSubpackagesConfig(path.join(fixturesPath, 'game-invalid-json'));
+    assert(Array.isArray(result));
+    assert.strictEqual(result.length, 0);
+  });
+});

package/__TEST__/tests/utils/unity.test.js

@@ -0,0 +1,30 @@
+const assert = require('assert');
+const path = require('path');
+const { isUnityEngine } = require('../../../dist/utils/unity');
+const { getUnityBuildConfig } = require('../../../dist/utils/unity/getUnityBuildConfig');
+const { GAME_PKG_SIZE_LIMIT } = require('../../../dist/constants');
+
+const fixturesPath = path.join(__dirname, '../fixtures');
+
+describe('Unity Utils', function() {
+  describe('isUnityEngine', function() {
+    it('should return true for unity engine', function() {
+      const result = isUnityEngine(path.join(fixturesPath, 'game-unity'));
+      assert.strictEqual(result, true);
+    });
+
+    it('should return false for non-unity engine', function() {
+      const result = isUnityEngine(path.join(fixturesPath, 'game-cocos'));
+      assert.strictEqual(result, false);
+    });
+  });
+
+  describe('getUnityBuildConfig', function() {
+    it('should return unity build config', function() {
+      const config = getUnityBuildConfig();
+      assert.strictEqual(config.pkgSizeLimit, GAME_PKG_SIZE_LIMIT.unity.project);
+      assert.strictEqual(config.mainPkgSizeLimit, GAME_PKG_SIZE_LIMIT.unity.main);
+      assert.strictEqual(config.independentSubPkgSizeLimit, GAME_PKG_SIZE_LIMIT.unity.independent);
+    });
+  });
+});

package/dist/index.js

@@ -1,9 +1,9 @@
 /**
  * ==========================================
  *  @Description: ttmg pack
- *  @Version: 0.4.4
+ *  @Version: 0.4.5
  *  @Author: zhanghongyang.mocha
- *  @Date: 2026-03-19 15:31:24
+ *  @Date: 2026-03-22 15:35:16
  * ==========================================
  */
 'use strict';
@@ -1838,7 +1838,7 @@ async function getPluginInfo(params) {
     return { url: meta.PackageCDNURL, md5: meta.PackageMD5 };
 }
 async function addDepsToPackages(gameEntry, outputDir, allDeps, config) {
-    var _a;
+    var _a, _b, _c;
     const gamePackConfigPath = path.join(outputDir, GAME_PACK_CONFIG_FILE_NAME);
     const gameJsonPath = path.join(gameEntry, GAME_ORIGIN_CONFIG_FILE_NAME);
     let gamePackConfig;
@@ -1852,11 +1852,13 @@ async function addDepsToPackages(gameEntry, outputDir, allDeps, config) {
     catch (error) {
         throw new Error('[ttmg-pack] Failed to read package file game.json or packageConfig.json');
     }
-    const unityDeps = ['data-package', 'StreamingAssets', 'wasmcode', 'wasmcode-android', 'wasmcode-ios'];
-    for (const dep of unityDeps) {
-        // 如果 game.json 的 subpackages 里有这个包，则添加进 __GAME__ 的 dependencies
-        if (((_a = gameJson.subpackages) !== null && _a !== void 0 ? _a : []).some(pkg => pkg.name === dep)) {
-            gamePackConfig.packages[GAME_MAIN_PACKAGE_NAME].dependencies.push(dep);
+    if (!((_a = config === null || config === void 0 ? void 0 : config.dev) === null || _a === void 0 ? void 0 : _a.enable)) {
+        const unityDeps = ['data-package', 'StreamingAssets', 'wasmcode', 'wasmcode-android', 'wasmcode-ios'];
+        for (const dep of unityDeps) {
+            // 如果 game.json 的 subpackages 里有这个包，则添加进 __GAME__ 的 dependencies
+            if (((_b = gameJson.subpackages) !== null && _b !== void 0 ? _b : []).some(pkg => pkg.name === dep)) {
+                gamePackConfig.packages[GAME_MAIN_PACKAGE_NAME].dependencies.push(dep);
+            }
         }
     }
     for (const [pkgName, plugins] of Object.entries(allDeps)) {
@@ -1867,7 +1869,7 @@ async function addDepsToPackages(gameEntry, outputDir, allDeps, config) {
             const pluginPkgName = `${pluginName}_${version}`;
             let url = '';
             let md5 = '';
-            if (config === null || config === void 0 ? void 0 : config.dev) {
+            if ((_c = config === null || config === void 0 ? void 0 : config.dev) === null || _c === void 0 ? void 0 : _c.enable) {
                 try {
                     const res = await getPluginInfo({
                         plugin_name: pluginName.toLowerCase(),
@@ -2418,7 +2420,7 @@ async function buildPkgs(config, context = {}) {
     let startTime = Date.now();
     logger.init(outputDir, true);
     logger.info(t('log.build.version', {
-        version: "0.4.4",
+        version: "0.4.5",
     }));
     logger.info(t('log.build.start', { startTime }));
     /**