@mrgrain/cdk-esbuild 4.0.0-alpha.7 → 4.0.0-beta.0

package/lib/private/esbuild-source.js

@@ -0,0 +1,59 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EsbuildSource = exports.Esbuild = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const dynamic_package_1 = require("./dynamic-package");
+const dynamicEsbuild = new dynamic_package_1.DynamicPackage('esbuild@^0.16.0');
+exports.Esbuild = {
+    name: dynamicEsbuild.name,
+    version: dynamicEsbuild.version,
+    spec: dynamicEsbuild.spec,
+};
+class EsbuildSource {
+    constructor() { }
+    /**
+     * `EsbuildSource.nodeJs()` for NodeJs, `EsbuildSource.auto()` for all other languages
+     */
+    static platformDefault() {
+        if (Boolean(process.env.JSII_AGENT)) {
+            return this.auto();
+        }
+        return this.nodeJs();
+    }
+    /**
+     * Try to find the module in most common paths.
+     */
+    static anywhere() {
+        return this.dynamicPackage.findInPaths();
+    }
+    /**
+     * Try to find the module in common global installation paths.
+     */
+    static globalPaths() {
+        return this.dynamicPackage.findInGlobalPaths();
+    }
+    /**
+     * Require module by name, do not attempt to find it anywhere else.
+     */
+    static nodeJs() {
+        return this.dynamicPackage.nodeJs();
+    }
+    /**
+     * Install the module to a temporary location.
+     */
+    static install() {
+        return this.dynamicPackage.install();
+    }
+    /**
+     * First try to find to module, then install it to a temporary location.
+     */
+    static auto() {
+        return this.dynamicPackage.auto();
+    }
+}
+exports.EsbuildSource = EsbuildSource;
+_a = JSII_RTTI_SYMBOL_1;
+EsbuildSource[_a] = { fqn: "@mrgrain/cdk-esbuild.EsbuildSource", version: "4.0.0-beta.0" };
+EsbuildSource.dynamicPackage = dynamicEsbuild;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/utils.d.ts

@@ -0,0 +1,7 @@
+import { BuildOptions, Platform, TransformOptions } from '../esbuild-types';
+export declare function isEsbuildError(error: unknown): boolean;
+export declare function nodeMajorVersion(): number;
+export declare function defaultPlatformProps(options?: BuildOptions | TransformOptions): {
+    platform?: Platform;
+    target?: string | string[];
+};

package/lib/private/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPlatformProps = exports.nodeMajorVersion = exports.isEsbuildError = void 0;
+function isEsbuildError(error) {
+    return !!error
+        && typeof error == 'object'
+        && error != null
+        && 'errors' in error
+        && 'warnings' in error;
+}
+exports.isEsbuildError = isEsbuildError;
+function nodeMajorVersion() {
+    return parseInt(process.versions.node.split('.')[0], 10);
+}
+exports.nodeMajorVersion = nodeMajorVersion;
+function defaultPlatformProps(options) {
+    if (!options?.platform || options?.platform === 'node') {
+        return { platform: 'node', target: 'node' + nodeMajorVersion() };
+    }
+    return {};
+}
+exports.defaultPlatformProps = defaultPlatformProps;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSxTQUFnQixjQUFjLENBQUMsS0FBYztJQUMzQyxPQUFPLENBQUMsQ0FBQyxLQUFLO1dBQ1gsT0FBTyxLQUFLLElBQUksUUFBUTtXQUN4QixLQUFLLElBQUksSUFBSTtXQUNiLFFBQVEsSUFBSSxLQUFLO1dBQ2pCLFVBQVUsSUFBSSxLQUFLLENBQUM7QUFDekIsQ0FBQztBQU5ELHdDQU1DO0FBRUQsU0FBZ0IsZ0JBQWdCO0lBQzlCLE9BQU8sUUFBUSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztBQUMzRCxDQUFDO0FBRkQsNENBRUM7QUFFRCxTQUFnQixvQkFBb0IsQ0FBQyxPQUF5QztJQUk1RSxJQUFJLENBQUMsT0FBTyxFQUFFLFFBQVEsSUFBSSxPQUFPLEVBQUUsUUFBUSxLQUFLLE1BQU0sRUFBRTtRQUN0RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxHQUFHLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztLQUNsRTtJQUVELE9BQU8sRUFBRSxDQUFDO0FBQ1osQ0FBQztBQVRELG9EQVNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQnVpbGRPcHRpb25zLCBQbGF0Zm9ybSwgVHJhbnNmb3JtT3B0aW9ucyB9IGZyb20gJy4uL2VzYnVpbGQtdHlwZXMnO1xuXG5leHBvcnQgZnVuY3Rpb24gaXNFc2J1aWxkRXJyb3IoZXJyb3I6IHVua25vd24pOiBib29sZWFuIHtcbiAgcmV0dXJuICEhZXJyb3JcbiAgJiYgdHlwZW9mIGVycm9yID09ICdvYmplY3QnXG4gICYmIGVycm9yICE9IG51bGxcbiAgJiYgJ2Vycm9ycycgaW4gZXJyb3JcbiAgJiYgJ3dhcm5pbmdzJyBpbiBlcnJvcjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIG5vZGVNYWpvclZlcnNpb24oKTogbnVtYmVyIHtcbiAgcmV0dXJuIHBhcnNlSW50KHByb2Nlc3MudmVyc2lvbnMubm9kZS5zcGxpdCgnLicpWzBdLCAxMCk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBkZWZhdWx0UGxhdGZvcm1Qcm9wcyhvcHRpb25zPzogQnVpbGRPcHRpb25zIHwgVHJhbnNmb3JtT3B0aW9ucyk6IHtcbiAgcGxhdGZvcm0/OiBQbGF0Zm9ybTtcbiAgdGFyZ2V0Pzogc3RyaW5nIHwgc3RyaW5nW107XG59IHtcbiAgaWYgKCFvcHRpb25zPy5wbGF0Zm9ybSB8fCBvcHRpb25zPy5wbGF0Zm9ybSA9PT0gJ25vZGUnKSB7XG4gICAgcmV0dXJuIHsgcGxhdGZvcm06ICdub2RlJywgdGFyZ2V0OiAnbm9kZScgKyBub2RlTWFqb3JWZXJzaW9uKCkgfTtcbiAgfVxuXG4gIHJldHVybiB7fTtcbn1cbiJdfQ==

package/lib/provider.d.ts

@@ -0,0 +1,129 @@
+import { BuildOptions, TransformOptions } from './esbuild-types';
+export { EsbuildSource } from './private/esbuild-source';
+export interface ProviderBuildOptions extends BuildOptions {
+    /** Documentation: https://esbuild.github.io/api/#entry-points */
+    readonly entryPoints?: string[] | Record<string, string>;
+}
+export interface ProviderTransformOptions extends TransformOptions {
+}
+/**
+ * Provides an implementation of the esbuild Build API
+ */
+export interface IBuildProvider {
+    /**
+     * A method implementing the code build.
+     *
+     * During synth time, the method will receive all computed `BuildOptions` from the bundler.
+     *
+     * It MUST implement any output options to integrate correctly and MAY use any other options.
+     * On failure, it SHOULD print any warnings & errors to stderr and throw a `BuildFailure` to inform the bundler.
+     *
+     * @throws `esbuild.BuildFailure`
+     */
+    buildSync(options: ProviderBuildOptions): void;
+}
+/**
+ * Provides an implementation of the esbuild Transform API
+ */
+export interface ITransformProvider {
+    /**
+     * A method implementing the inline code transformation.
+     *
+     * During synth time, the method will receive the inline code and all computed `TransformOptions` from the bundler.
+     *
+     * MUST return the transformed code as a string to integrate correctly.
+     * It MAY use these options to do so.
+     * On failure, it SHOULD print any warnings & errors to stderr and throw a `TransformFailure` to inform the bundler.
+     *
+     * @throws `esbuild.TransformFailure`
+     */
+    transformSync(input: string, options?: ProviderTransformOptions): string;
+}
+/**
+ * Provides an implementation of the esbuild Build & Transform API
+ */
+export interface IEsbuildProvider extends IBuildProvider, ITransformProvider {
+}
+/**
+ * Configure the default EsbuildProvider
+ */
+export interface EsbuildProviderProps {
+    /**
+     * Path to the binary used by esbuild.
+     *
+     * This is the same as setting the ESBUILD_BINARY_PATH environment variable.
+     *
+     * @stability stable
+     */
+    readonly esbuildBinaryPath?: string;
+    /**
+     * Absolute path to the esbuild module JS file.
+     *
+     * E.g. "/home/user/.npm/node_modules/esbuild/lib/main.js"
+     *
+     * If not set, the module path will be determined in the following order:
+     *
+     * - Use a path from the `CDK_ESBUILD_MODULE_PATH` environment variable
+     * - In TypeScript, fallback to the default Node.js package resolution mechanism
+     * - All other languages (Python, Go, .NET, Java) use an automatic "best effort" resolution mechanism. \
+     *   The exact algorithm of this mechanism is considered an implementation detail and should not be relied on.
+     *   If `esbuild` cannot be found, it might be installed dynamically to a temporary location.
+     *   To opt-out of this behavior, set either `esbuildModulePath` or `CDK_ESBUILD_MODULE_PATH` env variable.
+     *
+     * Use the static methods on `EsbuildSource` to customize the default behavior.
+     *
+     * @stability stable
+     * @default - `CDK_ESBUILD_MODULE_PATH` or package resolution (see description)
+     */
+    readonly esbuildModulePath?: string;
+}
+/**
+ * Default esbuild implementation calling esbuild's JavaScript API.
+ */
+export declare class EsbuildProvider implements IBuildProvider, ITransformProvider {
+    private static _fallbackProvider;
+    private static _buildProvider;
+    private static _transformationProvider;
+    /**
+     * Set the default implementation for both Build and Transformation API
+     */
+    static overrideDefaultProvider(provider: IEsbuildProvider): void;
+    /**
+     * Set the default implementation for the Build API
+     */
+    static overrideDefaultBuildProvider(provider: IBuildProvider): void;
+    /**
+     * Get the default implementation for the Build API
+     */
+    static defaultBuildProvider(): IBuildProvider;
+    /**
+     * Set the default implementation for the Transformation API
+     */
+    static overrideDefaultTransformationProvider(provider: ITransformProvider): void;
+    /**
+     * Get the default implementation for the Transformation API
+     */
+    static defaultTransformationProvider(): ITransformProvider;
+    private readonly esbuildBinaryPath?;
+    private readonly esbuildModulePath?;
+    constructor(props?: EsbuildProviderProps);
+    buildSync(options: ProviderBuildOptions): void;
+    transformSync(input: string, options?: ProviderTransformOptions): string;
+    /**
+     * Invoke a function with a specific `process.env.ESBUILD_BINARY_PATH`
+     * and restore the env var afterwards.
+     */
+    private withEsbuildBinaryPath;
+    /**
+     * Load the esbuild module according to defined rules.
+     */
+    private require;
+    /**
+     * Wrapper for require
+     */
+    private _require;
+    /**
+     * Resolve a token without context
+     */
+    private resolve;
+}

package/lib/provider.js

@@ -0,0 +1,115 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EsbuildProvider = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const esbuild_source_1 = require("./private/esbuild-source");
+var esbuild_source_2 = require("./private/esbuild-source");
+Object.defineProperty(exports, "EsbuildSource", { enumerable: true, get: function () { return esbuild_source_2.EsbuildSource; } });
+/**
+ * Default esbuild implementation calling esbuild's JavaScript API.
+ */
+class EsbuildProvider {
+    constructor(props = {}) {
+        this.esbuildBinaryPath = props.esbuildBinaryPath;
+        this.esbuildModulePath = props.esbuildModulePath;
+    }
+    /**
+     * Set the default implementation for both Build and Transformation API
+     */
+    static overrideDefaultProvider(provider) {
+        this.overrideDefaultBuildProvider(provider);
+        this.overrideDefaultTransformationProvider(provider);
+    }
+    /**
+     * Set the default implementation for the Build API
+     */
+    static overrideDefaultBuildProvider(provider) {
+        this._buildProvider = provider;
+    }
+    /**
+     * Get the default implementation for the Build API
+     */
+    static defaultBuildProvider() {
+        return this._buildProvider ?? this._fallbackProvider;
+    }
+    /**
+     * Set the default implementation for the Transformation API
+     */
+    static overrideDefaultTransformationProvider(provider) {
+        this._transformationProvider = provider;
+    }
+    /**
+     * Get the default implementation for the Transformation API
+     */
+    static defaultTransformationProvider() {
+        return this._transformationProvider ?? this._fallbackProvider;
+    }
+    buildSync(options) {
+        const esbuild = this.require(this.esbuildModulePath);
+        const buildFn = this.withEsbuildBinaryPath(esbuild.buildSync, this.esbuildBinaryPath);
+        buildFn(options);
+    }
+    transformSync(input, options) {
+        const esbuild = this.require(this.esbuildModulePath);
+        const transformFn = this.withEsbuildBinaryPath(esbuild.transformSync, this.esbuildBinaryPath);
+        return transformFn(input, options).code;
+    }
+    /**
+     * Invoke a function with a specific `process.env.ESBUILD_BINARY_PATH`
+     * and restore the env var afterwards.
+     */
+    withEsbuildBinaryPath(fn, esbuildBinaryPath) {
+        if (!esbuildBinaryPath) {
+            return fn;
+        }
+        return (...args) => {
+            const originalEsbuildBinaryPath = process.env.ESBUILD_BINARY_PATH;
+            if (esbuildBinaryPath) {
+                process.env.ESBUILD_BINARY_PATH = esbuildBinaryPath;
+            }
+            const result = fn(...args);
+            /**
+             * only reset `ESBUILD_BINARY_PATH` if it was explicitly set via the construct props
+             * since `esbuild` itself sometimes sets it (eg. when running in yarn 2 plug&play)
+             */
+            if (esbuildBinaryPath) {
+                process.env.ESBUILD_BINARY_PATH = originalEsbuildBinaryPath;
+            }
+            return result;
+        };
+    }
+    /**
+     * Load the esbuild module according to defined rules.
+     */
+    require(path) {
+        const module = path || process.env.CDK_ESBUILD_MODULE_PATH || esbuild_source_1.EsbuildSource.platformDefault() || esbuild_source_1.Esbuild.name;
+        return this._require(this.resolve(module));
+    }
+    /**
+     * Wrapper for require
+     */
+    _require(path) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require(path);
+    }
+    /**
+     * Resolve a token without context
+     */
+    resolve(token) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(token)) {
+            return token;
+        }
+        return aws_cdk_lib_1.Tokenization.resolve(token, {
+            scope: new constructs_1.Construct(undefined, ''),
+            resolver: new aws_cdk_lib_1.DefaultTokenResolver(new aws_cdk_lib_1.StringConcat()),
+        });
+    }
+}
+exports.EsbuildProvider = EsbuildProvider;
+_a = JSII_RTTI_SYMBOL_1;
+EsbuildProvider[_a] = { fqn: "@mrgrain/cdk-esbuild.EsbuildProvider", version: "4.0.0-beta.0" };
+EsbuildProvider._fallbackProvider = new EsbuildProvider();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { DefaultTokenResolver, StringConcat, Token, Tokenization } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { BuildOptions, TransformOptions } from './esbuild-types';\nimport { Esbuild, EsbuildSource } from './private/esbuild-source';\n\nexport { EsbuildSource } from './private/esbuild-source';\n\n\nexport interface ProviderBuildOptions extends BuildOptions {\n  /** Documentation: https://esbuild.github.io/api/#entry-points */\n  readonly entryPoints?: string[] | Record<string, string>;\n}\n\nexport interface ProviderTransformOptions extends TransformOptions {}\n\n\n/**\n * Provides an implementation of the esbuild Build API\n */\nexport interface IBuildProvider {\n  /**\n   * A method implementing the code build.\n   *\n   * During synth time, the method will receive all computed `BuildOptions` from the bundler.\n   *\n   * It MUST implement any output options to integrate correctly and MAY use any other options.\n   * On failure, it SHOULD print any warnings & errors to stderr and throw a `BuildFailure` to inform the bundler.\n   *\n   * @throws `esbuild.BuildFailure`\n   */\n  buildSync(options: ProviderBuildOptions): void;\n}\n\n/**\n * Provides an implementation of the esbuild Transform API\n */\nexport interface ITransformProvider {\n  /**\n   * A method implementing the inline code transformation.\n   *\n   * During synth time, the method will receive the inline code and all computed `TransformOptions` from the bundler.\n   *\n   * MUST return the transformed code as a string to integrate correctly.\n   * It MAY use these options to do so.\n   * On failure, it SHOULD print any warnings & errors to stderr and throw a `TransformFailure` to inform the bundler.\n   *\n   * @throws `esbuild.TransformFailure`\n   */\n  transformSync(input: string, options?: ProviderTransformOptions): string;\n}\n\n/**\n * Provides an implementation of the esbuild Build & Transform API\n */\nexport interface IEsbuildProvider extends IBuildProvider, ITransformProvider {}\n\n/**\n * Configure the default EsbuildProvider\n */\nexport interface EsbuildProviderProps {\n  /**\n   * Path to the binary used by esbuild.\n   *\n   * This is the same as setting the ESBUILD_BINARY_PATH environment variable.\n   *\n   * @stability stable\n   */\n  readonly esbuildBinaryPath?: string;\n\n  /**\n   * Absolute path to the esbuild module JS file.\n   *\n   * E.g. \"/home/user/.npm/node_modules/esbuild/lib/main.js\"\n   *\n   * If not set, the module path will be determined in the following order:\n   *\n   * - Use a path from the `CDK_ESBUILD_MODULE_PATH` environment variable\n   * - In TypeScript, fallback to the default Node.js package resolution mechanism\n   * - All other languages (Python, Go, .NET, Java) use an automatic \"best effort\" resolution mechanism. \\\n   *   The exact algorithm of this mechanism is considered an implementation detail and should not be relied on.\n   *   If `esbuild` cannot be found, it might be installed dynamically to a temporary location.\n   *   To opt-out of this behavior, set either `esbuildModulePath` or `CDK_ESBUILD_MODULE_PATH` env variable.\n   *\n   * Use the static methods on `EsbuildSource` to customize the default behavior.\n   *\n   * @stability stable\n   * @default - `CDK_ESBUILD_MODULE_PATH` or package resolution (see description)\n   */\n  readonly esbuildModulePath?: string;\n}\n\n/**\n * Default esbuild implementation calling esbuild's JavaScript API.\n */\nexport class EsbuildProvider implements IBuildProvider, ITransformProvider {\n  private static _fallbackProvider = new EsbuildProvider();\n  private static _buildProvider: IBuildProvider;\n  private static _transformationProvider: ITransformProvider;\n\n  /**\n   * Set the default implementation for both Build and Transformation API\n   */\n  public static overrideDefaultProvider(provider: IEsbuildProvider) {\n    this.overrideDefaultBuildProvider(provider);\n    this.overrideDefaultTransformationProvider(provider);\n  }\n\n  /**\n   * Set the default implementation for the Build API\n   */\n  public static overrideDefaultBuildProvider(provider: IBuildProvider) {\n    this._buildProvider = provider;\n  }\n\n  /**\n   * Get the default implementation for the Build API\n   */\n  public static defaultBuildProvider(): IBuildProvider {\n    return this._buildProvider ?? this._fallbackProvider;\n  }\n\n  /**\n   * Set the default implementation for the Transformation API\n   */\n  public static overrideDefaultTransformationProvider(provider: ITransformProvider) {\n    this._transformationProvider = provider;\n  }\n\n  /**\n   * Get the default implementation for the Transformation API\n   */\n  public static defaultTransformationProvider(): ITransformProvider {\n    return this._transformationProvider ?? this._fallbackProvider;\n  }\n\n  private readonly esbuildBinaryPath?: string;\n  private readonly esbuildModulePath?: string;\n\n  public constructor(props: EsbuildProviderProps = {}) {\n    this.esbuildBinaryPath = props.esbuildBinaryPath;\n    this.esbuildModulePath = props.esbuildModulePath;\n  }\n\n  public buildSync(options: ProviderBuildOptions): void {\n    const esbuild = this.require(this.esbuildModulePath);\n    const buildFn = this.withEsbuildBinaryPath(esbuild.buildSync, this.esbuildBinaryPath);\n\n    buildFn(options);\n  }\n\n  public transformSync(input: string, options?: ProviderTransformOptions): string {\n    const esbuild = this.require(this.esbuildModulePath);\n    const transformFn = this.withEsbuildBinaryPath(esbuild.transformSync, this.esbuildBinaryPath);\n\n    return transformFn(input, options).code;\n  }\n\n  /**\n   * Invoke a function with a specific `process.env.ESBUILD_BINARY_PATH`\n   * and restore the env var afterwards.\n   */\n  private withEsbuildBinaryPath<T extends CallableFunction>(fn: T, esbuildBinaryPath?: string) {\n    if (!esbuildBinaryPath) {\n      return fn;\n    }\n\n    return (...args: unknown[]) => {\n      const originalEsbuildBinaryPath = process.env.ESBUILD_BINARY_PATH;\n      if (esbuildBinaryPath) {\n        process.env.ESBUILD_BINARY_PATH = esbuildBinaryPath;\n      }\n\n      const result = fn(...args);\n\n      /**\n       * only reset `ESBUILD_BINARY_PATH` if it was explicitly set via the construct props\n       * since `esbuild` itself sometimes sets it (eg. when running in yarn 2 plug&play)\n       */\n      if (esbuildBinaryPath) {\n        process.env.ESBUILD_BINARY_PATH = originalEsbuildBinaryPath;\n      }\n\n      return result;\n    };\n  }\n\n  /**\n   * Load the esbuild module according to defined rules.\n   */\n  private require(path?: string): IBuildProvider & ITransformProvider {\n    const module = path || process.env.CDK_ESBUILD_MODULE_PATH || EsbuildSource.platformDefault() || Esbuild.name;\n\n    return this._require(this.resolve(module));\n  }\n\n  /**\n   * Wrapper for require\n   */\n  private _require(path: string): IBuildProvider & ITransformProvider {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    return require(path);\n  }\n\n  /**\n   * Resolve a token without context\n   */\n  private resolve(token: string): string {\n    if (!Token.isUnresolved(token)) {\n      return token;\n    }\n\n    return Tokenization.resolve(token, {\n      scope: new Construct(undefined as any, ''),\n      resolver: new DefaultTokenResolver(new StringConcat()),\n    });\n  }\n}\n"]}

package/lib/source.d.ts

@@ -10,20 +10,96 @@ declare abstract class Source<Props extends JavaScriptSourceProps | TypeScriptSo
     protected readonly abstract assetClass: new (scope: Construct, id: string, props: AssetProps) => Asset;
     protected props: AssetProps;
     protected asset: Asset;
+    constructor(
     /**
+     * A path or list or map of paths to the entry points of your code.
      *
-     * @param entryPoints - Relative path to the source code. Use `props.buildOptions.absWorkingDir` if an absolute path is required.
-     * @param props - Source properties.
+     * Relative paths are by default resolved from the current working directory.
+     * To change the working directory, see `buildOptions.absWorkingDir`.
+     *
+     * Absolute paths can be used if files are part of the working directory.
+     *
+     * Examples:
+     *  - `'src/index.ts'`
+     *  - `require.resolve('./lambda')`
+     *  - `['src/index.ts', 'src/util.ts']`
+     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`
+     *
+     * @stability stable
+     */
+    entryPoints: EntryPoints, 
+    /**
+     * Props to change the behavior of the bundler.
+     *
+     * Default values for `props.buildOptions`:
+     * - `bundle=true`
+     * - `platform=browser`
+     *
+     * @stability stable
      */
-    constructor(entryPoints: EntryPoints, props: Props);
+    props: Props);
     bind(scope: Construct, context?: DeploymentSourceContext): SourceConfig;
 }
 export declare class JavaScriptSource extends Source<JavaScriptSourceProps, JavaScriptAsset> {
     assetClass: typeof JavaScriptAsset;
-    constructor(entryPoints: EntryPoints, props?: JavaScriptSourceProps);
+    constructor(
+    /**
+     * A path or list or map of paths to the entry points of your code.
+     *
+     * Relative paths are by default resolved from the current working directory.
+     * To change the working directory, see `buildOptions.absWorkingDir`.
+     *
+     * Absolute paths can be used if files are part of the working directory.
+     *
+     * Examples:
+     *  - `'src/index.ts'`
+     *  - `require.resolve('./lambda')`
+     *  - `['src/index.ts', 'src/util.ts']`
+     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`
+     *
+     * @stability stable
+     */
+    entryPoints: EntryPoints, 
+    /**
+      * Props to change the behavior of the bundler.
+      *
+      * Default values for `props.buildOptions`:
+      * - `bundle=true`
+      * - `platform=browser`
+      *
+      * @stability stable
+      */
+    props?: JavaScriptSourceProps);
 }
 export declare class TypeScriptSource extends Source<TypeScriptSourceProps, TypeScriptAsset> {
     assetClass: typeof TypeScriptAsset;
-    constructor(entryPoints: EntryPoints, props?: TypeScriptSourceProps);
+    constructor(
+    /**
+     * A path or list or map of paths to the entry points of your code.
+     *
+     * Relative paths are by default resolved from the current working directory.
+     * To change the working directory, see `buildOptions.absWorkingDir`.
+     *
+     * Absolute paths can be used if files are part of the working directory.
+     *
+     * Examples:
+     *  - `'src/index.ts'`
+     *  - `require.resolve('./lambda')`
+     *  - `['src/index.ts', 'src/util.ts']`
+     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`
+     *
+     * @stability stable
+     */
+    entryPoints: EntryPoints, 
+    /**
+     * Props to change the behavior of the bundler.
+     *
+     * Default values for `props.buildOptions`:
+     * - `bundle=true`
+     * - `platform=browser`
+     *
+     * @stability stable
+     */
+    props?: TypeScriptSourceProps);
 }
 export {};

package/lib/source.js

@@ -8,12 +8,34 @@ const asset_1 = require("./asset");
 ;
 ;
 class Source {
+    constructor(
     /**
+     * A path or list or map of paths to the entry points of your code.
      *
-     * @param entryPoints - Relative path to the source code. Use `props.buildOptions.absWorkingDir` if an absolute path is required.
-     * @param props - Source properties.
+     * Relative paths are by default resolved from the current working directory.
+     * To change the working directory, see `buildOptions.absWorkingDir`.
+     *
+     * Absolute paths can be used if files are part of the working directory.
+     *
+     * Examples:
+     *  - `'src/index.ts'`
+     *  - `require.resolve('./lambda')`
+     *  - `['src/index.ts', 'src/util.ts']`
+     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`
+     *
+     * @stability stable
+     */
+    entryPoints, 
+    /**
+     * Props to change the behavior of the bundler.
+     *
+     * Default values for `props.buildOptions`:
+     * - `bundle=true`
+     * - `platform=browser`
+     *
+     * @stability stable
      */
-    constructor(entryPoints, props) {
+    props) {
         const defaultOptions = {
             platform: 'browser',
         };
@@ -48,21 +70,75 @@ class Source {
     }
 }
 class JavaScriptSource extends Source {
-    constructor(entryPoints, props = {}) {
+    constructor(
+    /**
+     * A path or list or map of paths to the entry points of your code.
+     *
+     * Relative paths are by default resolved from the current working directory.
+     * To change the working directory, see `buildOptions.absWorkingDir`.
+     *
+     * Absolute paths can be used if files are part of the working directory.
+     *
+     * Examples:
+     *  - `'src/index.ts'`
+     *  - `require.resolve('./lambda')`
+     *  - `['src/index.ts', 'src/util.ts']`
+     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`
+     *
+     * @stability stable
+     */
+    entryPoints, 
+    /**
+      * Props to change the behavior of the bundler.
+      *
+      * Default values for `props.buildOptions`:
+      * - `bundle=true`
+      * - `platform=browser`
+      *
+      * @stability stable
+      */
+    props = {}) {
         super(entryPoints, props);
         this.assetClass = asset_1.JavaScriptAsset;
     }
 }
 exports.JavaScriptSource = JavaScriptSource;
 _a = JSII_RTTI_SYMBOL_1;
-JavaScriptSource[_a] = { fqn: "@mrgrain/cdk-esbuild.JavaScriptSource", version: "4.0.0-alpha.7" };
+JavaScriptSource[_a] = { fqn: "@mrgrain/cdk-esbuild.JavaScriptSource", version: "4.0.0-beta.0" };
 class TypeScriptSource extends Source {
-    constructor(entryPoints, props = {}) {
+    constructor(
+    /**
+     * A path or list or map of paths to the entry points of your code.
+     *
+     * Relative paths are by default resolved from the current working directory.
+     * To change the working directory, see `buildOptions.absWorkingDir`.
+     *
+     * Absolute paths can be used if files are part of the working directory.
+     *
+     * Examples:
+     *  - `'src/index.ts'`
+     *  - `require.resolve('./lambda')`
+     *  - `['src/index.ts', 'src/util.ts']`
+     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`
+     *
+     * @stability stable
+     */
+    entryPoints, 
+    /**
+     * Props to change the behavior of the bundler.
+     *
+     * Default values for `props.buildOptions`:
+     * - `bundle=true`
+     * - `platform=browser`
+     *
+     * @stability stable
+     */
+    props = {}) {
         super(entryPoints, props);
         this.assetClass = asset_1.TypeScriptAsset;
     }
 }
 exports.TypeScriptSource = TypeScriptSource;
 _b = JSII_RTTI_SYMBOL_1;
-TypeScriptSource[_b] = { fqn: "@mrgrain/cdk-esbuild.TypeScriptSource", version: "4.0.0-alpha.7" };
-//# sourceMappingURL=data:application/json;base64,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
+TypeScriptSource[_b] = { fqn: "@mrgrain/cdk-esbuild.TypeScriptSource", version: "4.0.0-beta.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source.js","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":";;;;;AAAA,6CAAoC;AAOpC,mCAAuF;AAIxB,CAAC;AACD,CAAC;AAEhE,MAAe,MAAM;IAcnB;IACE;;;;;;;;;;;;;;;OAeG;IACH,WAAwB;IAExB;;;;;;;;OAQG;IACH,KAAY;QAEZ,MAAM,cAAc,GAA0B;YAC5C,QAAQ,EAAE,SAAS;SACpB,CAAC;QAEF,IAAI,CAAC,KAAK,GAAG;YACX,WAAW;YACX,GAAG,KAAK;YACR,YAAY,EAAE;gBACZ,GAAG,cAAc;gBACjB,GAAG,KAAK,CAAC,YAAY;aACtB;SACF,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,KAAgB,EAAE,OAAiC;QACtD,qFAAqF;QACrF,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACf,IAAI,CAAC,KAAK,GAAG,IAAI,IAAI,CAAC,UAAU,CAC9B,KAAK,EACL,IAAI,CAAC,WAAW,CAAC,IAAI,EACrB,IAAI,CAAC,KAAK,CACX,CAAC;SACH;aAAM,IAAI,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE;YACnD,MAAM,IAAI,KAAK,CACb,mDACE,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,SACvB,KAAK,GAAG,8CAA8C,CACvD,CAAC;SACH;QAED,IAAI,CAAC,OAAO,EAAE;YACZ,MAAM,IAAI,KAAK,CACb,YAAY,IAAI,CAAC,WAAW,CAAC,IAAI,4BAA4B,CAC9D,CAAC;SACH;QAED,wEAAwE;QACxE,sEAAsE;QACtE,6DAA6D;QAC7D,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAEjD,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;YACzB,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW;SACrC,CAAC;IACJ,CAAC;CACF;AAED,MAAa,gBAAiB,SAAQ,MAGrC;IAGC;IAEE;;;;;;;;;;;;;;;OAeG;IACH,WAAwB;IAExB;;;;;;;;QAQI;IACJ,QAA+B,EAAE;QAEjC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAjC5B,eAAU,GAAG,uBAAe,CAAC;IAkC7B,CAAC;;AAtCH,4CAuCC;;;AAED,MAAa,gBAAiB,SAAQ,MAGrC;IAGC;IACE;;;;;;;;;;;;;;;OAeG;IACH,WAAwB;IAExB;;;;;;;;OAQG;IACH,QAA+B,EAAE;QAEjC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAhC5B,eAAU,GAAG,uBAAe,CAAC;IAiC7B,CAAC;;AArCH,4CAsCC","sourcesContent":["import { Stack } from 'aws-cdk-lib';\nimport {\n  DeploymentSourceContext,\n  ISource,\n  SourceConfig,\n} from 'aws-cdk-lib/aws-s3-deployment';\nimport { Construct } from 'constructs';\nimport { AssetBaseProps, AssetProps, JavaScriptAsset, TypeScriptAsset } from './asset';\nimport { EntryPoints } from './bundler';\nimport { BuildOptions } from './esbuild-types';\n\nexport interface JavaScriptSourceProps extends AssetBaseProps{};\nexport interface TypeScriptSourceProps extends AssetBaseProps{};\n\nabstract class Source<\n  Props extends JavaScriptSourceProps | TypeScriptSourceProps,\n  Asset extends JavaScriptAsset | TypeScriptAsset,\n> implements ISource {\n  protected readonly abstract assetClass: new (\n    scope: Construct,\n    id: string,\n    props: AssetProps,\n  ) => Asset;\n\n  protected props: AssetProps;\n\n  protected asset!: Asset;\n\n  constructor(\n    /**\n     * A path or list or map of paths to the entry points of your code.\n     *\n     * Relative paths are by default resolved from the current working directory.\n     * To change the working directory, see `buildOptions.absWorkingDir`.\n     *\n     * Absolute paths can be used if files are part of the working directory.\n     *\n     * Examples:\n     *  - `'src/index.ts'`\n     *  - `require.resolve('./lambda')`\n     *  - `['src/index.ts', 'src/util.ts']`\n     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`\n     *\n     * @stability stable\n     */\n    entryPoints: EntryPoints,\n\n    /**\n     * Props to change the behavior of the bundler.\n     *\n     * Default values for `props.buildOptions`:\n     * - `bundle=true`\n     * - `platform=browser`\n     *\n     * @stability stable\n     */\n    props: Props,\n  ) {\n    const defaultOptions: Partial<BuildOptions> = {\n      platform: 'browser',\n    };\n\n    this.props = {\n      entryPoints,\n      ...props,\n      buildOptions: {\n        ...defaultOptions,\n        ...props.buildOptions,\n      },\n    };\n  }\n\n  bind(scope: Construct, context?: DeploymentSourceContext): SourceConfig {\n    // If the same AssetCode is used multiple times, retain only the first instantiation.\n    if (!this.asset) {\n      this.asset = new this.assetClass(\n        scope,\n        this.constructor.name,\n        this.props,\n      );\n    } else if (Stack.of(this.asset) !== Stack.of(scope)) {\n      throw new Error(\n        `Asset is already associated with another stack '${\n          Stack.of(this.asset).stackName\n        }'. ` + 'Create a new Asset instance for every stack.',\n      );\n    }\n\n    if (!context) {\n      throw new Error(\n        `To use a ${this.constructor.name}, context must be provided`,\n      );\n    }\n\n    // we give permissions on all files in the bucket since we don't want to\n    // accidentally revoke permission on old versions when deploying a new\n    // version (for example, when using Lambda traffic shifting).\n    this.asset.bucket.grantRead(context.handlerRole);\n\n    return {\n      bucket: this.asset.bucket,\n      zipObjectKey: this.asset.s3ObjectKey,\n    };\n  }\n}\n\nexport class JavaScriptSource extends Source<\nJavaScriptSourceProps,\nJavaScriptAsset\n> {\n  assetClass = JavaScriptAsset;\n\n  constructor(\n\n    /**\n     * A path or list or map of paths to the entry points of your code.\n     *\n     * Relative paths are by default resolved from the current working directory.\n     * To change the working directory, see `buildOptions.absWorkingDir`.\n     *\n     * Absolute paths can be used if files are part of the working directory.\n     *\n     * Examples:\n     *  - `'src/index.ts'`\n     *  - `require.resolve('./lambda')`\n     *  - `['src/index.ts', 'src/util.ts']`\n     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`\n     *\n     * @stability stable\n     */\n    entryPoints: EntryPoints,\n\n    /**\n      * Props to change the behavior of the bundler.\n      *\n      * Default values for `props.buildOptions`:\n      * - `bundle=true`\n      * - `platform=browser`\n      *\n      * @stability stable\n      */\n    props: JavaScriptSourceProps = {},\n  ) {\n    super(entryPoints, props);\n  }\n}\n\nexport class TypeScriptSource extends Source<\nTypeScriptSourceProps,\nTypeScriptAsset\n> {\n  assetClass = TypeScriptAsset;\n\n  constructor(\n    /**\n     * A path or list or map of paths to the entry points of your code.\n     *\n     * Relative paths are by default resolved from the current working directory.\n     * To change the working directory, see `buildOptions.absWorkingDir`.\n     *\n     * Absolute paths can be used if files are part of the working directory.\n     *\n     * Examples:\n     *  - `'src/index.ts'`\n     *  - `require.resolve('./lambda')`\n     *  - `['src/index.ts', 'src/util.ts']`\n     *  - `{one: 'src/two.ts', two: 'src/one.ts'}`\n     *\n     * @stability stable\n     */\n    entryPoints: EntryPoints,\n\n    /**\n     * Props to change the behavior of the bundler.\n     *\n     * Default values for `props.buildOptions`:\n     * - `bundle=true`\n     * - `platform=browser`\n     *\n     * @stability stable\n     */\n    props: TypeScriptSourceProps = {},\n  ) {\n    super(entryPoints, props);\n  }\n}\n"]}