rman 2.15.2 → 2.17.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/builtins/platforms/node/utils/copy-assets.d.ts

@@ -0,0 +1,30 @@
+import type { RunBinOptions, RunBinResult } from '../../../../utils/run-bin.js';
+/**
+ * The files `copyAssets` copies when it is given no patterns: the data formats a package keeps
+ * beside its sources - translations, fixtures, schemas - that `tsc` does not emit.
+ */
+export declare const DEFAULT_ASSET_PATTERNS: readonly string[];
+export interface CopyAssetsOptions {
+    /** The tsconfig the build compiles with - its `rootDir` and `outDir` say where the files are and
+     *  where they go. */
+    tsconfig: string;
+    /** Globs over paths relative to `rootDir`. Default `DEFAULT_ASSET_PATTERNS`. */
+    patterns?: readonly string[];
+    /** Runs `tsc` - a function step's own `ctx.runBin`, which already resolves the repository's
+     *  installed copy. */
+    runBin: (bin: string, argv: string[], options?: RunBinOptions) => Promise<RunBinResult>;
+}
+/**
+ * Copies the files under a tsconfig's `rootDir` that match `patterns` into its `outDir`, keeping
+ * their place in the tree - `src/i18n/tr.json` lands at `build/i18n/tr.json`, where the compiled
+ * code that reads it expects to find it. Returns the files it wrote, absolute.
+ *
+ * `tsc` emits none of them: it compiles sources, and a `.json` reaches the output only when code
+ * imports it under `resolveJsonModule`. A file read at run time - a translation, an XML template, a
+ * fixture - is left behind, and the built package fails on a path that exists only in `src`.
+ *
+ * A tsconfig with no `outDir` compiles beside its sources, so there is nothing to copy and nothing
+ * is. `node_modules`, the output directory itself, `tsconfig*.json`, `package.json` and
+ * `package-lock.json` are never copied.
+ */
+export declare function copyAssets(options: CopyAssetsOptions): Promise<string[]>;

package/builtins/platforms/node/utils/copy-assets.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import glob from 'fast-glob';
+/**
+ * The files `copyAssets` copies when it is given no patterns: the data formats a package keeps
+ * beside its sources - translations, fixtures, schemas - that `tsc` does not emit.
+ */
+/* **A list, not "everything that is not TypeScript"** - the user's call, and the reason is what
+ * ships: a published package is what lands in a consumer's `node_modules`, and "every other file"
+ * puts a stray `.md`, a `.DS_Store` or a test's data file there with nothing saying so. A list
+ * leaves out what nobody named, and a repository that needs more names it. */
+export const DEFAULT_ASSET_PATTERNS = ['**/*.json', '**/*.xml', '**/*.yaml', '**/*.yml'];
+/**
+ * Copies the files under a tsconfig's `rootDir` that match `patterns` into its `outDir`, keeping
+ * their place in the tree - `src/i18n/tr.json` lands at `build/i18n/tr.json`, where the compiled
+ * code that reads it expects to find it. Returns the files it wrote, absolute.
+ *
+ * `tsc` emits none of them: it compiles sources, and a `.json` reaches the output only when code
+ * imports it under `resolveJsonModule`. A file read at run time - a translation, an XML template, a
+ * fixture - is left behind, and the built package fails on a path that exists only in `src`.
+ *
+ * A tsconfig with no `outDir` compiles beside its sources, so there is nothing to copy and nothing
+ * is. `node_modules`, the output directory itself, `tsconfig*.json`, `package.json` and
+ * `package-lock.json` are never copied.
+ */
+/* **`rootDir`/`outDir` are asked of `tsc --showConfig`, not read out of the file.** A package's
+ * tsconfig usually inherits both through `extends` - a relative path or a package such as
+ * `@panates/tsconfig` - and resolving that chain is `tsc`'s own logic: JSON with comments, a list
+ * of bases, package `exports`. `--showConfig` prints the resolved result with every path relative
+ * to the config it was given, in about 0.4s (measured on `panates/opra`'s `common`), which is small
+ * beside the compile it follows.
+ *
+ * **No `rootDir` means `tsc` computed one** - the common directory of its inputs - and `--showConfig`
+ * lists those inputs under `files`, so the same answer is taken from there. Declaration files are
+ * left out of it, as `tsc` leaves them out. */
+export async function copyAssets(options) {
+    const configDir = path.dirname(path.resolve(options.tsconfig));
+    /** **`onLine` swallows the lines**: a step's `runBin` hands every line to the step's log, and the
+     *  whole resolved configuration printed under the package is noise. `output` still collects them. */
+    let output;
+    try {
+        ({ output } = await options.runBin('tsc', ['--showConfig', '-p', options.tsconfig], {
+            stdio: 'pipe',
+            onLine: () => undefined,
+        }));
+    }
+    catch (e) {
+        throw new Error(`"tsc --showConfig -p ${options.tsconfig}" failed:\n${String(e?.output ?? e?.message).trim()}`, {
+            cause: e,
+        });
+    }
+    const config = parseShowConfig(output, options.tsconfig);
+    const outDir = config.compilerOptions?.outDir;
+    if (!outDir)
+        return [];
+    const out = path.resolve(configDir, outDir);
+    const root = config.compilerOptions?.rootDir
+        ? path.resolve(configDir, config.compilerOptions.rootDir)
+        : (commonDir((config.files ?? []).filter(f => !/\.d\.[cm]?ts$/.test(f)).map(f => path.resolve(configDir, f))) ??
+            configDir);
+    /** `package.json` and its lockfile because a `rootDir` of the package itself would otherwise send
+     *  them along - and the build directory's manifest is `publish`'s (or the preset's) to write. */
+    const ignore = ['**/node_modules/**', '**/tsconfig*.json', '**/package.json', '**/package-lock.json'];
+    const outInsideRoot = path.relative(root, out);
+    if (outInsideRoot && !outInsideRoot.startsWith('..') && !path.isAbsolute(outInsideRoot)) {
+        ignore.push(`${outInsideRoot.split(path.sep).join('/')}/**`);
+    }
+    const files = await glob([...(options.patterns ?? DEFAULT_ASSET_PATTERNS)], {
+        cwd: root,
+        ignore,
+        onlyFiles: true,
+        dot: false,
+    });
+    const written = [];
+    for (const rel of files.sort()) {
+        const target = path.join(out, rel);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.copyFileSync(path.join(root, rel), target);
+        written.push(target);
+    }
+    return written;
+}
+/** `tsc --showConfig`'s answer. It prints the JSON alone on success; anything else is a tsconfig
+ *  `tsc` could not read, which is reported with what it said. */
+function parseShowConfig(output, tsconfig) {
+    const start = output.indexOf('{');
+    try {
+        return JSON.parse(output.slice(start));
+    }
+    catch {
+        throw new Error(`"tsc --showConfig -p ${tsconfig}" did not print a configuration:\n${output.trim()}`);
+    }
+}
+/** The deepest directory holding every one of `files`, or `undefined` for none. */
+function commonDir(files) {
+    if (!files.length)
+        return undefined;
+    let common = path.dirname(files[0]);
+    for (const file of files.slice(1)) {
+        while (path.relative(common, file).startsWith('..'))
+            common = path.dirname(common);
+    }
+    return common;
+}

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.2';
+export const version = '2.17.0';

package/index.d.ts

@@ -169,6 +169,7 @@ export { CiService } from './builtins/platforms/node/services/ci.service.js';
 export { CleanService } from './builtins/platforms/node/services/clean.service.js';
 export { PublishService } from './builtins/platforms/node/services/publish.service.js';
 export { NodeVersionPlanService } from './builtins/platforms/node/services/version-plan.service.js';
+export { copyAssets, type CopyAssetsOptions, DEFAULT_ASSET_PATTERNS, } from './builtins/platforms/node/utils/copy-assets.js';
 export type { ParsedWorkspaceRange } from './builtins/platforms/node/utils/workspace-range.js';
 export { NPM_TARGET, NpmPublishTarget } from './builtins/publish-targets/npm/npm-publish-target.js';
 export { isCalendarVersion } from './utils/release-version.js';

package/index.js

@@ -135,6 +135,7 @@ export { CiService } from './builtins/platforms/node/services/ci.service.js';
 export { CleanService } from './builtins/platforms/node/services/clean.service.js';
 export { PublishService } from './builtins/platforms/node/services/publish.service.js';
 export { NodeVersionPlanService } from './builtins/platforms/node/services/version-plan.service.js';
+export { copyAssets, DEFAULT_ASSET_PATTERNS, } from './builtins/platforms/node/utils/copy-assets.js';
 export { NPM_TARGET, NpmPublishTarget } from './builtins/publish-targets/npm/npm-publish-target.js';
 export { isCalendarVersion } from './utils/release-version.js';
 export { runBin } from './utils/run-bin.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.15.2",
+  "version": "2.17.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);