mrpj 0.0.1

package/lib/typescript-project-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript-project-options.js","sourceRoot":"","sources":["../src/typescript-project-options.ts"],"names":[],"mappings":"","sourcesContent":["// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\nimport { github, GitOptions, IgnoreFileOptions, javascript, LoggerOptions, Project, ProjectType, ProjenrcJsonOptions, release, RenovatebotOptions, SampleReadmeProps, typescript } from 'projen';\n\n/**\n * TypeScriptProjectOptions\n */\nexport interface TypeScriptProjectOptions {\n  /**\n   * TypeScript version to use.\n   * NOTE: Typescript is not semantically versioned and should remain on the\n   * same minor, so we recommend using a `~` dependency (e.g. `~1.2.3`).\n   * @default \"latest\"\n   * @stability experimental\n   */\n  readonly typescriptVersion?: string;\n  /**\n   * The name of the development tsconfig.json file.\n   * @default \"tsconfig.dev.json\"\n   * @stability experimental\n   */\n  readonly tsconfigDevFile?: string;\n  /**\n   * Custom tsconfig options for the development tsconfig.json file (used for testing).\n   * @default - use the production tsconfig options\n   * @stability experimental\n   */\n  readonly tsconfigDev?: javascript.TypescriptConfigOptions;\n  /**\n   * Custom TSConfig.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly tsconfig?: javascript.TypescriptConfigOptions;\n  /**\n   * Jest tests directory. Tests files should be named `xxx.test.ts`.\n   * If this directory is under `srcdir` (e.g. `src/test`, `src/__tests__`),\n   * then tests are going to be compiled into `lib/` and executed as javascript.\n   * If the test directory is outside of `src`, then we configure jest to\n   * compile the code in-memory.\n   * @default \"test\"\n   * @stability experimental\n   */\n  readonly testdir?: string;\n  /**\n   * Typescript sources directory.\n   * @default \"src\"\n   * @stability experimental\n   */\n  readonly srcdir?: string;\n  /**\n   * Generate one-time sample in `src/` and `test/` if there are no files there.\n   * @default true\n   * @stability experimental\n   */\n  readonly sampleCode?: boolean;\n  /**\n   * Options for .projenrc.ts.\n   * @stability experimental\n   */\n  readonly projenrcTsOptions?: typescript.ProjenrcOptions;\n  /**\n   * Use TypeScript for your projenrc file (`.projenrc.ts`).\n   * @default false\n   * @stability experimental\n   */\n  readonly projenrcTs?: boolean;\n  /**\n   * Typescript  artifacts output directory.\n   * @default \"lib\"\n   * @stability experimental\n   */\n  readonly libdir?: string;\n  /**\n   * Eslint options.\n   * @default - opinionated default options\n   * @stability experimental\n   */\n  readonly eslintOptions?: javascript.EslintOptions;\n  /**\n   * Setup eslint.\n   * @default true\n   * @stability experimental\n   */\n  readonly eslint?: boolean;\n  /**\n   * The .d.ts file that includes the type declarations for this module.\n   * @default - .d.ts file derived from the project's entrypoint (usually lib/index.d.ts)\n   * @stability experimental\n   */\n  readonly entrypointTypes?: string;\n  /**\n   * Docs directory.\n   * @default \"docs\"\n   * @stability experimental\n   */\n  readonly docsDirectory?: string;\n  /**\n   * Docgen by Typedoc.\n   * @default false\n   * @stability experimental\n   */\n  readonly docgen?: boolean;\n  /**\n   * Do not generate a `tsconfig.json` file (used by jsii projects since tsconfig.json is generated by the jsii compiler).\n   * @default false\n   * @stability experimental\n   */\n  readonly disableTsconfig?: boolean;\n  /**\n   * The node version to use in GitHub workflows.\n   * @default - same as `minNodeVersion`\n   * @stability experimental\n   */\n  readonly workflowNodeVersion?: string;\n  /**\n   * The git identity to use in workflows.\n   * @default - GitHub Actions\n   * @stability experimental\n   */\n  readonly workflowGitIdentity?: github.GitIdentity;\n  /**\n   * Workflow steps to use in order to bootstrap this repo.\n   * @default \"yarn install --frozen-lockfile && yarn projen\"\n   * @stability experimental\n   */\n  readonly workflowBootstrapSteps?: Array<github.workflows.JobStep>;\n  /**\n   * DEPRECATED: renamed to `release`.\n   * @default - true if not a subproject\n   * @deprecated see `release`.\n   * @stability deprecated\n   */\n  readonly releaseWorkflow?: boolean;\n  /**\n   * Automatically release to npm when new versions are introduced.\n   * @default false\n   * @stability experimental\n   */\n  readonly releaseToNpm?: boolean;\n  /**\n   * Add release management to this project.\n   * @default - true (false for subprojects)\n   * @stability experimental\n   */\n  readonly release?: boolean;\n  /**\n   * The contents of the pull request template.\n   * @default - default content\n   * @stability experimental\n   */\n  readonly pullRequestTemplateContents?: Array<string>;\n  /**\n   * Include a GitHub pull request template.\n   * @default true\n   * @stability experimental\n   */\n  readonly pullRequestTemplate?: boolean;\n  /**\n   * Version of projen to install.\n   * @default - Defaults to the latest version.\n   * @stability experimental\n   */\n  readonly projenVersion?: string;\n  /**\n   * Options for .projenrc.js.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly projenrcJsOptions?: javascript.ProjenrcOptions;\n  /**\n   * Generate (once) .projenrc.js (in JavaScript). Set to `false` in order to disable .projenrc.js generation.\n   * @default - true if projenrcJson is false\n   * @stability experimental\n   */\n  readonly projenrcJs?: boolean;\n  /**\n   * Indicates of \"projen\" should be installed as a devDependency.\n   * @default true\n   * @stability experimental\n   */\n  readonly projenDevDependency?: boolean;\n  /**\n   * Prettier options.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly prettierOptions?: javascript.PrettierOptions;\n  /**\n   * Setup prettier.\n   * @default false\n   * @stability experimental\n   */\n  readonly prettier?: boolean;\n  /**\n   * Defines a `package` task that will produce an npm tarball under the artifacts directory (e.g. `dist`).\n   * @default true\n   * @stability experimental\n   */\n  readonly package?: boolean;\n  /**\n   * Configuration options for .npmignore file.\n   * @stability experimental\n   */\n  readonly npmIgnoreOptions?: IgnoreFileOptions;\n  /**\n   * Defines an .npmignore file. Normally this is only needed for libraries that are packaged as tarballs.\n   * @default true\n   * @stability experimental\n   */\n  readonly npmignoreEnabled?: boolean;\n  /**\n   * Additional entries to .npmignore.\n   * @deprecated - use `project.addPackageIgnore`\n   * @stability deprecated\n   */\n  readonly npmignore?: Array<string>;\n  /**\n   * Automatically update files modified during builds to pull-request branches.\n   * This means\n   * that any files synthesized by projen or e.g. test snapshots will always be up-to-date\n   * before a PR is merged.\n   *\n   * Implies that PR builds do not have anti-tamper checks.\n   * @default true\n   * @stability experimental\n   */\n  readonly mutableBuild?: boolean;\n  /**\n   * Jest options.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly jestOptions?: javascript.JestOptions;\n  /**\n   * Setup jest unit tests.\n   * @default true\n   * @stability experimental\n   */\n  readonly jest?: boolean;\n  /**\n   * Additional entries to .gitignore.\n   * @stability experimental\n   */\n  readonly gitignore?: Array<string>;\n  /**\n   * Options for `UpgradeDependencies`.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly depsUpgradeOptions?: javascript.UpgradeDependenciesOptions;\n  /**\n   * Use github workflows to handle dependency upgrades.\n   * Cannot be used in conjunction with `dependabot`.\n   * @default true\n   * @stability experimental\n   */\n  readonly depsUpgrade?: boolean;\n  /**\n   * Options for dependabot.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly dependabotOptions?: github.DependabotOptions;\n  /**\n   * Use dependabot to handle dependency upgrades.\n   * Cannot be used in conjunction with `depsUpgrade`.\n   * @default false\n   * @stability experimental\n   */\n  readonly dependabot?: boolean;\n  /**\n   * The copyright years to put in the LICENSE file.\n   * @default - current year\n   * @stability experimental\n   */\n  readonly copyrightPeriod?: string;\n  /**\n   * License copyright owner.\n   * @default - defaults to the value of authorName or \"\" if `authorName` is undefined.\n   * @stability experimental\n   */\n  readonly copyrightOwner?: string;\n  /**\n   * Define the secret name for a specified https://codecov.io/ token A secret is required to send coverage for private repositories.\n   * @default - if this option is not specified, only public repositories are supported\n   * @stability experimental\n   */\n  readonly codeCovTokenSecret?: string;\n  /**\n   * Define a GitHub workflow step for sending code coverage metrics to https://codecov.io/ Uses codecov/codecov-action@v3 A secret is required for private repos. Configured with @codeCovTokenSecret.\n   * @default false\n   * @stability experimental\n   */\n  readonly codeCov?: boolean;\n  /**\n   * Options for `Bundler`.\n   * @stability experimental\n   */\n  readonly bundlerOptions?: javascript.BundlerOptions;\n  /**\n   * Build workflow triggers.\n   * @default \"{ pullRequest: {}, workflowDispatch: {} }\"\n   * @stability experimental\n   */\n  readonly buildWorkflowTriggers?: github.workflows.Triggers;\n  /**\n   * Define a GitHub workflow for building PRs.\n   * @default - true if not a subproject\n   * @stability experimental\n   */\n  readonly buildWorkflow?: boolean;\n  /**\n   * Automatically approve deps upgrade PRs, allowing them to be merged by mergify (if configued).\n   * Throw if set to true but `autoApproveOptions` are not defined.\n   * @default - true\n   * @stability experimental\n   */\n  readonly autoApproveUpgrades?: boolean;\n  /**\n   * A directory which will contain build artifacts.\n   * @default \"dist\"\n   * @stability experimental\n   */\n  readonly artifactsDirectory?: string;\n  /**\n   * The name of the main release branch.\n   * @default \"main\"\n   * @stability experimental\n   */\n  readonly defaultReleaseBranch: string;\n  /**\n   * Github Runner selection labels.\n   * @default [\"ubuntu-latest\"]\n   * @stability experimental\n   */\n  readonly workflowRunsOn?: Array<string>;\n  /**\n   * Container image to use for GitHub workflows.\n   * @default - default image\n   * @stability experimental\n   */\n  readonly workflowContainerImage?: string;\n  /**\n   * Custom configuration used when creating changelog with standard-version package.\n   * Given values either append to default configuration or overwrite values in it.\n   * @default - standard configuration applicable for GitHub repositories\n   * @stability experimental\n   */\n  readonly versionrcOptions?: Record<string, any>;\n  /**\n   * A set of workflow steps to execute in order to setup the workflow container.\n   * @stability experimental\n   */\n  readonly releaseWorkflowSetupSteps?: Array<github.workflows.JobStep>;\n  /**\n   * The name of the default release workflow.\n   * @default \"Release\"\n   * @stability experimental\n   */\n  readonly releaseWorkflowName?: string;\n  /**\n   * The release trigger to use.\n   * @default - Continuous releases (`ReleaseTrigger.continuous()`)\n   * @stability experimental\n   */\n  readonly releaseTrigger?: release.ReleaseTrigger;\n  /**\n   * Automatically add the given prefix to release tags. Useful if you are releasing on multiple branches with overlapping version numbers.\n   * Note: this prefix is used to detect the latest tagged version\n   * when bumping, so if you change this on a project with an existing version\n   * history, you may need to manually tag your latest release\n   * with the new prefix.\n   * @default \"v\"\n   * @stability experimental\n   */\n  readonly releaseTagPrefix?: string;\n  /**\n   * CRON schedule to trigger new releases.\n   * @default - no scheduled releases\n   * @deprecated Use `releaseTrigger: ReleaseTrigger.scheduled()` instead\n   * @stability deprecated\n   */\n  readonly releaseSchedule?: string;\n  /**\n   * The label to apply to issues indicating publish failures.\n   * Only applies if `releaseFailureIssue` is true.\n   * @default \"failed-release\"\n   * @stability experimental\n   */\n  readonly releaseFailureIssueLabel?: string;\n  /**\n   * Create a github issue on every failed publishing task.\n   * @default false\n   * @stability experimental\n   */\n  readonly releaseFailureIssue?: boolean;\n  /**\n   * Automatically release new versions every commit to one of branches in `releaseBranches`.\n   * @default true\n   * @deprecated Use `releaseTrigger: ReleaseTrigger.continuous()` instead\n   * @stability deprecated\n   */\n  readonly releaseEveryCommit?: boolean;\n  /**\n   * Defines additional release branches.\n   * A workflow will be created for each\n   * release branch which will publish releases from commits in this branch.\n   * Each release branch _must_ be assigned a major version number which is used\n   * to enforce that versions published from that branch always use that major\n   * version. If multiple branches are used, the `majorVersion` field must also\n   * be provided for the default branch.\n   * @default - no additional branches are used for release. you can use\n`addBranch()` to add additional branches.\n   * @stability experimental\n   */\n  readonly releaseBranches?: Record<string, release.BranchOptions>;\n  /**\n   * Define publishing tasks that can be executed manually as well as workflows.\n   * Normally, publishing only happens within automated workflows. Enable this\n   * in order to create a publishing task for each publishing activity.\n   * @default false\n   * @stability experimental\n   */\n  readonly publishTasks?: boolean;\n  /**\n   * Instead of actually publishing to package managers, just print the publishing command.\n   * @default false\n   * @stability experimental\n   */\n  readonly publishDryRun?: boolean;\n  /**\n   * Bump versions from the default branch as pre-releases (e.g. \"beta\", \"alpha\", \"pre\").\n   * @default - normal semantic versions\n   * @stability experimental\n   */\n  readonly prerelease?: string;\n  /**\n   * Steps to execute after build as part of the release workflow.\n   * @default []\n   * @stability experimental\n   */\n  readonly postBuildSteps?: Array<github.workflows.JobStep>;\n  /**\n   * The npmDistTag to use when publishing from the default branch.\n   * To set the npm dist-tag for release branches, set the `npmDistTag` property\n   * for each branch.\n   * @default \"latest\"\n   * @stability experimental\n   */\n  readonly npmDistTag?: string;\n  /**\n   * Minimal Major version to release.\n   * This can be useful to set to 1, as breaking changes before the 1.x major\n   * release are not incrementing the major version number.\n   *\n   * Can not be set together with `majorVersion`.\n   * @default - No minimum version is being enforced\n   * @stability experimental\n   */\n  readonly minMajorVersion?: number;\n  /**\n   * Major version to release from the default branch.\n   * If this is specified, we bump the latest version of this major version line.\n   * If not specified, we bump the global latest version.\n   * @default - Major version is not enforced.\n   * @stability experimental\n   */\n  readonly majorVersion?: number;\n  /**\n   * Version requirement of `publib` which is used to publish modules to npm.\n   * @default \"latest\"\n   * @stability experimental\n   */\n  readonly jsiiReleaseVersion?: string;\n  /**\n   * Package's Stability.\n   * @stability experimental\n   */\n  readonly stability?: string;\n  /**\n   * npm scripts to include.\n   * If a script has the same name as a standard script,\n   * the standard script will be overwritten.\n   * @default {}\n   * @stability experimental\n   */\n  readonly scripts?: Record<string, string>;\n  /**\n   * Options for privately hosted scoped packages.\n   * @default - fetch all scoped packages from the public npm registry\n   * @stability experimental\n   */\n  readonly scopedPackagesOptions?: Array<javascript.ScopedPackagesOptions>;\n  /**\n   * If the package.json for your package is not in the root directory (for example if it is part of a monorepo), you can specify the directory in which it lives.\n   * @stability experimental\n   */\n  readonly repositoryDirectory?: string;\n  /**\n   * The repository is the location where the actual code for your package lives.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-repository\n   * @stability experimental\n   */\n  readonly repository?: string;\n  /**\n   * The version of PNPM to use if using PNPM as a package manager.\n   * @default \"7\"\n   * @stability experimental\n   */\n  readonly pnpmVersion?: string;\n  /**\n   * Peer dependencies for this module.\n   * Dependencies listed here are required to\n   * be installed (and satisfied) by the _consumer_ of this library. Using peer\n   * dependencies allows you to ensure that only a single module of a certain\n   * library exists in the `node_modules` tree of your consumers.\n   *\n   * Note that prior to npm@7, peer dependencies are _not_ automatically\n   * installed, which means that adding peer dependencies to a library will be a\n   * breaking change for your customers.\n   *\n   * Unless `peerDependencyOptions.pinnedDevDependency` is disabled (it is\n   * enabled by default), projen will automatically add a dev dependency with a\n   * pinned version for each peer dependency. This will ensure that you build &\n   * test your module against the lowest peer version required.\n   * @default []\n   * @stability experimental\n   */\n  readonly peerDeps?: Array<string>;\n  /**\n   * Options for `peerDeps`.\n   * @stability experimental\n   */\n  readonly peerDependencyOptions?: javascript.PeerDependencyOptions;\n  /**\n   * The \"name\" in package.json.\n   * @default - defaults to project name\n   * @stability experimental\n   */\n  readonly packageName?: string;\n  /**\n   * The Node Package Manager used to execute scripts.\n   * @default NodePackageManager.YARN\n   * @stability experimental\n   */\n  readonly packageManager?: javascript.NodePackageManager;\n  /**\n   * GitHub secret which contains the NPM token to use when publishing packages.\n   * @default \"NPM_TOKEN\"\n   * @stability experimental\n   */\n  readonly npmTokenSecret?: string;\n  /**\n   * The base URL of the npm package registry.\n   * Must be a URL (e.g. start with \"https://\" or \"http://\")\n   * @default \"https://registry.npmjs.org\"\n   * @stability experimental\n   */\n  readonly npmRegistryUrl?: string;\n  /**\n   * The host name of the npm registry to publish to.\n   * Cannot be set together with `npmRegistryUrl`.\n   * @deprecated use `npmRegistryUrl` instead\n   * @stability deprecated\n   */\n  readonly npmRegistry?: string;\n  /**\n   * Access level of the npm package.\n   * @default - for scoped packages (e.g. `foo@bar`), the default is\n`NpmAccess.RESTRICTED`, for non-scoped packages, the default is\n`NpmAccess.PUBLIC`.\n   * @stability experimental\n   */\n  readonly npmAccess?: javascript.NpmAccess;\n  /**\n   * Minimum Node.js version to require via package.json `engines` (inclusive).\n   * @default - no \"engines\" specified\n   * @stability experimental\n   */\n  readonly minNodeVersion?: string;\n  /**\n   * Minimum node.js version to require via `engines` (inclusive).\n   * @default - no max\n   * @stability experimental\n   */\n  readonly maxNodeVersion?: string;\n  /**\n   * Indicates if a license should be added.\n   * @default true\n   * @stability experimental\n   */\n  readonly licensed?: boolean;\n  /**\n   * License's SPDX identifier.\n   * See https://github.com/projen/projen/tree/main/license-text for a list of supported licenses.\n   * Use the `licensed` option if you want to no license to be specified.\n   * @default \"Apache-2.0\"\n   * @stability experimental\n   */\n  readonly license?: string;\n  /**\n   * Keywords to include in `package.json`.\n   * @stability experimental\n   */\n  readonly keywords?: Array<string>;\n  /**\n   * Package's Homepage / Website.\n   * @stability experimental\n   */\n  readonly homepage?: string;\n  /**\n   * Module entrypoint (`main` in `package.json`).\n   * Set to an empty string to not include `main` in your package.json\n   * @default \"lib/index.js\"\n   * @stability experimental\n   */\n  readonly entrypoint?: string;\n  /**\n   * Build dependencies for this module.\n   * These dependencies will only be\n   * available in your build environment but will not be fetched when this\n   * module is consumed.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @default []\n   * @stability experimental\n   */\n  readonly devDeps?: Array<string>;\n  /**\n   * The description is just a string that helps people understand the purpose of the package.\n   * It can be used when searching for packages in a package manager as well.\n   * See https://classic.yarnpkg.com/en/docs/package-json/#toc-description\n   * @stability experimental\n   */\n  readonly description?: string;\n  /**\n   * Runtime dependencies of this module.\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @default []\n   * @stability experimental\n   */\n  readonly deps?: Array<string>;\n  /**\n   * Options for npm packages using AWS CodeArtifact.\n   * This is required if publishing packages to, or installing scoped packages from AWS CodeArtifact\n   * @default - undefined\n   * @stability experimental\n   */\n  readonly codeArtifactOptions?: javascript.CodeArtifactOptions;\n  /**\n   * List of dependencies to bundle into this module.\n   * These modules will be\n   * added both to the `dependencies` section and `bundledDependencies` section of\n   * your `package.json`.\n   *\n   * The recommendation is to only specify the module name here (e.g.\n   * `express`). This will behave similar to `yarn add` or `npm install` in the\n   * sense that it will add the module as a dependency to your `package.json`\n   * file with the latest version (`^`). You can specify semver requirements in\n   * the same syntax passed to `npm i` or `yarn add` (e.g. `express@^2`) and\n   * this will be what you `package.json` will eventually include.\n   * @stability experimental\n   */\n  readonly bundledDeps?: Array<string>;\n  /**\n   * The url to your project's issue tracker.\n   * @stability experimental\n   */\n  readonly bugsUrl?: string;\n  /**\n   * The email address to which issues should be reported.\n   * @stability experimental\n   */\n  readonly bugsEmail?: string;\n  /**\n   * Binary programs vended with your module.\n   * You can use this option to add/customize how binaries are represented in\n   * your `package.json`, but unless `autoDetectBin` is `false`, every\n   * executable file under `bin` will automatically be added to this section.\n   * @stability experimental\n   */\n  readonly bin?: Record<string, string>;\n  /**\n   * Automatically add all executables under the `bin` directory to your `package.json` file under the `bin` section.\n   * @default true\n   * @stability experimental\n   */\n  readonly autoDetectBin?: boolean;\n  /**\n   * Author's URL / Website.\n   * @stability experimental\n   */\n  readonly authorUrl?: string;\n  /**\n   * Is the author an organization.\n   * @stability experimental\n   */\n  readonly authorOrganization?: boolean;\n  /**\n   * Author's name.\n   * @stability experimental\n   */\n  readonly authorName?: string;\n  /**\n   * Author's e-mail.\n   * @stability experimental\n   */\n  readonly authorEmail?: string;\n  /**\n   * Allow the project to include `peerDependencies` and `bundledDependencies`.\n   * This is normally only allowed for libraries. For apps, there's no meaning\n   * for specifying these.\n   * @default true\n   * @stability experimental\n   */\n  readonly allowLibraryDependencies?: boolean;\n  /**\n   * Enable VSCode integration.\n   * Enabled by default for root projects. Disabled for non-root projects.\n   * @default true\n   * @stability experimental\n   */\n  readonly vscode?: boolean;\n  /**\n   * Auto-close stale issues and pull requests.\n   * To disable set `stale` to `false`.\n   * @default - see defaults in `StaleOptions`\n   * @stability experimental\n   */\n  readonly staleOptions?: github.StaleOptions;\n  /**\n   * Auto-close of stale issues and pull request.\n   * See `staleOptions` for options.\n   * @default false\n   * @stability experimental\n   */\n  readonly stale?: boolean;\n  /**\n   * The README setup.\n   * @default - { filename: 'README.md', contents: '# replace this' }\n   * @stability experimental\n   */\n  readonly readme?: SampleReadmeProps;\n  /**\n   * The name of a secret which includes a GitHub Personal Access Token to be used by projen workflows.\n   * This token needs to have the `repo`, `workflows`\n   * and `packages` scope.\n   * @default \"PROJEN_GITHUB_TOKEN\"\n   * @deprecated use `projenCredentials`\n   * @stability deprecated\n   */\n  readonly projenTokenSecret?: string;\n  /**\n   * Choose a method of providing GitHub API access for projen workflows.\n   * @default - use a personal access token named PROJEN_GITHUB_TOKEN\n   * @stability experimental\n   */\n  readonly projenCredentials?: github.GithubCredentials;\n  /**\n   * Which type of project this is (library/app).\n   * @default ProjectType.UNKNOWN\n   * @deprecated no longer supported at the base project level\n   * @stability deprecated\n   */\n  readonly projectType?: ProjectType;\n  /**\n   * Options for mergify.\n   * @default - default options\n   * @deprecated use `githubOptions.mergifyOptions` instead\n   * @stability deprecated\n   */\n  readonly mergifyOptions?: github.MergifyOptions;\n  /**\n   * Whether mergify should be enabled on this repository or not.\n   * @default true\n   * @deprecated use `githubOptions.mergify` instead\n   * @stability deprecated\n   */\n  readonly mergify?: boolean;\n  /**\n   * Add a Gitpod development environment.\n   * @default false\n   * @stability experimental\n   */\n  readonly gitpod?: boolean;\n  /**\n   * Options for GitHub integration.\n   * @default - see GitHubOptions\n   * @stability experimental\n   */\n  readonly githubOptions?: github.GitHubOptions;\n  /**\n   * Enable GitHub integration.\n   * Enabled by default for root projects. Disabled for non-root projects.\n   * @default true\n   * @stability experimental\n   */\n  readonly github?: boolean;\n  /**\n   * Add a VSCode development environment (used for GitHub Codespaces).\n   * @default false\n   * @stability experimental\n   */\n  readonly devContainer?: boolean;\n  /**\n   * Add a `clobber` task which resets the repo to origin.\n   * @default - true, but false for subprojects\n   * @stability experimental\n   */\n  readonly clobber?: boolean;\n  /**\n   * Configure options for automatic merging on GitHub.\n   * Has no effect if\n   * `github.mergify` or `autoMerge` is set to false.\n   * @default - see defaults in `AutoMergeOptions`\n   * @stability experimental\n   */\n  readonly autoMergeOptions?: github.AutoMergeOptions;\n  /**\n   * Enable automatic merging on GitHub.\n   * Has no effect if `github.mergify`\n   * is set to false.\n   * @default true\n   * @stability experimental\n   */\n  readonly autoMerge?: boolean;\n  /**\n   * Enable and configure the 'auto approve' workflow.\n   * @default - auto approve is disabled\n   * @stability experimental\n   */\n  readonly autoApproveOptions?: github.AutoApproveOptions;\n  /**\n   * Options for renovatebot.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly renovatebotOptions?: RenovatebotOptions;\n  /**\n   * Use renovatebot to handle dependency upgrades.\n   * @default false\n   * @stability experimental\n   */\n  readonly renovatebot?: boolean;\n  /**\n   * Options for .projenrc.json.\n   * @default - default options\n   * @stability experimental\n   */\n  readonly projenrcJsonOptions?: ProjenrcJsonOptions;\n  /**\n   * Generate (once) .projenrc.json (in JSON). Set to `false` in order to disable .projenrc.json generation.\n   * @default false\n   * @stability experimental\n   */\n  readonly projenrcJson?: boolean;\n  /**\n   * The shell command to use in order to run the projen CLI.\n   * Can be used to customize in special environments.\n   * @default \"npx projen\"\n   * @stability experimental\n   */\n  readonly projenCommand?: string;\n  /**\n   * The parent project, if this project is part of a bigger project.\n   * @stability experimental\n   */\n  readonly parent?: Project;\n  /**\n   * The root directory of the project.\n   * Relative to this directory, all files are synthesized.\n   *\n   * If this project has a parent, this directory is relative to the parent\n   * directory and it cannot be the same as the parent or any of it's other\n   * sub-projects.\n   * @default \".\"\n   * @stability experimental\n   */\n  readonly outdir?: string;\n  /**\n   * Configure logging options such as verbosity.\n   * @default {}\n   * @stability experimental\n   */\n  readonly logging?: LoggerOptions;\n  /**\n   * Configuration options for git.\n   * @stability experimental\n   */\n  readonly gitOptions?: GitOptions;\n  /**\n   * Configuration options for .gitignore file.\n   * @stability experimental\n   */\n  readonly gitIgnoreOptions?: IgnoreFileOptions;\n  /**\n   * Whether to commit the managed files by default.\n   * @default true\n   * @stability experimental\n   */\n  readonly commitGenerated?: boolean;\n  /**\n   * This is the name of your project.\n   * @default $BASEDIR\n   * @stability experimental\n   */\n  readonly name: string;\n}\n"]}

package/lib/typescript-project.d.ts

@@ -0,0 +1,6 @@
+import { typescript } from 'projen';
+/**
+ * @pjid ts
+ */
+export declare class TypeScriptProject extends typescript.TypeScriptProject {
+}

package/lib/typescript-project.js

@@ -0,0 +1,15 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptProject = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/**
+ * @pjid ts
+ */
+class TypeScriptProject extends projen_1.typescript.TypeScriptProject {
+}
+_a = JSII_RTTI_SYMBOL_1;
+TypeScriptProject[_a] = { fqn: "mrpj.TypeScriptProject", version: "0.0.1" };
+exports.TypeScriptProject = TypeScriptProject;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXNjcmlwdC1wcm9qZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3R5cGVzY3JpcHQtcHJvamVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG1DQUFvQztBQUVwQzs7R0FFRztBQUNILE1BQWEsaUJBQWtCLFNBQVEsbUJBQVUsQ0FBQyxpQkFBaUI7Ozs7QUFBdEQsOENBQWlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZXNjcmlwdCB9IGZyb20gJ3Byb2plbic7XG5cbi8qKlxuICogQHBqaWQgdHNcbiAqL1xuZXhwb3J0IGNsYXNzIFR5cGVTY3JpcHRQcm9qZWN0IGV4dGVuZHMgdHlwZXNjcmlwdC5UeXBlU2NyaXB0UHJvamVjdCB7XG59Il19

package/lib/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return a value if the check value is truthy, undefined otherwise.
+ */
+export declare function ifSet(check: any, then: any): any;
+/**
+ * Return the list without undefined or null elements.
+ */
+export declare function noEmpties(list: any[]): any[];
+/**
+ * Deep merge a user provided options object with defaults.
+ * User options take precedence.
+ */
+export declare function deepDefaults<T>(options?: Partial<T>, defaults?: Partial<T>): T;

package/lib/utils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepDefaults = exports.noEmpties = exports.ifSet = void 0;
+/**
+ * Return a value if the check value is truthy, undefined otherwise.
+ */
+function ifSet(check, then) {
+    if (check) {
+        return then;
+    }
+    return undefined;
+}
+exports.ifSet = ifSet;
+/**
+ * Return the list without undefined or null elements.
+ */
+function noEmpties(list) {
+    return list.filter(e => e !== undefined && e !== null);
+}
+exports.noEmpties = noEmpties;
+/**
+ * Deep merge a user provided options object with defaults.
+ * User options take precedence.
+ */
+function deepDefaults(options = {}, defaults = {}) {
+    return mergeDeep(defaults, options);
+}
+exports.deepDefaults = deepDefaults;
+function mergeDeep(...data) {
+    return data.reduce((result, current) => {
+        Object.keys(current).forEach(key => {
+            const resultValue = result[key];
+            const currentValue = current[key];
+            if (Array.isArray(resultValue) && Array.isArray(currentValue)) {
+                result[key] = resultValue.concat(...currentValue);
+            }
+            else if (isObject(resultValue) && isObject(currentValue)) {
+                result[key] = mergeDeep(resultValue, currentValue);
+            }
+            else {
+                result[key] = currentValue;
+            }
+        });
+        return result;
+    }, {});
+}
+function isObject(x) {
+    return (x && typeof x === 'object' && !Array.isArray(x));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "mrpj",
+  "description": "Opinionated projen project types. Just for me.",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:mrgrain/projen-projects.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Momo Kornher",
+    "url": "https://moritzkornher.de",
+    "organization": false
+  },
+  "devDependencies": {
+    "@jsii/spec": "^1.79.0",
+    "@mrgrain/jsii-struct-builder": "^0.2.0",
+    "@types/jest": "^27",
+    "@types/node": "^16",
+    "@typescript-eslint/eslint-plugin": "^5",
+    "@typescript-eslint/parser": "^5",
+    "eslint": "^8",
+    "eslint-import-resolver-node": "^0.3.7",
+    "eslint-import-resolver-typescript": "^3.5.3",
+    "eslint-plugin-import": "^2.27.5",
+    "jest": "^29",
+    "jest-junit": "^15",
+    "jsii": "5.0.x",
+    "jsii-diff": "^1.79.0",
+    "jsii-docgen": "^7.1.37",
+    "jsii-pacmak": "^1.79.0",
+    "npm-check-updates": "^16",
+    "projen": "^0.69.9",
+    "standard-version": "^9",
+    "ts-jest": "^29",
+    "ts-node": "^10.9.1",
+    "typescript": "5.0.x"
+  },
+  "peerDependencies": {
+    "projen": "^0.69.9"
+  },
+  "main": "lib/index.js",
+  "license": "MIT",
+  "homepage": "https://github.com/mrgrain/projen-projects",
+  "version": "0.0.1",
+  "jest": {
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/(test|src)/**/*(*.)@(spec|test).ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "preset": "ts-jest",
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.dev.json"
+      }
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\"."
+}