ts-repo-utils 7.8.1 → 7.9.0

package/src/functions/gen-index.mts

@@ -91,28 +91,35 @@ export const genIndex = async (
     // Step 1: Verify target directories exist
     for (const dir of targetDirs) {
       const resolvedDir = path.resolve(dir);
+
       // eslint-disable-next-line no-await-in-loop
       await assertPathExists(resolvedDir, `Target directory: ${dir}`);
     }
 
     // Step 2: Generate index files
     conditionalEcho('Generating index files...');
+
     for (const dir of targetDirs) {
       const resolvedDir = path.resolve(dir);
+
       // eslint-disable-next-line no-await-in-loop
       await generateIndexFileForDir(resolvedDir, filledConfig);
     }
+
     conditionalEcho('✓ Index files generated\n');
 
     // Step 3: Format generated files
     if (filledConfig.formatCommand !== undefined) {
       conditionalEcho('Formatting generated files...');
+
       const fmtResult = await $(filledConfig.formatCommand, {
         silent: filledConfig.silent,
       });
+
       if (Result.isErr(fmtResult)) {
         throw new Error(`Formatting failed: ${fmtResult.value.message}`);
       }
+
       conditionalEcho('✓ Formatting completed\n');
     }
 
@@ -121,6 +128,7 @@ export const genIndex = async (
     return Result.ok(undefined);
   } catch (error) {
     conditionalEcho(`❌ Index generation failed: ${String(error)}\n`);
+
     return Result.err(error);
   }
 };
@@ -148,6 +156,7 @@ const fillConfig = (config: GenIndexConfig): GenIndexConfigInternal => {
                 if (exclude !== undefined && Array.isArray(exclude)) {
                   yield* exclude;
                 }
+
                 yield* defaultConfig.exclude;
               }),
             ),
@@ -169,6 +178,7 @@ const fillConfig = (config: GenIndexConfig): GenIndexConfigInternal => {
                     return true;
                   }
                 }
+
                 return false;
               },
           ).value,
@@ -198,14 +208,18 @@ const generateIndexFileForDir = async (
 ): Promise<void> => {
   try {
     const actualBaseDir = baseDir ?? dirPath;
+
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
 
     const mut_subDirectories: string[] = [];
+
     const mut_filesToExport: string[] = [];
 
     for (const entry of entries) {
       const entryName = entry.name;
+
       const entryPath = path.join(dirPath, entryName);
+
       const relativePath = path.relative(actualBaseDir, entryPath);
 
       if (
@@ -220,6 +234,7 @@ const generateIndexFileForDir = async (
 
       if (entry.isDirectory()) {
         mut_subDirectories.push(entryName);
+
         // Recursively call for subdirectories first
         // eslint-disable-next-line no-await-in-loop
         await generateIndexFileForDir(entryPath, config, actualBaseDir);
@@ -244,6 +259,7 @@ const generateIndexFileForDir = async (
     const indexPath = path.join(dirPath, `index${config.indexFileExtension}`);
 
     await fs.writeFile(indexPath, indexContent);
+
     echo(`Generated: ${path.relative(process.cwd(), indexPath)}`);
   } catch (error) {
     throw new Error(

package/src/functions/should-run.mts

@@ -84,6 +84,7 @@ export const checkShouldRunTypeChecks = async (
 
   if (Result.isErr(files)) {
     console.error('Error getting diff:', files.value);
+
     process.exit(1);
   }
 
@@ -102,6 +103,7 @@ export const checkShouldRunTypeChecks = async (
       // File extension pattern match (pattern starts with '**.')
       if (pattern.startsWith('**.')) {
         const extension = pattern.slice(2); // Remove '**'
+
         return path.basename(file).endsWith(extension);
       }
 

package/src/functions/workspace-utils/execute-parallel.mts

@@ -1,4 +1,5 @@
 /* eslint-disable require-atomic-updates */
+import { isError } from '@sindresorhus/is';
 import { spawn } from 'node:child_process';
 import {
   createPromise,
@@ -35,6 +36,7 @@ export const executeParallel = async (
   >[] = [];
 
   const mut_executing = new Set<Promise<unknown>>();
+
   let mut_failed = false as boolean;
 
   for (const pkg of packages) {
@@ -48,8 +50,10 @@ export const executeParallel = async (
       // Check for failure immediately
       if (Result.isErr(result)) {
         mut_failed = true;
+
         throw result.value; // Throw the error to trigger fail-fast
       }
+
       return result.value; // Return the unwrapped value for success
     });
 
@@ -59,10 +63,12 @@ export const executeParallel = async (
       // eslint-disable-next-line @typescript-eslint/no-loop-func
       .catch((error: unknown) => {
         mut_failed = true;
+
         throw error; // Re-throw to ensure fail-fast propagation
       })
       .finally(() => {
         mut_executing.delete(wrappedPromise);
+
         if (DEBUG) {
           console.debug('executing size', mut_executing.size);
         }
@@ -83,6 +89,7 @@ export const executeParallel = async (
         // If any process fails, cancel remaining processes and throw immediately
         // eslint-disable-next-line no-useless-assignment
         mut_failed = true;
+
         throw error;
       }
     }
@@ -116,6 +123,7 @@ export const executeStages = async (
   const sorted = topologicalSortPackages(packages, dependencyGraph);
 
   const mut_stages: (readonly Package[])[] = [];
+
   const mut_completed = new Set<string>();
 
   while (mut_completed.size < sorted.length) {
@@ -125,6 +133,7 @@ export const executeStages = async (
       if (mut_completed.has(pkg.name)) continue;
 
       const deps = dependencyGraph.get(pkg.name) ?? [];
+
       const depsCompleted = deps.every((dep) => mut_completed.has(dep));
 
       if (depsCompleted) {
@@ -137,6 +146,7 @@ export const executeStages = async (
     }
 
     mut_stages.push(mut_stage);
+
     for (const pkg of mut_stage) {
       mut_completed.add(pkg.name);
     }
@@ -149,6 +159,7 @@ export const executeStages = async (
   for (const [i, stage] of mut_stages.entries()) {
     if (stage.length > 0) {
       console.log(`Stage ${i + 1}: ${stage.map((p) => p.name).join(', ')}`);
+
       try {
         // eslint-disable-next-line no-await-in-loop
         const results = await executeParallel(stage, scriptName, concurrency);
@@ -160,11 +171,12 @@ export const executeStages = async (
         );
       } catch (error) {
         // executeParallel will throw immediately on any failure (fail-fast)
-        const errorMessage = Error.isError(error)
-          ? error.message
-          : String(error);
+        const errorMessage = isError(error) ? error.message : String(error);
+
         console.error(`\n❌ Stage ${i + 1} failed (fail-fast):`);
+
         console.error(errorMessage);
+
         throw new Error(`Stage ${i + 1} failed: ${errorMessage}`, {
           cause: error,
         });
@@ -203,12 +215,15 @@ const executeScript = (
             : {};
 
         const hasScript = hasKey(packageJsonScripts, scriptName);
+
         if (!hasScript) {
           resolve({ skipped: true });
+
           return;
         }
 
         const prefixStr = prefix ? `[${pkg.name}] ` : '';
+
         const proc = spawn('npm', ['run', scriptName], {
           cwd: pkg.path,
           shell: true,
@@ -227,6 +242,7 @@ const executeScript = (
           if (DEBUG) {
             console.debug(`${pkg.name} process closed with code: ${code}`);
           }
+
           if (code === 0 || code === null) {
             resolve({ code: code ?? 0 });
           } else {
@@ -240,14 +256,15 @@ const executeScript = (
   ).map((result) =>
     result.then(
       Result.mapErr((err) => {
-        const errorMessage: string = Error.isError(err)
+        const errorMessage: string = isError(err)
           ? err.message
           : isRecord(err) && hasKey(err, 'message')
             ? (err.message?.toString() ?? 'Unknown error message')
             : 'Unknown error';
 
         console.error(`\nError in ${pkg.name}:`, errorMessage);
-        return Error.isError(err) ? err : new Error(errorMessage);
+
+        return isError(err) ? err : new Error(errorMessage);
       }),
     ),
   ).value;
@@ -264,15 +281,18 @@ const topologicalSortPackages = (
   dependencyGraph: ReadonlyMap<string, readonly string[]>,
 ): readonly Package[] => {
   const mut_visited = new Set<string>();
+
   const mut_result: string[] = [];
 
   const packageMap = new Map(packages.map((p) => [p.name, p]));
 
   const visit = (pkgName: string): void => {
     if (mut_visited.has(pkgName)) return;
+
     mut_visited.add(pkgName);
 
     const deps = dependencyGraph.get(pkgName) ?? [];
+
     for (const dep of deps) {
       visit(dep);
     }
@@ -301,12 +321,14 @@ const buildDependencyGraph = (
   packages: readonly Package[],
 ): ReadonlyMap<string, readonly string[]> => {
   const packageMap = new Map(packages.map((p) => [p.name, p]));
+
   const mut_graph = new Map<string, readonly string[]>();
 
   for (const pkg of packages) {
     const deps = Object.keys(pkg.dependencies).filter((depName) =>
       packageMap.has(depName),
     );
+
     mut_graph.set(pkg.name, deps);
   }
 

package/src/functions/workspace-utils/get-workspace-packages.mts

@@ -80,6 +80,7 @@ export const getWorkspacePackages = async (
   });
 
   const allPackageArrays = await Promise.all(packagePromises);
+
   const finalPackages = allPackageArrays.flat();
 
   return finalPackages;
@@ -108,12 +109,16 @@ const getKeyValueRecordFromJsonValue = (
   if (!isRecord(value) || !hasKey(value, key)) {
     return {};
   }
+
   const obj = value[key];
+
   if (!isRecord(obj)) {
     return {};
   }
+
   const entries = Object.entries(obj).filter(
     (entry): entry is [string, string] => isString(entry[1]),
   );
+
   return Object.fromEntries(entries);
 };

package/src/functions/workspace-utils/run-cmd-in-parallel.mts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 
+import { isError } from '@sindresorhus/is';
 import { executeParallel } from './execute-parallel.mjs';
 import { getWorkspacePackages } from './get-workspace-packages.mjs';
 
@@ -40,14 +41,19 @@ export const runCmdInParallelAcrossWorkspaces = async ({
     console.log(
       `\nStarting ${cmd} across ${filteredPackages.length} packages (fail-fast parallel mode)...`,
     );
+
     await executeParallel(filteredPackages, cmd, concurrency);
+
     console.log(`\n✅ ${cmd} completed successfully (all packages)`);
   } catch (error) {
-    const errorMessage = Error.isError(error)
+    const errorMessage = isError(error)
       ? error.message
       : (error?.toString() ?? '');
+
     console.error(`\n❌ ${cmd} failed (fail-fast mode stopped execution):`);
+
     console.error(errorMessage);
+
     process.exit(1);
   }
 };

package/src/functions/workspace-utils/run-cmd-in-stages.mts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 
+import { isError } from '@sindresorhus/is';
 import { executeStages } from './execute-parallel.mjs';
 import { getWorkspacePackages } from './get-workspace-packages.mjs';
 
@@ -42,14 +43,19 @@ export const runCmdInStagesAcrossWorkspaces = async ({
     console.log(
       `\nStarting ${cmd} across ${filteredPackages.length} packages (fail-fast mode)...`,
     );
+
     await executeStages(filteredPackages, cmd, concurrency);
+
     console.log(`\n✅ ${cmd} completed successfully (all stages)`);
   } catch (error) {
-    const errorMessage = Error.isError(error)
+    const errorMessage = isError(error)
       ? error.message
       : (error?.toString() ?? '');
+
     console.error(`\n❌ ${cmd} failed (fail-fast mode stopped execution):`);
+
     console.error(errorMessage);
+
     process.exit(1);
   }
 };

package/src/functions/workspace-utils/run-cmd-in-stages.test.mts

@@ -7,15 +7,15 @@ import { runCmdInStagesAcrossWorkspaces } from './run-cmd-in-stages.mjs';
 import { type Package } from './types.mjs';
 
 // Mock the dependencies
-vi.mock('./execute-parallel.mjs', () => ({
+vi.mock(import('./execute-parallel.mjs'), () => ({
   executeStages: vi.fn(),
 }));
 
-vi.mock('./get-workspace-packages.mjs', () => ({
+vi.mock(import('./get-workspace-packages.mjs'), () => ({
   getWorkspacePackages: vi.fn(),
 }));
 
-describe('runCmdInStagesAcrossWorkspaces', () => {
+describe(runCmdInStagesAcrossWorkspaces, () => {
   type MockedSpies = Readonly<{
     consoleLogSpy: MockInstance<typeof console.log>;
     consoleErrorSpy: MockInstance<typeof console.error>;
@@ -24,9 +24,11 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
 
   const setupSpies = (): MockedSpies => {
     vi.clearAllMocks();
+
     const consoleLogSpy = vi
       .spyOn(console, 'log')
       .mockImplementation((): void => {});
+
     const consoleErrorSpy = vi
       .spyOn(console, 'error')
       .mockImplementation((): void => {});
@@ -42,7 +44,9 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   const cleanupSpies = (spies: MockedSpies): void => {
     spies.consoleLogSpy.mockRestore();
+
     spies.consoleErrorSpy.mockRestore();
+
     spies.processExitSpy.mockRestore();
   };
 
@@ -76,6 +80,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
 
       // Mock executeStages to throw an error (simulating a failed command)
       const mockError = new Error('package-a exited with code 1');
+
       vi.mocked(executeStages).mockRejectedValue(mockError);
 
       // Record start time
@@ -90,6 +95,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
 
       // Record end time
       const endTime = Date.now();
+
       const executionTime = endTime - startTime;
 
       // Verify that execution was fast (fail-fast behavior)
@@ -103,6 +109,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
       expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
         '\n❌ test failed (fail-fast mode stopped execution):',
       );
+
       expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
         'package-a exited with code 1',
       );
@@ -140,6 +147,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
       ];
 
       vi.mocked(getWorkspacePackages).mockResolvedValue(mockPackages);
+
       vi.mocked(executeStages).mockResolvedValue(undefined);
 
       // Execute the function
@@ -156,6 +164,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
       expect(spies.consoleLogSpy).toHaveBeenCalledWith(
         '\nStarting test across 2 packages (fail-fast mode)...',
       );
+
       expect(spies.consoleLogSpy).toHaveBeenCalledWith(
         '\n✅ test completed successfully (all stages)',
       );
@@ -200,6 +209,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
       ];
 
       vi.mocked(getWorkspacePackages).mockResolvedValue(mockPackages);
+
       vi.mocked(executeStages).mockResolvedValue(undefined);
 
       // Filter to only packages starting with 'package-'
@@ -217,6 +227,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
       const expectedFilteredPackages = mockPackages.filter((pkg) =>
         pkg.name.startsWith('package-'),
       );
+
       expect(executeStages).toHaveBeenCalledWith(
         expectedFilteredPackages,
         'test',
@@ -238,6 +249,7 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
     try {
       // Mock getWorkspacePackages to throw an error
       const mockError = new Error('Failed to load workspace packages');
+
       vi.mocked(getWorkspacePackages).mockRejectedValue(mockError);
 
       // Execute the function
@@ -254,9 +266,11 @@ describe('runCmdInStagesAcrossWorkspaces', () => {
       expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
         '\n❌ test failed (fail-fast mode stopped execution):',
       );
+
       expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
         'Failed to load workspace packages',
       );
+
       expect(spies.processExitSpy).toHaveBeenCalledWith(1);
     } finally {
       cleanupSpies(spies);

package/src/node-global.mts

@@ -29,14 +29,20 @@ Object.assign(globalThis, globalsDef);
 
 declare global {
   const path: typeof path_;
+
   const fs: typeof fs_;
+
   const os: typeof os_;
+
   const glob: typeof glob_;
 
   const $: typeof $_;
+
   const Result: typeof Result_;
-  type Result<S, E> = Result_<S, E>;
+
   const echo: typeof console.log;
+
   const cd: typeof chdir_;
+
   const isDirectlyExecuted: typeof isDirectlyExecuted_;
 }