projen 0.0.0

package/lib/javascript/npm-config.js

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmConfig = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const ini_1 = require("../ini");
+/**
+ * (experimental) File representing the local NPM config in .npmrc.
+ *
+ * @experimental
+ */
+class NpmConfig extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        super(project);
+        /**
+         * The config object. This object can be mutated until the project is
+         * synthesized.
+         */
+        this.config = {};
+        new ini_1.IniFile(project, '.npmrc', { obj: this.config });
+        if (options.registry) {
+            this.addRegistry(options.registry);
+        }
+    }
+    /**
+     * (experimental) configure a scoped registry.
+     *
+     * @param url the URL of the registry to use.
+     * @param scope the scope the registry is used for;
+     * @experimental
+     */
+    addRegistry(url, scope) {
+        this.addConfig(scope ? `${scope}:registry` : 'registry', url);
+    }
+    /**
+     * (experimental) configure a generic property.
+     *
+     * @param name the name of the property.
+     * @param value the value of the property.
+     * @experimental
+     */
+    addConfig(name, value) {
+        this.config[name] = value;
+    }
+}
+exports.NpmConfig = NpmConfig;
+_a = JSII_RTTI_SYMBOL_1;
+NpmConfig[_a] = { fqn: "projen.javascript.NpmConfig", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/javascript/projenrc.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.js"
+     * @experimental
+     */
+    readonly filename?: string;
+}
+/**
+ * (experimental) Sets up a javascript project to use TypeScript for projenrc.
+ *
+ * @experimental
+ */
+export declare class Projenrc extends Component {
+    private readonly rcfile;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, options?: ProjenrcOptions);
+    private generateProjenrc;
+}

package/lib/javascript/projenrc.js

@@ -0,0 +1,59 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Projenrc = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const component_1 = require("../component");
+const render_options_1 = require("./render-options");
+/**
+ * (experimental) Sets up a javascript project to use TypeScript for projenrc.
+ *
+ * @experimental
+ */
+class Projenrc extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        var _b;
+        super(project);
+        this.rcfile = (_b = options.filename) !== null && _b !== void 0 ? _b : '.projenrc.js';
+        // this is the task projen executes when running `projen`
+        project.defaultTask.exec(`node ${this.rcfile}`);
+        this.generateProjenrc();
+    }
+    generateProjenrc() {
+        const rcfile = path_1.resolve(this.project.outdir, this.rcfile);
+        if (fs_1.existsSync(rcfile)) {
+            return; // already exists
+        }
+        const bootstrap = this.project.initProject;
+        if (!bootstrap) {
+            return;
+        }
+        const parts = bootstrap.fqn.split('.');
+        const moduleName = parts[0];
+        const importName = parts[1];
+        const className = parts.slice(1).join('.');
+        const { renderedOptions, imports } = render_options_1.renderJavaScriptOptions({
+            comments: bootstrap.comments,
+            args: bootstrap.args,
+            type: bootstrap.type,
+        });
+        imports.add(importName);
+        const lines = new Array();
+        lines.push(`const { ${[...imports].sort().join(', ')} } = require("${moduleName}");`);
+        lines.push();
+        lines.push(`const project = new ${className}(${renderedOptions});`);
+        lines.push();
+        lines.push('project.synth();');
+        fs_1.writeFileSync(rcfile, lines.join('\n'));
+        this.project.logger.info(`Project definition file was created at ${rcfile}`);
+    }
+}
+exports.Projenrc = Projenrc;
+_a = JSII_RTTI_SYMBOL_1;
+Projenrc[_a] = { fqn: "projen.javascript.Projenrc", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/javascript/render-options.d.ts

@@ -0,0 +1,57 @@
+import * as inventory from '../inventory';
+import { InitProjectOptionHints } from '../option-hints';
+/**
+ * Options for `renderProjectOptions`.
+ */
+export interface RenderProjectOptions {
+    /**
+     * The project type to render.
+     */
+    readonly type: inventory.ProjectType;
+    /**
+     * Project arguments as passed to `projen new`.
+     */
+    readonly args: Record<string, any>;
+    /**
+     * Include commented out options.
+     * @default InitProjectOptionHints.FEATURED
+     */
+    readonly comments?: InitProjectOptionHints;
+    /**
+     * Inject a `__new__` attribute to the project constructor with a stringified
+     * version of the project parameters and a `jsiiFqn` attribute that includes
+     * the FQN of the project type. This is needed in order to generate initial
+     * projenrc files.
+     *
+     * @default false
+     */
+    readonly bootstrap?: boolean;
+    /**
+     * A list of fields to omit from the initial projenrc file.
+     * @default - none
+     */
+    readonly omitFromBootstrap?: string[];
+}
+/**
+ * Renders options as if the project was created via `projen new` (embeds the __new__ field).
+ */
+export declare function renderProjenInitOptions(fqn: string, args: Record<string, any>, comments?: InitProjectOptionHints): any;
+export declare function resolveInitProject(opts: any): {
+    args: Record<string, any>;
+    fqn: string;
+    type: inventory.ProjectType;
+    comments: InitProjectOptionHints;
+} | undefined;
+/**
+ * Prints all parameters that can be used in a project type, alongside their descriptions.
+ *
+ * Parameters in `params` that aren't undefined are rendered as defaults,
+ * while all other parameters are rendered as commented out.
+ *
+ * Returns the printed output and a set of required imports as an object
+ * in the form { options, imports }.
+ */
+export declare function renderJavaScriptOptions(opts: RenderProjectOptions): {
+    renderedOptions: string;
+    imports: Set<unknown>;
+};

package/lib/javascript/render-options.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJavaScriptOptions = exports.resolveInitProject = exports.renderProjenInitOptions = void 0;
+const inventory = require("../inventory");
+const option_hints_1 = require("../option-hints");
+const PROJEN_NEW = '__new__';
+const TAB = makePadding(2);
+/**
+ * Renders options as if the project was created via `projen new` (embeds the __new__ field).
+ */
+function renderProjenInitOptions(fqn, args, comments = option_hints_1.InitProjectOptionHints.NONE) {
+    return {
+        ...args,
+        [PROJEN_NEW]: { fqn, args, comments },
+    };
+}
+exports.renderProjenInitOptions = renderProjenInitOptions;
+function resolveInitProject(opts) {
+    const f = opts[PROJEN_NEW];
+    if (!f) {
+        return undefined;
+    }
+    const type = inventory.resolveProjectType(f.fqn);
+    if (!type) {
+        throw new Error(`unable to resolve project type for ${f.fqn}`);
+    }
+    return {
+        args: f.args,
+        fqn: f.fqn,
+        type: type,
+        comments: f.comments,
+    };
+}
+exports.resolveInitProject = resolveInitProject;
+/**
+ * Prints all parameters that can be used in a project type, alongside their descriptions.
+ *
+ * Parameters in `params` that aren't undefined are rendered as defaults,
+ * while all other parameters are rendered as commented out.
+ *
+ * Returns the printed output and a set of required imports as an object
+ * in the form { options, imports }.
+ */
+function renderJavaScriptOptions(opts) {
+    var _a, _b, _c, _d;
+    const renders = {};
+    const optionsWithDefaults = [];
+    const allImports = new Set();
+    for (const option of opts.type.options) {
+        if (option.deprecated) {
+            continue;
+        }
+        const optionName = option.name;
+        if (opts.args[optionName] !== undefined) {
+            const arg = opts.args[optionName];
+            const { js, imports } = renderArgAsJavaScript(arg, option);
+            for (const importStr of imports) {
+                allImports.add(importStr);
+            }
+            renders[optionName] = `${optionName}: ${js},`;
+            optionsWithDefaults.push(optionName);
+        }
+        else {
+            const defaultValue = ((_a = option.default) === null || _a === void 0 ? void 0 : _a.startsWith('-')) ? undefined : ((_b = option.default) !== null && _b !== void 0 ? _b : undefined);
+            renders[optionName] = `// ${optionName}: ${defaultValue},`;
+        }
+    }
+    const bootstrap = (_c = opts.bootstrap) !== null && _c !== void 0 ? _c : false;
+    if (bootstrap) {
+        for (const arg of ((_d = opts.omitFromBootstrap) !== null && _d !== void 0 ? _d : [])) {
+            delete opts.args[arg];
+        }
+        renders[PROJEN_NEW] = `${PROJEN_NEW}: ${JSON.stringify({ args: opts.args, fqn: opts.type.fqn, comments: opts.comments })},`;
+        optionsWithDefaults.push(PROJEN_NEW);
+    }
+    // generate rendering
+    const result = [];
+    result.push('{');
+    // render options with defaults
+    optionsWithDefaults.sort();
+    for (const optionName of optionsWithDefaults) {
+        result.push(`${TAB}${renders[optionName]}`);
+    }
+    if (result.length > 1) {
+        result.push('');
+    }
+    // render options without defaults as comments
+    if (opts.comments === option_hints_1.InitProjectOptionHints.ALL) {
+        const options = opts.type.options.filter((opt) => !opt.deprecated && opts.args[opt.name] === undefined);
+        result.push(...renderCommentedOptionsByModule(renders, options));
+    }
+    else if (opts.comments === option_hints_1.InitProjectOptionHints.FEATURED) {
+        const options = opts.type.options.filter((opt) => !opt.deprecated && opts.args[opt.name] === undefined && opt.featured);
+        result.push(...renderCommentedOptionsInOrder(renders, options));
+    }
+    else if (opts.comments === option_hints_1.InitProjectOptionHints.NONE) {
+        // don't render any extra options
+    }
+    if (result[result.length - 1] === '') {
+        result.pop();
+    }
+    result.push('}');
+    return { renderedOptions: result.join('\n'), imports: allImports };
+}
+exports.renderJavaScriptOptions = renderJavaScriptOptions;
+function renderCommentedOptionsByModule(renders, options) {
+    var _a;
+    const optionsByModule = {};
+    for (const option of options) {
+        const parentModule = option.parent;
+        optionsByModule[parentModule] = (_a = optionsByModule[parentModule]) !== null && _a !== void 0 ? _a : [];
+        optionsByModule[parentModule].push(option);
+    }
+    for (const parentModule in optionsByModule) {
+        optionsByModule[parentModule].sort((o1, o2) => o1.name.localeCompare(o2.name));
+    }
+    const result = [];
+    const marginSize = Math.max(...options.map((opt) => renders[opt.name].length));
+    for (const [moduleName, optionGroup] of Object.entries(optionsByModule).sort()) {
+        result.push(`${TAB}/* ${moduleName} */`);
+        for (const option of optionGroup) {
+            const paramRender = renders[option.name];
+            const docstring = option.docs || 'No documentation found.';
+            result.push(`${TAB}${paramRender}${makePadding(marginSize - paramRender.length + 2)}/* ${docstring} */`);
+        }
+        result.push('');
+    }
+    return result;
+}
+function renderCommentedOptionsInOrder(renders, options) {
+    const result = [];
+    const marginSize = Math.max(...options.map((opt) => renders[opt.name].length));
+    for (const option of options) {
+        const paramRender = renders[option.name];
+        const docstring = option.docs || 'No documentation found.';
+        result.push(`${TAB}${paramRender}${makePadding(marginSize - paramRender.length + 2)}/* ${docstring} */`);
+    }
+    return result;
+}
+/**
+ * Renders a value as a JavaScript value, converting strings to enums where
+ * appropriate. The type must be JSON-like (string, number, boolean, array,
+ * enum, or JSON object).
+ *
+ * Returns a JavaScript expression as a string, and the names of any
+ * necessary imports.
+ */
+function renderArgAsJavaScript(arg, option) {
+    if (option.kind === 'enum') {
+        if (!option.fqn) {
+            throw new Error(`fqn field is missing from enum option ${option.name}`);
+        }
+        const parts = option.fqn.split('.'); // -> ['projen', 'web', 'MyEnum']
+        const enumChoice = String(arg).toUpperCase().replace(/-/g, '_'); // custom-value -> CUSTOM_VALUE
+        const js = `${parts.slice(1).join('.')}.${enumChoice}`; // -> web.MyEnum.CUSTOM_VALUE
+        const importName = parts[1]; // -> web
+        return { js, imports: [importName] };
+    }
+    else if (option.jsonLike) {
+        return { js: JSON.stringify(arg), imports: [] };
+    }
+    else {
+        throw new Error(`Unexpected option ${option.name} - cannot render a value for this option because it does not have a JSON-like type.`);
+    }
+}
+function makePadding(paddingLength) {
+    return ' '.repeat(paddingLength);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-options.js","sourceRoot":"","sources":["../../src/javascript/render-options.ts"],"names":[],"mappings":"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","sourcesContent":["import * as inventory from '../inventory';\nimport { InitProjectOptionHints } from '../option-hints';\n\nconst PROJEN_NEW = '__new__';\nconst TAB = makePadding(2);\n\n/**\n * Options for `renderProjectOptions`.\n */\nexport interface RenderProjectOptions {\n  /**\n   * The project type to render.\n   */\n  readonly type: inventory.ProjectType;\n\n  /**\n   * Project arguments as passed to `projen new`.\n   */\n  readonly args: Record<string, any>;\n\n  /**\n   * Include commented out options.\n   * @default InitProjectOptionHints.FEATURED\n   */\n  readonly comments?: InitProjectOptionHints;\n\n  /**\n   * Inject a `__new__` attribute to the project constructor with a stringified\n   * version of the project parameters and a `jsiiFqn` attribute that includes\n   * the FQN of the project type. This is needed in order to generate initial\n   * projenrc files.\n   *\n   * @default false\n   */\n  readonly bootstrap?: boolean;\n\n  /**\n   * A list of fields to omit from the initial projenrc file.\n   * @default - none\n   */\n  readonly omitFromBootstrap?: string[];\n}\n\n/**\n * Information passed from `projen new` to the project object when the project\n * is first created. It is used to generate projenrc files in various languages.\n */\ninterface ProjenInit {\n  /**\n   * The JSII FQN of the project type.\n   */\n  readonly fqn: string;\n\n  /**\n   * Initial arguments passed to `projen new`.\n   */\n  readonly args: Record<string, any>;\n\n  /**\n   * Include commented out options. Does not apply to projenrc.json files.\n   */\n  readonly comments: InitProjectOptionHints;\n}\n\n\n/**\n * Renders options as if the project was created via `projen new` (embeds the __new__ field).\n */\nexport function renderProjenInitOptions(fqn: string, args: Record<string, any>, comments: InitProjectOptionHints = InitProjectOptionHints.NONE): any {\n  return {\n    ...args,\n    [PROJEN_NEW]: { fqn, args, comments } as ProjenInit,\n  };\n}\n\nexport function resolveInitProject(opts: any) {\n  const f = opts[PROJEN_NEW] as ProjenInit;\n  if (!f) {\n    return undefined;\n  }\n\n  const type = inventory.resolveProjectType(f.fqn);\n  if (!type) {\n    throw new Error(`unable to resolve project type for ${f.fqn}`);\n  }\n  return {\n    args: f.args,\n    fqn: f.fqn,\n    type: type,\n    comments: f.comments,\n  };\n}\n\n/**\n * Prints all parameters that can be used in a project type, alongside their descriptions.\n *\n * Parameters in `params` that aren't undefined are rendered as defaults,\n * while all other parameters are rendered as commented out.\n *\n * Returns the printed output and a set of required imports as an object\n * in the form { options, imports }.\n */\nexport function renderJavaScriptOptions(opts: RenderProjectOptions) {\n  const renders: Record<string, string> = {};\n  const optionsWithDefaults: string[] = [];\n  const allImports = new Set();\n\n  for (const option of opts.type.options) {\n    if (option.deprecated) {\n      continue;\n    }\n\n    const optionName = option.name;\n\n    if (opts.args[optionName] !== undefined) {\n      const arg = opts.args[optionName];\n      const { js, imports } = renderArgAsJavaScript(arg, option);\n      for (const importStr of imports) {\n        allImports.add(importStr);\n      }\n      renders[optionName] = `${optionName}: ${js},`;\n      optionsWithDefaults.push(optionName);\n    } else {\n      const defaultValue = option.default?.startsWith('-') ? undefined : (option.default ?? undefined);\n      renders[optionName] = `// ${optionName}: ${defaultValue},`;\n    }\n  }\n\n  const bootstrap = opts.bootstrap ?? false;\n  if (bootstrap) {\n    for (const arg of (opts.omitFromBootstrap ?? [])) {\n      delete opts.args[arg];\n    }\n    renders[PROJEN_NEW] = `${PROJEN_NEW}: ${JSON.stringify({ args: opts.args, fqn: opts.type.fqn, comments: opts.comments } as ProjenInit)},`;\n    optionsWithDefaults.push(PROJEN_NEW);\n  }\n\n  // generate rendering\n  const result: string[] = [];\n  result.push('{');\n\n  // render options with defaults\n  optionsWithDefaults.sort();\n  for (const optionName of optionsWithDefaults) {\n    result.push(`${TAB}${renders[optionName]}`);\n  }\n  if (result.length > 1) {\n    result.push('');\n  }\n\n  // render options without defaults as comments\n  if (opts.comments === InitProjectOptionHints.ALL) {\n    const options = opts.type.options.filter((opt) => !opt.deprecated && opts.args[opt.name] === undefined);\n    result.push(...renderCommentedOptionsByModule(renders, options));\n  } else if (opts.comments === InitProjectOptionHints.FEATURED) {\n    const options = opts.type.options.filter((opt) => !opt.deprecated && opts.args[opt.name] === undefined && opt.featured);\n    result.push(...renderCommentedOptionsInOrder(renders, options));\n  } else if (opts.comments === InitProjectOptionHints.NONE) {\n    // don't render any extra options\n  }\n\n  if (result[result.length - 1] === '') {\n    result.pop();\n  }\n  result.push('}');\n  return { renderedOptions: result.join('\\n'), imports: allImports };\n}\n\nfunction renderCommentedOptionsByModule(renders: Record<string, string>, options: inventory.ProjectOption[]) {\n  const optionsByModule: Record<string, inventory.ProjectOption[]> = {};\n\n  for (const option of options) {\n    const parentModule = option.parent;\n    optionsByModule[parentModule] = optionsByModule[parentModule] ?? [];\n    optionsByModule[parentModule].push(option);\n  }\n\n  for (const parentModule in optionsByModule) {\n    optionsByModule[parentModule].sort((o1, o2) => o1.name.localeCompare(o2.name));\n  }\n\n  const result = [];\n  const marginSize = Math.max(...options.map((opt) => renders[opt.name].length));\n  for (const [moduleName, optionGroup] of Object.entries(optionsByModule).sort()) {\n    result.push(`${TAB}/* ${moduleName} */`);\n    for (const option of optionGroup) {\n      const paramRender = renders[option.name];\n      const docstring = option.docs || 'No documentation found.';\n      result.push(`${TAB}${paramRender}${makePadding(marginSize - paramRender.length + 2)}/* ${docstring} */`);\n    }\n    result.push('');\n  }\n  return result;\n}\n\nfunction renderCommentedOptionsInOrder(renders: Record<string, string>, options: inventory.ProjectOption[]) {\n  const result = [];\n  const marginSize = Math.max(...options.map((opt) => renders[opt.name].length));\n  for (const option of options) {\n    const paramRender = renders[option.name];\n    const docstring = option.docs || 'No documentation found.';\n    result.push(`${TAB}${paramRender}${makePadding(marginSize - paramRender.length + 2)}/* ${docstring} */`);\n  }\n  return result;\n}\n\n/**\n * Renders a value as a JavaScript value, converting strings to enums where\n * appropriate. The type must be JSON-like (string, number, boolean, array,\n * enum, or JSON object).\n *\n * Returns a JavaScript expression as a string, and the names of any\n * necessary imports.\n */\nfunction renderArgAsJavaScript(arg: any, option: inventory.ProjectOption) {\n  if (option.kind === 'enum') {\n    if (!option.fqn) {\n      throw new Error(`fqn field is missing from enum option ${option.name}`);\n    }\n    const parts = option.fqn.split('.'); // -> ['projen', 'web', 'MyEnum']\n    const enumChoice = String(arg).toUpperCase().replace(/-/g, '_'); // custom-value -> CUSTOM_VALUE\n    const js = `${parts.slice(1).join('.')}.${enumChoice}`; // -> web.MyEnum.CUSTOM_VALUE\n    const importName = parts[1]; // -> web\n    return { js, imports: [importName] };\n  } else if (option.jsonLike) {\n    return { js: JSON.stringify(arg), imports: [] };\n  } else {\n    throw new Error(`Unexpected option ${option.name} - cannot render a value for this option because it does not have a JSON-like type.`);\n  }\n}\n\nfunction makePadding(paddingLength: number): string {\n  return ' '.repeat(paddingLength);\n}\n"]}