rman 2.8.0 → 2.10.0

package/services/version.service.js

@@ -86,7 +86,10 @@ export class VersionService extends Service {
             const hook = (slot) => RunService.runLifecycleSlot(pkg, VERSION_LIFECYCLE, slot, RunService.normalizeScriptValue(
             /** `at`: the path is what tells a step function from a value one, and this is a fragment -
              *  without it a function here was called while the hook was being prepared. */
-            interpolator.interpolate({ config: pkg.config?.version?.[slot], scope, at: ['version', slot] }), `version.${slot}`));
+            interpolator.interpolate({ config: pkg.config?.version?.[slot], scope, at: ['version', slot] }), `version.${slot}`, 
+            /** A version hook runs for one package around its own version write - there is no
+             *  package graph here to wait on, so `topo` is refused rather than silently ignored. */
+            { topo: false }));
             await hook('before');
             /** Through the manifest, not through a `package.json` field: where a version is written is
              *  the provider's business (see `Plugin`'s manifest members), and this is the one place rman changes
@@ -286,8 +289,10 @@ export class VersionService extends Service {
      * never run. (The doc comment also still named `.script`/`.preScript`/`.postScript`, three keys
      * that have been `before`/`exec`/`after` for a long time.)
      */
+    /** `topo` is refused by default here, which is the one way this differs from `RunService`'s: a
+     *  version hook has no package ordering to join. */
     function normalizeScriptValue(value, at) {
-        return RunService.normalizeScriptValue(value, at);
+        return RunService.normalizeScriptValue(value, at, { topo: false });
     }
     VersionService.normalizeScriptValue = normalizeScriptValue;
     /**

package/utils/run-options.d.ts

@@ -1,4 +1,48 @@
 import type { RunService } from '../services/run.service.js';
+/**
+ * The three scheduling flags any command that sweeps packages can take - `--parallel`, `--bail`,
+ * `--progress`.
+ *
+ * **Exported as a group for the reason `packageFilterOptions` is**: a command spreading it gets the
+ * flags spelled and behaving exactly as `run`'s, where restating them means `--parallel` quietly
+ * accepting a number on one command and not on another. `--parallel`'s `coerce` is the part nobody
+ * would copy correctly - it takes a boolean *or* a number, and the type of the parsed value is read
+ * off that function.
+ *
+ * **`--topo` is deliberately not in it.** `run`'s default is ordering on; a command reaching for
+ * this is sweeping packages with an independent tool, where a wait nobody asked for costs the whole
+ * point. A command that does want it declares it, and `forEachPackage` takes `topo` as an option.
+ *
+ * The `describe` texts here name no `.rmanrc run.<script>` key, because a command using them owns
+ * its own (`check.concurrency`) - which is also why `runOptions` keeps its own wording rather than
+ * spreading this.
+ */
+export declare const parallelOptions: {
+    parallel: {
+        target: "cli";
+        describe: string;
+        /** No `type`: the flag takes a boolean *or* a number, and `coerce` is what says so - which is
+         *  also where `OptionValue` reads this option's type from. */
+        coerce: (v: unknown) => boolean | number | undefined;
+    };
+    bail: {
+        target: "cli";
+        describe: string;
+        type: "boolean";
+    };
+    progress: {
+        target: "cli";
+        describe: string;
+        type: "boolean";
+    };
+};
+/** The scheduling half of `forEachPackage`'s options, read off argv - the mirror of
+ *  `readRunOptions` for a command that declared `parallelOptions`. */
+export declare function readParallelOptions(args: any): {
+    parallel?: boolean | number;
+    bail?: boolean;
+    progress?: boolean;
+};
 /**
  * Everything `run`, `build` and `test` accept - the package filter, the branch guard, `--from-root`, and
  * the scheduling flags on top.

package/utils/run-options.js

@@ -1,5 +1,60 @@
 import { branchGuardOptions } from './branch-guard.js';
 import { fromRootOption, packageFilterOptions, readPackageFilterOptions } from './package-filter.js';
+/**
+ * The three scheduling flags any command that sweeps packages can take - `--parallel`, `--bail`,
+ * `--progress`.
+ *
+ * **Exported as a group for the reason `packageFilterOptions` is**: a command spreading it gets the
+ * flags spelled and behaving exactly as `run`'s, where restating them means `--parallel` quietly
+ * accepting a number on one command and not on another. `--parallel`'s `coerce` is the part nobody
+ * would copy correctly - it takes a boolean *or* a number, and the type of the parsed value is read
+ * off that function.
+ *
+ * **`--topo` is deliberately not in it.** `run`'s default is ordering on; a command reaching for
+ * this is sweeping packages with an independent tool, where a wait nobody asked for costs the whole
+ * point. A command that does want it declares it, and `forEachPackage` takes `topo` as an option.
+ *
+ * The `describe` texts here name no `.rmanrc run.<script>` key, because a command using them owns
+ * its own (`check.concurrency`) - which is also why `runOptions` keeps its own wording rather than
+ * spreading this.
+ */
+export const parallelOptions = {
+    parallel: {
+        target: 'cli',
+        describe: 'Max packages at once: omit/true for CPU count, a number for that many, false to run serially',
+        /** No `type`: the flag takes a boolean *or* a number, and `coerce` is what says so - which is
+         *  also where `OptionValue` reads this option's type from. */
+        coerce: (v) => {
+            if (v === undefined)
+                return undefined;
+            if (v === 'false' || v === false)
+                return false;
+            if (v === 'true' || v === true)
+                return true;
+            const n = Number(v);
+            return Number.isFinite(n) ? n : true;
+        },
+    },
+    bail: {
+        target: 'cli',
+        describe: 'Stop at the first failure. Default true.',
+        type: 'boolean',
+    },
+    progress: {
+        target: 'cli',
+        describe: 'Show a live progress panel (default: true; auto-disabled when not a TTY)',
+        type: 'boolean',
+    },
+};
+/** The scheduling half of `forEachPackage`'s options, read off argv - the mirror of
+ *  `readRunOptions` for a command that declared `parallelOptions`. */
+export function readParallelOptions(args) {
+    return {
+        parallel: args.parallel,
+        bail: args.bail,
+        progress: args.progress,
+    };
+}
 /**
  * Everything `run`, `build` and `test` accept - the package filter, the branch guard, `--from-root`, and
  * the scheduling flags on top.