@codedrifters/configulator 0.0.0 → 0.0.1

package/lib/jsii/jsii-faker.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsiiFaker = void 0;
+const spec = __importStar(require("@jsii/spec"));
+const projen_1 = require("projen");
+/**
+ * The FQNs for the base classes and options used by Jsii.
+ *
+ * These are the defaults used by Projen's TypeScriptProject.
+ */
+const ProjenBaseFqn = {
+    TYPESCRIPT_PROJECT: "projen.typescript.TypeScriptProject",
+    TYPESCRIPT_PROJECT_OPTIONS: "projen.typescript.TypeScriptProjectOptions",
+};
+class JsiiFaker extends projen_1.Component {
+    // find project singleton
+    static of(project) {
+        const isDefined = (c) => c instanceof JsiiFaker;
+        return project.components.find(isDefined);
+    }
+    constructor(project) {
+        super(project);
+        this.project = project;
+        this._types = {};
+        this.toJSON = () => {
+            return {
+                types: this._types,
+            };
+        };
+        /**
+         * In JSII, the assembly name is essentially the package name. It's used as a
+         * scope when targeting types and metadata in other "jsii assemblies" that
+         * might be in sub-packages used by the project.
+         *
+         * For this case, we'll just use the package name from Projen.
+         */
+        this._assemblyName = this.project.package.packageName;
+        new projen_1.JsonFile(project, ".jsii", {
+            obj: () => {
+                return {
+                    name: this._assemblyName,
+                    types: this._types,
+                };
+            },
+        });
+    }
+    addClassType(options) {
+        const fqn = [this._assemblyName, options.name].join(".");
+        const type = {
+            assembly: this._assemblyName,
+            base: options.baseFqn ?? ProjenBaseFqn.TYPESCRIPT_PROJECT,
+            fqn,
+            kind: spec.TypeKind.Class,
+            name: options.name,
+            initializer: {
+                parameters: [
+                    {
+                        name: "options",
+                        type: {
+                            fqn: options.optionsFqn ?? ProjenBaseFqn.TYPESCRIPT_PROJECT_OPTIONS,
+                        },
+                    },
+                ],
+            },
+        };
+        this._types[fqn] = type;
+    }
+}
+exports.JsiiFaker = JsiiFaker;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pnpm/pnpm-workspace.d.ts

@@ -1,5 +1,244 @@
 import { Component, Project } from "projen";
+import { ValueOf } from "type-fest";
+/**
+ * Predefined minimum release age values in minutes.
+ */
+export declare const MIMIMUM_RELEASE_AGE: {
+    ZERO_DAYS: number;
+    ONE_HOUR: number;
+    SIX_HOURS: number;
+    TWELVE_HOURS: number;
+    ONE_DAY: number;
+    TWO_DAYS: number;
+    THREE_DAYS: number;
+    FOUR_DAYS: number;
+    FIVE_DAYS: number;
+    SIX_DAYS: number;
+    ONE_WEEK: number;
+};
+export interface PnpmWorkspaceOptions {
+    /**
+     * Filename for the pnpm workspace file. This should probably never change.
+     *
+     * @default "pnpm-workspace.yaml"
+     */
+    readonly fileName?: string;
+    /**
+     * To reduce the risk of installing compromised packages, you can delay the
+     * installation of newly published versions. In most cases, malicious releases
+     * are discovered and removed from the registry within an hour.
+     *
+     * minimumReleaseAge defines the minimum number of minutes that must pass
+     * after a version is published before pnpm will install it. This applies to
+     * all dependencies, including transitive ones.
+     *
+     * Note: this should match depsUpgradeOptions.cooldown in the project config.
+     *
+     * See: https://pnpm.io/settings#minimumreleaseage
+     *
+     * @default MIMIMUM_RELEASE_AGE.ONE_DAY
+     */
+    readonly minimumReleaseAge?: ValueOf<typeof MIMIMUM_RELEASE_AGE>;
+    /**
+     * If you set minimumReleaseAge but need certain dependencies to always
+     * install the newest version immediately, you can list them under
+     * minimumReleaseAgeExclude. The exclusion works by package name and applies
+     * to all versions of that package.
+     *
+     * @default - no exclusions (empty array)
+     *
+     * See: https://pnpm.io/settings#minimumreleaseageexclude
+     */
+    readonly minimumReleaseAgeExclude?: Array<string>;
+    /**
+     * A list of package names that are allowed to execute "preinstall",
+     * "install", and/or "postinstall" scripts during installation. Only the
+     * packages listed in this array will be able to run those lifecycle scripts.
+     * If onlyBuiltDependenciesFile and neverBuiltDependencies are omitted, this
+     * configuration option will default to blocking all install scripts.
+     *
+     * You may restrict allowances to specific versions (and lists of versions
+     * using a disjunction with ||). When versions are specified, only those
+     * versions of the package may run lifecycle scripts:
+     *
+     * See: https://pnpm.io/settings#onlybuiltdependencies
+     *
+     * @default none (empty array)
+     */
+    readonly onlyBuiltDependencies?: Array<string>;
+    /**
+     * A list of package names that are NOT allowed to execute "preinstall",
+     * "install", and/or "postinstall" scripts during installation and will not
+     * warn or ask to be executed.
+     *
+     * This is useful when you want to hide the warning because you know the
+     * lifecycle scripts are not needed.
+     *
+     * https://pnpm.io/settings#ignoredbuiltdependencies
+     *
+     * @default none (empty array)
+     */
+    readonly ignoredBuiltDependencies?: Array<string>;
+    /**
+     * Additional subproject paths to include in the workspace packages array.
+     * These will be combined with any subprojects discovered via projen's
+     * project.subprojects property. Paths should be relative to the project root.
+     *
+     * @default none (empty array)
+     */
+    readonly subprojects?: Array<string>;
+    /**
+     * Catalog of reusable dependency version ranges.
+     *
+     * The catalog allows you to define dependency versions as reusable constants
+     * that can be referenced in package.json files using the catalog: protocol.
+     *
+     * Example:
+     * ```yaml
+     * catalog:
+     *   react: ^18.0.0
+     *   typescript: ^5.0.0
+     * ```
+     *
+     * Then in package.json:
+     * ```json
+     * {
+     *   "dependencies": {
+     *     "react": "catalog:react"
+     *   }
+     * }
+     * ```
+     *
+     * @default undefined (not included in output)
+     *
+     * See: https://pnpm.io/pnpm-workspace_yaml#catalog
+     */
+    readonly defaultCatalog?: {
+        [key: string]: string;
+    };
+    /**
+     * Named catalogs of reusable dependency version ranges.
+     *
+     * Multiple named catalogs with arbitrarily chosen names can be configured under the namedCatalogs key.
+     *
+     * Example:
+     * ```yaml
+     * namedCatalogs:
+     *   frontend:
+     *     react: ^18.0.0
+     *     typescript: ^5.0.0
+     *   backend:
+     *     express: ^4.18.0
+     * ```
+     *
+     * Then in package.json:
+     * ```json
+     * {
+     *   "dependencies": {
+     *     "react": "catalog:frontend/react"
+     *   }
+     * }
+     * ```
+     *
+     * @default undefined (not included in output)
+     *
+     * See: https://pnpm.io/catalogs
+     */
+    readonly namedCatalogs?: {
+        [catalogName: string]: {
+            [dependencyName: string]: string;
+        };
+    };
+}
 export declare class PnpmWorkspace extends Component {
+    /**
+     * Get the pnpm workspace component of a project. If it does not exist,
+     * return undefined.
+     *
+     * @param project
+     * @returns
+     */
     static of(project: Project): PnpmWorkspace | undefined;
-    constructor(project: Project);
+    /**
+     * Filename for the pnpm workspace file.
+     */
+    readonly fileName: string;
+    /**
+     * To reduce the risk of installing compromised packages, you can delay the
+     * installation of newly published versions. In most cases, malicious releases
+     * are discovered and removed from the registry within an hour.
+     *
+     * minimumReleaseAge defines the minimum number of minutes that must pass
+     * after a version is published before pnpm will install it. This applies to
+     * all dependencies, including transitive ones.
+     *
+     * Note: this should match depsUpgradeOptions.cooldown in the project config.
+     *
+     * See: https://pnpm.io/settings#minimumreleaseage
+     */
+    minimumReleaseAge: ValueOf<typeof MIMIMUM_RELEASE_AGE>;
+    /**
+     * If you set minimumReleaseAge but need certain dependencies to always
+     * install the newest version immediately, you can list them under
+     * minimumReleaseAgeExclude. The exclusion works by package name and applies
+     * to all versions of that package.
+     *
+     * See: https://pnpm.io/settings#minimumreleaseageexclude
+     */
+    minimumReleaseAgeExclude: Array<string>;
+    /**
+     * A list of package names that are allowed to execute "preinstall",
+     * "install", and/or "postinstall" scripts during installation. Only the
+     * packages listed in this array will be able to run those lifecycle scripts.
+     * If onlyBuiltDependenciesFile and neverBuiltDependencies are omitted, this
+     * configuration option will default to blocking all install scripts.
+     *
+     * You may restrict allowances to specific versions (and lists of versions
+     * using a disjunction with ||). When versions are specified, only those
+     * versions of the package may run lifecycle scripts:
+     *
+     * See: https://pnpm.io/settings#onlybuiltdependencies
+     */
+    onlyBuiltDependencies: Array<string>;
+    /**
+     * A list of package names that are NOT allowed to execute "preinstall",
+     * "install", and/or "postinstall" scripts during installation and will not
+     * warn or ask to be executed.
+     *
+     * This is useful when you want to hide the warning because you know the
+     * lifecycle scripts are not needed.
+     *
+     * https://pnpm.io/settings#ignoredbuiltdependencies
+     */
+    ignoredBuiltDependencies: Array<string>;
+    /**
+     * Additional subproject paths to include in the workspace packages array.
+     * These will be combined with any subprojects discovered via projen's
+     * project.subprojects property.
+     */
+    subprojects: Array<string>;
+    /**
+     * Default catalog of reusable dependency version ranges.
+     *
+     * The default catalog is used to define dependency versions as reusable constants
+     * that can be referenced in package.json files using the catalog: protocol.
+     *
+     * See:https://pnpm.io/catalogs
+     */
+    defaultCatalog?: {
+        [key: string]: string;
+    };
+    /**
+     * Named catalogs of reusable dependency version ranges.
+     *
+     * Multiple named catalogs with arbitrarily chosen names can be configured under the namedCatalogs key.
+     *
+     * See: https://pnpm.io/catalogs
+     */
+    namedCatalogs?: {
+        [catalogName: string]: {
+            [dependencyName: string]: string;
+        };
+    };
+    constructor(project: Project, options?: PnpmWorkspaceOptions);
 }

package/lib/pnpm/pnpm-workspace.js

@@ -1,36 +1,176 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PnpmWorkspace = void 0;
+exports.PnpmWorkspace = exports.MIMIMUM_RELEASE_AGE = void 0;
 const path_1 = require("path");
 const projen_1 = require("projen");
+/**
+ * Predefined minimum release age values in minutes.
+ */
+exports.MIMIMUM_RELEASE_AGE = {
+    ZERO_DAYS: 0,
+    ONE_HOUR: 60,
+    SIX_HOURS: 360,
+    TWELVE_HOURS: 720,
+    ONE_DAY: 1440,
+    TWO_DAYS: 2880,
+    THREE_DAYS: 4320,
+    FOUR_DAYS: 5760,
+    FIVE_DAYS: 7200,
+    SIX_DAYS: 8640,
+    ONE_WEEK: 10080,
+};
 class PnpmWorkspace extends projen_1.Component {
+    /**
+     * Get the pnpm workspace component of a project. If it does not exist,
+     * return undefined.
+     *
+     * @param project
+     * @returns
+     */
     static of(project) {
         const isDefined = (c) => c instanceof PnpmWorkspace;
         return project.root.components.find(isDefined);
     }
-    constructor(project) {
+    constructor(project, options = {}) {
         super(project);
-        const fileName = "pnpm-workspace.yaml";
+        /***************************************************************************
+         *
+         * CLEAR package,json
+         *
+         * It appears that if ANY pnpm settings exist in the package.json file, all
+         * of the setting in the pnpm-workspace.yaml file are ignored. so we need to
+         * clear out anything that was placed into the package.json file.
+         *
+         **************************************************************************/
+        project.tryFindObjectFile("package.json")?.addDeletionOverride("pnpm");
+        /***************************************************************************
+         *
+         * Setup pnpm-workspace.yaml file.
+         *
+         * Now that the package.json file is cleared of any pnpm settings, we can
+         * safely write settings to the pnpm-workspace.yaml file.
+         *
+         **************************************************************************
+    
+        /**
+         * Set filename to default if not provided.
+         */
+        this.fileName = options.fileName ?? "pnpm-workspace.yaml";
+        /**
+         * Set minimum release age to default if not provided
+         */
+        this.minimumReleaseAge = options.minimumReleaseAge
+            ? options.minimumReleaseAge
+            : exports.MIMIMUM_RELEASE_AGE.ONE_DAY;
+        /**
+         * Set minimum release age exclude to empty array if not provided
+         */
+        this.minimumReleaseAgeExclude = options.minimumReleaseAgeExclude
+            ? ["@codedrifters/*", ...options.minimumReleaseAgeExclude]
+            : ["@codedrifters/*"];
+        /**
+         * Set only built dependencies to empty array if not provided
+         */
+        this.onlyBuiltDependencies = options.onlyBuiltDependencies
+            ? options.onlyBuiltDependencies
+            : [];
+        /**
+         * Set ignored built dependencies to empty array if not provided
+         */
+        this.ignoredBuiltDependencies = options.ignoredBuiltDependencies
+            ? options.ignoredBuiltDependencies
+            : [];
+        /**
+         * Store additional subproject paths if provided
+         */
+        this.subprojects = options.subprojects ?? [];
+        /**
+         * Store catalog if provided
+         */
+        this.defaultCatalog = options.defaultCatalog;
+        /**
+         * Store named catalogs if provided
+         */
+        this.namedCatalogs = options.namedCatalogs;
         /**
          * In case that this file is in a package, don't package it.
          */
-        project.addPackageIgnore(fileName);
+        project.addPackageIgnore(this.fileName);
         /**
          * Write pnpm workspace file
          */
-        new projen_1.YamlFile(this.project, fileName, {
-            obj: {
-                packages: () => {
-                    const packages = new Array();
-                    for (const subproject of project.subprojects) {
-                        // grab the relative out directory
-                        packages.push((0, path_1.relative)(this.project.outdir, subproject.outdir));
-                    }
-                    return packages;
-                },
+        new projen_1.YamlFile(this.project, this.fileName, {
+            obj: () => {
+                const pnpmConfig = {};
+                const packages = new Array();
+                /**
+                 * Add projen subprojects to the packages array.
+                 */
+                for (const subproject of project.subprojects) {
+                    // grab the relative out directory
+                    packages.push((0, path_1.relative)(this.project.outdir, subproject.outdir));
+                }
+                /**
+                 * Add additional subproject paths provided via options.
+                 * Use a Set to deduplicate paths to avoid including the same
+                 * subproject multiple times.
+                 */
+                const packageSet = new Set(packages);
+                for (const subprojectPath of this.subprojects) {
+                    packageSet.add(subprojectPath);
+                }
+                /**
+                 * Convert back to array if we added any additional paths
+                 */
+                if (this.subprojects.length > 0) {
+                    packages.length = 0;
+                    packages.push(...packageSet);
+                }
+                /**
+                 * Set minimum release age.
+                 */
+                pnpmConfig.minimumReleaseAge = this.minimumReleaseAge;
+                /**
+                 * Set minimum release age exclude if any are provided.
+                 */
+                if (this.minimumReleaseAgeExclude.length > 0) {
+                    pnpmConfig.minimumReleaseAgeExclude = this.minimumReleaseAgeExclude;
+                }
+                /**
+                 * Set only built dependencies if any are provided.
+                 */
+                if (this.onlyBuiltDependencies.length > 0) {
+                    pnpmConfig.onlyBuiltDependencies = this.onlyBuiltDependencies;
+                }
+                /**
+                 * Set ignored built dependencies if any are provided.
+                 */
+                if (this.ignoredBuiltDependencies.length > 0) {
+                    pnpmConfig.ignoreBuiltDependencies = this.ignoredBuiltDependencies;
+                }
+                /**
+                 * Set default catalog if provided.
+                 */
+                if (this.defaultCatalog &&
+                    Object.keys(this.defaultCatalog).length > 0) {
+                    pnpmConfig.catalog = this.defaultCatalog;
+                }
+                /**
+                 * Set named catalogs if provided.
+                 */
+                if (this.namedCatalogs && Object.keys(this.namedCatalogs).length > 0) {
+                    pnpmConfig.namedCatalogs = this.namedCatalogs;
+                }
+                /**
+                 * Return the final pnpm config object.
+                 */
+                return {
+                    ...(packages.length > 0 ? { packages } : {}),
+                    ...(pnpmConfig ? { ...pnpmConfig } : {}),
+                };
             },
         });
     }
 }
 exports.PnpmWorkspace = PnpmWorkspace;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG5wbS13b3Jrc3BhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcG5wbS9wbnBtLXdvcmtzcGFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQkFBZ0M7QUFDaEMsbUNBQXNEO0FBRXRELE1BQWEsYUFBYyxTQUFRLGtCQUFTO0lBQ25DLE1BQU0sQ0FBQyxFQUFFLENBQUMsT0FBZ0I7UUFDL0IsTUFBTSxTQUFTLEdBQUcsQ0FBQyxDQUFZLEVBQXNCLEVBQUUsQ0FDckQsQ0FBQyxZQUFZLGFBQWEsQ0FBQztRQUM3QixPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNqRCxDQUFDO0lBRUQsWUFBWSxPQUFnQjtRQUMxQixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFZixNQUFNLFFBQVEsR0FBVyxxQkFBcUIsQ0FBQztRQUUvQzs7V0FFRztRQUNILE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUVuQzs7V0FFRztRQUNILElBQUksaUJBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRTtZQUNuQyxHQUFHLEVBQUU7Z0JBQ0gsUUFBUSxFQUFFLEdBQUcsRUFBRTtvQkFDYixNQUFNLFFBQVEsR0FBRyxJQUFJLEtBQUssRUFBVSxDQUFDO29CQUNyQyxLQUFLLE1BQU0sVUFBVSxJQUFJLE9BQU8sQ0FBQyxXQUFXLEVBQUUsQ0FBQzt3QkFDN0Msa0NBQWtDO3dCQUNsQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUEsZUFBUSxFQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO29CQUNsRSxDQUFDO29CQUNELE9BQU8sUUFBUSxDQUFDO2dCQUNsQixDQUFDO2FBQ0Y7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUFqQ0Qsc0NBaUNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcmVsYXRpdmUgfSBmcm9tIFwicGF0aFwiO1xuaW1wb3J0IHsgQ29tcG9uZW50LCBQcm9qZWN0LCBZYW1sRmlsZSB9IGZyb20gXCJwcm9qZW5cIjtcblxuZXhwb3J0IGNsYXNzIFBucG1Xb3Jrc3BhY2UgZXh0ZW5kcyBDb21wb25lbnQge1xuICBwdWJsaWMgc3RhdGljIG9mKHByb2plY3Q6IFByb2plY3QpOiBQbnBtV29ya3NwYWNlIHwgdW5kZWZpbmVkIHtcbiAgICBjb25zdCBpc0RlZmluZWQgPSAoYzogQ29tcG9uZW50KTogYyBpcyBQbnBtV29ya3NwYWNlID0+XG4gICAgICBjIGluc3RhbmNlb2YgUG5wbVdvcmtzcGFjZTtcbiAgICByZXR1cm4gcHJvamVjdC5yb290LmNvbXBvbmVudHMuZmluZChpc0RlZmluZWQpO1xuICB9XG5cbiAgY29uc3RydWN0b3IocHJvamVjdDogUHJvamVjdCkge1xuICAgIHN1cGVyKHByb2plY3QpO1xuXG4gICAgY29uc3QgZmlsZU5hbWU6IHN0cmluZyA9IFwicG5wbS13b3Jrc3BhY2UueWFtbFwiO1xuXG4gICAgLyoqXG4gICAgICogSW4gY2FzZSB0aGF0IHRoaXMgZmlsZSBpcyBpbiBhIHBhY2thZ2UsIGRvbid0IHBhY2thZ2UgaXQuXG4gICAgICovXG4gICAgcHJvamVjdC5hZGRQYWNrYWdlSWdub3JlKGZpbGVOYW1lKTtcblxuICAgIC8qKlxuICAgICAqIFdyaXRlIHBucG0gd29ya3NwYWNlIGZpbGVcbiAgICAgKi9cbiAgICBuZXcgWWFtbEZpbGUodGhpcy5wcm9qZWN0LCBmaWxlTmFtZSwge1xuICAgICAgb2JqOiB7XG4gICAgICAgIHBhY2thZ2VzOiAoKSA9PiB7XG4gICAgICAgICAgY29uc3QgcGFja2FnZXMgPSBuZXcgQXJyYXk8c3RyaW5nPigpO1xuICAgICAgICAgIGZvciAoY29uc3Qgc3VicHJvamVjdCBvZiBwcm9qZWN0LnN1YnByb2plY3RzKSB7XG4gICAgICAgICAgICAvLyBncmFiIHRoZSByZWxhdGl2ZSBvdXQgZGlyZWN0b3J5XG4gICAgICAgICAgICBwYWNrYWdlcy5wdXNoKHJlbGF0aXZlKHRoaXMucHJvamVjdC5vdXRkaXIsIHN1YnByb2plY3Qub3V0ZGlyKSk7XG4gICAgICAgICAgfVxuICAgICAgICAgIHJldHVybiBwYWNrYWdlcztcbiAgICAgICAgfSxcbiAgICAgIH0sXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pnpm-workspace.js","sourceRoot":"","sources":["../../src/pnpm/pnpm-workspace.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative } from \"path\";\nimport { Component, Project, YamlFile } from \"projen\";\nimport { ValueOf } from \"type-fest\";\n\n/**\n * Predefined minimum release age values in minutes.\n */\nexport const MIMIMUM_RELEASE_AGE = {\n  ZERO_DAYS: 0,\n  ONE_HOUR: 60,\n  SIX_HOURS: 360,\n  TWELVE_HOURS: 720,\n  ONE_DAY: 1440,\n  TWO_DAYS: 2880,\n  THREE_DAYS: 4320,\n  FOUR_DAYS: 5760,\n  FIVE_DAYS: 7200,\n  SIX_DAYS: 8640,\n  ONE_WEEK: 10080,\n};\n\nexport interface PnpmWorkspaceOptions {\n  /**\n   * Filename for the pnpm workspace file. This should probably never change.\n   *\n   * @default \"pnpm-workspace.yaml\"\n   */\n  readonly fileName?: string;\n\n  /**\n   * To reduce the risk of installing compromised packages, you can delay the\n   * installation of newly published versions. In most cases, malicious releases\n   * are discovered and removed from the registry within an hour.\n   *\n   * minimumReleaseAge defines the minimum number of minutes that must pass\n   * after a version is published before pnpm will install it. This applies to\n   * all dependencies, including transitive ones.\n   *\n   * Note: this should match depsUpgradeOptions.cooldown in the project config.\n   *\n   * See: https://pnpm.io/settings#minimumreleaseage\n   *\n   * @default MIMIMUM_RELEASE_AGE.ONE_DAY\n   */\n  readonly minimumReleaseAge?: ValueOf<typeof MIMIMUM_RELEASE_AGE>;\n\n  /**\n   * If you set minimumReleaseAge but need certain dependencies to always\n   * install the newest version immediately, you can list them under\n   * minimumReleaseAgeExclude. The exclusion works by package name and applies\n   * to all versions of that package.\n   *\n   * @default - no exclusions (empty array)\n   *\n   * See: https://pnpm.io/settings#minimumreleaseageexclude\n   */\n  readonly minimumReleaseAgeExclude?: Array<string>;\n\n  /**\n   * A list of package names that are allowed to execute \"preinstall\",\n   * \"install\", and/or \"postinstall\" scripts during installation. Only the\n   * packages listed in this array will be able to run those lifecycle scripts.\n   * If onlyBuiltDependenciesFile and neverBuiltDependencies are omitted, this\n   * configuration option will default to blocking all install scripts.\n   *\n   * You may restrict allowances to specific versions (and lists of versions\n   * using a disjunction with ||). When versions are specified, only those\n   * versions of the package may run lifecycle scripts:\n   *\n   * See: https://pnpm.io/settings#onlybuiltdependencies\n   *\n   * @default none (empty array)\n   */\n  readonly onlyBuiltDependencies?: Array<string>;\n\n  /**\n   * A list of package names that are NOT allowed to execute \"preinstall\",\n   * \"install\", and/or \"postinstall\" scripts during installation and will not\n   * warn or ask to be executed.\n   *\n   * This is useful when you want to hide the warning because you know the\n   * lifecycle scripts are not needed.\n   *\n   * https://pnpm.io/settings#ignoredbuiltdependencies\n   *\n   * @default none (empty array)\n   */\n  readonly ignoredBuiltDependencies?: Array<string>;\n\n  /**\n   * Additional subproject paths to include in the workspace packages array.\n   * These will be combined with any subprojects discovered via projen's\n   * project.subprojects property. Paths should be relative to the project root.\n   *\n   * @default none (empty array)\n   */\n  readonly subprojects?: Array<string>;\n\n  /**\n   * Catalog of reusable dependency version ranges.\n   *\n   * The catalog allows you to define dependency versions as reusable constants\n   * that can be referenced in package.json files using the catalog: protocol.\n   *\n   * Example:\n   * ```yaml\n   * catalog:\n   *   react: ^18.0.0\n   *   typescript: ^5.0.0\n   * ```\n   *\n   * Then in package.json:\n   * ```json\n   * {\n   *   \"dependencies\": {\n   *     \"react\": \"catalog:react\"\n   *   }\n   * }\n   * ```\n   *\n   * @default undefined (not included in output)\n   *\n   * See: https://pnpm.io/pnpm-workspace_yaml#catalog\n   */\n  readonly defaultCatalog?: { [key: string]: string };\n\n  /**\n   * Named catalogs of reusable dependency version ranges.\n   *\n   * Multiple named catalogs with arbitrarily chosen names can be configured under the namedCatalogs key.\n   *\n   * Example:\n   * ```yaml\n   * namedCatalogs:\n   *   frontend:\n   *     react: ^18.0.0\n   *     typescript: ^5.0.0\n   *   backend:\n   *     express: ^4.18.0\n   * ```\n   *\n   * Then in package.json:\n   * ```json\n   * {\n   *   \"dependencies\": {\n   *     \"react\": \"catalog:frontend/react\"\n   *   }\n   * }\n   * ```\n   *\n   * @default undefined (not included in output)\n   *\n   * See: https://pnpm.io/catalogs\n   */\n  readonly namedCatalogs?: {\n    [catalogName: string]: { [dependencyName: string]: string };\n  };\n}\n\nexport class PnpmWorkspace extends Component {\n  /**\n   * Get the pnpm workspace component of a project. If it does not exist,\n   * return undefined.\n   *\n   * @param project\n   * @returns\n   */\n  public static of(project: Project): PnpmWorkspace | undefined {\n    const isDefined = (c: Component): c is PnpmWorkspace =>\n      c instanceof PnpmWorkspace;\n    return project.root.components.find(isDefined);\n  }\n\n  /**\n   * Filename for the pnpm workspace file.\n   */\n  public readonly fileName: string;\n\n  /**\n   * To reduce the risk of installing compromised packages, you can delay the\n   * installation of newly published versions. In most cases, malicious releases\n   * are discovered and removed from the registry within an hour.\n   *\n   * minimumReleaseAge defines the minimum number of minutes that must pass\n   * after a version is published before pnpm will install it. This applies to\n   * all dependencies, including transitive ones.\n   *\n   * Note: this should match depsUpgradeOptions.cooldown in the project config.\n   *\n   * See: https://pnpm.io/settings#minimumreleaseage\n   */\n  public minimumReleaseAge: ValueOf<typeof MIMIMUM_RELEASE_AGE>;\n\n  /**\n   * If you set minimumReleaseAge but need certain dependencies to always\n   * install the newest version immediately, you can list them under\n   * minimumReleaseAgeExclude. The exclusion works by package name and applies\n   * to all versions of that package.\n   *\n   * See: https://pnpm.io/settings#minimumreleaseageexclude\n   */\n  public minimumReleaseAgeExclude: Array<string>;\n\n  /**\n   * A list of package names that are allowed to execute \"preinstall\",\n   * \"install\", and/or \"postinstall\" scripts during installation. Only the\n   * packages listed in this array will be able to run those lifecycle scripts.\n   * If onlyBuiltDependenciesFile and neverBuiltDependencies are omitted, this\n   * configuration option will default to blocking all install scripts.\n   *\n   * You may restrict allowances to specific versions (and lists of versions\n   * using a disjunction with ||). When versions are specified, only those\n   * versions of the package may run lifecycle scripts:\n   *\n   * See: https://pnpm.io/settings#onlybuiltdependencies\n   */\n  public onlyBuiltDependencies: Array<string>;\n\n  /**\n   * A list of package names that are NOT allowed to execute \"preinstall\",\n   * \"install\", and/or \"postinstall\" scripts during installation and will not\n   * warn or ask to be executed.\n   *\n   * This is useful when you want to hide the warning because you know the\n   * lifecycle scripts are not needed.\n   *\n   * https://pnpm.io/settings#ignoredbuiltdependencies\n   */\n  public ignoredBuiltDependencies: Array<string>;\n\n  /**\n   * Additional subproject paths to include in the workspace packages array.\n   * These will be combined with any subprojects discovered via projen's\n   * project.subprojects property.\n   */\n  public subprojects: Array<string>;\n\n  /**\n   * Default catalog of reusable dependency version ranges.\n   *\n   * The default catalog is used to define dependency versions as reusable constants\n   * that can be referenced in package.json files using the catalog: protocol.\n   *\n   * See:https://pnpm.io/catalogs\n   */\n  public defaultCatalog?: { [key: string]: string };\n\n  /**\n   * Named catalogs of reusable dependency version ranges.\n   *\n   * Multiple named catalogs with arbitrarily chosen names can be configured under the namedCatalogs key.\n   *\n   * See: https://pnpm.io/catalogs\n   */\n  public namedCatalogs?: {\n    [catalogName: string]: { [dependencyName: string]: string };\n  };\n\n  constructor(project: Project, options: PnpmWorkspaceOptions = {}) {\n    super(project);\n\n    /***************************************************************************\n     *\n     * CLEAR package,json\n     *\n     * It appears that if ANY pnpm settings exist in the package.json file, all\n     * of the setting in the pnpm-workspace.yaml file are ignored. so we need to\n     * clear out anything that was placed into the package.json file.\n     *\n     **************************************************************************/\n\n    project.tryFindObjectFile(\"package.json\")?.addDeletionOverride(\"pnpm\");\n\n    /***************************************************************************\n     * \n     * Setup pnpm-workspace.yaml file.\n     * \n     * Now that the package.json file is cleared of any pnpm settings, we can\n     * safely write settings to the pnpm-workspace.yaml file.\n     * \n     **************************************************************************\n\n    /**\n     * Set filename to default if not provided.\n     */\n    this.fileName = options.fileName ?? \"pnpm-workspace.yaml\";\n\n    /**\n     * Set minimum release age to default if not provided\n     */\n    this.minimumReleaseAge = options.minimumReleaseAge\n      ? options.minimumReleaseAge\n      : MIMIMUM_RELEASE_AGE.ONE_DAY;\n\n    /**\n     * Set minimum release age exclude to empty array if not provided\n     */\n    this.minimumReleaseAgeExclude = options.minimumReleaseAgeExclude\n      ? [\"@codedrifters/*\", ...options.minimumReleaseAgeExclude]\n      : [\"@codedrifters/*\"];\n\n    /**\n     * Set only built dependencies to empty array if not provided\n     */\n    this.onlyBuiltDependencies = options.onlyBuiltDependencies\n      ? options.onlyBuiltDependencies\n      : [];\n\n    /**\n     * Set ignored built dependencies to empty array if not provided\n     */\n    this.ignoredBuiltDependencies = options.ignoredBuiltDependencies\n      ? options.ignoredBuiltDependencies\n      : [];\n\n    /**\n     * Store additional subproject paths if provided\n     */\n    this.subprojects = options.subprojects ?? [];\n\n    /**\n     * Store catalog if provided\n     */\n    this.defaultCatalog = options.defaultCatalog;\n\n    /**\n     * Store named catalogs if provided\n     */\n    this.namedCatalogs = options.namedCatalogs;\n\n    /**\n     * In case that this file is in a package, don't package it.\n     */\n    project.addPackageIgnore(this.fileName);\n\n    /**\n     * Write pnpm workspace file\n     */\n    new YamlFile(this.project, this.fileName, {\n      obj: () => {\n        const pnpmConfig: any = {};\n        const packages = new Array<string>();\n\n        /**\n         * Add projen subprojects to the packages array.\n         */\n        for (const subproject of project.subprojects) {\n          // grab the relative out directory\n          packages.push(relative(this.project.outdir, subproject.outdir));\n        }\n\n        /**\n         * Add additional subproject paths provided via options.\n         * Use a Set to deduplicate paths to avoid including the same\n         * subproject multiple times.\n         */\n        const packageSet = new Set(packages);\n        for (const subprojectPath of this.subprojects) {\n          packageSet.add(subprojectPath);\n        }\n\n        /**\n         * Convert back to array if we added any additional paths\n         */\n        if (this.subprojects.length > 0) {\n          packages.length = 0;\n          packages.push(...packageSet);\n        }\n\n        /**\n         * Set minimum release age.\n         */\n        pnpmConfig.minimumReleaseAge = this.minimumReleaseAge;\n\n        /**\n         * Set minimum release age exclude if any are provided.\n         */\n        if (this.minimumReleaseAgeExclude.length > 0) {\n          pnpmConfig.minimumReleaseAgeExclude = this.minimumReleaseAgeExclude;\n        }\n\n        /**\n         * Set only built dependencies if any are provided.\n         */\n        if (this.onlyBuiltDependencies.length > 0) {\n          pnpmConfig.onlyBuiltDependencies = this.onlyBuiltDependencies;\n        }\n\n        /**\n         * Set ignored built dependencies if any are provided.\n         */\n        if (this.ignoredBuiltDependencies.length > 0) {\n          pnpmConfig.ignoreBuiltDependencies = this.ignoredBuiltDependencies;\n        }\n\n        /**\n         * Set default catalog if provided.\n         */\n        if (\n          this.defaultCatalog &&\n          Object.keys(this.defaultCatalog).length > 0\n        ) {\n          pnpmConfig.catalog = this.defaultCatalog;\n        }\n\n        /**\n         * Set named catalogs if provided.\n         */\n        if (this.namedCatalogs && Object.keys(this.namedCatalogs).length > 0) {\n          pnpmConfig.namedCatalogs = this.namedCatalogs;\n        }\n\n        /**\n         * Return the final pnpm config object.\n         */\n        return {\n          ...(packages.length > 0 ? { packages } : {}),\n          ...(pnpmConfig ? { ...pnpmConfig } : {}),\n        };\n      },\n    });\n  }\n}\n"]}

package/lib/projects/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./monorepo-project";
+export * from "./typescript-project";

package/lib/projects/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./monorepo-project"), exports);
+__exportStar(require("./typescript-project"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvamVjdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQztBQUNuQyx1REFBcUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9tb25vcmVwby1wcm9qZWN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc2NyaXB0LXByb2plY3RcIjtcbiJdfQ==