rman 2.15.1 → 2.16.0

package/builtins/platforms/node/node-config.interface.d.ts

@@ -61,6 +61,17 @@ export declare namespace RmanNodeConfig {
          * own "Unknown command: stage" is a better message than a guess made somewhere else.
          */
         staged?: ConfigValue<boolean>;
+        /**
+         * The prerelease identifiers that are **not previews** for this package - a version on one of
+         * them publishes to `latest` like a release, instead of under a dist-tag of its own.
+         *
+         * For a package whose every release is a prerelease by design: `["rev"]` publishes
+         * `4.13.3-rev.9` to `latest`, while a `4.14.0-beta.0` of the same package keeps its own `beta`
+         * tag. Pairs with `.rmanrc "version.preid"`.
+         *
+         * @example ["rev"]
+         */
+        latestPrereleases?: ConfigValue<string[]>;
     }
 }
 /**

package/builtins/platforms/node/services/publish.service.js

@@ -501,7 +501,7 @@ function retiredDirectoryKey(pkg) {
  * checks; they agree deliberately.
  */
 function distTagFor(pkg, tag) {
-    const isPreview = !isCalendarVersion(pkg.version) && pkg.versionScheme.isPrerelease(pkg.version);
+    const isPreview = !isCalendarVersion(pkg.version) && pkg.versionScheme.isPrerelease(pkg.version) && !releasesAsLatest(pkg);
     if (!isPreview)
         return { tag };
     if (tag) {
@@ -553,3 +553,18 @@ function resolveStaged(pkg, override) {
         return override;
     return !!pkg.config?.publish?.npm?.staged;
 }
+/**
+ * Whether `pkg`'s prerelease identifier is one `.rmanrc "publish.npm.latestPrereleases"` lists - a
+ * line the package releases on for good, which publishes to `latest` like any release.
+ */
+/* **An explicit list, not "whatever `version.preid` says".** A repository can put its previews on a
+ * declared line too (`preid: beta`), and reading the bump's setting as a statement about the
+ * registry would have every such beta land on `latest` - the one mistake `distTagFor` exists to
+ * stop. Naming the identifier also keeps the protection for every other one: a `-beta.0` of a
+ * package publishing `-rev.N` to `latest` still gets its own tag. Requested from `panates/browsery`,
+ * which repackages upstream modules as `<upstream version>-rev.N`. */
+function releasesAsLatest(pkg) {
+    const listed = pkg.config?.publish?.npm?.latestPrereleases;
+    const id = pkg.versionScheme.prereleaseId(pkg.version);
+    return !!id && Array.isArray(listed) && listed.includes(id);
+}

package/commands/deps.command.js

@@ -200,9 +200,13 @@ function jsonPlan(entries) {
 function printPlan(entries, root) {
     const updated = entries.filter(e => e.status === 'update');
     const behind = entries.filter(e => e.status === 'held' || e.status === 'skipped' || e.status === 'error' || (e.status === 'update' && e.reason));
-    if (!updated.length && !behind.length) {
-        console.log(colors.gray('Every dependency is up to date.'));
-        return;
+    /** Said first when nothing moves, so a run whose only lines are majors left behind does not read
+     *  as a list of things to do. */
+    if (!updated.length) {
+        console.log(colors.green('All dependencies are up to date') +
+            (behind.length ? colors.gray(' - newer versions their settings leave out, or another rule holds back:') : '.'));
+        if (!behind.length)
+            return;
     }
     const shown = [...updated, ...behind];
     const nameWidth = Math.max(...shown.map(e => e.name.length));

package/commands/version.command.d.ts

@@ -58,8 +58,10 @@ declare const config: {
         describe: string;
         type: "boolean";
     };
+    /** `target: 'both'`: a flag for one prerelease, and `.rmanrc "version.preid"` for a repository
+     *  that releases on a prerelease line for good (`4.13.3-rev.N`). */
     preid: {
-        target: "cli";
+        target: "both";
         describe: string;
         type: "string";
     };
@@ -257,8 +259,10 @@ declare const versionCommand: (app: import("../index.js").RmanApplication) => {
             describe: string;
             type: "boolean";
         };
+        /** `target: 'both'`: a flag for one prerelease, and `.rmanrc "version.preid"` for a repository
+         *  that releases on a prerelease line for good (`4.13.3-rev.N`). */
         preid: {
-            target: "cli";
+            target: "both";
             describe: string;
             type: "string";
         };

package/commands/version.command.js

@@ -77,11 +77,14 @@ const config = {
             '"version.changelog", or false - --no-changelog forces it off even when that\'s true.',
         type: 'boolean',
     },
+    /** `target: 'both'`: a flag for one prerelease, and `.rmanrc "version.preid"` for a repository
+     *  that releases on a prerelease line for good (`4.13.3-rev.N`). */
     preid: {
-        target: 'cli',
+        target: 'both',
         describe: 'Make the bump a prerelease with this identifier (e.g. "beta" -> 1.2.3-beta.0). ' +
             'Running again with the same --preid increments it (-> 1.2.3-beta.1); a different ' +
-            'identifier starts a fresh prerelease line. Ignored when bump is an explicit version.',
+            'identifier starts a fresh prerelease line. Ignored when bump is an explicit version. ' +
+            'Default: .rmanrc "version.preid", which every member of a group has to agree on.',
         type: 'string',
     },
     /**

package/constants.js

@@ -1 +1 @@
-export const version = '2.15.1';
+export const version = '2.16.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/services/version-plan.service.d.ts

@@ -129,6 +129,12 @@ export declare abstract class VersionPlanService {
      * case the technology's own `cascade` answers. Members disagreeing take the widest, the same rule
      * and the same direction `cascadeFor` applies to two technologies.
      */
+    /**
+     * The prerelease identifier a group's members declare in `.rmanrc "version.preid"`, or `undefined`
+     * when none does. Members declaring different ones are an error naming them: a group is one
+     * version line, and a line cannot be on two prerelease identifiers at once.
+     */
+    protected declaredPreid(members: Package[], label: string): string | undefined;
     protected declaredCascade(members: Package[]): VersionPlanService.Cascade | undefined;
     /**
      * The largest bump `commits` ask for, in `scheme`'s own names.

package/services/version-plan.service.js

@@ -160,7 +160,8 @@ export class VersionPlanService {
                 groups.set(key, [pkg]);
         }
         for (const [key, members] of groups) {
-            this.computeGroupPlan(key, members, changeByPackage, explicitVersion, options.preid, entries);
+            const preid = options.preid ?? this.declaredPreid(members, this.groupLabel(key));
+            this.computeGroupPlan(key, members, changeByPackage, explicitVersion, preid, entries);
         }
         this.rippleCrossGroup(packages, entries, options.preid);
         const result = packages.map(pkg => entries.get(pkg.name));
@@ -267,6 +268,31 @@ export class VersionPlanService {
      * `^1.0.0` does not admit `2.0.0` and an in-group dependent left at the old number would declare
      * a range its own group no longer satisfies. So `changed` means "no floor of my own", not "never
      * more than the changed packages". */
+    /**
+     * The prerelease identifier a group's members declare in `.rmanrc "version.preid"`, or `undefined`
+     * when none does. Members declaring different ones are an error naming them: a group is one
+     * version line, and a line cannot be on two prerelease identifiers at once.
+     */
+    /* **A member saying nothing agrees with whoever does.** The usual shape is one declaration above
+     * the group (`"[*]"`, or a shared preset), which reaches every member; a group where only some
+     * members say it is still one line, and refusing it would make adding a package to a group a way
+     * to break its release. Two different words are the only disagreement, and that one has no
+     * answer: `4.13.3-rev.9` and `4.13.3-beta.0` cannot both be the group's next version. */
+    declaredPreid(members, label) {
+        const declared = new Map();
+        for (const m of members) {
+            const preid = m.config?.version?.preid;
+            if (typeof preid !== 'string' || !preid)
+                continue;
+            declared.set(preid, [...(declared.get(preid) ?? []), m.name]);
+        }
+        if (declared.size > 1) {
+            const sides = [...declared].map(([preid, names]) => `"${preid}" (${names.join(', ')})`).join(' and ');
+            throw new Error(`Group ${label} is one version line, but its members declare different "version.preid": ${sides}. ` +
+                'Declare one identifier for the whole group.');
+        }
+        return declared.keys().next().value;
+    }
     declaredCascade(members) {
         const declared = new Set(members.map(m => m.config?.version?.cascade).filter((c) => !!c));
         if (!declared.size)
@@ -454,7 +480,10 @@ export class VersionPlanService {
                 const next = {
                     ...entry,
                     status: 'bump',
-                    to: pkg.versionScheme.next(groupCeiling, pkg.versionScheme.smallestBump(), { preid }),
+                    to: pkg.versionScheme.next(groupCeiling, pkg.versionScheme.smallestBump(), {
+                        preid: preid ??
+                            this.declaredPreid(packages.filter(p => entries.get(p.name).groupKey === entry.groupKey), entry.group ?? entry.groupKey),
+                    }),
                     reason: `depends on ${source.package.name}@${source.to}`,
                 };
                 entries.set(pkg.name, next);

package/utils/status-region.d.ts

@@ -33,6 +33,12 @@ export declare class StatusRegion implements TerminalRegion {
      * there, so `runBin` keeps asking one object (`app.statusRegion`) whatever is actually drawing.
      */
     private takeover?;
+    /** Puts back the stream writes `guardWrites` replaced. */
+    private restoreWrites?;
+    /** Set while this region is writing its own frame, so the guard lets it through untouched. */
+    private drawing;
+    /** The last write from outside ended mid-line, so no frame is drawn until the line is finished. */
+    private partial;
     constructor(label: string, detail?: string, enabled?: boolean);
     /** Whether the spinner is actually drawn. `false` leaves `passThrough` a plain write and `stop`
      *  its single line, which is what a non-TTY wants. */
@@ -69,6 +75,14 @@ export declare class StatusRegion implements TerminalRegion {
     passThrough(text: string): void;
     /** Erases the spinner and leaves one line saying how it went. */
     stop(outcome: 'ok' | 'fail'): void;
+    /**
+     * Moves every write to stdout and stderr above the spinner: erase it, write, draw it again below.
+     * Undone by `stop`.
+     */
+    private guardWrites;
+    /** Runs `write` as one of this region's own writes, so the guard passes it through. */
+    private own;
+    private clear;
     private draw;
     /** `0.4s` while running and `950ms` / `4.1s` / `2m 03s` at the end - one formatter, because a
      *  duration that changes shape as it ticks reads as a glitch. */

package/utils/status-region.js

@@ -12,6 +12,12 @@ export class StatusRegion {
      * there, so `runBin` keeps asking one object (`app.statusRegion`) whatever is actually drawing.
      */
     takeover;
+    /** Puts back the stream writes `guardWrites` replaced. */
+    restoreWrites;
+    /** Set while this region is writing its own frame, so the guard lets it through untouched. */
+    drawing = false;
+    /** The last write from outside ended mid-line, so no frame is drawn until the line is finished. */
+    partial = false;
     constructor(label, detail = '', enabled) {
         this.label = label;
         this.detail = detail;
@@ -26,6 +32,7 @@ export class StatusRegion {
     start() {
         if (!this.region.enabled)
             return;
+        this.guardWrites();
         this.draw();
         /** **`unref`, so a spinner never holds the process open.** A command that finishes its work and
          *  leaves nothing else pending would otherwise wait out the interval before exiting. */
@@ -55,7 +62,7 @@ export class StatusRegion {
         if (this.timer)
             clearInterval(this.timer);
         this.timer = undefined;
-        this.region.clear();
+        this.clear();
     }
     /**
      * Takes the terminal back - a no-op when it was never suspended.
@@ -88,8 +95,8 @@ export class StatusRegion {
             process.stderr.write(text);
             return;
         }
-        this.region.clear();
-        process.stderr.write(text);
+        this.clear();
+        this.own(() => process.stderr.write(text));
         this.draw();
     }
     /** Erases the spinner and leaves one line saying how it went. */
@@ -98,11 +105,62 @@ export class StatusRegion {
         if (this.timer)
             clearInterval(this.timer);
         this.timer = undefined;
-        this.region.clear();
+        this.clear();
+        this.restoreWrites?.();
+        this.restoreWrites = undefined;
         const mark = outcome === 'ok' ? colors.green('✔') : colors.red('✖');
-        process.stderr.write(`${mark} ${colors.bold(this.label)} ${colors.gray(this.elapsed())}\n`);
+        const lead = this.partial ? '\n' : '';
+        process.stderr.write(`${lead}${mark} ${colors.bold(this.label)} ${colors.gray(this.elapsed())}\n`);
+    }
+    /**
+     * Moves every write to stdout and stderr above the spinner: erase it, write, draw it again below.
+     * Undone by `stop`.
+     */
+    /* **Here, once, rather than in every command.** Measured with a pseudo-terminal: `rman deps`
+     * printed its plan with `console.log`, the spinner's next erase moved up one row from *below* the
+     * plan, and the plan's last line - the one dependency it was reporting - was gone from the screen,
+     * leaving a "not updated" heading with nothing under it. `version --show` lost its closing
+     * "Nothing to version." the same way. Asking each command to route its output through
+     * `passThrough` is a rule every new command would have to remember; a command's own `console.log`
+     * is the ordinary thing to write.
+     *
+     * **Left alone while suspended**: the region that took over draws to stdout itself, and it owns the
+     * terminal until `resume`. **A write ending mid-line holds the next frame back** (`partial`), or the
+     * frame's `\r` + erase would wipe the half-written line. */
+    guardWrites() {
+        const streams = [process.stdout, process.stderr];
+        const originals = streams.map(stream => stream.write);
+        streams.forEach((stream, i) => {
+            const original = originals[i];
+            stream.write = ((chunk, ...rest) => {
+                if (this.drawing || this.takeover)
+                    return original.call(stream, chunk, ...rest);
+                this.clear();
+                const written = this.own(() => original.call(stream, chunk, ...rest));
+                this.partial = !String(chunk).endsWith('\n');
+                this.draw();
+                return written;
+            });
+        });
+        this.restoreWrites = () => streams.forEach((stream, i) => (stream.write = originals[i]));
+    }
+    /** Runs `write` as one of this region's own writes, so the guard passes it through. */
+    own(write) {
+        const was = this.drawing;
+        this.drawing = true;
+        try {
+            return write();
+        }
+        finally {
+            this.drawing = was;
+        }
+    }
+    clear() {
+        this.own(() => this.region.clear());
     }
     draw() {
+        if (this.partial)
+            return;
         const spinner = colors.cyan(FRAMES[this.frame % FRAMES.length]);
         const parts = [
             spinner,
@@ -110,7 +168,7 @@ export class StatusRegion {
             this.detail && colors.gray(this.detail),
             colors.gray(this.elapsed()),
         ];
-        this.region.render([parts.filter(Boolean).join(' ')]);
+        this.own(() => this.region.render([parts.filter(Boolean).join(' ')]));
     }
     /** `0.4s` while running and `950ms` / `4.1s` / `2m 03s` at the end - one formatter, because a
      *  duration that changes shape as it ticks reads as a glitch. */