projen 0.0.0

package/lib/util/synth.d.ts

@@ -0,0 +1,24 @@
+import { Project } from '../project';
+export interface SynthOutput {
+    [filePath: string]: any;
+}
+/**
+ * Creates a snapshot of the files generated by a project. Ignores any non-text
+ * files so that the snapshots are human readable.
+ */
+export declare function synthSnapshot(project: Project): SynthOutput;
+export interface DirectorySnapshotOptions {
+    /**
+     * Globs of files to exclude.
+     * @default [] include all files
+     */
+    readonly excludeGlobs?: string[];
+    /**
+     * Only snapshot the names of files and not their contents.
+     * The value for a path will be `true` if it exists.
+     *
+     * @default false include file content
+     */
+    readonly onlyFileNames?: boolean;
+}
+export declare function directorySnapshot(root: string, options?: DirectorySnapshotOptions): SynthOutput;

package/lib/util/synth.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directorySnapshot = exports.synthSnapshot = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const glob_1 = require("glob");
+/**
+ * Creates a snapshot of the files generated by a project. Ignores any non-text
+ * files so that the snapshots are human readable.
+ */
+function synthSnapshot(project) {
+    // defensive: verify that "outdir" is actually in a temporary directory
+    if (!path.resolve(project.outdir).startsWith(os.tmpdir()) && !project.outdir.includes('project-temp-dir')) {
+        throw new Error('Trying to capture a snapshot of a project outside of tmpdir, which implies this test might corrupt an existing project');
+    }
+    const synthed = Symbol.for('synthed');
+    if (synthed in project) {
+        throw new Error('duplicate synth()');
+    }
+    project[synthed] = true;
+    const ENV_PROJEN_DISABLE_POST = process.env.PROJEN_DISABLE_POST;
+    try {
+        process.env.PROJEN_DISABLE_POST = 'true';
+        project.synth();
+        const ignoreExts = ['png', 'ico'];
+        return directorySnapshot(project.outdir, { excludeGlobs: ignoreExts.map(ext => `**/*.${ext}`) });
+    }
+    finally {
+        fs.removeSync(project.outdir);
+        // values assigned to process.env.XYZ are automatically converted to strings
+        if (ENV_PROJEN_DISABLE_POST === undefined) {
+            delete process.env.PROJEN_DISABLE_POST;
+        }
+        else {
+            process.env.PROJEN_DISABLE_POST = ENV_PROJEN_DISABLE_POST;
+        }
+    }
+}
+exports.synthSnapshot = synthSnapshot;
+function directorySnapshot(root, options = {}) {
+    var _a;
+    const output = {};
+    const files = glob_1.glob.sync('**', {
+        ignore: ['.git/**', ...((_a = options.excludeGlobs) !== null && _a !== void 0 ? _a : [])],
+        cwd: root,
+        nodir: true,
+        dot: true,
+    }); // returns relative file paths with POSIX separators
+    for (const file of files) {
+        const filePath = path.join(root, file);
+        let content;
+        if (!options.onlyFileNames) {
+            if (path.extname(filePath) === '.json') {
+                content = fs.readJsonSync(filePath);
+            }
+            else {
+                content = fs.readFileSync(filePath, 'utf-8');
+            }
+        }
+        else {
+            content = true;
+        }
+        output[file] = content;
+    }
+    return output;
+}
+exports.directorySnapshot = directorySnapshot;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="node" />
+/**
+ * Executes a command with STDOUT > STDERR.
+ */
+export declare function exec(command: string, options: {
+    cwd: string;
+}): void;
+/**
+ * Executes command and returns STDOUT. If the command fails (non-zero), throws an error.
+ */
+export declare function execCapture(command: string, options: {
+    cwd: string;
+}): string | Buffer;
+/**
+ * Executes `command` and returns its value or undefined if the command failed.
+ */
+export declare function execOrUndefined(command: string, options: {
+    cwd: string;
+}): string | undefined;
+export interface WriteFileOptions {
+    /**
+     * Whether the generated file should be marked as executable.
+     *
+     * @default false
+     */
+    executable?: boolean;
+    /**
+     * Whether the generated file should be readonly.
+     *
+     * @default false
+     */
+    readonly?: boolean;
+}
+export declare function getFilePermissions(options: WriteFileOptions): string;
+export declare function writeFile(filePath: string, data: any, options?: WriteFileOptions): void;
+/**
+ * Decamelizes the keys of an object structure, recursing through child objects and arrays.
+ * @experimental
+ */
+export interface DecamelizeRecursivelyOptions {
+    /**
+     * Max depth to recurse before erroring.
+     * @default 10
+     */
+    maxDepth?: number;
+    /**
+     * Returns true when a key should be decamelized
+     * @default - all keys are decamelized
+     */
+    shouldDecamelize?: (path: string[], value: any) => boolean;
+    /**
+     * Separator for decamelizing.
+     * @default "_"
+     */
+    separator?: string;
+    /**
+     * Current path.
+     * @internal
+     */
+    path?: string[];
+}
+export declare function decamelizeKeysRecursively(input: any, opt?: DecamelizeRecursivelyOptions): any;
+/**
+ * Returns false if value is unset or a falsey value, and true otherwise.
+ * @param value an environment variable
+ */
+export declare function isTruthy(value: string | undefined): boolean;
+/**
+ * Type of a map mapping strings to some arbitrary type
+ */
+export declare type Obj<T> = {
+    [key: string]: T;
+};
+/**
+ * Return whether the given value is an object
+ *
+ * Even though arrays and instances of classes technically are objects, we
+ * usually want to treat them differently, so we return false in those cases.
+ */
+export declare function isObject(x: any): x is Obj<any>;
+/**
+ * Recursively merge objects together
+ *
+ * The leftmost object is mutated and returned. Arrays are not merged
+ * but overwritten just like scalars.
+ *
+ * If an object is merged into a non-object, the non-object is lost.
+ *
+ * `undefined`s will cause a value to be deleted if destructive is enabled.
+ */
+export declare function deepMerge(objects: Array<Obj<any> | undefined>, destructive?: boolean): Obj<any>;
+export declare function dedupArray<T>(array: T[]): T[];
+/**
+ * Returns a sorted version of `x` or `undefined` if it is an empty array or object.
+ */
+export declare function sorted<T>(x: T): unknown[] | T | undefined;
+export declare function formatAsPythonModule(name: string): string;
+export declare function kebabCaseKeys<T = unknown>(obj: T, recursive?: boolean): T;
+export declare function tryReadFile(file: string): Promise<string>;

package/lib/util.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryReadFile = exports.kebabCaseKeys = exports.formatAsPythonModule = exports.sorted = exports.dedupArray = exports.deepMerge = exports.isObject = exports.isTruthy = exports.decamelizeKeysRecursively = exports.writeFile = exports.getFilePermissions = exports.execOrUndefined = exports.execCapture = exports.exec = void 0;
+const child_process = require("child_process");
+const path = require("path");
+const Case = require("case");
+const fs = require("fs-extra");
+const logging = require("./logging");
+const MAX_BUFFER = 10 * 1024 * 1024;
+/**
+ * Executes a command with STDOUT > STDERR.
+ */
+function exec(command, options) {
+    logging.debug(command);
+    child_process.execSync(command, {
+        stdio: ['inherit', process.stderr, 'pipe'],
+        maxBuffer: MAX_BUFFER,
+        cwd: options.cwd,
+    });
+}
+exports.exec = exec;
+/**
+ * Executes command and returns STDOUT. If the command fails (non-zero), throws an error.
+ */
+function execCapture(command, options) {
+    logging.debug(command);
+    return child_process.execSync(command, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        maxBuffer: MAX_BUFFER,
+        cwd: options.cwd,
+    });
+}
+exports.execCapture = execCapture;
+/**
+ * Executes `command` and returns its value or undefined if the command failed.
+ */
+function execOrUndefined(command, options) {
+    try {
+        const value = child_process.execSync(command, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+            maxBuffer: MAX_BUFFER,
+            cwd: options.cwd,
+        }).toString('utf-8').trim();
+        if (!value) {
+            return undefined;
+        } // an empty string is the same as undefined
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.execOrUndefined = execOrUndefined;
+function getFilePermissions(options) {
+    var _a, _b;
+    const readonly = (_a = options.readonly) !== null && _a !== void 0 ? _a : false;
+    const executable = (_b = options.executable) !== null && _b !== void 0 ? _b : false;
+    if (readonly && executable) {
+        return '500';
+    }
+    else if (readonly) {
+        return '400';
+    }
+    else if (executable) {
+        return '755';
+    }
+    else {
+        return '644';
+    }
+}
+exports.getFilePermissions = getFilePermissions;
+function writeFile(filePath, data, options = {}) {
+    if (fs.existsSync(filePath)) {
+        fs.chmodSync(filePath, '600');
+    }
+    fs.mkdirpSync(path.dirname(filePath));
+    fs.writeFileSync(filePath, data);
+    fs.chmodSync(filePath, getFilePermissions(options));
+}
+exports.writeFile = writeFile;
+function decamelizeKeysRecursively(input, opt) {
+    var _a, _b, _c, _d;
+    const shouldAlwaysDecamelize = () => true;
+    const shouldDecamelize = (_a = opt === null || opt === void 0 ? void 0 : opt.shouldDecamelize) !== null && _a !== void 0 ? _a : shouldAlwaysDecamelize;
+    const separator = (_b = opt === null || opt === void 0 ? void 0 : opt.separator) !== null && _b !== void 0 ? _b : '_';
+    const path_ = (_c = opt === null || opt === void 0 ? void 0 : opt.path) !== null && _c !== void 0 ? _c : [];
+    const maxDepth = (_d = opt === null || opt === void 0 ? void 0 : opt.maxDepth) !== null && _d !== void 0 ? _d : 10;
+    if (path_.length > maxDepth) {
+        throw new Error('Decamelled too deeply - check that the input has no circular references');
+    }
+    if (Array.isArray(input)) {
+        return input.map((k, i) => decamelizeKeysRecursively(k, {
+            ...opt,
+            path: [...path_, i.toString()],
+        }));
+    }
+    if (typeof input === 'object' && input !== null) {
+        const mappedObject = {};
+        for (const [key, value] of Object.entries(input)) {
+            const transformedKey = shouldDecamelize([...path_, key], value)
+                ? decamelize(key, separator)
+                : key;
+            mappedObject[transformedKey] = decamelizeKeysRecursively(value, {
+                ...opt,
+                path: [...path_, key],
+            });
+        }
+        return mappedObject;
+    }
+    return input;
+}
+exports.decamelizeKeysRecursively = decamelizeKeysRecursively;
+/**
+ * Returns false if value is unset or a falsey value, and true otherwise.
+ * @param value an environment variable
+ */
+function isTruthy(value) {
+    return !(value === undefined || ['null', 'undefined', '0', 'false', ''].includes(value.toLocaleLowerCase()));
+}
+exports.isTruthy = isTruthy;
+/**
+ * Return whether the given value is an object
+ *
+ * Even though arrays and instances of classes technically are objects, we
+ * usually want to treat them differently, so we return false in those cases.
+ */
+function isObject(x) {
+    return x !== null && typeof x === 'object' && !Array.isArray(x)
+        && x.constructor.name === 'Object';
+}
+exports.isObject = isObject;
+/**
+ * Recursively merge objects together
+ *
+ * The leftmost object is mutated and returned. Arrays are not merged
+ * but overwritten just like scalars.
+ *
+ * If an object is merged into a non-object, the non-object is lost.
+ *
+ * `undefined`s will cause a value to be deleted if destructive is enabled.
+ */
+function deepMerge(objects, destructive = false) {
+    function mergeOne(target, source) {
+        for (const key of Object.keys(source)) {
+            const value = source[key];
+            if (isObject(value)) {
+                // if the value at the target is not an object, override it with an
+                // object so we can continue the recursion
+                if (typeof (target[key]) !== 'object') {
+                    target[key] = value;
+                }
+                mergeOne(target[key], value);
+                // if the result of the merge is an empty object, it's because the
+                // eventual value we assigned is `undefined`, and there are no
+                // sibling concrete values alongside, so we can delete this tree.
+                const output = target[key];
+                if (typeof (output) === 'object' && Object.keys(output).length === 0 && destructive) {
+                    delete target[key];
+                }
+            }
+            else if (value === undefined && destructive) {
+                delete target[key];
+            }
+            else if (typeof value !== 'undefined') {
+                target[key] = value;
+            }
+        }
+    }
+    const others = objects.filter(x => x != null);
+    if (others.length === 0) {
+        return {};
+    }
+    const into = others.splice(0, 1)[0];
+    others.forEach(other => mergeOne(into, other));
+    return into;
+}
+exports.deepMerge = deepMerge;
+/*
+ * Deduplicate values in a list, returning a new array.
+ * @param array list of values
+ */
+function dedupArray(array) {
+    return array.filter((val, idx) => array.indexOf(val) === idx);
+}
+exports.dedupArray = dedupArray;
+/**
+ * Returns a sorted version of `x` or `undefined` if it is an empty array or object.
+ */
+function sorted(x) {
+    if (x == null) {
+        return undefined;
+    }
+    if (Array.isArray(x)) {
+        if (x.length === 0) {
+            return undefined;
+        }
+        return x.sort();
+    }
+    else if (typeof x === 'object') {
+        if (Object.keys(x).length === 0) {
+            return undefined;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(x).sort(([l], [r]) => l.localeCompare(r))) {
+            result[key] = value;
+        }
+        return result;
+    }
+    else {
+        return x;
+    }
+}
+exports.sorted = sorted;
+function formatAsPythonModule(name) {
+    return name.replace(/-/g, '_').replace(/\./g, '_');
+}
+exports.formatAsPythonModule = formatAsPythonModule;
+function kebabCaseKeys(obj, recursive = true) {
+    if (typeof obj !== 'object' || obj == null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        if (recursive) {
+            obj = obj.map((v) => kebabCaseKeys(v, recursive));
+        }
+        return obj;
+    }
+    const result = {};
+    for (let [k, v] of Object.entries(obj)) {
+        if (recursive) {
+            v = kebabCaseKeys(v, recursive);
+        }
+        result[decamelize(k).replace(/_/mg, '-')] = v;
+    }
+    return result;
+}
+exports.kebabCaseKeys = kebabCaseKeys;
+async function tryReadFile(file) {
+    if (!(await fs.pathExists(file))) {
+        return '';
+    }
+    return fs.readFile(file, 'utf8');
+}
+exports.tryReadFile = tryReadFile;
+function decamelize(s, sep = '_') {
+    if (Case.of(s) === 'camel') {
+        return Case.lower(s, sep);
+    }
+    else {
+        return s;
+    }
+}
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport * as path from 'path';\nimport * as Case from 'case';\nimport * as fs from 'fs-extra';\nimport * as logging from './logging';\n\nconst MAX_BUFFER = 10 * 1024 * 1024;\n\n/**\n * Executes a command with STDOUT > STDERR.\n */\nexport function exec(command: string, options: { cwd: string }): void {\n  logging.debug(command);\n  child_process.execSync(command, {\n    stdio: ['inherit', process.stderr, 'pipe'], // \"pipe\" for STDERR means it appears in exceptions\n    maxBuffer: MAX_BUFFER,\n    cwd: options.cwd,\n  });\n}\n\n/**\n * Executes command and returns STDOUT. If the command fails (non-zero), throws an error.\n */\nexport function execCapture(command: string, options: { cwd: string }) {\n  logging.debug(command);\n  return child_process.execSync(command, {\n    stdio: ['inherit', 'pipe', 'pipe'], // \"pipe\" for STDERR means it appears in exceptions\n    maxBuffer: MAX_BUFFER,\n    cwd: options.cwd,\n  });\n}\n\n/**\n * Executes `command` and returns its value or undefined if the command failed.\n */\nexport function execOrUndefined(command: string, options: { cwd: string }): string | undefined {\n  try {\n    const value = child_process.execSync(command, {\n      stdio: ['inherit', 'pipe', 'pipe'], // \"pipe\" for STDERR means it appears in exceptions\n      maxBuffer: MAX_BUFFER,\n      cwd: options.cwd,\n    }).toString('utf-8').trim();\n\n    if (!value) { return undefined; } // an empty string is the same as undefined\n    return value;\n  } catch {\n    return undefined;\n  }\n}\n\nexport interface WriteFileOptions {\n  /**\n   * Whether the generated file should be marked as executable.\n   *\n   * @default false\n   */\n  executable?: boolean;\n\n  /**\n   * Whether the generated file should be readonly.\n   *\n   * @default false\n   */\n  readonly?: boolean;\n}\n\nexport function getFilePermissions(options: WriteFileOptions): string {\n  const readonly = options.readonly ?? false;\n  const executable = options.executable ?? false;\n  if (readonly && executable) {\n    return '500';\n  } else if (readonly) {\n    return '400';\n  } else if (executable) {\n    return '755';\n  } else {\n    return '644';\n  }\n}\n\nexport function writeFile(filePath: string, data: any, options: WriteFileOptions = {}) {\n  if (fs.existsSync(filePath)) {\n    fs.chmodSync(filePath, '600');\n  }\n\n  fs.mkdirpSync(path.dirname(filePath));\n  fs.writeFileSync(filePath, data);\n\n  fs.chmodSync(filePath, getFilePermissions(options));\n}\n\n/**\n * Decamelizes the keys of an object structure, recursing through child objects and arrays.\n * @experimental\n */\nexport interface DecamelizeRecursivelyOptions {\n  /**\n   * Max depth to recurse before erroring.\n   * @default 10\n   */\n  maxDepth?: number;\n\n  /**\n   * Returns true when a key should be decamelized\n   * @default - all keys are decamelized\n   */\n  shouldDecamelize?: (path: string[], value: any) => boolean;\n\n  /**\n   * Separator for decamelizing.\n   * @default \"_\"\n   */\n  separator?: string;\n\n  /**\n   * Current path.\n   * @internal\n   */\n  path?: string[];\n}\n\nexport function decamelizeKeysRecursively(input: any, opt?: DecamelizeRecursivelyOptions): any {\n  const shouldAlwaysDecamelize = () => true;\n  const shouldDecamelize = opt?.shouldDecamelize ?? shouldAlwaysDecamelize;\n  const separator = opt?.separator ?? '_';\n  const path_ = opt?.path ?? [];\n  const maxDepth = opt?.maxDepth ?? 10;\n\n  if (path_.length > maxDepth) {\n    throw new Error('Decamelled too deeply - check that the input has no circular references');\n  }\n\n  if (Array.isArray(input)) {\n    return input.map((k, i) => decamelizeKeysRecursively(k, {\n      ...opt,\n      path: [...path_, i.toString()],\n    }));\n  }\n\n  if (typeof input === 'object' && input !== null) {\n    const mappedObject: Record<string, any> = {};\n    for (const [key, value] of Object.entries(input)) {\n      const transformedKey = shouldDecamelize([...path_, key], value)\n        ? decamelize(key, separator)\n        : key;\n\n      mappedObject[transformedKey] = decamelizeKeysRecursively(value, {\n        ...opt,\n        path: [...path_, key],\n      });\n    }\n\n    return mappedObject;\n  }\n\n  return input;\n}\n\n/**\n * Returns false if value is unset or a falsey value, and true otherwise.\n * @param value an environment variable\n */\nexport function isTruthy(value: string | undefined): boolean {\n  return !(value === undefined || ['null', 'undefined', '0', 'false', ''].includes(value.toLocaleLowerCase()));\n}\n\n/**\n * Type of a map mapping strings to some arbitrary type\n */\nexport type Obj<T> = { [key: string]: T };\n\n/**\n * Return whether the given value is an object\n *\n * Even though arrays and instances of classes technically are objects, we\n * usually want to treat them differently, so we return false in those cases.\n */\nexport function isObject(x: any): x is Obj<any> {\n  return x !== null && typeof x === 'object' && !Array.isArray(x)\n    && x.constructor.name === 'Object';\n}\n\n/**\n * Recursively merge objects together\n *\n * The leftmost object is mutated and returned. Arrays are not merged\n * but overwritten just like scalars.\n *\n * If an object is merged into a non-object, the non-object is lost.\n *\n * `undefined`s will cause a value to be deleted if destructive is enabled.\n */\nexport function deepMerge(objects: Array<Obj<any> | undefined>, destructive: boolean = false) {\n  function mergeOne(target: Obj<any>, source: Obj<any>) {\n    for (const key of Object.keys(source)) {\n      const value = source[key];\n\n      if (isObject(value)) {\n        // if the value at the target is not an object, override it with an\n        // object so we can continue the recursion\n        if (typeof(target[key]) !== 'object') {\n          target[key] = value;\n        }\n        mergeOne(target[key], value);\n\n        // if the result of the merge is an empty object, it's because the\n        // eventual value we assigned is `undefined`, and there are no\n        // sibling concrete values alongside, so we can delete this tree.\n        const output = target[key];\n        if (typeof(output) === 'object' && Object.keys(output).length === 0 && destructive) {\n          delete target[key];\n        }\n      } else if (value === undefined && destructive) {\n        delete target[key];\n      } else if (typeof value !== 'undefined') {\n        target[key] = value;\n      }\n    }\n  }\n\n  const others = objects.filter(x => x != null) as Array<Obj<any>>;\n\n  if (others.length === 0) { return {}; }\n  const into = others.splice(0, 1)[0];\n\n  others.forEach(other => mergeOne(into, other));\n  return into;\n}\n\n/*\n * Deduplicate values in a list, returning a new array.\n * @param array list of values\n */\nexport function dedupArray<T>(array: T[]): T[] {\n  return array.filter((val, idx) => array.indexOf(val) === idx);\n}\n\n/**\n * Returns a sorted version of `x` or `undefined` if it is an empty array or object.\n */\nexport function sorted<T>(x: T) {\n  if (x == null) { return undefined; }\n  if (Array.isArray(x)) {\n    if (x.length === 0) { return undefined; }\n    return (x as unknown[]).sort();\n  } else if (typeof x === 'object') {\n    if (Object.keys(x).length === 0) { return undefined; }\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(x).sort(([l], [r]) => l.localeCompare(r))) {\n      result[key] = value;\n    }\n    return result as T;\n  } else {\n    return x;\n  }\n}\n\nexport function formatAsPythonModule(name: string) {\n  return name.replace(/-/g, '_').replace(/\\./g, '_');\n}\n\nexport function kebabCaseKeys<T = unknown>(obj: T, recursive = true): T {\n  if (typeof obj !== 'object' || obj == null) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    if (recursive) {\n      obj = obj.map((v) => kebabCaseKeys(v, recursive)) as any;\n    }\n    return obj;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (let [k, v] of Object.entries(obj)) {\n    if (recursive) {\n      v = kebabCaseKeys(v, recursive);\n    }\n    result[decamelize(k).replace(/_/mg, '-')] = v;\n  }\n  return result as any;\n}\n\nexport async function tryReadFile(file: string) {\n  if (!(await fs.pathExists(file))) {\n    return '';\n  }\n\n  return fs.readFile(file, 'utf8');\n}\n\nfunction decamelize(s: string, sep: string = '_') {\n  if (Case.of(s) === 'camel') {\n    return Case.lower(s, sep);\n  } else {\n    return s;\n  }\n};\n"]}

package/lib/version.d.ts

@@ -0,0 +1,70 @@
+import { Component } from './component';
+import { Project } from './project';
+import { Task } from './task';
+/**
+ * (experimental) Options for `Version`.
+ *
+ * @experimental
+ */
+export interface VersionOptions {
+    /**
+     * (experimental) A name of a .json file to set the `version` field in after a bump.
+     *
+     * @experimental
+     * @example
+     *
+     * "package.json"
+     */
+    readonly versionInputFile: string;
+    /**
+     * (experimental) The name of the directory into which `changelog.md` and `version.txt` files are emitted.
+     *
+     * @experimental
+     */
+    readonly artifactsDirectory: string;
+    /**
+     * (experimental) Custom configuration for versionrc file used by standard-release.
+     *
+     * @experimental
+     */
+    readonly versionrcOptions?: Record<string, any>;
+}
+/**
+ * @experimental
+ */
+export declare class Version extends Component {
+    /**
+     * @experimental
+     */
+    static readonly STANDARD_VERSION = "standard-version@^9";
+    /**
+     * @experimental
+     */
+    readonly bumpTask: Task;
+    /**
+     * @experimental
+     */
+    readonly unbumpTask: Task;
+    /**
+     * (experimental) The name of the changelog file (under `artifactsDirectory`).
+     *
+     * @experimental
+     */
+    readonly changelogFileName: string;
+    /**
+     * (experimental) The name of the file that contains the version (under `artifactsDirectory`).
+     *
+     * @experimental
+     */
+    readonly versionFileName: string;
+    /**
+     * (experimental) The name of the file that contains the release tag (under `artifactsDirectory`).
+     *
+     * @experimental
+     */
+    readonly releaseTagFileName: string;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, options: VersionOptions);
+}

package/lib/version.js

@@ -0,0 +1,60 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path_1 = require("path");
+const component_1 = require("./component");
+/**
+ * @experimental
+ */
+class Version extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        super(project);
+        this.changelogFileName = 'changelog.md';
+        this.versionFileName = 'version.txt';
+        this.releaseTagFileName = 'releasetag.txt';
+        const versionInputFile = options.versionInputFile;
+        // this command determines if there were any changes since the last release
+        // (the top-most commit is not a bump). it is used as a condition for both
+        // the `bump` and the `release` tasks.
+        const changesSinceLastRelease = '! git log --oneline -1 | grep -q "chore(release):"';
+        const changelogFile = path_1.posix.join(options.artifactsDirectory, this.changelogFileName);
+        const bumpFile = path_1.posix.join(options.artifactsDirectory, this.versionFileName);
+        const releaseTagFile = path_1.posix.join(options.artifactsDirectory, this.releaseTagFileName);
+        const env = {
+            OUTFILE: versionInputFile,
+            CHANGELOG: changelogFile,
+            BUMPFILE: bumpFile,
+            RELEASETAG: releaseTagFile,
+            // doesn't work if custom configuration is long
+            VERSIONRCOPTIONS: JSON.stringify(options.versionrcOptions),
+        };
+        this.bumpTask = project.addTask('bump', {
+            description: 'Bumps version based on latest git tag and generates a changelog entry',
+            condition: changesSinceLastRelease,
+            env: env,
+        });
+        this.bumpTask.builtin('release/bump-version');
+        this.unbumpTask = project.addTask('unbump', {
+            description: 'Restores version to 0.0.0',
+            env: env,
+        });
+        this.unbumpTask.builtin('release/reset-version');
+        project.addGitIgnore(`/${changelogFile}`);
+        project.addGitIgnore(`/${bumpFile}`);
+        project.addPackageIgnore(`/${changelogFile}`);
+        project.addPackageIgnore(`/${bumpFile}`);
+    }
+}
+exports.Version = Version;
+_a = JSII_RTTI_SYMBOL_1;
+Version[_a] = { fqn: "projen.Version", version: "0.46.8" };
+/**
+ * @experimental
+ */
+Version.STANDARD_VERSION = 'standard-version@^9';
+//# sourceMappingURL=data:application/json;base64,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