projen 0.0.0

package/lib/python/setuppy.d.ts

@@ -0,0 +1,88 @@
+import { FileBase, IResolver } from '../file';
+import { PythonProject } from './python-project';
+/**
+ * (experimental) Fields to pass in the setup() function of setup.py.
+ *
+ * @see https://docs.python.org/3/distutils/setupscript.html
+ * @experimental
+ */
+export interface SetupPyOptions {
+    /**
+     * (experimental) Name of the package.
+     *
+     * @experimental
+     */
+    readonly name?: string;
+    /**
+     * (experimental) List of submodules to be packaged.
+     *
+     * @experimental
+     */
+    readonly packages?: string[];
+    /**
+     * (experimental) Author's name.
+     *
+     * @experimental
+     */
+    readonly authorName?: string;
+    /**
+     * (experimental) Author's e-mail.
+     *
+     * @experimental
+     */
+    readonly authorEmail?: string;
+    /**
+     * (experimental) Manually specify package version.
+     *
+     * @experimental
+     */
+    readonly version?: string;
+    /**
+     * (experimental) A short project description.
+     *
+     * @experimental
+     */
+    readonly description?: string;
+    /**
+     * (experimental) The project license.
+     *
+     * @experimental
+     */
+    readonly license?: string;
+    /**
+     * (experimental) Package's Homepage / Website.
+     *
+     * @experimental
+     */
+    readonly homepage?: string;
+    /**
+     * (experimental) A list of PyPI trove classifiers that describe the project.
+     *
+     * @see https://pypi.org/classifiers/
+     * @experimental
+     */
+    readonly classifiers?: string[];
+    /**
+     * Escape hatch to allow any value
+     */
+    readonly [name: string]: any;
+}
+/**
+ * (experimental) Python packaging script where package metadata can be placed.
+ *
+ * @experimental
+ */
+export declare class SetupPy extends FileBase {
+    private readonly setupConfig;
+    /**
+     * @experimental
+     */
+    constructor(project: PythonProject, options: SetupPyOptions);
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    protected synthesizeContent(resolver: IResolver): string | undefined;
+    private renameFields;
+}

package/lib/python/setuppy.js

@@ -0,0 +1,78 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetupPy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const file_1 = require("../file");
+/**
+ * (experimental) Python packaging script where package metadata can be placed.
+ *
+ * @experimental
+ */
+class SetupPy extends file_1.FileBase {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        super(project, 'setup.py');
+        this.setupConfig = {
+            name: project.name,
+            packages: [project.moduleName],
+            python_requires: '>=3.6',
+            classifiers: [
+                'Intended Audience :: Developers',
+                'Programming Language :: Python :: 3 :: Only',
+                'Programming Language :: Python :: 3.6',
+                'Programming Language :: Python :: 3.7',
+                'Programming Language :: Python :: 3.8',
+                'Programming Language :: Python :: 3.9',
+            ],
+            ...options ? this.renameFields(options) : [],
+        };
+    }
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    synthesizeContent(resolver) {
+        const lines = [
+            `# ${file_1.FileBase.PROJEN_MARKER}`,
+            '',
+            'import json',
+            'from setuptools import setup',
+            '',
+            'kwargs = json.loads(',
+            '    """',
+            JSON.stringify(this.setupConfig, null, 4),
+            '"""',
+            ')',
+            '',
+            'setup(**kwargs)',
+        ];
+        return `${resolver.resolve(lines).join('\n')}\n`;
+    }
+    // modify some key names since JSII interfaces require fields to be camelCase
+    renameFields(options) {
+        const obj = {};
+        for (const [key, value] of Object.entries(options)) {
+            if (key === 'authorName') {
+                obj.author = value;
+            }
+            else if (key === 'authorEmail') {
+                obj.author_email = value;
+            }
+            else if (key === 'homepage') {
+                obj.url = value;
+            }
+            else {
+                obj[key] = value;
+            }
+        }
+        return obj;
+    }
+}
+exports.SetupPy = SetupPy;
+_a = JSII_RTTI_SYMBOL_1;
+SetupPy[_a] = { fqn: "projen.python.SetupPy", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/python/setuptools.d.ts

@@ -0,0 +1,27 @@
+import { Component } from '../component';
+import { Task } from '../task';
+import { IPythonPackaging, PythonPackagingOptions } from './python-packaging';
+import { PythonProject } from './python-project';
+/**
+ * (experimental) Manages packaging through setuptools with a setup.py script.
+ *
+ * @experimental
+ */
+export declare class Setuptools extends Component implements IPythonPackaging {
+    /**
+     * (experimental) A task that uploads the package to a package repository.
+     *
+     * @experimental
+     */
+    readonly publishTask: Task;
+    /**
+     * (experimental) A task that uploads the package to the Test PyPI repository.
+     *
+     * @experimental
+     */
+    readonly publishTestTask: Task;
+    /**
+     * @experimental
+     */
+    constructor(project: PythonProject, options: PythonPackagingOptions);
+}

package/lib/python/setuptools.js

@@ -0,0 +1,47 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Setuptools = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const setuppy_1 = require("./setuppy");
+/**
+ * (experimental) Manages packaging through setuptools with a setup.py script.
+ *
+ * @experimental
+ */
+class Setuptools extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        super(project);
+        project.addDevDependency('wheel@0.36.2');
+        project.addDevDependency('twine@3.3.0');
+        project.packageTask.exec('python setup.py sdist bdist_wheel');
+        this.publishTestTask = project.addTask('publish:test', {
+            description: 'Uploads the package against a test PyPI endpoint.',
+            exec: 'twine upload --repository-url https://test.pypi.org/legacy/ dist/*',
+        });
+        this.publishTask = project.addTask('publish', {
+            description: 'Uploads the package against a test PyPI endpoint.',
+            exec: 'twine upload dist/*',
+        });
+        new setuppy_1.SetupPy(project, {
+            name: project.name,
+            packages: [project.moduleName],
+            authorName: options.authorName,
+            authorEmail: options.authorEmail,
+            version: options.version,
+            description: options.description,
+            license: options.license,
+            homepage: options.homepage,
+            classifiers: options.classifiers,
+            ...options.setupConfig,
+        });
+    }
+}
+exports.Setuptools = Setuptools;
+_a = JSII_RTTI_SYMBOL_1;
+Setuptools[_a] = { fqn: "projen.python.Setuptools", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/python/venv.d.ts

@@ -0,0 +1,38 @@
+import { Component } from '../component';
+import { IPythonEnv } from './python-env';
+import { PythonProject } from './python-project';
+/**
+ * (experimental) Options for venv.
+ *
+ * @experimental
+ */
+export interface VenvOptions {
+    /**
+     * (experimental) Name of directory to store the environment in.
+     *
+     * @default ".env"
+     * @experimental
+     */
+    readonly envdir?: string;
+}
+/**
+ * (experimental) Manages a virtual environment through the Python venv module.
+ *
+ * @experimental
+ */
+export declare class Venv extends Component implements IPythonEnv {
+    /**
+     * Name of directory to store the environment in
+     */
+    private readonly envdir;
+    /**
+     * @experimental
+     */
+    constructor(project: PythonProject, options?: VenvOptions);
+    /**
+     * (experimental) Initializes the virtual environment if it doesn't exist (called during post-synthesis).
+     *
+     * @experimental
+     */
+    setupEnvironment(): void;
+}

package/lib/python/venv.js

@@ -0,0 +1,44 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Venv = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const fs = require("fs-extra");
+const component_1 = require("../component");
+const util_1 = require("../util");
+/**
+ * (experimental) Manages a virtual environment through the Python venv module.
+ *
+ * @experimental
+ */
+class Venv extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        var _b;
+        super(project);
+        this.envdir = (_b = options.envdir) !== null && _b !== void 0 ? _b : '.env';
+        this.project.addGitIgnore(`/${this.envdir}`);
+        this.project.tasks.addEnvironment('VIRTUAL_ENV', `$(echo $PWD/${this.envdir})`);
+        this.project.tasks.addEnvironment('PATH', `$(echo $PWD/${this.envdir}/bin:$PATH)`);
+    }
+    /**
+     * (experimental) Initializes the virtual environment if it doesn't exist (called during post-synthesis).
+     *
+     * @experimental
+     */
+    setupEnvironment() {
+        const absoluteEnvdir = path.join(this.project.outdir, this.envdir);
+        if (!fs.pathExistsSync(absoluteEnvdir)) {
+            this.project.logger.info('Setting up a virtual environment...');
+            util_1.exec(`python -m venv ${this.envdir}`, { cwd: this.project.outdir });
+            this.project.logger.info(`Environment successfully created (located in ./${this.envdir}).`);
+        }
+    }
+}
+exports.Venv = Venv;
+_a = JSII_RTTI_SYMBOL_1;
+Venv[_a] = { fqn: "projen.python.Venv", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/readme.d.ts

@@ -0,0 +1,37 @@
+import { Project } from './project';
+import { SampleFile } from './sample-file';
+/**
+ * (experimental) SampleReadme Properties.
+ *
+ * @experimental
+ */
+export interface SampleReadmeProps {
+    /**
+     * (experimental) The name of the README.md file.
+     *
+     * @default "README.md"
+     * @experimental
+     * @example
+     *
+     * "readme.md"
+     */
+    readonly filename?: string;
+    /**
+     * (experimental) The contents.
+     *
+     * @default "# replace this"
+     * @experimental
+     */
+    readonly contents?: string;
+}
+/**
+ * (experimental) Represents a README.md sample file. You are expected to manage this file after creation.
+ *
+ * @experimental
+ */
+export declare class SampleReadme extends SampleFile {
+    /**
+     * @experimental
+     */
+    constructor(project: Project, props?: SampleReadmeProps);
+}

package/lib/readme.js

@@ -0,0 +1,24 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SampleReadme = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const sample_file_1 = require("./sample-file");
+/**
+ * (experimental) Represents a README.md sample file. You are expected to manage this file after creation.
+ *
+ * @experimental
+ */
+class SampleReadme extends sample_file_1.SampleFile {
+    /**
+     * @experimental
+     */
+    constructor(project, props) {
+        var _b, _c;
+        super(project, (_b = props === null || props === void 0 ? void 0 : props.filename) !== null && _b !== void 0 ? _b : 'README.md', { contents: (_c = props === null || props === void 0 ? void 0 : props.contents) !== null && _c !== void 0 ? _c : '# replace this' });
+    }
+}
+exports.SampleReadme = SampleReadme;
+_a = JSII_RTTI_SYMBOL_1;
+SampleReadme[_a] = { fqn: "projen.SampleReadme", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZG1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3JlYWRtZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLCtDQUEyQzs7Ozs7O0FBWTNDLE1BQWEsWUFBYSxTQUFRLHdCQUFVOzs7O0lBQzFDLFlBQVksT0FBZ0IsRUFBRSxLQUF5Qjs7UUFDckQsS0FBSyxDQUFDLE9BQU8sUUFBRSxLQUFLLGFBQUwsS0FBSyx1QkFBTCxLQUFLLENBQUUsUUFBUSxtQ0FBSSxXQUFXLEVBQUUsRUFBRSxRQUFRLFFBQUUsS0FBSyxhQUFMLEtBQUssdUJBQUwsS0FBSyxDQUFFLFFBQVEsbUNBQUksZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDO0lBQ3BHLENBQUM7O0FBSEgsb0NBSUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcm9qZWN0IH0gZnJvbSAnLi9wcm9qZWN0JztcbmltcG9ydCB7IFNhbXBsZUZpbGUgfSBmcm9tICcuL3NhbXBsZS1maWxlJztcblxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuZXhwb3J0IGludGVyZmFjZSBTYW1wbGVSZWFkbWVQcm9wcyB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuICByZWFkb25seSBmaWxlbmFtZT86IHN0cmluZztcblxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG4gIHJlYWRvbmx5IGNvbnRlbnRzPzogc3RyaW5nO1xufVxuXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbmV4cG9ydCBjbGFzcyBTYW1wbGVSZWFkbWUgZXh0ZW5kcyBTYW1wbGVGaWxlIHtcbiAgY29uc3RydWN0b3IocHJvamVjdDogUHJvamVjdCwgcHJvcHM/OiBTYW1wbGVSZWFkbWVQcm9wcykge1xuICAgIHN1cGVyKHByb2plY3QsIHByb3BzPy5maWxlbmFtZSA/PyAnUkVBRE1FLm1kJywgeyBjb250ZW50czogcHJvcHM/LmNvbnRlbnRzID8/ICcjIHJlcGxhY2UgdGhpcycgfSk7XG4gIH1cbn1cbiJdfQ==

package/lib/release/bump-version.d.ts

@@ -0,0 +1,59 @@
+import { Config } from 'conventional-changelog-config-spec';
+export interface BumpOptions {
+    /**
+     * The name of a .json file to set `version`.
+     */
+    readonly versionFile: string;
+    /**
+     * The name of the changelog file to generate.
+     */
+    readonly changelog: string;
+    /**
+     * Use a pre-release suffix.
+     * @default - normal versioning
+     */
+    readonly prerelease?: string;
+    /**
+     * Defines the major version line. This is used to select the latest version
+     * and also enforce that new major versions are not released accidentally.
+     *
+     * @default - any version is supported
+     */
+    readonly majorVersion?: number;
+    /**
+     * The name of a file which will include the output version number (a text file).
+     *
+     * Relative to cwd.
+     *
+     * @example ".version.txt"
+     */
+    readonly bumpFile: string;
+    /**
+     * The name of the file which will include the release tag (a text file).
+     *
+     * Relative to cwd.
+     *
+     * @example ".releasetag.txt"
+     */
+    readonly releaseTagFile: string;
+    /**
+     * The prefix applied to release tags. Bumps will be made based on the latest
+     * version found with this prefix.
+     */
+    readonly tagPrefix?: string;
+    /**
+     * Conguration values that would append to versionrc file or overwrite values
+     * coming to that from default one.
+     */
+    readonly versionrcOptions?: Config;
+}
+/**
+ * Resolves the latest version from git tags and uses `standard-version` to bump
+ * to the next version based on commits.
+ *
+ * This expects `standard-version` to be installed in the path.
+ *
+ * @param cwd working directory (git repository)
+ * @param options options
+ */
+export declare function bump(cwd: string, options: BumpOptions): Promise<void>;

package/lib/release/bump-version.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bump = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const logging = require("../logging");
+const util_1 = require("../util");
+/**
+ * Resolves the latest version from git tags and uses `standard-version` to bump
+ * to the next version based on commits.
+ *
+ * This expects `standard-version` to be installed in the path.
+ *
+ * @param cwd working directory (git repository)
+ * @param options options
+ */
+async function bump(cwd, options) {
+    var _a;
+    const versionFile = path_1.join(cwd, options.versionFile);
+    const prerelease = options.prerelease;
+    const major = options.majorVersion;
+    const prefix = (_a = options.tagPrefix) !== null && _a !== void 0 ? _a : '';
+    const bumpFile = path_1.join(cwd, options.bumpFile);
+    const changelogFile = path_1.join(cwd, options.changelog);
+    const releaseTagFile = path_1.join(cwd, options.releaseTagFile);
+    await fs_extra_1.mkdirp(path_1.dirname(bumpFile));
+    await fs_extra_1.mkdirp(path_1.dirname(changelogFile));
+    await fs_extra_1.mkdirp(path_1.dirname(releaseTagFile));
+    const { latestVersion, latestTag, isFirstRelease } = determineLatestTag({ cwd, major, prerelease, prefix });
+    const content = await tryReadVersionFile(versionFile);
+    // update version
+    content.version = latestVersion;
+    logging.info(`Update ${versionFile} to latest resolved version: ${latestVersion}`);
+    await fs_extra_1.writeFile(versionFile, JSON.stringify(content, undefined, 2));
+    // check if the latest commit already has a version tag
+    const currentTags = util_1.execCapture('git tag --points-at HEAD', { cwd }).toString('utf8').split('\n');
+    logging.info(`Tags listed on current commit: ${currentTags}`);
+    let skipBump = false;
+    if (currentTags.includes(latestTag)) {
+        logging.info('Skipping bump...');
+        skipBump = true;
+        // delete the existing tag (locally)
+        // if we don't do this, standard-version generates an empty changelog
+        util_1.exec(`git tag --delete ${latestTag}`, { cwd });
+    }
+    // create a standard-version configuration file
+    const rcfile = path_1.join(cwd, '.versionrc.json');
+    await generateVersionrcFile(rcfile, versionFile, changelogFile, skipBump, prerelease, options.versionrcOptions);
+    const cmd = ['npx', 'standard-version@^9'];
+    if (isFirstRelease) {
+        cmd.push('--first-release');
+    }
+    util_1.exec(cmd.join(' '), { cwd });
+    // add the tag back if it was previously removed
+    if (currentTags.includes(latestTag)) {
+        util_1.exec(`git tag ${latestTag}`, { cwd });
+    }
+    await fs_extra_1.remove(rcfile);
+    const newVersion = (await tryReadVersionFile(versionFile)).version;
+    if (!newVersion) {
+        throw new Error(`bump failed: ${versionFile} does not have a version set`);
+    }
+    // if MAJOR is defined, ensure that the new version is within the same major version
+    if (major) {
+        if (!newVersion.startsWith(`${major}.`)) {
+            throw new Error(`bump failed: this branch is configured to only publish v${major} releases - bump resulted in ${newVersion}`);
+        }
+    }
+    await fs_extra_1.writeFile(bumpFile, newVersion);
+    const newTag = `${prefix}v${newVersion}`;
+    await fs_extra_1.writeFile(releaseTagFile, newTag);
+}
+exports.bump = bump;
+async function tryReadVersionFile(versionFile) {
+    if (!(await fs_extra_1.pathExists(versionFile))) {
+        return {};
+    }
+    return JSON.parse(await fs_extra_1.readFile(versionFile, 'utf8'));
+}
+function generateVersionrcFile(rcfile, versionFile, changelogFile, skipBump, prerelease, configOptions) {
+    return fs_extra_1.writeFile(rcfile, JSON.stringify({
+        ...{
+            packageFiles: [{
+                    filename: versionFile,
+                    type: 'json',
+                }],
+            bumpFiles: [{
+                    filename: versionFile,
+                    type: 'json',
+                }],
+            commitAll: false,
+            infile: changelogFile,
+            prerelease: prerelease,
+            header: '',
+            skip: {
+                commit: true,
+                tag: true,
+                bump: skipBump,
+            },
+            ...configOptions,
+        },
+    }, undefined, 2));
+}
+/**
+ * Determines the latest release tag.
+ * @param major (optional) A major version line to select from
+ * @param prerelease (optional) A pre-release suffix.
+ * @returns the latest tag, and whether it is the first release or not
+ */
+function determineLatestTag(options) {
+    const { cwd, major, prerelease, prefix } = options;
+    // filter only tags for this prefix and major version if specified (start with "vNN.").
+    const prefixFilter = major ? `${prefix}v${major}.*` : `${prefix}v*`;
+    const listGitTags = [
+        'git',
+        '-c "versionsort.suffix=-"',
+        'tag',
+        '--sort="-version:refname"',
+        '--list',
+        `"${prefixFilter}"`,
+    ].join(' ');
+    const stdout = util_1.execCapture(listGitTags, { cwd }).toString('utf8');
+    let tags = stdout === null || stdout === void 0 ? void 0 : stdout.split('\n');
+    // if "pre" is set, filter versions that end with "-PRE.ddd".
+    if (prerelease) {
+        tags = tags.filter(x => new RegExp(`-${prerelease}\.[0-9]+$`).test(x));
+    }
+    tags = tags.filter(x => x);
+    // if a pre-release tag is used, then add it to the initial version
+    let isFirstRelease = false;
+    let latestTag;
+    if (tags.length > 0) {
+        latestTag = tags[0];
+    }
+    else {
+        const initial = `${prefix}v${major !== null && major !== void 0 ? major : 0}.0.0`;
+        latestTag = prerelease ? `${initial}-${prerelease}.0` : initial;
+        isFirstRelease = true;
+    }
+    // remove tag prefix (if exists)
+    let latestVersion = latestTag;
+    if (prefix && latestVersion.startsWith(prefix)) {
+        latestVersion = latestVersion.substr(prefix.length);
+    }
+    // remove "v" prefix (if exists)
+    if (latestVersion.startsWith('v')) {
+        latestVersion = latestVersion.substr(1);
+    }
+    return { latestVersion, latestTag, isFirstRelease };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bump-version.js","sourceRoot":"","sources":["../../src/release/bump-version.ts"],"names":[],"mappings":"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","sourcesContent":["import { dirname, join } from 'path';\nimport { Config } from 'conventional-changelog-config-spec';\nimport { mkdirp, pathExists, readFile, remove, writeFile } from 'fs-extra';\nimport * as logging from '../logging';\nimport { exec, execCapture } from '../util';\n\nexport interface BumpOptions {\n  /**\n   * The name of a .json file to set `version`.\n   */\n  readonly versionFile: string;\n\n  /**\n   * The name of the changelog file to generate.\n   */\n  readonly changelog: string;\n\n  /**\n   * Use a pre-release suffix.\n   * @default - normal versioning\n   */\n  readonly prerelease?: string;\n\n  /**\n   * Defines the major version line. This is used to select the latest version\n   * and also enforce that new major versions are not released accidentally.\n   *\n   * @default - any version is supported\n   */\n  readonly majorVersion?: number;\n\n  /**\n   * The name of a file which will include the output version number (a text file).\n   *\n   * Relative to cwd.\n   *\n   * @example \".version.txt\"\n   */\n  readonly bumpFile: string;\n\n  /**\n   * The name of the file which will include the release tag (a text file).\n   *\n   * Relative to cwd.\n   *\n   * @example \".releasetag.txt\"\n   */\n  readonly releaseTagFile: string;\n\n  /**\n   * The prefix applied to release tags. Bumps will be made based on the latest\n   * version found with this prefix.\n   */\n  readonly tagPrefix?: string;\n\n  /**\n   * Conguration values that would append to versionrc file or overwrite values\n   * coming to that from default one.\n   */\n  readonly versionrcOptions?: Config;\n}\n\n/**\n * Resolves the latest version from git tags and uses `standard-version` to bump\n * to the next version based on commits.\n *\n * This expects `standard-version` to be installed in the path.\n *\n * @param cwd working directory (git repository)\n * @param options options\n */\nexport async function bump(cwd: string, options: BumpOptions) {\n  const versionFile = join(cwd, options.versionFile);\n  const prerelease = options.prerelease;\n  const major = options.majorVersion;\n  const prefix = options.tagPrefix ?? '';\n  const bumpFile = join(cwd, options.bumpFile);\n  const changelogFile = join(cwd, options.changelog);\n  const releaseTagFile = join(cwd, options.releaseTagFile);\n\n  await mkdirp(dirname(bumpFile));\n  await mkdirp(dirname(changelogFile));\n  await mkdirp(dirname(releaseTagFile));\n\n  const { latestVersion, latestTag, isFirstRelease } = determineLatestTag({ cwd, major, prerelease, prefix });\n\n  const content = await tryReadVersionFile(versionFile);\n\n  // update version\n  content.version = latestVersion;\n\n  logging.info(`Update ${versionFile} to latest resolved version: ${latestVersion}`);\n  await writeFile(versionFile, JSON.stringify(content, undefined, 2));\n\n  // check if the latest commit already has a version tag\n  const currentTags = execCapture('git tag --points-at HEAD', { cwd }).toString('utf8').split('\\n');\n  logging.info(`Tags listed on current commit: ${currentTags}`);\n\n  let skipBump = false;\n\n  if (currentTags.includes(latestTag)) {\n    logging.info('Skipping bump...');\n    skipBump = true;\n\n    // delete the existing tag (locally)\n    // if we don't do this, standard-version generates an empty changelog\n    exec(`git tag --delete ${latestTag}`, { cwd });\n  }\n\n  // create a standard-version configuration file\n  const rcfile = join(cwd, '.versionrc.json');\n  await generateVersionrcFile(rcfile, versionFile, changelogFile, skipBump, prerelease, options.versionrcOptions);\n\n  const cmd = ['npx', 'standard-version@^9'];\n  if (isFirstRelease) {\n    cmd.push('--first-release');\n  }\n\n  exec(cmd.join(' '), { cwd });\n\n  // add the tag back if it was previously removed\n  if (currentTags.includes(latestTag)) {\n    exec(`git tag ${latestTag}`, { cwd });\n  }\n\n  await remove(rcfile);\n\n  const newVersion = (await tryReadVersionFile(versionFile)).version;\n  if (!newVersion) {\n    throw new Error(`bump failed: ${versionFile} does not have a version set`);\n  }\n\n  // if MAJOR is defined, ensure that the new version is within the same major version\n  if (major) {\n    if (!newVersion.startsWith(`${major}.`)) {\n      throw new Error(`bump failed: this branch is configured to only publish v${major} releases - bump resulted in ${newVersion}`);\n    }\n  }\n\n  await writeFile(bumpFile, newVersion);\n\n  const newTag = `${prefix}v${newVersion}`;\n  await writeFile(releaseTagFile, newTag);\n}\n\nasync function tryReadVersionFile(versionFile: string) {\n  if (!(await pathExists(versionFile))) {\n    return {};\n  }\n\n  return JSON.parse(await readFile(versionFile, 'utf8'));\n}\n\ninterface LatestTagOptions {\n  /**\n   * Working directory of the git repository.\n   */\n  readonly cwd: string;\n  /**\n   * Major version to select from.\n   */\n  readonly major?: number;\n  /**\n   * A pre-release suffix.\n   */\n  readonly prerelease?: string;\n  /**\n   * A prefix applied to all tags.\n   */\n  readonly prefix: string;\n}\n\nfunction generateVersionrcFile(\n  rcfile: string,\n  versionFile: string,\n  changelogFile: string,\n  skipBump: boolean,\n  prerelease?: string, configOptions?: Config,\n) {\n  return writeFile(rcfile, JSON.stringify({\n    ...{\n      packageFiles: [{\n        filename: versionFile,\n        type: 'json',\n      }],\n      bumpFiles: [{\n        filename: versionFile,\n        type: 'json',\n      }],\n      commitAll: false,\n      infile: changelogFile,\n      prerelease: prerelease,\n      header: '',\n      skip: {\n        commit: true,\n        tag: true,\n        bump: skipBump,\n      },\n      ...configOptions,\n    },\n  }, undefined, 2));\n}\n\n/**\n * Determines the latest release tag.\n * @param major (optional) A major version line to select from\n * @param prerelease (optional) A pre-release suffix.\n * @returns the latest tag, and whether it is the first release or not\n */\nfunction determineLatestTag(options: LatestTagOptions): { latestVersion: string; latestTag: string; isFirstRelease: boolean } {\n  const { cwd, major, prerelease, prefix } = options;\n\n  // filter only tags for this prefix and major version if specified (start with \"vNN.\").\n  const prefixFilter = major ? `${prefix}v${major}.*` : `${prefix}v*`;\n\n  const listGitTags = [\n    'git',\n    '-c \"versionsort.suffix=-\"', // makes sure pre-release versions are listed after the primary version\n    'tag',\n    '--sort=\"-version:refname\"', // sort as versions and not lexicographically\n    '--list',\n    `\"${prefixFilter}\"`,\n  ].join(' ');\n\n  const stdout = execCapture(listGitTags, { cwd }).toString('utf8');\n\n  let tags = stdout?.split('\\n');\n\n  // if \"pre\" is set, filter versions that end with \"-PRE.ddd\".\n  if (prerelease) {\n    tags = tags.filter(x => new RegExp(`-${prerelease}\\.[0-9]+$`).test(x));\n  }\n\n  tags = tags.filter(x => x);\n\n  // if a pre-release tag is used, then add it to the initial version\n  let isFirstRelease = false;\n  let latestTag;\n\n  if (tags.length > 0) {\n    latestTag = tags[0];\n  } else {\n    const initial = `${prefix}v${major ?? 0}.0.0`;\n    latestTag = prerelease ? `${initial}-${prerelease}.0` : initial;\n    isFirstRelease = true;\n  }\n\n  // remove tag prefix (if exists)\n  let latestVersion = latestTag;\n  if (prefix && latestVersion.startsWith(prefix)) {\n    latestVersion = latestVersion.substr(prefix.length);\n  }\n\n  // remove \"v\" prefix (if exists)\n  if (latestVersion.startsWith('v')) {\n    latestVersion = latestVersion.substr(1);\n  }\n\n  return { latestVersion, latestTag, isFirstRelease };\n}\n"]}

package/lib/release/bump-version.task.d.ts

@@ -0,0 +1 @@
+export {};