ttmg-pack 0.4.0 → 0.4.3

package/CHANGELOG.md

@@ -379,4 +379,14 @@ for  unity plugin
 ## 0.4.0
 
 1. **优化 wasmFuncCount 校验逻辑**：当 game.json 中没有 wasmFuncCount 字段时直接返回 null，不进行校验，保证老用户不被干扰
-2. **完善边界条件处理**：wasmFuncCount 为 0 时仍会进行正常校验
+2. **完善边界条件处理**：wasmFuncCount 为 0 时仍会进行正常校验
+
+## 0.4.1-0.4.2
+
+1. **所有 CheckResult 新增 `required` 字段**：用于区分校验项是否为必须通过项
+   - API 校验（`checkAPI`）：`required: false`，表示为建议性校验
+   - 其他校验（config / size / performance）：`required: true`，表示为强制性校验
+2. **类型定义更新**：`CheckSizeResult`、`CheckConfigResult`、`CheckPerfResult` 接口均新增 `required: boolean` 字段
+
+## 0.4.3
+1. 支持日志多语言

package/__TEST__/tests/fixtures/check-project/non-unity/src/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/check-project/non-unity/src/game.json

@@ -0,0 +1,3 @@
+{
+  "gameEngine": "cocos"
+}

package/__TEST__/tests/fixtures/check-project/subpackages-camel-case/src/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/check-project/subpackages-camel-case/src/game.json

@@ -0,0 +1,4 @@
+{
+  "gameEngine": "cocos",
+  "subPackages": []
+}

package/__TEST__/tests/fixtures/check-project/unity-large-config-disabled/src/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/check-project/unity-large-config-disabled/src/game.json

@@ -0,0 +1,4 @@
+{
+  "gameEngine": "unity",
+  "wasmFuncCount": 80000
+}

package/__TEST__/tests/fixtures/check-project/unity-large-config-disabled/src/webgl-wasm-split.json

@@ -0,0 +1,3 @@
+{
+  "enableWasmSplit": false
+}

package/__TEST__/tests/fixtures/check-project/unity-large-config-enabled/src/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/check-project/unity-large-config-enabled/src/game.json

@@ -0,0 +1,4 @@
+{
+  "gameEngine": "unity",
+  "wasmFuncCount": 80000
+}

package/__TEST__/tests/fixtures/check-project/unity-large-config-enabled/src/webgl-wasm-split.json

@@ -0,0 +1,3 @@
+{
+  "enableWasmSplit": true
+}

package/__TEST__/tests/fixtures/check-project/unity-large-no-config/src/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/check-project/unity-large-no-config/src/game.json

@@ -0,0 +1,4 @@
+{
+  "gameEngine": "unity",
+  "wasmFuncCount": 80000
+}

package/__TEST__/tests/fixtures/check-project/unity-small/src/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/check-project/unity-small/src/game.json

@@ -0,0 +1,4 @@
+{
+  "gameEngine": "unity",
+  "wasmFuncCount": 79999
+}

package/__TEST__/tests/fixtures/game-cocos/game.json

@@ -0,0 +1,3 @@
+{
+  "gameEngine": "cocos"
+}

package/__TEST__/tests/fixtures/game-invalid-json/game.json

@@ -0,0 +1 @@
+{ invalid json }

package/__TEST__/tests/fixtures/game-no-config/game.js

@@ -0,0 +1 @@
+console.log('test');

package/__TEST__/tests/fixtures/game-no-engine/game.json

@@ -0,0 +1,3 @@
+{
+  "name": "test game"
+}

package/__TEST__/tests/fixtures/game-unity/game.json

@@ -0,0 +1,15 @@
+{
+  "gameEngine": "unity",
+  "wasmFuncCount": 79999,
+  "subpackages": [
+    {
+      "name": "sub1",
+      "root": "subpackages/sub1"
+    },
+    {
+      "name": "sub2",
+      "root": "subpackages/sub2",
+      "independent": true
+    }
+  ]
+}

package/__TEST__/tests/libs/checkProject.test.js

@@ -0,0 +1,68 @@
+const assert = require('assert');
+const path = require('path');
+const { checkGameJson, checkProjectSize } = require('../../../dist/libs/checkPkgs/checkProject');
+const { createPackTranslator } = require('../../../dist/utils');
+
+const t = createPackTranslator('en-US');
+const fixturesPath = path.join(__dirname, '../fixtures/check-project');
+
+describe('checkProject', function() {
+  describe('checkGameJson', function() {
+    it('should check game.json exists and passes', function() {
+      const result = checkGameJson({
+        entry: path.join(fixturesPath, 'non-unity/src'),
+        dev: { enable: true }
+      }, t);
+      assert.strictEqual(result.passed, true);
+    });
+
+    it('should return error when game.json is missing (dev mode)', function() {
+      const result = checkGameJson({
+        entry: path.join(fixturesPath, 'game-json-missing/src'),
+        dev: { enable: true }
+      }, t);
+      assert.strictEqual(result.passed, false);
+      assert.strictEqual(result.level, 'error');
+    });
+
+    it('should throw error when game.json is missing (non-dev mode)', function() {
+      assert.throws(() => {
+        checkGameJson({
+          entry: path.join(fixturesPath, 'game-json-missing/src'),
+          dev: { enable: false }
+        }, t);
+      }, /Cannot find game\.json/);
+    });
+
+    it('should check for subPackages (camelCase) and return error (dev mode)', function() {
+      const result = checkGameJson({
+        entry: path.join(fixturesPath, 'subpackages-camel-case/src'),
+        dev: { enable: true }
+      }, t);
+      assert.strictEqual(result.passed, false);
+      assert.strictEqual(result.level, 'error');
+    });
+
+    it('should check for subPackages (camelCase) and throw error (non-dev mode)', function() {
+      assert.throws(() => {
+        checkGameJson({
+          entry: path.join(fixturesPath, 'subpackages-camel-case/src'),
+          dev: { enable: false }
+        }, t);
+      }, /subPackages/);
+    });
+  });
+
+  describe('checkProjectSize', function() {
+    it('should check project size and pass within limit', function() {
+      const result = checkProjectSize({
+        entry: path.join(fixturesPath, 'non-unity/src'),
+        dev: { enable: true },
+        build: {
+          pkgSizeLimit: 100 * 1024 * 1024
+        }
+      }, t);
+      assert.strictEqual(result.passed, true);
+    });
+  });
+});

package/__TEST__/tests/runner-simple.js

@@ -0,0 +1,120 @@
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const { checkPkgs } = require('../../dist/index');
+
+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);
+  }
+}
+
+describe('checkPkgs Integration Tests', function() {
+  it('should run checkPkgs on unity-small test case', async function() {
+    const result = await checkPkgs({
+      entry: path.join(__dirname, '../wasm-test/unity-small/src'),
+      output: path.join(__dirname, '../output'),
+      dev: {
+        enable: true,
+        enableLog: false
+      },
+      build: {
+        enableOdr: false,
+        pkgSizeLimit: 30 * 1024 * 1024,
+        mainPkgSizeLimit: 1 * 1024 * 1024,
+        independentSubPkgSizeLimit: 4 * 1024 * 1024
+      }
+    });
+    assert(Array.isArray(result));
+  });
+
+  it('should run checkPkgs on unity-large-config-enabled test case', async function() {
+    const result = await checkPkgs({
+      entry: path.join(__dirname, '../wasm-test/unity-large-config-enabled/src'),
+      output: path.join(__dirname, '../output'),
+      dev: {
+        enable: true,
+        enableLog: false
+      },
+      build: {
+        enableOdr: false,
+        pkgSizeLimit: 30 * 1024 * 1024,
+        mainPkgSizeLimit: 1 * 1024 * 1024,
+        independentSubPkgSizeLimit: 4 * 1024 * 1024
+      }
+    });
+    assert(Array.isArray(result));
+  });
+});
+
+async function runTests() {
+  console.log('========================================');
+  console.log('Running unit tests');
+  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/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);
+  });
+});