@travetto/repo 7.0.5 → 7.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/repo",
-  "version": "7.0.5",
+  "version": "7.0.7",
   "type": "module",
   "description": "Monorepo utilities",
   "keywords": [
@@ -23,10 +23,10 @@
     "directory": "module/repo"
   },
   "dependencies": {
-    "@travetto/worker": "^7.0.3"
+    "@travetto/worker": "^7.0.5"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.5"
+    "@travetto/cli": "^7.0.7"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/support/bin/exec.ts

@@ -1,6 +1,6 @@
-import { ChildProcess } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
 
-import { ExecutionResult, Env, Util, ExecUtil, castTo } from '@travetto/runtime';
+import { type ExecutionResult, Env, Util, ExecUtil, castTo } from '@travetto/runtime';
 import { CliModuleUtil } from '@travetto/cli';
 import type { IndexedModule } from '@travetto/manifest';
 import { StyleUtil, Terminal, TerminalUtil } from '@travetto/terminal';
@@ -14,9 +14,9 @@ const COLORS = ([...[
 ] as const]).toSorted(() => Math.random() < .5 ? -1 : 1).map(color => StyleUtil.getStyle(color));
 
 type ModuleRunConfig<T = ExecutionResult<string>> = {
-  progressMessage?: (mod: IndexedModule | undefined) => string;
-  filter?: (mod: IndexedModule) => boolean | Promise<boolean>;
-  transformResult?: (mod: IndexedModule, result: ExecutionResult<string>) => T;
+  progressMessage?: (module: IndexedModule | undefined) => string;
+  filter?: (module: IndexedModule) => boolean | Promise<boolean>;
+  transformResult?: (module: IndexedModule, result: ExecutionResult<string>) => T;
   workerCount?: number;
   prefixOutput?: boolean;
   showStdout?: boolean;
@@ -33,11 +33,11 @@ export class RepoExecUtil {
 
   /**
    * Build equal sized prefix labels for outputting
-   * @param mods
+   * @param modules
    * @returns
    */
-  static #buildPrefixes(mods: IndexedModule[]): Record<string, string> {
-    const folders = mods.map(mod => mod.sourceFolder);
+  static #buildPrefixes(modules: IndexedModule[]): Record<string, string> {
+    const folders = modules.map(module => module.sourceFolder);
     const maxWidth = Math.max(...folders.map(folder => folder.length));
     return Object.fromEntries(folders.map((folder, i) => [folder, colorize(folder.padStart(maxWidth, ' ').padEnd(maxWidth + 1), i)]));
   }
@@ -47,30 +47,30 @@ export class RepoExecUtil {
    */
   static async execOnModules<T = ExecutionResult>(
     mode: 'all' | 'workspace' | 'changed',
-    operation: (mod: IndexedModule) => ChildProcess,
+    operation: (module: IndexedModule) => ChildProcess,
     config: ModuleRunConfig<T> = {}
   ): Promise<Map<IndexedModule, T>> {
 
     config.showStdout = config.showStdout ?? (Env.DEBUG.isSet && !Env.DEBUG.isFalse);
     config.showStderr = config.showStderr ?? true;
-    const transform = config.transformResult ?? ((mod, result): T => castTo(result));
+    const transform = config.transformResult ?? ((module, result): T => castTo(result));
 
     const workerCount = config.workerCount ?? WorkPool.DEFAULT_SIZE;
 
-    const mods = await CliModuleUtil.findModules(mode);
+    const modules = await CliModuleUtil.findModules(mode);
     const results = new Map<IndexedModule, T>();
     const processes = new Map<IndexedModule, ChildProcess>();
 
-    const prefixes = config.prefixOutput !== false ? this.#buildPrefixes(mods) : {};
+    const prefixes = config.prefixOutput !== false ? this.#buildPrefixes(modules) : {};
     const stdoutTerm = new Terminal(process.stdout);
     const stderrTerm = new Terminal(process.stderr);
 
-    const work = WorkPool.runStreamProgress(async (mod) => {
+    const work = WorkPool.runStreamProgress(async (module) => {
       try {
-        if (!(await config.filter?.(mod) === false)) {
-          const prefix = prefixes[mod.sourceFolder] ?? '';
-          const subProcess = operation(mod);
-          processes.set(mod, subProcess);
+        if (!(await config.filter?.(module) === false)) {
+          const prefix = prefixes[module.sourceFolder] ?? '';
+          const subProcess = operation(module);
+          processes.set(module, subProcess);
 
           if (config.showStdout && subProcess.stdout) {
             ExecUtil.readLines(subProcess.stdout, line =>
@@ -84,14 +84,14 @@ export class RepoExecUtil {
           }
 
           const result = await ExecUtil.getResult(subProcess, { catch: true });
-          const output = transform(mod, result);
-          results.set(mod, output);
+          const output = transform(module, result);
+          results.set(module, output);
         }
-        return config.progressMessage?.(mod) ?? mod.name;
+        return config.progressMessage?.(module) ?? module.name;
       } finally {
-        processes.get(mod!)?.kill();
+        processes.get(module!)?.kill();
       }
-    }, mods, mods.length, { max: workerCount, min: workerCount });
+    }, modules, modules.length, { max: workerCount, min: workerCount });
 
     if (config.progressMessage && stdoutTerm.interactive) {
       await stdoutTerm.streamToBottom(Util.mapAsyncIterable(work, TerminalUtil.progressBarUpdater(stdoutTerm, { withWaiting: true })));

package/support/bin/package-manager.ts

@@ -1,8 +1,8 @@
 import path from 'node:path';
-import { spawn, ChildProcess } from 'node:child_process';
+import { spawn, type ChildProcess } from 'node:child_process';
 import fs from 'node:fs/promises';
 
-import { ExecUtil, ExecutionResult, JSONUtil } from '@travetto/runtime';
+import { ExecUtil, type ExecutionResult, JSONUtil } from '@travetto/runtime';
 import { type IndexedModule, type ManifestContext, type Package, PackageUtil } from '@travetto/manifest';
 import { CliModuleUtil } from '@travetto/cli';
 
@@ -18,23 +18,23 @@ export class PackageManager {
   /**
    * Is a module already published
    */
-  static isPublished(ctx: Ctx, mod: IndexedModule): ChildProcess {
+  static isPublished(ctx: Ctx, module: IndexedModule): ChildProcess {
     let args: string[];
     switch (ctx.workspace.manager) {
       case 'npm':
-        args = ['show', `${mod.name}@${mod.version}`, 'version', '--json'];
+        args = ['show', `${module.name}@${module.version}`, 'version', '--json'];
         break;
       case 'yarn':
-        args = ['info', `${mod.name}@${mod.version}`, 'dist.integrity', '--json'];
+        args = ['info', `${module.name}@${module.version}`, 'dist.integrity', '--json'];
         break;
     }
-    return spawn(ctx.workspace.manager, args, { cwd: mod.sourceFolder });
+    return spawn(ctx.workspace.manager, args, { cwd: module.sourceFolder });
   }
 
   /**
    * Validate published result
    */
-  static validatePublishedResult(ctx: Ctx, mod: IndexedModule, result: ExecutionResult<string>): boolean {
+  static validatePublishedResult(ctx: Ctx, module: IndexedModule, result: ExecutionResult<string>): boolean {
     switch (ctx.workspace.manager) {
       case 'npm': {
         if (!result.valid && !result.stderr.includes('E404')) {
@@ -42,7 +42,7 @@ export class PackageManager {
         }
         const item: (string[] | string) = result.stdout ? JSONUtil.parseSafe(result.stdout) : [];
         const found = Array.isArray(item) ? item.pop() : item;
-        return !!found && found === mod.version;
+        return !!found && found === module.version;
       }
       case 'yarn': {
         const parsed = JSONUtil.parseSafe<{ data?: unknown }>(result.stdout);
@@ -55,12 +55,12 @@ export class PackageManager {
    * Setting the version
    */
   static async version(ctx: Ctx, modules: IndexedModule[], level: SemverLevel, preid?: string): Promise<void> {
-    const mods = modules.flatMap(mod => ['-w', mod.sourceFolder]);
+    const moduleArgs = modules.flatMap(module => ['-w', module.sourceFolder]);
     let args: string[];
     switch (ctx.workspace.manager) {
       case 'npm':
       case 'yarn':
-        args = ['version', '--no-workspaces-update', level, ...(preid ? ['--preid', preid] : []), ...mods];
+        args = ['version', '--no-workspaces-update', level, ...(preid ? ['--preid', preid] : []), ...moduleArgs];
         break;
     }
     await ExecUtil.getResult(spawn(ctx.workspace.manager, args, { cwd: ctx.workspace.path, stdio: 'inherit' }));
@@ -69,7 +69,7 @@ export class PackageManager {
   /**
    * Dry-run packaging
    */
-  static dryRunPackaging(ctx: Ctx, mod: IndexedModule): ChildProcess {
+  static dryRunPackaging(ctx: Ctx, module: IndexedModule): ChildProcess {
     let args: string[];
     switch (ctx.workspace.manager) {
       case 'npm':
@@ -77,18 +77,18 @@ export class PackageManager {
         args = ['pack', '--dry-run'];
         break;
     }
-    return spawn(ctx.workspace.manager, args, { cwd: mod.sourcePath });
+    return spawn(ctx.workspace.manager, args, { cwd: module.sourcePath });
   }
 
   /**
    * Publish a module
    */
-  static publish(ctx: Ctx, mod: IndexedModule, dryRun: boolean | undefined): ChildProcess {
+  static publish(ctx: Ctx, module: IndexedModule, dryRun: boolean | undefined): ChildProcess {
     if (dryRun) {
-      return this.dryRunPackaging(ctx, mod);
+      return this.dryRunPackaging(ctx, module);
     }
 
-    const versionTag = mod.version.match(/^.*-(rc|alpha|beta|next)[.]\d+/)?.[1] ?? 'latest';
+    const versionTag = module.version.match(/^.*-(rc|alpha|beta|next)[.]\d+/)?.[1] ?? 'latest';
     let args: string[];
     switch (ctx.workspace.manager) {
       case 'npm':
@@ -96,7 +96,7 @@ export class PackageManager {
         args = ['publish', '--tag', versionTag, '--access', 'public'];
         break;
     }
-    return spawn(ctx.workspace.manager, args, { cwd: mod.sourcePath });
+    return spawn(ctx.workspace.manager, args, { cwd: module.sourcePath });
   }
 
   /**
@@ -116,7 +116,7 @@ export class PackageManager {
    */
   static async synchronizeVersions(): Promise<Record<string, string>> {
     const versions: Record<string, string> = {};
-    const folders = (await CliModuleUtil.findModules('workspace')).map(mod => mod.sourcePath);
+    const folders = (await CliModuleUtil.findModules('workspace')).map(module => module.sourcePath);
     const packages = folders.map(folder => {
       const pkg = PackageUtil.readPackage(folder, true);
       versions[pkg.name] = `^${pkg.version}`;
@@ -130,9 +130,9 @@ export class PackageManager {
         pkg.optionalDependencies ?? {},
         pkg.peerDependencies ?? {}
       ]) {
-        for (const [mod, ver] of Object.entries(versions)) {
-          if (mod in group && !/^[*]|(file:.*)$/.test(group[mod])) {
-            group[mod] = ver;
+        for (const [module, ver] of Object.entries(versions)) {
+          if (module in group && !/^[*]|(file:.*)$/.test(group[module])) {
+            group[module] = ver;
           }
         }
       }

package/support/cli.repo_exec.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 
-import { CliCommand, CliCommandShape, ParsedState } from '@travetto/cli';
+import { CliCommand, type CliCommandShape, type ParsedState } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';
 import { Env } from '@travetto/runtime';
 import { Ignore, Max, Min } from '@travetto/schema';
@@ -38,16 +38,16 @@ export class RepoExecCommand implements CliCommandShape {
 
     await RepoExecUtil.execOnModules(
       this.changed ? 'changed' : 'workspace',
-      mod => spawn(cmd, finalArgs, {
-        cwd: mod.sourceFolder,
+      module => spawn(cmd, finalArgs, {
+        cwd: module.sourceFolder,
         env: {
           ...process.env,
-          ...Env.TRV_MODULE.export(mod.name),
+          ...Env.TRV_MODULE.export(module.name),
           ...Env.TRV_MANIFEST.export(undefined)
         }
       }),
       {
-        progressMessage: mod => `Running '${cmd} ${finalArgs.join(' ')}' [%idx/%total] ${mod?.sourceFolder ?? ''}`,
+        progressMessage: module => `Running '${cmd} ${finalArgs.join(' ')}' [%idx/%total] ${module?.sourceFolder ?? ''}`,
         showStdout: this.showStdout,
         prefixOutput: this.prefixOutput,
         workerCount: this.workers,

package/support/cli.repo_list.ts

@@ -1,4 +1,4 @@
-import { CliCommandShape, CliCommand, CliModuleUtil } from '@travetto/cli';
+import { type CliCommandShape, CliCommand, CliModuleUtil } from '@travetto/cli';
 import { Runtime, RuntimeIndex } from '@travetto/runtime';
 
 const write = (line: string): Promise<void> => new Promise(resolve => process.stdout.write(`${line}\n`, () => resolve()));
@@ -29,26 +29,26 @@ export class ListModuleCommand implements CliCommandShape {
 
   async main(): Promise<void> {
 
-    const mods = await CliModuleUtil.findModules(this.changed ? 'changed' : 'workspace', this.fromHash, this.toHash);
+    const modules = await CliModuleUtil.findModules(this.changed ? 'changed' : 'workspace', this.fromHash, this.toHash);
     switch (this.format) {
       case 'list': {
-        for (const folder of mods.map(mod => mod.sourceFolder).toSorted()) {
+        for (const folder of modules.map(module => module.sourceFolder).toSorted()) {
           await write(folder);
         }
         break;
       }
       case 'json': {
-        const outputMap = CliModuleUtil.getDependencyGraph(mods);
+        const outputMap = CliModuleUtil.getDependencyGraph(modules);
         await write(JSON.stringify(Object.entries(outputMap)
           .map(([name, children]) => ({ name, children, workspace: RuntimeIndex.getModule(name)?.workspace })), null, 2));
         break;
       }
       case 'graph': {
         await write('digraph g {');
-        for (const mod of mods) {
-          for (const parent of mod.parents) {
+        for (const module of modules) {
+          for (const parent of module.parents) {
             if (parent !== Runtime.main.name) {
-              await write(`  "${parent}" -> "${mod.name}";`);
+              await write(`  "${parent}" -> "${module.name}";`);
             }
           }
         }

package/support/cli.repo_publish.ts

@@ -1,4 +1,4 @@
-import { CliCommandShape, CliCommand } from '@travetto/cli';
+import { type CliCommandShape, CliCommand } from '@travetto/cli';
 import { Runtime } from '@travetto/runtime';
 
 import { PackageManager } from './bin/package-manager.ts';
@@ -14,23 +14,23 @@ export class RepoPublishCommand implements CliCommandShape {
   dryRun = true;
 
   async main(): Promise<void> {
-    const published = await RepoExecUtil.execOnModules('workspace', mod => PackageManager.isPublished(Runtime, mod), {
-      filter: mod => !!mod.workspace && !mod.internal,
-      progressMessage: (mod) => `Checking published [%idx/%total] -- ${mod?.name}`,
+    const published = await RepoExecUtil.execOnModules('workspace', module => PackageManager.isPublished(Runtime, module), {
+      filter: module => !!module.workspace && !module.internal,
+      progressMessage: (module) => `Checking published [%idx/%total] -- ${module?.name}`,
       showStderr: false,
-      transformResult: (mod, result) => PackageManager.validatePublishedResult(Runtime, mod, result),
+      transformResult: (module, result) => PackageManager.validatePublishedResult(Runtime, module, result),
     });
 
     if (this.dryRun) {
-      console.log('Unpublished modules', [...published.entries()].filter(entry => !entry[1]).map(([mod]) => mod.sourceFolder));
+      console.log('Unpublished modules', [...published.entries()].filter(entry => !entry[1]).map(([module]) => module.sourceFolder));
     }
 
     await RepoExecUtil.execOnModules(
-      'workspace', mod => PackageManager.publish(Runtime, mod, this.dryRun),
+      'workspace', module => PackageManager.publish(Runtime, module, this.dryRun),
       {
-        progressMessage: (mod) => `Published [%idx/%total] -- ${mod?.name}`,
+        progressMessage: (module) => `Published [%idx/%total] -- ${module?.name}`,
         showStdout: false,
-        filter: mod => published.get(mod) === false
+        filter: module => published.get(module) === false
       }
     );
   }

package/support/cli.repo_version-sync.ts

@@ -1,4 +1,4 @@
-import { CliCommandShape, CliCommand } from '@travetto/cli';
+import { type CliCommandShape, CliCommand } from '@travetto/cli';
 import { PackageManager } from './bin/package-manager.ts';
 
 /**

package/support/cli.repo_version.ts

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
 
-import { CliModuleUtil, CliCommandShape, CliCommand, CliScmUtil, CliValidationError } from '@travetto/cli';
+import { CliModuleUtil, type CliCommandShape, CliCommand, CliScmUtil, type CliValidationError } from '@travetto/cli';
 import { Runtime } from '@travetto/runtime';
 
-import { PackageManager, SemverLevel } from './bin/package-manager.ts';
+import { PackageManager, type SemverLevel } from './bin/package-manager.ts';
 
 const CHANGE_LEVELS = new Set<SemverLevel>(['prerelease', 'patch', 'prepatch']);
 
@@ -39,7 +39,7 @@ export class RepoVersionCommand implements CliCommandShape {
 
     const allModules = await CliModuleUtil.findModules(mode);
 
-    const modules = allModules.filter(mod => !mod.internal && (this.mode !== 'direct' || this.modules?.includes(mod.name)));
+    const modules = allModules.filter(module => !module.internal && (this.mode !== 'direct' || this.modules?.includes(module.name)));
 
     // Do we have valid changes?
     if (!modules.length) {
@@ -50,7 +50,7 @@ export class RepoVersionCommand implements CliCommandShape {
 
     const versions = await PackageManager.synchronizeVersions();
     if (this.commit) {
-      const commitMessage = `Publish ${modules.map(mod => `${mod.name}#${versions[mod.name]?.replace('^', '') ?? mod.version}`).join(',')}`;
+      const commitMessage = `Publish ${modules.map(module => `${module.name}#${versions[module.name]?.replace('^', '') ?? module.version}`).join(',')}`;
       console.log!(await CliScmUtil.createCommit(commitMessage));
       if (this.tag) {
         await CliScmUtil.createTag(versions['@travetto/manifest']);