velocious 1.0.431 → 1.0.433

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

@@ -1,177 +1,149 @@
 // @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}`)
+    /**
+     * 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();
     }
-
-    if (!Number.isInteger(groupNumber) || groupNumber < 1 || groupNumber > groups) {
-      throw new Error(`--group-number must be between 1 and ${groups}, got: ${groupNumber}`)
+    /**
+     * 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;
     }
-
-    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 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)
+        }));
     }
-
-    // Browser spec files are heavier
-    if (filePath.endsWith(".browser-spec.js") || filePath.endsWith(".browser-spec.mjs")) {
-      weight *= BROWSER_SPEC_MULTIPLIER
+    /**
+     * 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;
     }
-
-    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) {
     /**
-     * Buckets.
-      @type {GroupBucket[]} */
-    const buckets = []
-
-    for (let i = 0; i < this._groups; i++) {
-      buckets.push({totalWeight: 0, files: []})
+     * 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);
+        });
     }
-
-    for (const entry of sortedFiles) {
-      const lightest = this.findLightestBucket(buckets)
-
-      lightest.files.push(entry.filePath)
-      lightest.totalWeight += entry.weight
+    /**
+     * 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;
     }
-
-    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]
-      }
+    /**
+     * 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 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"]}