@virmator/publish 13.0.1

package/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 electrovir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @virmator/publish
+
+A default plugin for [virmator](https://www.npmjs.com/package/virmator).
+
+## Available commands
+
+-   **publish**
+
+    Publish a package or mono-repo to NPM with an optional test script and auto-incrementing package version.
+
+    -   Examples
+        -   With tests: `virmator publish npm test`
+        -   Without tests: `virmator publish`

package/dist/publish.d.ts

@@ -0,0 +1,34 @@
+/** A virmator plugin for publishing a package to npm. */
+export declare const virmatorPublishPlugin: Readonly<Readonly<{
+    name: string;
+    cliCommands: NoInfer<{
+        readonly publish: {
+            readonly doc: {
+                readonly sections: readonly ["\n                            Publish a package or mono-repo to NPM with an optional test script and auto-incrementing package version.\n                        "];
+                readonly examples: readonly [{
+                    readonly title: "With tests";
+                    readonly content: "virmator publish npm test";
+                }, {
+                    readonly title: "Without tests";
+                    readonly content: "virmator publish";
+                }];
+            };
+        };
+    }>;
+}> & {
+    pluginPackageRootPath: string;
+    executor: import("@virmator/core").VirmatorPluginExecutor<NoInfer<{
+        readonly publish: {
+            readonly doc: {
+                readonly sections: readonly ["\n                            Publish a package or mono-repo to NPM with an optional test script and auto-incrementing package version.\n                        "];
+                readonly examples: readonly [{
+                    readonly title: "With tests";
+                    readonly content: "virmator publish npm test";
+                }, {
+                    readonly title: "Without tests";
+                    readonly content: "virmator publish";
+                }];
+            };
+        };
+    }>>;
+}>;

package/dist/publish.js

@@ -0,0 +1,286 @@
+import { awaitedBlockingMap, extractErrorMessage, isEnumValue, isTruthy, safeMatch, } from '@augment-vir/common';
+import { askQuestionUntilConditionMet, readPackageJson, runShellCommand as runHiddenShellCommand, runShellCommand, } from '@augment-vir/node-js';
+import { defineVirmatorPlugin, parseTsConfig, VirmatorNoTraceError, } from '@virmator/core';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { assertDefined } from 'run-time-assertions';
+import semver from 'semver';
+import simpleGit from 'simple-git';
+const inVirmatorEnvKey = 'IN_VIRMATOR';
+/** A virmator plugin for publishing a package to npm. */
+export const virmatorPublishPlugin = defineVirmatorPlugin(import.meta.dirname, {
+    name: 'Publish',
+    cliCommands: {
+        publish: {
+            doc: {
+                sections: [
+                    `
+                            Publish a package or mono-repo to NPM with an optional test script and auto-incrementing package version.
+                        `,
+                ],
+                examples: [
+                    {
+                        title: 'With tests',
+                        content: 'virmator publish npm test',
+                    },
+                    {
+                        title: 'Without tests',
+                        content: 'virmator publish',
+                    },
+                ],
+            },
+        },
+    },
+}, async ({ cliInputs: { filteredArgs }, package: { cwdValidPackageJson, monoRepoRootPath, monoRepoPackages }, log, cwd, runPerPackage, runShellCommand, }) => {
+    if (process.env[inVirmatorEnvKey]) {
+        return { noLog: true };
+    }
+    else if (!cwdValidPackageJson) {
+        throw new VirmatorNoTraceError(`Missing "name" / "version" package.json fields.`);
+    }
+    const monoRepoPackageJson = await readPackageJson(monoRepoRootPath);
+    const version = monoRepoPackageJson.version;
+    if (!version) {
+        throw new VirmatorNoTraceError(`No "version" found in package.json at '${relative(cwd, monoRepoRootPath)}'`);
+    }
+    else if (await doChangesExist(monoRepoRootPath)) {
+        throw new VirmatorNoTraceError('Git changes exist, cannot run publish. Commit or stash the changes.');
+    }
+    const flagArgs = filteredArgs.filter((arg) => arg.startsWith('--'));
+    const isDryRun = flagArgs.includes('--dry-run');
+    const monoRepoPackageJsonFiles = await Promise.all(monoRepoPackages.map(async (monoRepoPackage) => {
+        const packageJson = await readPackageJson(monoRepoPackage.fullPath);
+        if (!packageJson.name) {
+            throw new VirmatorNoTraceError(`No package.json name in '${monoRepoPackage.relativePath}'`);
+        }
+        else if (!packageJson.version) {
+            throw new VirmatorNoTraceError(`No package.json version in '${packageJson.name}'`);
+        }
+        return packageJson;
+    }));
+    const git = simpleGit(monoRepoRootPath);
+    if (await isVersionPublished(version, [
+        cwdValidPackageJson,
+        ...monoRepoPackageJsonFiles,
+    ])) {
+        let nextVersion;
+        try {
+            nextVersion = await determineNextVersion(git);
+        }
+        catch (error) {
+            log.faint(extractErrorMessage(error));
+        }
+        const allPackageJsonFiles = [
+            cwdValidPackageJson,
+            ...monoRepoPackageJsonFiles,
+        ];
+        if (!nextVersion || (await isVersionPublished(nextVersion, allPackageJsonFiles))) {
+            nextVersion = await askQuestionUntilConditionMet({
+                async conditionCallback(response) {
+                    const version = semver.coerce(response)?.raw;
+                    if (!version) {
+                        return false;
+                    }
+                    return !(await isVersionPublished(version, allPackageJsonFiles));
+                },
+                invalidInputMessage: 'Invalid semver version.',
+                questionToAsk: 'Failed to automatically determine next publish version. Please enter one:',
+            });
+        }
+        await updateVersions(nextVersion, monoRepoRootPath, monoRepoPackages, log);
+        await runHiddenShellCommand('npm i');
+    }
+    await runShellCommand(filteredArgs.join(' '));
+    const publishCommand = [
+        `${inVirmatorEnvKey}=true`,
+        'npm',
+        'publish',
+        ...flagArgs,
+    ]
+        .filter(isTruthy)
+        .join(' ');
+    const alteredPackageJsonFiles = [];
+    async function alterPackageEntryPoints(packagePath) {
+        const packageJsonPath = join(packagePath, 'package.json');
+        let packageJsonContents = (await readFile(packageJsonPath)).toString();
+        const packageJson = await readPackageJson(packagePath);
+        const alteredJsonFile = {
+            path: packageJsonPath,
+            original: packageJsonContents,
+        };
+        const relativeOutDir = parseTsConfig(packagePath)?.options.outDir || 'dist';
+        const outDir = relative(packagePath, resolve(packagePath, relativeOutDir));
+        if (packageJson.main?.endsWith('.ts')) {
+            packageJsonContents = packageJsonContents.replace(`"main": "${packageJson.main}"`, `"main": "${packageJson.main.replace('src', outDir).replace('.ts', '.js')}"`);
+        }
+        if (packageJson.module?.endsWith('.ts')) {
+            packageJsonContents = packageJsonContents.replace(`"module": "${packageJson.module}"`, `"module": "${packageJson.module.replace('src', outDir).replace('.ts', '.js')}"`);
+        }
+        if (packageJson.types?.startsWith('src')) {
+            packageJsonContents = packageJsonContents.replace(`"types": "${packageJson.types}"`, `"types": "${packageJson.types.replace('src', outDir).replace('.ts', '.d.ts')}"`);
+        }
+        if (packageJsonContents !== alteredJsonFile.original) {
+            alteredPackageJsonFiles.push(alteredJsonFile);
+            await writeFile(alteredJsonFile.path, packageJsonContents);
+        }
+    }
+    try {
+        if (monoRepoPackages.length) {
+            await runPerPackage(async ({ packageCwd, packageName }) => {
+                const isPrivate = (await readPackageJson(packageCwd)).private;
+                if (isPrivate) {
+                    log.faint(`Skipping ${packageName} because it's private.`);
+                    return undefined;
+                }
+                await alterPackageEntryPoints(packageCwd);
+                return publishCommand;
+            });
+        }
+        else {
+            const isPrivate = monoRepoPackageJson.private;
+            if (isPrivate) {
+                log.info(`This package is private. Skipping publish.`);
+                return;
+            }
+            await alterPackageEntryPoints(monoRepoRootPath);
+            await runShellCommand(publishCommand);
+        }
+        if (!isDryRun) {
+            await updateGit(monoRepoRootPath);
+        }
+        return;
+    }
+    finally {
+        await Promise.all(alteredPackageJsonFiles.map(async (alteredFile) => {
+            await writeFile(alteredFile.path, alteredFile.original);
+        }));
+    }
+});
+async function updateGit(packageDirPath) {
+    const newVersion = (await readPackageJson(packageDirPath)).version;
+    assertDefined(newVersion);
+    if (await doChangesExist(packageDirPath)) {
+        await runShellCommand(`git commit -a --amend --no-edit`, {
+            cwd: packageDirPath,
+            rejectOnError: true,
+        });
+    }
+    await runShellCommand(`git tag v${newVersion} && git push && git push --tags`, {
+        cwd: packageDirPath,
+        rejectOnError: true,
+    });
+}
+async function doChangesExist(repoDirPath) {
+    const getChangesOutput = await runHiddenShellCommand('git status --porcelain=v1 2>/dev/null', {
+        cwd: repoDirPath,
+        rejectOnError: true,
+    });
+    return !!getChangesOutput.stdout;
+}
+async function isVersionPublished(latestVersion, allPackageJsonFiles) {
+    let hasBeenPublished = false;
+    await Promise.all(allPackageJsonFiles.map(async (packageJson) => {
+        if (await isPublished({
+            name: packageJson.name,
+            version: latestVersion,
+        })) {
+            hasBeenPublished = true;
+        }
+    }));
+    return hasBeenPublished;
+}
+async function isPublished({ name, version }) {
+    const output = await runHiddenShellCommand(`npm show ${name}@${version}`);
+    return output.exitCode === 0;
+}
+const gitCommitFormatDelimiter = '<**..**>';
+var ChangeMarker;
+(function (ChangeMarker) {
+    ChangeMarker["Patch"] = "patch";
+    ChangeMarker["Minor"] = "minor";
+    ChangeMarker["Major"] = "major";
+})(ChangeMarker || (ChangeMarker = {}));
+async function getGitCommitVersion(decrement, git) {
+    const output = await git.raw(`show HEAD~${decrement} --pretty='%D${gitCommitFormatDelimiter}%s' -s`.split(' '));
+    const [maybeTag, message,] = output.split(gitCommitFormatDelimiter);
+    const tags = maybeTag
+        ? Array.from(maybeTag.matchAll(/tag: ([^),]+)(?:\)|,)/g))
+            .map((entry) => entry[1])
+            .filter(isTruthy)
+        : [];
+    const versionTags = tags
+        .map((tag) => {
+        return semver.coerce(tag);
+    })
+        .filter(isTruthy);
+    const sortedVersionTags = semver.sort(versionTags);
+    const latestVersionTag = sortedVersionTags.slice(-1)[0];
+    const [, rawChangeMarker,] = message ? safeMatch(message.trim(), /^\[([^\]]+)]/) : [];
+    const changeMarker = rawChangeMarker && isEnumValue(rawChangeMarker, ChangeMarker) ? rawChangeMarker : undefined;
+    return {
+        version: latestVersionTag,
+        changeMarker,
+    };
+}
+async function determineNextVersion(git) {
+    const changeMarkers = {
+        [ChangeMarker.Patch]: 0,
+        [ChangeMarker.Minor]: 0,
+        [ChangeMarker.Major]: 0,
+    };
+    let decrement = 0;
+    let latestVersion = undefined;
+    while (!latestVersion) {
+        if (decrement > 100) {
+            throw new Error("Couldn't find a version tag in the past 100 commits.");
+        }
+        const { changeMarker, version } = await getGitCommitVersion(decrement, git);
+        if (version) {
+            latestVersion = version;
+        }
+        else if (changeMarker) {
+            changeMarkers[changeMarker]++;
+        }
+        decrement++;
+    }
+    if (changeMarkers[ChangeMarker.Major]) {
+        return latestVersion.inc('major').raw;
+    }
+    else if (changeMarkers[ChangeMarker.Minor]) {
+        return latestVersion.inc('minor').raw;
+    }
+    else if (changeMarkers[ChangeMarker.Patch]) {
+        return latestVersion.inc('patch').raw;
+    }
+    else {
+        throw new Error('No change markers fround since last tagged version.');
+    }
+}
+async function updateVersions(version, monoRepoRootPath, monoPackages, log) {
+    const packagePaths = [
+        monoRepoRootPath,
+        ...monoPackages.map((monoPackage) => {
+            return monoPackage.fullPath;
+        }),
+    ];
+    await awaitedBlockingMap(packagePaths, async (packagePath) => {
+        const logPath = relative(monoRepoRootPath, join(monoRepoRootPath, packagePath, 'package.json'));
+        log.faint(`Updating ${logPath}...`);
+        await updateVersion(version, packagePath, monoPackages);
+    });
+}
+async function updateVersion(version, packagePath, monoPackages) {
+    const packageJsonPath = join(packagePath, 'package.json');
+    const packageJsonContents = (await readFile(packageJsonPath)).toString();
+    const packageJson = JSON.parse(packageJsonContents);
+    const packageName = packageJson.name;
+    if (!packageName) {
+        throw new Error(`Missing package name in '${packagePath}'.`);
+    }
+    await writeFile(packageJsonPath, packageJsonContents.replace(/"version": "[^"]+"/, `"version": "${version}"`));
+    await awaitedBlockingMap(monoPackages, async (monoPackage) => {
+        const monoPackageJsonPath = join(monoPackage.fullPath, 'package.json');
+        const monoPackageJsonContents = (await readFile(monoPackageJsonPath)).toString();
+        await writeFile(monoPackageJsonPath, monoPackageJsonContents.replace(new RegExp(`"${packageName}": "[^"]+"`), `"${packageName}": "^${version}"`));
+    });
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@virmator/publish",
+    "version": "13.0.1",
+    "description": "Default publish plugin for virmator.",
+    "keywords": [
+        "virmator",
+        "npm",
+        "publish",
+        "deploy",
+        "pipeline"
+    ],
+    "homepage": "https://github.com/electrovir/virmator",
+    "bugs": {
+        "url": "https://github.com/electrovir/virmator/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/electrovir/virmator.git"
+    },
+    "license": "(MIT or CC0 1.0)",
+    "author": {
+        "name": "electrovir",
+        "url": "https://github.com/electrovir"
+    },
+    "type": "module",
+    "main": "dist/publish.js",
+    "module": "dist/publish.js",
+    "types": "dist/publish.d.ts",
+    "scripts": {
+        "compile": "virmator compile",
+        "test": "exit 0",
+        "test:coverage": "npm test",
+        "test:update": "npm test"
+    },
+    "dependencies": {
+        "@augment-vir/common": "^29.3.0",
+        "@augment-vir/node-js": "^29.3.0",
+        "@virmator/core": "^13.0.1",
+        "chalk": "^5.3.0",
+        "mri": "^1.2.0",
+        "run-time-assertions": "^1.5.2",
+        "semver": "^7.6.3",
+        "simple-git": "^3.25.0",
+        "url-vir": "^1.5.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.1.0",
+        "@types/semver": "^7.5.8",
+        "markdown-code-example-inserter": "^1.0.0",
+        "type-fest": "^4.23.0",
+        "typedoc": "^0.26.5"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}