projen 0.70.2 → 0.70.4

package/lib/.types-compat/ts3.9/lib/java/java-project.d.ts

@@ -0,0 +1,141 @@
+import { Junit, JunitOptions } from "./junit";
+import { MavenCompile, MavenCompileOptions } from "./maven-compile";
+import { MavenPackaging, MavenPackagingOptions } from "./maven-packaging";
+import { PluginOptions, Pom, PomOptions } from "./pom";
+import { Projenrc as ProjenrcJava, ProjenrcOptions } from "./projenrc";
+import { GitHubProject, GitHubProjectOptions } from "../github";
+/**
+ * Options for `JavaProject`.
+ */
+export interface JavaProjectCommonOptions extends GitHubProjectOptions, PomOptions {
+    /**
+     * Final artifact output directory.
+     *
+     * @default "dist/java"
+     */
+    readonly distdir?: string;
+    /**
+     * List of runtime dependencies for this project.
+     *
+     * Dependencies use the format: `<groupId>/<artifactId>@<semver>`
+     *
+     * Additional dependencies can be added via `project.addDependency()`.
+     *
+     * @default []
+     * @featured
+     */
+    readonly deps?: string[];
+    /**
+     * List of test dependencies for this project.
+     *
+     * Dependencies use the format: `<groupId>/<artifactId>@<semver>`
+     *
+     * Additional dependencies can be added via `project.addTestDependency()`.
+     *
+     * @default []
+     * @featured
+     */
+    readonly testDeps?: string[];
+    /**
+     * Include junit tests.
+     * @default true
+     */
+    readonly junit?: boolean;
+    /**
+     * junit options
+     * @default - defaults
+     */
+    readonly junitOptions?: JunitOptions;
+    /**
+     * Packaging options.
+     * @default - defaults
+     */
+    readonly packagingOptions?: MavenPackagingOptions;
+    /**
+     * Compile options.
+     * @default - defaults
+     */
+    readonly compileOptions?: MavenCompileOptions;
+    /**
+     * Use projenrc in java.
+     *
+     * This will install `projen` as a java dependency and will add a `synth` task which
+     * will compile & execute `main()` from `src/main/java/projenrc.java`.
+     *
+     * @default true
+     */
+    readonly projenrcJava?: boolean;
+    /**
+     * Options related to projenrc in java.
+     * @default - default options
+     */
+    readonly projenrcJavaOptions?: ProjenrcOptions;
+}
+/**
+ * Options for `JavaProject`.
+ */
+export interface JavaProjectOptions extends JavaProjectCommonOptions {
+    /**
+     * Include sample code and test if the relevant directories don't exist.
+     * @default true
+     */
+    readonly sample?: boolean;
+    /**
+     * The java package to use for the code sample.
+     * @default "org.acme"
+     */
+    readonly sampleJavaPackage?: string;
+}
+/**
+ * Java project.
+ *
+ * @pjid java
+ */
+export declare class JavaProject extends GitHubProject {
+    /**
+     * API for managing `pom.xml`.
+     */
+    readonly pom: Pom;
+    /**
+     * JUnit component.
+     */
+    readonly junit?: Junit;
+    /**
+     * Packaging component.
+     */
+    readonly packaging: MavenPackaging;
+    /**
+     * Compile component.
+     */
+    readonly compile: MavenCompile;
+    /**
+     * Projenrc component.
+     */
+    readonly projenrc?: ProjenrcJava;
+    /**
+     * Maven artifact output directory.
+     */
+    readonly distdir: string;
+    constructor(options: JavaProjectOptions);
+    /**
+     * Adds a runtime dependency.
+     *
+     * @param spec Format `<groupId>/<artifactId>@<semver>`
+     */
+    addDependency(spec: string): void;
+    /**
+     * Adds a test dependency.
+     *
+     * @param spec Format `<groupId>/<artifactId>@<semver>`
+     */
+    addTestDependency(spec: string): void;
+    /**
+     * Adds a build plugin to the pom.
+     *
+     * The plug in is also added as a BUILD dep to the project.
+     *
+     * @param spec dependency spec (`group/artifact@version`)
+     * @param options plugin options
+     */
+    addPlugin(spec: string, options?: PluginOptions): import("..").Dependency;
+}

package/lib/.types-compat/ts3.9/lib/java/junit.d.ts

@@ -0,0 +1,29 @@
+import { Pom } from "./pom";
+import { Component } from "../component";
+import { Project } from "../project";
+/**
+ * Options for `Junit`.
+ */
+export interface JunitOptions {
+    /**
+     * Java pom.
+     */
+    readonly pom: Pom;
+    /**
+     * Junit version
+     *
+     * @default "5.7.0"
+     */
+    readonly version?: string;
+    /**
+     * Java package for test sample.
+     * @default "org.acme"
+     */
+    readonly sampleJavaPackage?: string;
+}
+/**
+ * Implements JUnit-based testing.
+ */
+export declare class Junit extends Component {
+    constructor(project: Project, options: JunitOptions);
+}

package/lib/.types-compat/ts3.9/lib/java/maven-compile.d.ts

@@ -0,0 +1,26 @@
+import { Pom } from "./pom";
+import { Component } from "../component";
+import { Project } from "../project";
+/**
+ * Options for `MavenCompile`.
+ */
+export interface MavenCompileOptions {
+    /**
+     * Source language version.
+     *
+     * @default "1.8"
+     */
+    readonly source?: string;
+    /**
+     * Target JVM version.
+     *
+     * @default "1.8"
+     */
+    readonly target?: string;
+}
+/**
+ * Adds the maven-compiler plugin to a POM file and the `compile` task.
+ */
+export declare class MavenCompile extends Component {
+    constructor(project: Project, pom: Pom, options?: MavenCompileOptions);
+}

package/lib/.types-compat/ts3.9/lib/java/maven-packaging.d.ts

@@ -0,0 +1,34 @@
+import { Pom } from "./pom";
+import { Component } from "../component";
+import { Project } from "../project";
+/**
+ * Options for `MavenPackage`.
+ */
+export interface MavenPackagingOptions {
+    /**
+     * Include sources jar in package.
+     * @default true
+     */
+    readonly sources?: boolean;
+    /**
+     * Where to place the package output?
+     * @default "dist/java"
+     */
+    readonly distdir?: string;
+    /**
+     * Include javadocs jar in package.
+     * @default true
+     */
+    readonly javadocs?: boolean;
+    /**
+     * Exclude source files from docs.
+     * @default []
+     */
+    readonly javadocsExclude?: string[];
+}
+/**
+ * Configures a maven project to produce a .jar archive with sources and javadocs.
+ */
+export declare class MavenPackaging extends Component {
+    constructor(project: Project, pom: Pom, options?: MavenPackagingOptions);
+}

package/lib/.types-compat/ts3.9/lib/java/maven-sample.d.ts

@@ -0,0 +1,14 @@
+import { Component } from "../component";
+import { Project } from "../project";
+export interface MavenSampleOptions {
+    /**
+     * Project root java package.
+     */
+    readonly package: string;
+}
+/**
+ * Java code sample.
+ */
+export declare class MavenSample extends Component {
+    constructor(project: Project, options: MavenSampleOptions);
+}

package/lib/.types-compat/ts3.9/lib/java/pom.d.ts

@@ -0,0 +1,214 @@
+import { Component } from "../component";
+import { Project } from "../project";
+/**
+ * Options for `Pom`.
+ */
+export interface PomOptions {
+    /**
+     * This is generally unique amongst an organization or a project. For example,
+     * all core Maven artifacts do (well, should) live under the groupId
+     * org.apache.maven. Group ID's do not necessarily use the dot notation, for
+     * example, the junit project. Note that the dot-notated groupId does not have
+     * to correspond to the package structure that the project contains. It is,
+     * however, a good practice to follow. When stored within a repository, the
+     * group acts much like the Java packaging structure does in an operating
+     * system. The dots are replaced by OS specific directory separators (such as
+     * '/' in Unix) which becomes a relative directory structure from the base
+     * repository. In the example given, the org.codehaus.mojo group lives within
+     * the directory $M2_REPO/org/codehaus/mojo.
+     * @default "org.acme"
+     * @featured
+     */
+    readonly groupId: string;
+    /**
+     * The artifactId is generally the name that the project is known by. Although
+     * the groupId is important, people within the group will rarely mention the
+     * groupId in discussion (they are often all be the same ID, such as the
+     * MojoHaus project groupId: org.codehaus.mojo). It, along with the groupId,
+     * creates a key that separates this project from every other project in the
+     * world (at least, it should :) ). Along with the groupId, the artifactId
+     * fully defines the artifact's living quarters within the repository. In the
+     * case of the above project, my-project lives in
+     * $M2_REPO/org/codehaus/mojo/my-project.
+     * @default "my-app"
+     * @featured
+     */
+    readonly artifactId: string;
+    /**
+     * This is the last piece of the naming puzzle. groupId:artifactId denotes a
+     * single project but they cannot delineate which incarnation of that project
+     * we are talking about. Do we want the junit:junit of 2018 (version 4.12), or
+     * of 2007 (version 3.8.2)? In short: code changes, those changes should be
+     * versioned, and this element keeps those versions in line. It is also used
+     * within an artifact's repository to separate versions from each other.
+     * my-project version 1.0 files live in the directory structure
+     * $M2_REPO/org/codehaus/mojo/my-project/1.0.
+     * @default "0.1.0"
+     * @featured
+     */
+    readonly version: string;
+    /**
+     * Project packaging format.
+     *
+     * @default "jar"
+     */
+    readonly packaging?: string;
+    /**
+     * Description of a project is always good. Although this should not replace
+     * formal documentation, a quick comment to any readers of the POM is always
+     * helpful.
+     *
+     * @default undefined
+     * @featured
+     */
+    readonly description?: string;
+    /**
+     * The URL, like the name, is not required. This is a nice gesture for
+     * projects users, however, so that they know where the project lives.
+     *
+     * @default undefined
+     * @featured
+     */
+    readonly url?: string;
+}
+/**
+ * Represents a Maven repository
+ * @see https://maven.apache.org/guides/introduction/introduction-to-repositories.html
+ */
+export interface MavenRepository {
+    /**
+     * The identifier for the repository
+     */
+    readonly id: string;
+    /**
+     * The url of the repository
+     */
+    readonly url: string;
+    /**
+     * The name of the repository
+     */
+    readonly name?: string;
+    /**
+     * The layout of the repository
+     */
+    readonly layout?: string;
+}
+/**
+ * A Project Object Model or POM is the fundamental unit of work in Maven. It is
+ * an XML file that contains information about the project and configuration
+ * details used by Maven to build the project.
+ */
+export declare class Pom extends Component {
+    /**
+     * The name of the pom file.
+     */
+    readonly fileName: string;
+    /**
+     * Maven group ID.
+     */
+    readonly groupId: string;
+    /**
+     * Maven artifact ID.
+     */
+    readonly artifactId: string;
+    /**
+     * Project version.
+     */
+    readonly version: string;
+    /**
+     * Maven packaging format.
+     */
+    readonly packaging: string;
+    /**
+     * Project display name.
+     */
+    readonly name?: string;
+    /**
+     * Project description.
+     */
+    readonly description?: string;
+    /**
+     * Project URL.
+     */
+    readonly url?: string;
+    private readonly properties;
+    private readonly repositories;
+    constructor(project: Project, options: PomOptions);
+    /**
+     * Adds a key/value property to the pom.
+     * @param key the key
+     * @param value the value
+     */
+    addProperty(key: string, value: string): void;
+    /**
+     * Adds a runtime dependency.
+     *
+     * @param spec Format `<groupId>/<artifactId>@<semver>`
+     */
+    addDependency(spec: string): void;
+    /**
+     * Adds a test dependency.
+     *
+     * @param spec Format `<groupId>/<artifactId>@<semver>`
+     */
+    addTestDependency(spec: string): void;
+    /**
+     * Adds a build plugin to the pom.
+     *
+     * The plug in is also added as a BUILD dep to the project.
+     *
+     * @param spec dependency spec (`group/artifact@version`)
+     * @param options plugin options
+     */
+    addPlugin(spec: string, options?: PluginOptions): import("../dependencies").Dependency;
+    /**
+     * Adds a repository to the pom
+     * @param repository the repository to add
+     */
+    addRepository(repository: MavenRepository): void;
+    private synthPom;
+    private synthDependencies;
+    private synthRepositories;
+}
+/**
+ * Options for Maven plugins.
+ */
+export interface PluginOptions {
+    /**
+     * Plugin key/value configuration
+     * @default {}
+     */
+    readonly configuration?: {
+        [key: string]: any;
+    };
+    /**
+     * Plugin executions
+     * @default []
+     */
+    readonly executions?: PluginExecution[];
+    /**
+     * You could configure the dependencies for the plugin.
+     *
+     * Dependencies are in `<groupId>/<artifactId>@<semver>` format.
+     *
+     * @default []
+     */
+    readonly dependencies?: string[];
+}
+/**
+ * Plugin execution definition.
+ */
+export interface PluginExecution {
+    /**
+     * The ID.
+     */
+    readonly id: string;
+    /**
+     * Which Maven goals this plugin should be associated with.
+     */
+    readonly goals: string[];
+    /**
+     * The phase in which the plugin should execute.
+     */
+    readonly phase?: string;
+}

package/lib/.types-compat/ts3.9/lib/java/projenrc.d.ts

@@ -0,0 +1,59 @@
+import { Pom } from "./pom";
+import { ProjectOption } from "../inventory";
+import { Project } from "../project";
+import { ProjenrcFile } from "../projenrc";
+/**
+ * Options for `Projenrc`.
+ */
+export interface ProjenrcOptions {
+    /**
+     * The name of the Java class which contains the `main()` method for projen.
+     * @default "projenrc"
+     */
+    readonly className?: string;
+    /**
+     * The projen version to use
+     * @default - current version
+     */
+    readonly projenVersion?: string;
+    /**
+     * Defines projenrc under the test scope instead of the main scope, which is
+     * reserved to the app. This means that projenrc will be under
+     * `src/test/java/projenrc.java` and projen will be defined as a test
+     * dependency. This enforces that application code does not take a dependency
+     * on projen code.
+     *
+     * If this is disabled, projenrc should be under
+     * `src/main/java/projenrc.java`.
+     *
+     * @default true
+     */
+    readonly testScope?: boolean;
+}
+/**
+ * Allows writing projenrc files in java.
+ *
+ * This will install `org.projen/projen` as a Maven dependency and will add a
+ * `synth` task which will compile & execute `main()` from
+ * `src/main/java/projenrc.java`.
+ */
+export declare class Projenrc extends ProjenrcFile {
+    /**
+     * The name of the java class that includes the projen entrypoint.
+     */
+    readonly className: string;
+    /**
+     * Whether the class is in the "test" or "main" scope?
+     */
+    private readonly testScope;
+    constructor(project: Project, pom: Pom, options?: ProjenrcOptions);
+    private get javaClass();
+    private get javaPackage();
+    /**
+     * The path of the projenrc file.
+     */
+    get filePath(): string;
+    private generateProjenrc;
+}
+export declare function generateJavaOptionNames(options: ProjectOption[], jsiiManifest: any): Record<string, string>;
+export declare function getJavaImport(jsiiType: any, jsiiManifest: any): string;

package/lib/.types-compat/ts3.9/lib/javascript/bundler.d.ts

@@ -0,0 +1,174 @@
+import { Component } from "../component";
+import { Project } from "../project";
+import { Task } from "../task";
+/**
+ * Options for `Bundler`.
+ */
+export interface BundlerOptions {
+    /**
+     * The semantic version requirement for `esbuild`.
+     *
+     * @default - no specific version (implies latest)
+     */
+    readonly esbuildVersion?: string;
+    /**
+     * Output directory for all bundles.
+     * @default "assets"
+     */
+    readonly assetsDir?: string;
+    /**
+     * Install the `bundle` command as a pre-compile phase.
+     *
+     * @default true
+     */
+    readonly addToPreCompile?: boolean;
+    /**
+     * Map of file extensions (without dot) and loaders to use for this file type.
+     * Loaders are appended to the esbuild command by `--loader:.extension=loader`
+     */
+    readonly loaders?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Adds support for bundling JavaScript applications and dependencies into a
+ * single file. In the future, this will also supports bundling websites.
+ */
+export declare class Bundler extends Component {
+    /**
+     * Returns the `Bundler` instance associated with a project or `undefined` if
+     * there is no Bundler.
+     * @param project The project
+     * @returns A bundler
+     */
+    static of(project: Project): Bundler | undefined;
+    /**
+     * The semantic version requirement for `esbuild` (if defined).
+     */
+    readonly esbuildVersion: string | undefined;
+    /**
+     * Root bundle directory.
+     */
+    readonly bundledir: string;
+    private _task;
+    private readonly addToPreCompile;
+    private readonly loaders?;
+    /**
+     * Creates a `Bundler`.
+     */
+    constructor(project: Project, options?: BundlerOptions);
+    /**
+     * Gets or creates the singleton "bundle" task of the project.
+     *
+     * If the project doesn't have a "bundle" task, it will be created and spawned
+     * during the pre-compile phase.
+     */
+    get bundleTask(): Task;
+    /**
+     * Adds a task to the project which bundles a specific entrypoint and all of
+     * its dependencies into a single javascript output file.
+     *
+     * @param entrypoint The relative path of the artifact within the project
+     * @param options Bundling options
+     */
+    addBundle(entrypoint: string, options: AddBundleOptions): Bundle;
+    /**
+     * Add bundling support to a project. This is called implicitly when
+     * `bundleTask` is referenced first. It adds the dependency on `esbuild`,
+     * gitignore/npmignore, etc.
+     */
+    private addBundlingSupport;
+}
+export interface Bundle {
+    /**
+     * The task that produces this bundle.
+     */
+    readonly bundleTask: Task;
+    /**
+     * The "watch" task for this bundle.
+     */
+    readonly watchTask?: Task;
+    /**
+     * Location of the output file (relative to project root).
+     */
+    readonly outfile: string;
+    /**
+     * Base directory containing the output file (relative to project root).
+     */
+    readonly outdir: string;
+}
+/**
+ * Options for bundling.
+ */
+export interface BundlingOptions {
+    /**
+     * You can mark a file or a package as external to exclude it from your build.
+     * Instead of being bundled, the import will be preserved (using require for
+     * the iife and cjs formats and using import for the esm format) and will be
+     * evaluated at run time instead.
+     *
+     * This has several uses. First of all, it can be used to trim unnecessary
+     * code from your bundle for a code path that you know will never be executed.
+     * For example, a package may contain code that only runs in node but you will
+     * only be using that package in the browser. It can also be used to import
+     * code in node at run time from a package that cannot be bundled. For
+     * example, the fsevents package contains a native extension, which esbuild
+     * doesn't support.
+     *
+     * @default []
+     */
+    readonly externals?: string[];
+    /**
+     * Include a source map in the bundle.
+     *
+     * @default false
+     */
+    readonly sourcemap?: boolean;
+    /**
+     * In addition to the `bundle:xyz` task, creates `bundle:xyz:watch` task which will
+     * invoke the same esbuild command with the `--watch` flag. This can be used
+     * to continusouly watch for changes.
+     *
+     * @default true
+     */
+    readonly watchTask?: boolean;
+}
+/**
+ * Options for `addBundle()`.
+ */
+export interface AddBundleOptions extends BundlingOptions {
+    /**
+     * esbuild target.
+     *
+     * @example "node12"
+     */
+    readonly target: string;
+    /**
+     * esbuild platform.
+     *
+     * @example "node"
+     */
+    readonly platform: string;
+    /**
+     * Bundler output path relative to the asset's output directory.
+     * @default "index.js"
+     */
+    readonly outfile?: string;
+    /**
+     * Mark the output file as executable.
+     * @default false
+     */
+    readonly executable?: boolean;
+    /**
+     * The path of the tsconfig.json file to use for bundling
+     * @default "tsconfig.json"
+     */
+    readonly tsconfigPath?: string;
+    /**
+     * Map of file extensions (without dot) and loaders to use for this file type.
+     * Loaders are appended to the esbuild command by `--loader:.extension=loader`
+     */
+    readonly loaders?: {
+        [key: string]: string;
+    };
+}