velocious 1.0.430 → 1.0.431

package/build/src/testing/test-suite-splitter.js

@@ -1,149 +1,177 @@
 // @ts-check
-import path from "path";
-import restArgsError from "../utils/rest-args-error.js";
+
+import path from "path"
+import restArgsError from "../utils/rest-args-error.js"
+
 /**
  * SplitterFileEntry type.
  * @typedef {object} SplitterFileEntry
  * @property {string} filePath - Absolute file path.
  * @property {number} weight - Computed weight for load balancing.
  */
+
 /**
  * GroupBucket type.
  * @typedef {object} GroupBucket
  * @property {number} totalWeight - Accumulated weight.
  * @property {string[]} files - Files assigned to this group.
  */
+
 /** Default weight for a regular test file. */
-const DEFAULT_WEIGHT = 1;
+const DEFAULT_WEIGHT = 1
+
 /**
  * Weight multipliers by spec directory name.
  * Heavier test types get higher weights so greedy distribution balances wall-clock time.
  * @type {Record<string, number>}
  */
 const DIRECTORY_WEIGHTS = {
-    system: 20,
-    "frontend-models": 10,
-    controller: 3
-};
+  system: 20,
+  "frontend-models": 10,
+  controller: 3
+}
+
 /** Extra multiplier applied to browser spec files on top of directory weight. */
-const BROWSER_SPEC_MULTIPLIER = 2;
+const BROWSER_SPEC_MULTIPLIER = 2
+
 /**
  * Splits a list of test files into balanced groups using a greedy load-balancing algorithm.
  * Modeled after test_suite_splitter for RSpec.
  */
 export default class TestSuiteSplitter {
-    /**
-     * Runs constructor.
-     * @param {object} args - Options.
-     * @param {number} args.groups - Total number of groups.
-     * @param {number} args.groupNumber - Which group to return (1-indexed).
-     * @param {string[]} args.testFiles - All discovered test file paths.
-     * @param {string} [args.baseDirectory] - Base directory for relative path computation.
-     */
-    constructor({ groups, groupNumber, testFiles, baseDirectory, ...restArgs }) {
-        restArgsError(restArgs);
-        if (!Number.isInteger(groups) || groups < 1) {
-            throw new Error(`--groups must be a positive integer, got: ${groups}`);
-        }
-        if (!Number.isInteger(groupNumber) || groupNumber < 1 || groupNumber > groups) {
-            throw new Error(`--group-number must be between 1 and ${groups}, got: ${groupNumber}`);
-        }
-        this._groups = groups;
-        this._groupNumber = groupNumber;
-        this._testFiles = testFiles;
-        this._baseDirectory = baseDirectory || process.cwd();
+  /**
+   * Runs constructor.
+   * @param {object} args - Options.
+   * @param {number} args.groups - Total number of groups.
+   * @param {number} args.groupNumber - Which group to return (1-indexed).
+   * @param {string[]} args.testFiles - All discovered test file paths.
+   * @param {string} [args.baseDirectory] - Base directory for relative path computation.
+   */
+  constructor({groups, groupNumber, testFiles, baseDirectory, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!Number.isInteger(groups) || groups < 1) {
+      throw new Error(`--groups must be a positive integer, got: ${groups}`)
     }
-    /**
-     * Returns the test files assigned to this group.
-     * @returns {string[]} - File paths for the requested group.
-     */
-    getGroupFiles() {
-        const weighted = this.computeWeightedFiles();
-        const sorted = this.sortByWeightDescending(weighted);
-        const buckets = this.distributeGreedily(sorted);
-        return buckets[this._groupNumber - 1].files;
+
+    if (!Number.isInteger(groupNumber) || groupNumber < 1 || groupNumber > groups) {
+      throw new Error(`--group-number must be between 1 and ${groups}, got: ${groupNumber}`)
     }
-    /**
-     * Computes weight for each test file based on directory type and file suffix.
-     * @returns {SplitterFileEntry[]} - Weighted file entries.
-     */
-    computeWeightedFiles() {
-        return this._testFiles.map((filePath) => ({
-            filePath,
-            weight: this.computeWeight(filePath)
-        }));
+
+    this._groups = groups
+    this._groupNumber = groupNumber
+    this._testFiles = testFiles
+    this._baseDirectory = baseDirectory || process.cwd()
+  }
+
+  /**
+   * Returns the test files assigned to this group.
+   * @returns {string[]} - File paths for the requested group.
+   */
+  getGroupFiles() {
+    const weighted = this.computeWeightedFiles()
+    const sorted = this.sortByWeightDescending(weighted)
+    const buckets = this.distributeGreedily(sorted)
+
+    return buckets[this._groupNumber - 1].files
+  }
+
+  /**
+   * Computes weight for each test file based on directory type and file suffix.
+   * @returns {SplitterFileEntry[]} - Weighted file entries.
+   */
+  computeWeightedFiles() {
+    return this._testFiles.map((filePath) => ({
+      filePath,
+      weight: this.computeWeight(filePath)
+    }))
+  }
+
+  /**
+   * Computes the weight for a single file.
+   * @param {string} filePath - Absolute file path.
+   * @returns {number} - Weight value.
+   */
+  computeWeight(filePath) {
+    const relativePath = path.relative(this._baseDirectory, filePath).split(path.sep).join("/")
+    let weight = DEFAULT_WEIGHT
+
+    // Extract the type directory from the relative path.
+    // Matches both "spec/system/..." (base is project root) and "system/..." (base is spec/ itself).
+    const specDirMatch = relativePath.match(/^(?:(?:spec|__tests__|tests)\/)?([^/]+)\//)
+
+    if (specDirMatch) {
+      const dirName = specDirMatch[1]
+
+      if (DIRECTORY_WEIGHTS[dirName] !== undefined) {
+        weight = DIRECTORY_WEIGHTS[dirName]
+      }
     }
-    /**
-     * Computes the weight for a single file.
-     * @param {string} filePath - Absolute file path.
-     * @returns {number} - Weight value.
-     */
-    computeWeight(filePath) {
-        const relativePath = path.relative(this._baseDirectory, filePath).split(path.sep).join("/");
-        let weight = DEFAULT_WEIGHT;
-        // Extract the type directory from the relative path.
-        // Matches both "spec/system/..." (base is project root) and "system/..." (base is spec/ itself).
-        const specDirMatch = relativePath.match(/^(?:(?:spec|__tests__|tests)\/)?([^/]+)\//);
-        if (specDirMatch) {
-            const dirName = specDirMatch[1];
-            if (DIRECTORY_WEIGHTS[dirName] !== undefined) {
-                weight = DIRECTORY_WEIGHTS[dirName];
-            }
-        }
-        // Browser spec files are heavier
-        if (filePath.endsWith(".browser-spec.js") || filePath.endsWith(".browser-spec.mjs")) {
-            weight *= BROWSER_SPEC_MULTIPLIER;
-        }
-        return weight;
+
+    // Browser spec files are heavier
+    if (filePath.endsWith(".browser-spec.js") || filePath.endsWith(".browser-spec.mjs")) {
+      weight *= BROWSER_SPEC_MULTIPLIER
     }
+
+    return weight
+  }
+
+  /**
+   * Sorts files by weight descending, then by path for determinism.
+   * @param {SplitterFileEntry[]} files - Weighted files.
+   * @returns {SplitterFileEntry[]} - Sorted files.
+   */
+  sortByWeightDescending(files) {
+    return [...files].sort((a, b) => {
+      if (b.weight !== a.weight) {
+        return b.weight - a.weight
+      }
+
+      return a.filePath.localeCompare(b.filePath)
+    })
+  }
+
+  /**
+   * Distributes files greedily into N balanced groups.
+   * Each file is assigned to the group with the least accumulated weight.
+   * @param {SplitterFileEntry[]} sortedFiles - Files sorted by weight descending.
+   * @returns {GroupBucket[]} - Array of group buckets.
+   */
+  distributeGreedily(sortedFiles) {
     /**
-     * Sorts files by weight descending, then by path for determinism.
-     * @param {SplitterFileEntry[]} files - Weighted files.
-     * @returns {SplitterFileEntry[]} - Sorted files.
-     */
-    sortByWeightDescending(files) {
-        return [...files].sort((a, b) => {
-            if (b.weight !== a.weight) {
-                return b.weight - a.weight;
-            }
-            return a.filePath.localeCompare(b.filePath);
-        });
+     * Buckets.
+      @type {GroupBucket[]} */
+    const buckets = []
+
+    for (let i = 0; i < this._groups; i++) {
+      buckets.push({totalWeight: 0, files: []})
     }
-    /**
-     * Distributes files greedily into N balanced groups.
-     * Each file is assigned to the group with the least accumulated weight.
-     * @param {SplitterFileEntry[]} sortedFiles - Files sorted by weight descending.
-     * @returns {GroupBucket[]} - Array of group buckets.
-     */
-    distributeGreedily(sortedFiles) {
-        /**
-         * Buckets.
-          @type {GroupBucket[]} */
-        const buckets = [];
-        for (let i = 0; i < this._groups; i++) {
-            buckets.push({ totalWeight: 0, files: [] });
-        }
-        for (const entry of sortedFiles) {
-            const lightest = this.findLightestBucket(buckets);
-            lightest.files.push(entry.filePath);
-            lightest.totalWeight += entry.weight;
-        }
-        return buckets;
+
+    for (const entry of sortedFiles) {
+      const lightest = this.findLightestBucket(buckets)
+
+      lightest.files.push(entry.filePath)
+      lightest.totalWeight += entry.weight
     }
-    /**
-     * Finds the bucket with the least accumulated weight.
-     * Ties are broken by bucket index (earlier bucket wins) for determinism.
-     * @param {GroupBucket[]} buckets - Group buckets.
-     * @returns {GroupBucket} - The lightest bucket.
-     */
-    findLightestBucket(buckets) {
-        let lightest = buckets[0];
-        for (let i = 1; i < buckets.length; i++) {
-            if (buckets[i].totalWeight < lightest.totalWeight) {
-                lightest = buckets[i];
-            }
-        }
-        return lightest;
+
+    return buckets
+  }
+
+  /**
+   * Finds the bucket with the least accumulated weight.
+   * Ties are broken by bucket index (earlier bucket wins) for determinism.
+   * @param {GroupBucket[]} buckets - Group buckets.
+   * @returns {GroupBucket} - The lightest bucket.
+   */
+  findLightestBucket(buckets) {
+    let lightest = buckets[0]
+
+    for (let i = 1; i < buckets.length; i++) {
+      if (buckets[i].totalWeight < lightest.totalWeight) {
+        lightest = buckets[i]
+      }
     }
+
+    return lightest
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-suite-splitter.js","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\n/**\n * SplitterFileEntry type.\n * @typedef {object} SplitterFileEntry\n * @property {string} filePath - Absolute file path.\n * @property {number} weight - Computed weight for load balancing.\n */\n\n/**\n * GroupBucket type.\n * @typedef {object} GroupBucket\n * @property {number} totalWeight - Accumulated weight.\n * @property {string[]} files - Files assigned to this group.\n */\n\n/** Default weight for a regular test file. */\nconst DEFAULT_WEIGHT = 1\n\n/**\n * Weight multipliers by spec directory name.\n * Heavier test types get higher weights so greedy distribution balances wall-clock time.\n * @type {Record<string, number>}\n */\nconst DIRECTORY_WEIGHTS = {\n  system: 20,\n  \"frontend-models\": 10,\n  controller: 3\n}\n\n/** Extra multiplier applied to browser spec files on top of directory weight. */\nconst BROWSER_SPEC_MULTIPLIER = 2\n\n/**\n * Splits a list of test files into balanced groups using a greedy load-balancing algorithm.\n * Modeled after test_suite_splitter for RSpec.\n */\nexport default class TestSuiteSplitter {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {number} args.groups - Total number of groups.\n   * @param {number} args.groupNumber - Which group to return (1-indexed).\n   * @param {string[]} args.testFiles - All discovered test file paths.\n   * @param {string} [args.baseDirectory] - Base directory for relative path computation.\n   */\n  constructor({groups, groupNumber, testFiles, baseDirectory, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!Number.isInteger(groups) || groups < 1) {\n      throw new Error(`--groups must be a positive integer, got: ${groups}`)\n    }\n\n    if (!Number.isInteger(groupNumber) || groupNumber < 1 || groupNumber > groups) {\n      throw new Error(`--group-number must be between 1 and ${groups}, got: ${groupNumber}`)\n    }\n\n    this._groups = groups\n    this._groupNumber = groupNumber\n    this._testFiles = testFiles\n    this._baseDirectory = baseDirectory || process.cwd()\n  }\n\n  /**\n   * Returns the test files assigned to this group.\n   * @returns {string[]} - File paths for the requested group.\n   */\n  getGroupFiles() {\n    const weighted = this.computeWeightedFiles()\n    const sorted = this.sortByWeightDescending(weighted)\n    const buckets = this.distributeGreedily(sorted)\n\n    return buckets[this._groupNumber - 1].files\n  }\n\n  /**\n   * Computes weight for each test file based on directory type and file suffix.\n   * @returns {SplitterFileEntry[]} - Weighted file entries.\n   */\n  computeWeightedFiles() {\n    return this._testFiles.map((filePath) => ({\n      filePath,\n      weight: this.computeWeight(filePath)\n    }))\n  }\n\n  /**\n   * Computes the weight for a single file.\n   * @param {string} filePath - Absolute file path.\n   * @returns {number} - Weight value.\n   */\n  computeWeight(filePath) {\n    const relativePath = path.relative(this._baseDirectory, filePath).split(path.sep).join(\"/\")\n    let weight = DEFAULT_WEIGHT\n\n    // Extract the type directory from the relative path.\n    // Matches both \"spec/system/...\" (base is project root) and \"system/...\" (base is spec/ itself).\n    const specDirMatch = relativePath.match(/^(?:(?:spec|__tests__|tests)\\/)?([^/]+)\\//)\n\n    if (specDirMatch) {\n      const dirName = specDirMatch[1]\n\n      if (DIRECTORY_WEIGHTS[dirName] !== undefined) {\n        weight = DIRECTORY_WEIGHTS[dirName]\n      }\n    }\n\n    // Browser spec files are heavier\n    if (filePath.endsWith(\".browser-spec.js\") || filePath.endsWith(\".browser-spec.mjs\")) {\n      weight *= BROWSER_SPEC_MULTIPLIER\n    }\n\n    return weight\n  }\n\n  /**\n   * Sorts files by weight descending, then by path for determinism.\n   * @param {SplitterFileEntry[]} files - Weighted files.\n   * @returns {SplitterFileEntry[]} - Sorted files.\n   */\n  sortByWeightDescending(files) {\n    return [...files].sort((a, b) => {\n      if (b.weight !== a.weight) {\n        return b.weight - a.weight\n      }\n\n      return a.filePath.localeCompare(b.filePath)\n    })\n  }\n\n  /**\n   * Distributes files greedily into N balanced groups.\n   * Each file is assigned to the group with the least accumulated weight.\n   * @param {SplitterFileEntry[]} sortedFiles - Files sorted by weight descending.\n   * @returns {GroupBucket[]} - Array of group buckets.\n   */\n  distributeGreedily(sortedFiles) {\n    /**\n     * Buckets.\n      @type {GroupBucket[]} */\n    const buckets = []\n\n    for (let i = 0; i < this._groups; i++) {\n      buckets.push({totalWeight: 0, files: []})\n    }\n\n    for (const entry of sortedFiles) {\n      const lightest = this.findLightestBucket(buckets)\n\n      lightest.files.push(entry.filePath)\n      lightest.totalWeight += entry.weight\n    }\n\n    return buckets\n  }\n\n  /**\n   * Finds the bucket with the least accumulated weight.\n   * Ties are broken by bucket index (earlier bucket wins) for determinism.\n   * @param {GroupBucket[]} buckets - Group buckets.\n   * @returns {GroupBucket} - The lightest bucket.\n   */\n  findLightestBucket(buckets) {\n    let lightest = buckets[0]\n\n    for (let i = 1; i < buckets.length; i++) {\n      if (buckets[i].totalWeight < lightest.totalWeight) {\n        lightest = buckets[i]\n      }\n    }\n\n    return lightest\n  }\n}\n"]}