projen 0.0.0

package/lib/project.js

@@ -0,0 +1,391 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectType = exports.Project = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path = require("path");
+const cleanup_1 = require("./cleanup");
+const common_1 = require("./common");
+const dependencies_1 = require("./dependencies");
+const file_1 = require("./file");
+const gitattributes_1 = require("./gitattributes");
+const ignore_file_1 = require("./ignore-file");
+const render_options_1 = require("./javascript/render-options");
+const json_1 = require("./json");
+const logger_1 = require("./logger");
+const object_file_1 = require("./object-file");
+const project_build_1 = require("./project-build");
+const projenrc_json_1 = require("./projenrc-json");
+const tasks_1 = require("./tasks");
+const util_1 = require("./util");
+/**
+ * (experimental) Base project.
+ *
+ * @experimental
+ */
+class Project {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        var _b, _c, _d;
+        this._components = new Array();
+        this.subprojects = new Array();
+        this.tips = new Array();
+        this.initProject = render_options_1.resolveInitProject(options);
+        this.name = options.name;
+        this.parent = options.parent;
+        this.excludeFromCleanup = [];
+        this.projenCommand = (_b = options.projenCommand) !== null && _b !== void 0 ? _b : 'npx projen';
+        this.outdir = this.determineOutdir(options.outdir);
+        this.root = this.parent ? this.parent.root : this;
+        // must happen after this.outdir, this.parent and this.root are initialized
+        (_c = this.parent) === null || _c === void 0 ? void 0 : _c._addSubProject(this);
+        // ------------------------------------------------------------------------
+        this.gitattributes = new gitattributes_1.GitAttributesFile(this);
+        this.annotateGenerated('/.projen/**'); // contents  of the .projen/ directory are generated by projen
+        this.annotateGenerated(`/${this.gitattributes.path}`); // the .gitattributes file itself is generated
+        this.gitignore = new ignore_file_1.IgnoreFile(this, '.gitignore');
+        this.gitignore.exclude('node_modules/'); // created by running `npx projen`
+        this.gitignore.include(`/${this.gitattributes.path}`);
+        // oh no: tasks depends on gitignore so it has to be initialized after
+        // smells like dep injectionn but god forbid.
+        this.tasks = new tasks_1.Tasks(this);
+        this.defaultTask = this.tasks.addTask(Project.DEFAULT_TASK, {
+            description: 'Synthesize project files',
+        });
+        this.projectBuild = new project_build_1.ProjectBuild(this);
+        this.deps = new dependencies_1.Dependencies(this);
+        this.logger = new logger_1.Logger(this, options.logging);
+        const projenrcJson = (_d = options.projenrcJson) !== null && _d !== void 0 ? _d : false;
+        if (projenrcJson) {
+            new projenrc_json_1.Projenrc(this, options.projenrcJsonOptions);
+        }
+        new json_1.JsonFile(this, cleanup_1.FILE_MANIFEST, {
+            omitEmpty: true,
+            obj: () => ({
+                // replace `\` with `/` to ensure paths match across platforms
+                files: this.files.filter(f => f.readonly).map(f => f.path.replace(/\\/g, '/')),
+            }),
+        });
+    }
+    /**
+     * (experimental) Returns all the components within this project.
+     *
+     * @experimental
+     */
+    get components() {
+        return [...this._components];
+    }
+    /**
+     * (experimental) All files in this project.
+     *
+     * @experimental
+     */
+    get files() {
+        const isFile = (c) => c instanceof file_1.FileBase;
+        return this._components.filter(isFile).sort((f1, f2) => f1.path.localeCompare(f2.path));
+    }
+    /**
+     * (experimental) Adds a new task to this project.
+     *
+     * This will fail if the project already has
+     * a task with this name.
+     *
+     * @param name The task name to add.
+     * @param props Task properties.
+     * @experimental
+     */
+    addTask(name, props = {}) {
+        return this.tasks.addTask(name, props);
+    }
+    /**
+     * (experimental) Removes a task from a project.
+     *
+     * @param name The name of the task to remove.
+     * @returns The `Task` that was removed, otherwise `undefined`.
+     * @experimental
+     */
+    removeTask(name) {
+        return this.tasks.removeTask(name);
+    }
+    /**
+     * @experimental
+     */
+    get buildTask() { return this.projectBuild.buildTask; }
+    /**
+     * @experimental
+     */
+    get compileTask() { return this.projectBuild.compileTask; }
+    /**
+     * @experimental
+     */
+    get testTask() { return this.projectBuild.testTask; }
+    /**
+     * @experimental
+     */
+    get preCompileTask() { return this.projectBuild.preCompileTask; }
+    /**
+     * @experimental
+     */
+    get postCompileTask() { return this.projectBuild.postCompileTask; }
+    /**
+     * @experimental
+     */
+    get packageTask() { return this.projectBuild.packageTask; }
+    /**
+     * (experimental) Finds a file at the specified relative path within this project and all its subprojects.
+     *
+     * @param filePath The file path.
+     * @returns a `FileBase` or undefined if there is no file in that path
+     * @experimental
+     */
+    tryFindFile(filePath) {
+        const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(this.outdir, filePath);
+        for (const file of this.files) {
+            if (absolute === file.absolutePath) {
+                return file;
+            }
+        }
+        for (const child of this.subprojects) {
+            const file = child.tryFindFile(absolute);
+            if (file) {
+                return file;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * (deprecated) Finds a json file by name.
+     *
+     * @param filePath The file path.
+     * @deprecated use `tryFindObjectFile`
+     */
+    tryFindJsonFile(filePath) {
+        const file = this.tryFindObjectFile(filePath);
+        if (!file) {
+            return undefined;
+        }
+        if (!(file instanceof json_1.JsonFile)) {
+            throw new Error(`found file ${filePath} but it is not a JsonFile. got: ${file.constructor.name}`);
+        }
+        return file;
+    }
+    /**
+     * (experimental) Finds an object file (like JsonFile, YamlFile, etc.) by name.
+     *
+     * @param filePath The file path.
+     * @experimental
+     */
+    tryFindObjectFile(filePath) {
+        const file = this.tryFindFile(filePath);
+        if (!file) {
+            return undefined;
+        }
+        if (!(file instanceof object_file_1.ObjectFile)) {
+            throw new Error(`found file ${filePath} but it is not a ObjectFile. got: ${file.constructor.name}`);
+        }
+        return file;
+    }
+    /**
+     * (deprecated) Prints a "tip" message during synthesis.
+     *
+     * @param message The message.
+     * @deprecated - use `project.logger.info(message)` to show messages during synthesis
+     */
+    addTip(message) {
+        this.tips.push(message);
+    }
+    /**
+     * (experimental) Exclude the matching files from pre-synth cleanup.
+     *
+     * Can be used when, for example, some
+     * source files include the projen marker and we don't want them to be erased during synth.
+     *
+     * @param globs The glob patterns to match.
+     * @experimental
+     */
+    addExcludeFromCleanup(...globs) {
+        this.excludeFromCleanup.push(...globs);
+    }
+    /**
+     * (experimental) Returns the shell command to execute in order to run a task.
+     *
+     * By default, this is `npx projen@<version> <task>`
+     *
+     * @param task The task for which the command is required.
+     * @experimental
+     */
+    runTaskCommand(task) {
+        return `npx projen@${common_1.PROJEN_VERSION} ${task.name}`;
+    }
+    /**
+     * (experimental) Exclude these files from the bundled package.
+     *
+     * Implemented by project types based on the
+     * packaging mechanism. For example, `NodeProject` delegates this to `.npmignore`.
+     *
+     * @param _pattern The glob pattern to exclude.
+     * @experimental
+     */
+    addPackageIgnore(_pattern) {
+        // nothing to do at the abstract level
+    }
+    /**
+     * (experimental) Adds a .gitignore pattern.
+     *
+     * @param pattern The glob pattern to ignore.
+     * @experimental
+     */
+    addGitIgnore(pattern) {
+        this.gitignore.addPatterns(pattern);
+    }
+    /**
+     * (experimental) Consider a set of files as "generated".
+     *
+     * This method is implemented by
+     * derived classes and used for example, to add git attributes to tell GitHub
+     * that certain files are generated.
+     *
+     * @param _glob the glob pattern to match (could be a file path).
+     * @experimental
+     */
+    annotateGenerated(_glob) {
+        // nothing to do at the abstract level
+    }
+    /**
+     * (experimental) Synthesize all project files into `outdir`.
+     *
+     * 1. Call "this.preSynthesize()"
+     * 2. Delete all generated files
+     * 3. Synthesize all sub-projects
+     * 4. Synthesize all components of this project
+     * 5. Call "postSynthesize()" for all components of this project
+     * 6. Call "this.postSynthesize()"
+     *
+     * @experimental
+     */
+    synth() {
+        const outdir = this.outdir;
+        this.logger.debug('Synthesizing project...');
+        this.preSynthesize();
+        for (const comp of this._components) {
+            comp.preSynthesize();
+        }
+        // we exclude all subproject directories to ensure that when subproject.synth()
+        // gets called below after cleanup(), subproject generated files are left intact
+        for (const subproject of this.subprojects) {
+            this.addExcludeFromCleanup(subproject.outdir + '/**');
+        }
+        // delete all generated files before we start synthesizing new ones
+        cleanup_1.cleanup(outdir, this.excludeFromCleanup);
+        for (const subproject of this.subprojects) {
+            subproject.synth();
+        }
+        for (const comp of this._components) {
+            comp.synthesize();
+        }
+        if (!util_1.isTruthy(process.env.PROJEN_DISABLE_POST)) {
+            for (const comp of this._components) {
+                comp.postSynthesize();
+            }
+            // project-level hook
+            this.postSynthesize();
+        }
+        this.logger.debug('Synthesis complete');
+    }
+    /**
+     * (experimental) Called before all components are synthesized.
+     *
+     * @experimental
+     */
+    preSynthesize() { }
+    /**
+     * (experimental) Called after all components are synthesized.
+     *
+     * Order is *not* guaranteed.
+     *
+     * @experimental
+     */
+    postSynthesize() { }
+    /**
+     * Adds a component to the project.
+     * @internal
+     */
+    _addComponent(component) {
+        this._components.push(component);
+    }
+    /**
+     * Adds a sub-project to this project.
+     *
+     * This is automatically called when a new project is created with `parent`
+     * pointing to this project, so there is no real need to call this manually.
+     *
+     * @param sub-project The child project to add.
+     * @internal
+     */
+    _addSubProject(subproject) {
+        if (subproject.parent !== this) {
+            throw new Error('"parent" of child project must be this project');
+        }
+        // check that `outdir` is exclusive
+        for (const p of this.subprojects) {
+            if (path.resolve(p.outdir) === path.resolve(subproject.outdir)) {
+                throw new Error(`there is already a sub-project with "outdir": ${subproject.outdir}`);
+            }
+        }
+        this.subprojects.push(subproject);
+    }
+    /**
+     * Resolves the project's output directory.
+     */
+    determineOutdir(outdirOption) {
+        if (this.parent && outdirOption && path.isAbsolute(outdirOption)) {
+            throw new Error('"outdir" must be a relative path');
+        }
+        // if this is a subproject, it is relative to the parent
+        if (this.parent) {
+            if (!outdirOption) {
+                throw new Error('"outdir" must be specified for subprojects');
+            }
+            return path.resolve(this.parent.outdir, outdirOption);
+        }
+        // if this is running inside a test and outdir is not explicitly set
+        // use a temp directory (unless cwd is aleady under tmp)
+        if (common_1.IS_TEST_RUN && !outdirOption) {
+            const realCwd = fs_1.realpathSync(process.cwd());
+            const realTmp = fs_1.realpathSync(os_1.tmpdir());
+            if (realCwd.startsWith(realTmp)) {
+                return path.resolve(realCwd, outdirOption !== null && outdirOption !== void 0 ? outdirOption : '.');
+            }
+            return fs_1.mkdtempSync(path.join(os_1.tmpdir(), 'projen.'));
+        }
+        return path.resolve(outdirOption !== null && outdirOption !== void 0 ? outdirOption : '.');
+    }
+}
+exports.Project = Project;
+_a = JSII_RTTI_SYMBOL_1;
+Project[_a] = { fqn: "projen.Project", version: "0.46.8" };
+/**
+ * (experimental) The name of the default task (the task executed when `projen` is run without arguments).
+ *
+ * Normally
+ * this task should synthesize the project files.
+ *
+ * @experimental
+ */
+Project.DEFAULT_TASK = 'default';
+/**
+ * (deprecated) Which type of project this is.
+ *
+ * @deprecated no longer supported at the base project level
+ */
+var ProjectType;
+(function (ProjectType) {
+    ProjectType["UNKNOWN"] = "unknown";
+    ProjectType["LIB"] = "lib";
+    ProjectType["APP"] = "app";
+})(ProjectType = exports.ProjectType || (exports.ProjectType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.js","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdtempSync, realpathSync } from 'fs';\nimport { tmpdir } from 'os';\nimport * as path from 'path';\nimport { cleanup, FILE_MANIFEST } from './cleanup';\nimport { IS_TEST_RUN, PROJEN_VERSION } from './common';\nimport { Component } from './component';\nimport { Dependencies } from './dependencies';\nimport { FileBase } from './file';\nimport { GitAttributesFile } from './gitattributes';\nimport { IgnoreFile } from './ignore-file';\nimport * as inventory from './inventory';\nimport { resolveInitProject } from './javascript/render-options';\nimport { JsonFile } from './json';\nimport { Logger, LoggerOptions } from './logger';\nimport { ObjectFile } from './object-file';\nimport { InitProjectOptionHints } from './option-hints';\nimport { ProjectBuild as ProjectBuild } from './project-build';\nimport { Projenrc, ProjenrcOptions } from './projenrc-json';\nimport { Task, TaskOptions } from './task';\nimport { Tasks } from './tasks';\nimport { isTruthy } from './util';\n\n                                 \nexport interface ProjectOptions {\n                                                                                             \n  readonly name: string;\n\n                                                                                 \n  readonly parent?: Project;\n\n                                                                                                                                                                                                                                                                                                                           \n  readonly outdir?: string;\n\n                                                                              \n  readonly logging?: LoggerOptions;\n\n                                                                                                                                                      \n  readonly projenrcJson?: boolean;\n\n                                                                              \n  readonly projenrcJsonOptions?: ProjenrcOptions;\n\n                                                                                                                                                                     \n  readonly projenCommand?: string;\n}\n\n                       \nexport class Project {\n                                                                                                                                                                      \n  public static readonly DEFAULT_TASK = 'default';\n\n                              \n  public readonly name: string;\n\n                           \n  public readonly gitignore: IgnoreFile;\n\n\n                                                             \n  public readonly gitattributes: GitAttributesFile;\n\n\n                                                                          \n  public readonly parent?: Project;\n\n                                                           \n  public readonly outdir: string;\n\n                                   \n  public readonly root: Project;\n\n                               \n  public readonly tasks: Tasks;\n\n                                      \n  public readonly deps: Dependencies;\n\n                                   \n  public readonly logger: Logger;\n\n                                                                                                                                                                                                    \n  public readonly initProject?: InitProject;\n\n                                                                   \n  public readonly projenCommand: string;\n\n                                                                            \n  public readonly defaultTask: Task;\n\n                                                          \n  public readonly projectBuild: ProjectBuild;\n\n  private readonly _components = new Array<Component>();\n  private readonly subprojects = new Array<Project>();\n  private readonly tips = new Array<string>();\n  private readonly excludeFromCleanup: string[];\n\n  constructor(options: ProjectOptions) {\n    this.initProject = resolveInitProject(options);\n\n    this.name = options.name;\n    this.parent = options.parent;\n    this.excludeFromCleanup = [];\n    this.projenCommand = options.projenCommand ?? 'npx projen';\n\n    this.outdir = this.determineOutdir(options.outdir);\n    this.root = this.parent ? this.parent.root : this;\n\n    // must happen after this.outdir, this.parent and this.root are initialized\n    this.parent?._addSubProject(this);\n\n    // ------------------------------------------------------------------------\n\n    this.gitattributes = new GitAttributesFile(this);\n    this.annotateGenerated('/.projen/**'); // contents  of the .projen/ directory are generated by projen\n    this.annotateGenerated(`/${this.gitattributes.path}`); // the .gitattributes file itself is generated\n\n    this.gitignore = new IgnoreFile(this, '.gitignore');\n    this.gitignore.exclude('node_modules/'); // created by running `npx projen`\n    this.gitignore.include(`/${this.gitattributes.path}`);\n\n    // oh no: tasks depends on gitignore so it has to be initialized after\n    // smells like dep injectionn but god forbid.\n    this.tasks = new Tasks(this);\n\n    this.defaultTask = this.tasks.addTask(Project.DEFAULT_TASK, {\n      description: 'Synthesize project files',\n    });\n\n    this.projectBuild = new ProjectBuild(this);\n\n    this.deps = new Dependencies(this);\n\n    this.logger = new Logger(this, options.logging);\n\n    const projenrcJson = options.projenrcJson ?? false;\n    if (projenrcJson) {\n      new Projenrc(this, options.projenrcJsonOptions);\n    }\n\n    new JsonFile(this, FILE_MANIFEST, {\n      omitEmpty: true,\n      obj: () => ({\n        // replace `\\` with `/` to ensure paths match across platforms\n        files: this.files.filter(f => f.readonly).map(f => f.path.replace(/\\\\/g, '/')),\n      }),\n    });\n  }\n\n                                                                \n  public get components() {\n    return [...this._components];\n  }\n\n                                           \n  public get files(): FileBase[] {\n    const isFile = (c: Component): c is FileBase => c instanceof FileBase;\n    return this._components.filter(isFile).sort((f1, f2) => f1.path.localeCompare(f2.path));\n  }\n\n                                                                                                                                                                                                    \n  public addTask(name: string, props: TaskOptions = { }) {\n    return this.tasks.addTask(name, props);\n  }\n\n                                                                                                                                                                            \n  public removeTask(name: string) {\n    return this.tasks.removeTask(name);\n  }\n\n  public get buildTask() { return this.projectBuild.buildTask; }\n  public get compileTask() { return this.projectBuild.compileTask; }\n  public get testTask() { return this.projectBuild.testTask; }\n  public get preCompileTask() { return this.projectBuild.preCompileTask; }\n  public get postCompileTask() { return this.projectBuild.postCompileTask; }\n  public get packageTask() { return this.projectBuild.packageTask; }\n\n                                                                                                                                                                                                                                                                                                                    \n  public tryFindFile(filePath: string): FileBase | undefined {\n    const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(this.outdir, filePath);\n    for (const file of this.files) {\n      if (absolute === file.absolutePath) {\n        return file;\n      }\n    }\n\n    for (const child of this.subprojects) {\n      const file = child.tryFindFile(absolute);\n      if (file) {\n        return file;\n      }\n    }\n\n    return undefined;\n  }\n\n                                                                                                                        \n  public tryFindJsonFile(filePath: string): JsonFile | undefined {\n    const file = this.tryFindObjectFile(filePath);\n    if (!file) {\n      return undefined;\n    }\n\n    if (!(file instanceof JsonFile)) {\n      throw new Error(`found file ${filePath} but it is not a JsonFile. got: ${file.constructor.name}`);\n    }\n\n    return file;\n  }\n\n                                                                                                                  \n  public tryFindObjectFile(filePath: string): ObjectFile | undefined {\n    const file = this.tryFindFile(filePath);\n    if (!file) {\n      return undefined;\n    }\n\n    if (!(file instanceof ObjectFile)) {\n      throw new Error(`found file ${filePath} but it is not a ObjectFile. got: ${file.constructor.name}`);\n    }\n\n    return file;\n  }\n\n                                                                                                                                                                                 \n  public addTip(message: string) {\n    this.tips.push(message);\n  }\n\n                                                                                                                                                                                                                                                       \n  public addExcludeFromCleanup(...globs: string[]) {\n    this.excludeFromCleanup.push(...globs);\n  }\n\n                                                                                                                                                                                                          \n  public runTaskCommand(task: Task) {\n    return `npx projen@${PROJEN_VERSION} ${task.name}`;\n  }\n\n                                                                                                                                                                                                                                                   \n  public addPackageIgnore(_pattern: string) {\n    // nothing to do at the abstract level\n  }\n\n                                                                                           \n  public addGitIgnore(pattern: string) {\n    this.gitignore.addPatterns(pattern);\n  }\n\n                                                                                                                                                                                                                                                                                      \n  public annotateGenerated(_glob: string): void {\n    // nothing to do at the abstract level\n  }\n\n                                                                                                                                                                                                                                                                                                                                      \n  public synth(): void {\n    const outdir = this.outdir;\n    this.logger.debug('Synthesizing project...');\n\n    this.preSynthesize();\n\n    for (const comp of this._components) {\n      comp.preSynthesize();\n    }\n\n    // we exclude all subproject directories to ensure that when subproject.synth()\n    // gets called below after cleanup(), subproject generated files are left intact\n    for (const subproject of this.subprojects) {\n      this.addExcludeFromCleanup(subproject.outdir + '/**');\n    }\n\n    // delete all generated files before we start synthesizing new ones\n    cleanup(outdir, this.excludeFromCleanup);\n\n    for (const subproject of this.subprojects) {\n      subproject.synth();\n    }\n\n    for (const comp of this._components) {\n      comp.synthesize();\n    }\n\n    if (!isTruthy(process.env.PROJEN_DISABLE_POST)) {\n      for (const comp of this._components) {\n        comp.postSynthesize();\n      }\n\n      // project-level hook\n      this.postSynthesize();\n    }\n\n    this.logger.debug('Synthesis complete');\n  }\n\n                                                              \n  public preSynthesize() {}\n\n                                                                                        \n  public postSynthesize() {}\n\n  /**\n   * Adds a component to the project.\n   * @internal\n   */\n  public _addComponent(component: Component) {\n    this._components.push(component);\n  }\n\n  /**\n   * Adds a sub-project to this project.\n   *\n   * This is automatically called when a new project is created with `parent`\n   * pointing to this project, so there is no real need to call this manually.\n   *\n   * @param sub-project The child project to add.\n   * @internal\n   */\n  _addSubProject(subproject: Project) {\n    if (subproject.parent !== this) {\n      throw new Error('\"parent\" of child project must be this project');\n    }\n\n    // check that `outdir` is exclusive\n    for (const p of this.subprojects) {\n      if (path.resolve(p.outdir) === path.resolve(subproject.outdir)) {\n        throw new Error(`there is already a sub-project with \"outdir\": ${subproject.outdir}`);\n      }\n    }\n\n    this.subprojects.push(subproject);\n  }\n\n  /**\n   * Resolves the project's output directory.\n   */\n  private determineOutdir(outdirOption?: string) {\n    if (this.parent && outdirOption && path.isAbsolute(outdirOption)) {\n      throw new Error('\"outdir\" must be a relative path');\n    }\n\n    // if this is a subproject, it is relative to the parent\n    if (this.parent) {\n      if (!outdirOption) {\n        throw new Error('\"outdir\" must be specified for subprojects');\n      }\n\n      return path.resolve(this.parent.outdir, outdirOption);\n    }\n\n    // if this is running inside a test and outdir is not explicitly set\n    // use a temp directory (unless cwd is aleady under tmp)\n    if (IS_TEST_RUN && !outdirOption) {\n      const realCwd = realpathSync(process.cwd());\n      const realTmp = realpathSync(tmpdir());\n\n      if (realCwd.startsWith(realTmp)) {\n        return path.resolve(realCwd, outdirOption ?? '.');\n      }\n\n      return mkdtempSync(path.join(tmpdir(), 'projen.'));\n    }\n\n    return path.resolve(outdirOption ?? '.');\n  }\n}\n\n\n                                                                                                         \nexport enum ProjectType {\n                                                                 \n  UNKNOWN = 'unknown',\n\n                                                                                                                      \n  LIB = 'lib',\n\n                                                                                                                                                    \n  APP = 'app'\n}\n\n                                                                                                                                                                       \nexport interface InitProject {\n                                                  \n  readonly fqn: string;\n\n                                                          \n  readonly args: Record<string, any>;\n\n                                  \n  readonly type: inventory.ProjectType;\n\n                                                                                                                                    \n  readonly comments: InitProjectOptionHints;\n}\n"]}

package/lib/projects.d.ts

@@ -0,0 +1,80 @@
+import { InitProjectOptionHints } from './option-hints';
+/**
+ * @experimental
+ */
+export interface CreateProjectOptions {
+    /**
+     * (experimental) Directory that the project will be generated in.
+     *
+     * @experimental
+     */
+    readonly dir: string;
+    /**
+     * (experimental) Fully-qualified name of the project type (usually formatted as `module.ProjectType`).
+     *
+     * @experimental
+     * @example
+     *
+     * `projen.TypescriptProject`
+     */
+    readonly projectFqn: string;
+    /**
+     * (experimental) Project options.
+     *
+     * Only JSON-like values can be passed in (strings,
+     * booleans, numbers, enums, arrays, and objects that are not
+     * derived from classes).
+     *
+     * Consult the API reference of the project type you are generating for
+     * information about what fields and types are available.
+     *
+     * @experimental
+     */
+    readonly projectOptions: Record<string, any>;
+    /**
+     * (experimental) Should we render commented-out default options in the projenrc file?
+     *
+     * Does not apply to projenrc.json files.
+     *
+     * @default InitProjectOptionHints.FEATURED
+     * @experimental
+     */
+    readonly optionHints?: InitProjectOptionHints;
+    /**
+     * (experimental) Should we call `project.synth()` or instantiate the project (could still have side-effects) and render the .projenrc file.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly synth?: boolean;
+    /**
+     * (experimental) Should we execute post synthesis hooks?
+     *
+     * (usually package manager install).
+     *
+     * @default true
+     * @experimental
+     */
+    readonly post?: boolean;
+}
+/**
+ * (experimental) Programmatic API for projen.
+ *
+ * @experimental
+ */
+export declare class Projects {
+    /**
+     * (experimental) Creates a new project with defaults.
+     *
+     * This function creates the project type in-process (with in VM) and calls
+     * `.synth()` on it (if `options.synth` is not `false`).
+     *
+     * At the moment, it also generates a `.projenrc.js` file with the same code
+     * that was just executed. In the future, this will also be done by the project
+     * type, so we can easily support multiple languages of projenrc.
+     *
+     * @experimental
+     */
+    static createProject(options: CreateProjectOptions): void;
+    private constructor();
+}

package/lib/projects.js

@@ -0,0 +1,81 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Projects = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const vm = require("vm");
+const inventory_1 = require("./inventory");
+const render_options_1 = require("./javascript/render-options");
+const option_hints_1 = require("./option-hints");
+/**
+ * (experimental) Programmatic API for projen.
+ *
+ * @experimental
+ */
+class Projects {
+    constructor() { }
+    /**
+     * (experimental) Creates a new project with defaults.
+     *
+     * This function creates the project type in-process (with in VM) and calls
+     * `.synth()` on it (if `options.synth` is not `false`).
+     *
+     * At the moment, it also generates a `.projenrc.js` file with the same code
+     * that was just executed. In the future, this will also be done by the project
+     * type, so we can easily support multiple languages of projenrc.
+     *
+     * @experimental
+     */
+    static createProject(options) {
+        createProject(options);
+    }
+}
+exports.Projects = Projects;
+_a = JSII_RTTI_SYMBOL_1;
+Projects[_a] = { fqn: "projen.Projects", version: "0.46.8" };
+function createProject(opts) {
+    var _b, _c, _d;
+    const projectType = inventory_1.resolveProjectType(opts.projectFqn);
+    // Default project resolution location
+    let mod = './index';
+    // External projects need to load the module from the modules directory
+    if (projectType.moduleName !== 'projen') {
+        try {
+            mod = path.dirname(require.resolve(path.join(projectType.moduleName, 'package.json'), { paths: [process.cwd()] }));
+        }
+        catch (err) {
+            throw new Error(`External project module '${projectType.moduleName}' could not be resolved.`);
+        }
+    }
+    // "dir" is exposed as a top-level option to require users to specify a value for it
+    opts.projectOptions.outdir = opts.dir;
+    // pass the FQN of the project type to the project initializer so it can
+    // generate the projenrc file.
+    const { renderedOptions } = render_options_1.renderJavaScriptOptions({
+        bootstrap: true,
+        comments: (_b = opts.optionHints) !== null && _b !== void 0 ? _b : option_hints_1.InitProjectOptionHints.FEATURED,
+        type: projectType,
+        args: opts.projectOptions,
+        omitFromBootstrap: ['outdir'],
+    });
+    // generate a random variable name because jest tests appear to share
+    // VM contexts, causing
+    //
+    // > SyntaxError: Identifier 'project' has already been declared
+    //
+    // errors if this isn't unique
+    const varName = 'project' + Math.random().toString(36).slice(2);
+    const initProjectCode = `const ${varName} = new ${projectType.typename}(${renderedOptions});`;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const module = require(mod);
+    const ctx = vm.createContext(module);
+    const synth = (_c = opts.synth) !== null && _c !== void 0 ? _c : true;
+    const postSynth = (_d = opts.post) !== null && _d !== void 0 ? _d : true;
+    process.env.PROJEN_DISABLE_POST = (!postSynth).toString();
+    vm.runInContext([
+        initProjectCode,
+        synth ? `${varName}.synth();` : '',
+    ].join('\n'), ctx);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/projenrc-json.d.ts

@@ -0,0 +1,27 @@
+import { Component } from './component';
+import { Project } from './project';
+/**
+ * @experimental
+ */
+export interface ProjenrcOptions {
+    /**
+     * (experimental) The name of the projenrc file.
+     *
+     * @default ".projenrc.json"
+     * @experimental
+     */
+    readonly filename?: string;
+}
+/**
+ * (experimental) Sets up a project to use JSON for projenrc.
+ *
+ * @experimental
+ */
+export declare class Projenrc extends Component {
+    private readonly rcfile;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, options?: ProjenrcOptions);
+    private generateProjenrc;
+}