projen 0.0.0

package/lib/makefile.js

@@ -0,0 +1,99 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Makefile = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const file_1 = require("./file");
+/**
+ * (experimental) Minimal Makefile.
+ *
+ * @experimental
+ */
+class Makefile extends file_1.FileBase {
+    /**
+     * @experimental
+     */
+    constructor(project, filePath, options = {}) {
+        super(project, filePath, options);
+        const all = options.all ? options.all : [];
+        const rules = options.rules ? options.rules : [];
+        rules.forEach(e => this.validateRule(e));
+        this.all = {
+            targets: ['all'],
+            prerequisites: all,
+            phony: true,
+        };
+        this.rules = [
+            this.all,
+            ...rules,
+        ];
+    }
+    /**
+     * (experimental) Add a target to all.
+     *
+     * @experimental
+     */
+    addAll(target) {
+        this.all.prerequisites.push(target);
+        return this;
+    }
+    /**
+     * (experimental) Add multiple targets to all.
+     *
+     * @experimental
+     */
+    addAlls(...targets) {
+        targets.forEach(e => this.addAll(e));
+        return this;
+    }
+    /**
+     * (experimental) Add a rule to the Makefile.
+     *
+     * @experimental
+     */
+    addRule(rule) {
+        this.validateRule(rule);
+        this.rules.push(rule);
+        return this;
+    }
+    /**
+     * (experimental) Add multiple rules to the Makefile.
+     *
+     * @experimental
+     */
+    addRules(...rules) {
+        rules.forEach(e => this.addRule(e));
+        return this;
+    }
+    validateRule(rule) {
+        if (!rule.targets || !rule.targets.length) {
+            throw new Error('"targets" cannot be undefined or empty for items in "rules"');
+        }
+    }
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    synthesizeContent(resolver) {
+        const rules = resolver.resolve(this.rules);
+        const lines = [
+            ...rules.map((rule) => {
+                const targets = rule.targets.join(' ');
+                const prerequisites = (rule.prerequisites ? rule.prerequisites : []).join(' ');
+                const recipe = rule.recipe ? rule.recipe : [];
+                const phony = rule.phony ? [`.PHONY: ${targets}`] : [];
+                return [
+                    ...phony,
+                    `${targets}: ${prerequisites}`.trim(),
+                    ...recipe.map(step => `\t${step}`),
+                ].join('\n');
+            }),
+        ];
+        return `${lines.join('\n\n')}\n`;
+    }
+}
+exports.Makefile = Makefile;
+_a = JSII_RTTI_SYMBOL_1;
+Makefile[_a] = { fqn: "projen.Makefile", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/object-file.d.ts

@@ -0,0 +1,112 @@
+import { FileBase, FileBaseOptions, IResolver } from './file';
+import { Project } from './project';
+/**
+ * (experimental) Options for `ObjectFile`.
+ *
+ * @experimental
+ */
+export interface ObjectFileOptions extends FileBaseOptions {
+    /**
+     * (experimental) The object that will be serialized.
+     *
+     * You can modify the object's contents
+     * before synthesis.
+     *
+     * @default {} an empty object (use `file.obj` to mutate).
+     * @experimental
+     */
+    readonly obj?: any;
+    /**
+     * (experimental) Omits empty objects and arrays.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly omitEmpty?: boolean;
+    /**
+     * (experimental) Adds the projen marker to the file.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly marker?: boolean;
+}
+/**
+ * (experimental) Represents an Object file.
+ *
+ * @experimental
+ */
+export declare abstract class ObjectFile extends FileBase {
+    /**
+     * The output object. This object can be mutated until the project is
+     * synthesized.
+     */
+    private readonly obj;
+    /**
+     * (experimental) Indicates if the projen marker JSON-comment will be added to the output object.
+     *
+     * @experimental
+     */
+    marker: boolean;
+    /**
+     * An object to be merged on top of `obj` after the resolver is called
+     */
+    private readonly rawOverrides;
+    /**
+     * (experimental) Indicates if empty objects and arrays are omitted from the output object.
+     *
+     * @experimental
+     */
+    readonly omitEmpty: boolean;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, filePath: string, options: ObjectFileOptions);
+    /**
+     * (experimental) Adds an override to the synthesized object file.
+     *
+     * If the override is nested, separate each nested level using a dot (.) in the path parameter.
+     * If there is an array as part of the nesting, specify the index in the path.
+     *
+     * To include a literal `.` in the property name, prefix with a `\`. In most
+     * programming languages you will need to write this as `"\\."` because the
+     * `\` itself will need to be escaped.
+     *
+     * For example,
+     * ```typescript
+     * project.tsconfig.file.addOverride('compilerOptions.alwaysStrict', true);
+     * project.tsconfig.file.addOverride('compilerOptions.lib', ['dom', 'dom.iterable', 'esnext']);
+     * ```
+     * would add the overrides
+     * ```json
+     * "compilerOptions": {
+     *    "alwaysStrict": true,
+     *    "lib": [
+     *      "dom",
+     *      "dom.iterable",
+     *      "esnext"
+     *    ]
+     *    ...
+     * }
+     * ...
+     * ```
+     *
+     * @param path - The path of the property, you can use dot notation to override values in complex types.
+     * @param value - The value.
+     * @experimental
+     */
+    addOverride(path: string, value: any): void;
+    /**
+     * (experimental) Syntactic sugar for `addOverride(path, undefined)`.
+     *
+     * @param path The path of the value to delete.
+     * @experimental
+     */
+    addDeletionOverride(path: string): void;
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    protected synthesizeContent(resolver: IResolver): string | undefined;
+}

package/lib/object-file.js

@@ -0,0 +1,125 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectFile = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const file_1 = require("./file");
+const util_1 = require("./util");
+/**
+ * (experimental) Represents an Object file.
+ *
+ * @experimental
+ */
+class ObjectFile extends file_1.FileBase {
+    /**
+     * @experimental
+     */
+    constructor(project, filePath, options) {
+        var _b, _c, _d;
+        super(project, filePath, options);
+        this.obj = (_b = options.obj) !== null && _b !== void 0 ? _b : {};
+        this.marker = (_c = options.marker) !== null && _c !== void 0 ? _c : true;
+        this.omitEmpty = (_d = options.omitEmpty) !== null && _d !== void 0 ? _d : false;
+        this.rawOverrides = {};
+    }
+    /**
+     * (experimental) Adds an override to the synthesized object file.
+     *
+     * If the override is nested, separate each nested level using a dot (.) in the path parameter.
+     * If there is an array as part of the nesting, specify the index in the path.
+     *
+     * To include a literal `.` in the property name, prefix with a `\`. In most
+     * programming languages you will need to write this as `"\\."` because the
+     * `\` itself will need to be escaped.
+     *
+     * For example,
+     * ```typescript
+     * project.tsconfig.file.addOverride('compilerOptions.alwaysStrict', true);
+     * project.tsconfig.file.addOverride('compilerOptions.lib', ['dom', 'dom.iterable', 'esnext']);
+     * ```
+     * would add the overrides
+     * ```json
+     * "compilerOptions": {
+     *    "alwaysStrict": true,
+     *    "lib": [
+     *      "dom",
+     *      "dom.iterable",
+     *      "esnext"
+     *    ]
+     *    ...
+     * }
+     * ...
+     * ```
+     *
+     * @param path - The path of the property, you can use dot notation to override values in complex types.
+     * @param value - The value.
+     * @experimental
+     */
+    addOverride(path, value) {
+        const parts = splitOnPeriods(path);
+        let curr = this.rawOverrides;
+        while (parts.length > 1) {
+            const key = parts.shift();
+            // if we can't recurse further or the previous value is not an
+            // object overwrite it with an object.
+            const isObject = curr[key] != null && typeof (curr[key]) === 'object' && !Array.isArray(curr[key]);
+            if (!isObject) {
+                curr[key] = {};
+            }
+            curr = curr[key];
+        }
+        const lastKey = parts.shift();
+        curr[lastKey] = value;
+    }
+    /**
+     * (experimental) Syntactic sugar for `addOverride(path, undefined)`.
+     *
+     * @param path The path of the value to delete.
+     * @experimental
+     */
+    addDeletionOverride(path) {
+        this.addOverride(path, undefined);
+    }
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    synthesizeContent(resolver) {
+        var _b;
+        const obj = this.obj;
+        const resolved = (_b = resolver.resolve(obj, {
+            omitEmpty: this.omitEmpty,
+        })) !== null && _b !== void 0 ? _b : undefined;
+        if (resolved) {
+            util_1.deepMerge([resolved, this.rawOverrides], true);
+        }
+        return resolved ? JSON.stringify(resolved, undefined, 2) : undefined;
+    }
+}
+exports.ObjectFile = ObjectFile;
+_a = JSII_RTTI_SYMBOL_1;
+ObjectFile[_a] = { fqn: "projen.ObjectFile", version: "0.46.8" };
+/**
+ * Split on periods while processing escape characters \
+ */
+function splitOnPeriods(x) {
+    // Build this list in reverse because it's more convenient to get the "current"
+    // item by doing ret[0] than by ret[ret.length - 1].
+    const ret = [''];
+    for (let i = 0; i < x.length; i++) {
+        if (x[i] === '\\' && i + 1 < x.length) {
+            ret[0] += x[i + 1];
+            i++;
+        }
+        else if (x[i] === '.') {
+            ret.unshift('');
+        }
+        else {
+            ret[0] += x[i];
+        }
+    }
+    ret.reverse();
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-file.js","sourceRoot":"","sources":["../src/object-file.ts"],"names":[],"mappings":"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","sourcesContent":["import { FileBase, FileBaseOptions, IResolver } from './file';\nimport { Project } from './project';\nimport { deepMerge } from './util';\n\n                                    \nexport interface ObjectFileOptions extends FileBaseOptions {\n                                                                                                                                                                                  \n  readonly obj?: any;\n\n                                                                    \n  readonly omitEmpty?: boolean;\n\n                                                                            \n  readonly marker?: boolean;\n}\n\n                                     \nexport abstract class ObjectFile extends FileBase {\n  /**\n   * The output object. This object can be mutated until the project is\n   * synthesized.\n   */\n  private readonly obj: object;\n\n                                                                                                     \n  public marker: boolean;\n\n  /**\n   * An object to be merged on top of `obj` after the resolver is called\n   */\n  private readonly rawOverrides: object;\n\n                                                                                          \n  public readonly omitEmpty: boolean;\n\n  constructor(project: Project, filePath: string, options: ObjectFileOptions) {\n    super(project, filePath, options);\n\n    this.obj = options.obj ?? {};\n    this.marker = options.marker ?? true;\n    this.omitEmpty = options.omitEmpty ?? false;\n    this.rawOverrides = {};\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \n  public addOverride(path: string, value: any) {\n    const parts = splitOnPeriods(path);\n    let curr: any = this.rawOverrides;\n\n    while (parts.length > 1) {\n      const key = parts.shift()!;\n\n      // if we can't recurse further or the previous value is not an\n      // object overwrite it with an object.\n      const isObject = curr[key] != null && typeof(curr[key]) === 'object' && !Array.isArray(curr[key]);\n      if (!isObject) {\n        curr[key] = {};\n      }\n\n      curr = curr[key];\n    }\n\n    const lastKey = parts.shift()!;\n    curr[lastKey] = value;\n  }\n\n                                                                                                                     \n  public addDeletionOverride(path: string) {\n    this.addOverride(path, undefined);\n  }\n\n  protected synthesizeContent(resolver: IResolver): string | undefined {\n    const obj = this.obj;\n\n    const resolved = resolver.resolve(obj, {\n      omitEmpty: this.omitEmpty,\n    }) ?? undefined;\n\n    if (resolved) {\n      deepMerge([resolved, this.rawOverrides], true);\n    }\n\n    return resolved ? JSON.stringify(resolved, undefined, 2) : undefined;\n  }\n}\n\n/**\n * Split on periods while processing escape characters \\\n */\nfunction splitOnPeriods(x: string): string[] {\n  // Build this list in reverse because it's more convenient to get the \"current\"\n  // item by doing ret[0] than by ret[ret.length - 1].\n  const ret = [''];\n  for (let i = 0; i < x.length; i++) {\n    if (x[i] === '\\\\' && i + 1 < x.length) {\n      ret[0] += x[i + 1];\n      i++;\n    } else if (x[i] === '.') {\n      ret.unshift('');\n    } else {\n      ret[0] += x[i];\n    }\n  }\n\n  ret.reverse();\n  return ret;\n}\n"]}

package/lib/option-hints.d.ts

@@ -0,0 +1,27 @@
+/**
+ * (experimental) Choices for how to display commented out options in projenrc files.
+ *
+ * Does not apply to projenrc.json files.
+ *
+ * @experimental
+ */
+export declare enum InitProjectOptionHints {
+    /**
+     * (experimental) Display all possible options (grouped by which interface they belong to).
+     *
+     * @experimental
+     */
+    ALL = "all",
+    /**
+     * (experimental) Display only featured options, in alphabetical order.
+     *
+     * @experimental
+     */
+    FEATURED = "featured",
+    /**
+     * (experimental) Display no extra options.
+     *
+     * @experimental
+     */
+    NONE = "none"
+}

package/lib/option-hints.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitProjectOptionHints = void 0;
+/**
+ * (experimental) Choices for how to display commented out options in projenrc files.
+ *
+ * Does not apply to projenrc.json files.
+ *
+ * @experimental
+ */
+var InitProjectOptionHints;
+(function (InitProjectOptionHints) {
+    InitProjectOptionHints["ALL"] = "all";
+    InitProjectOptionHints["FEATURED"] = "featured";
+    InitProjectOptionHints["NONE"] = "none";
+})(InitProjectOptionHints = exports.InitProjectOptionHints || (exports.InitProjectOptionHints = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLWhpbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL29wdGlvbi1oaW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7O0FBQ0EsSUFBWSxzQkFTWDtBQVRELFdBQVksc0JBQXNCO0lBRWhDLHFDQUFXLENBQUE7SUFHWCwrQ0FBcUIsQ0FBQTtJQUdyQix1Q0FBYSxDQUFBO0FBQ2YsQ0FBQyxFQVRXLHNCQUFzQixHQUF0Qiw4QkFBc0IsS0FBdEIsOEJBQXNCLFFBU2pDIiwic291cmNlc0NvbnRlbnQiOlsiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG5leHBvcnQgZW51bSBJbml0UHJvamVjdE9wdGlvbkhpbnRzIHtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuICBBTEwgPSAnYWxsJyxcblxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuICBGRUFUVVJFRCA9ICdmZWF0dXJlZCcsXG5cbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuICBOT05FID0gJ25vbmUnXG59XG4iXX0=

package/lib/project-build.d.ts

@@ -0,0 +1,60 @@
+import { Component } from './component';
+import { Project } from './project';
+import { Task } from './task';
+/**
+ * (experimental) Manages a standard build process for all projects.
+ *
+ * Build spawns these tasks in order:
+ * 1. default
+ * 2. pre-compile
+ * 3. compile
+ * 4. post-compile
+ * 5. test
+ * 6. package
+ *
+ * @experimental
+ */
+export declare class ProjectBuild extends Component {
+    /**
+     * (experimental) The task responsible for a full release build.
+     *
+     * @experimental
+     */
+    readonly buildTask: Task;
+    /**
+     * (experimental) Pre-compile task.
+     *
+     * @experimental
+     */
+    readonly preCompileTask: Task;
+    /**
+     * (experimental) Compiles the code.
+     *
+     * By default for node.js projects this task is empty.
+     *
+     * @experimental
+     */
+    readonly compileTask: Task;
+    /**
+     * (experimental) Post-compile task.
+     *
+     * @experimental
+     */
+    readonly postCompileTask: Task;
+    /**
+     * (experimental) Tests the code.
+     *
+     * @experimental
+     */
+    readonly testTask: Task;
+    /**
+     * (experimental) The "package" task.
+     *
+     * @experimental
+     */
+    readonly packageTask: Task;
+    /**
+     * @experimental
+     */
+    constructor(project: Project);
+}

package/lib/project-build.js

@@ -0,0 +1,61 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectBuild = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("./component");
+/**
+ * (experimental) Manages a standard build process for all projects.
+ *
+ * Build spawns these tasks in order:
+ * 1. default
+ * 2. pre-compile
+ * 3. compile
+ * 4. post-compile
+ * 5. test
+ * 6. package
+ *
+ * @experimental
+ */
+class ProjectBuild extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project) {
+        super(project);
+        this.preCompileTask = project.tasks.addTask('pre-compile', {
+            description: 'Prepare the project for compilation',
+        });
+        this.compileTask = project.tasks.addTask('compile', {
+            description: 'Only compile',
+        });
+        this.postCompileTask = project.tasks.addTask('post-compile', {
+            description: 'Runs after successful compilation',
+        });
+        this.testTask = project.tasks.addTask('test', {
+            description: 'Run tests',
+        });
+        this.packageTask = project.tasks.addTask('package', {
+            description: 'Creates the distribution package',
+        });
+        this.buildTask = project.tasks.addTask('build', {
+            description: 'Full release build',
+        });
+        // if this is not subproject, execute the "default" task which will
+        // synthesize project files.
+        if (!this.project.parent) {
+            this.buildTask.spawn(this.project.defaultTask);
+        }
+        this.buildTask.spawn(this.preCompileTask);
+        this.buildTask.spawn(this.compileTask);
+        this.buildTask.spawn(this.postCompileTask);
+        this.buildTask.spawn(this.testTask);
+        this.buildTask.spawn(this.packageTask);
+        // do not allow additional build phases
+        this.buildTask.lock();
+    }
+}
+exports.ProjectBuild = ProjectBuild;
+_a = JSII_RTTI_SYMBOL_1;
+ProjectBuild[_a] = { fqn: "projen.ProjectBuild", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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