@mrgrain/cdk-esbuild 1.127.0 → 2.0.0-alpha.2

package/lib/esbuild-types.d.ts

@@ -0,0 +1,464 @@
+export declare type Platform = 'browser' | 'node' | 'neutral';
+export declare type Format = 'iife' | 'cjs' | 'esm';
+export declare type Loader = 'js' | 'jsx' | 'ts' | 'tsx' | 'css' | 'json' | 'text' | 'base64' | 'file' | 'dataurl' | 'binary' | 'default';
+export declare type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent';
+export declare type Charset = 'ascii' | 'utf8';
+interface CommonOptions {
+    /**
+     * @stability stable
+     */
+    readonly sourcemap?: boolean | 'inline' | 'external' | 'both';
+    /**
+     * @stability stable
+     */
+    readonly legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'external';
+    /**
+     * @stability stable
+     */
+    readonly sourceRoot?: string;
+    /**
+     * @stability stable
+     */
+    readonly sourcesContent?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly format?: Format;
+    /**
+     * @stability stable
+     */
+    readonly globalName?: string;
+    /**
+     * @stability stable
+     */
+    readonly target?: string | string[];
+    /**
+     * @stability stable
+     */
+    readonly minify?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly minifyWhitespace?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly minifyIdentifiers?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly minifySyntax?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly charset?: Charset;
+    /**
+     * @stability stable
+     */
+    readonly treeShaking?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly ignoreAnnotations?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly jsx?: 'transform' | 'preserve';
+    /**
+     * @stability stable
+     */
+    readonly jsxFactory?: string;
+    /**
+     * @stability stable
+     */
+    readonly jsxFragment?: string;
+    /**
+     * @stability stable
+     */
+    readonly define?: {
+        [key: string]: string;
+    };
+    /**
+     * @stability stable
+     */
+    readonly pure?: string[];
+    /**
+     * @stability stable
+     */
+    readonly keepNames?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly color?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly logLevel?: LogLevel;
+    /**
+     * @stability stable
+     */
+    readonly logLimit?: number;
+}
+/**
+ * @stability stable
+ */
+export interface BuildOptions extends CommonOptions {
+    /**
+     * @stability stable
+     */
+    readonly bundle?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly splitting?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly preserveSymlinks?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly outfile?: string;
+    /**
+     * @stability stable
+     */
+    readonly metafile?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly outdir?: string;
+    /**
+     * @stability stable
+     */
+    readonly outbase?: string;
+    /**
+     * @stability stable
+     */
+    readonly platform?: Platform;
+    /**
+     * @stability stable
+     */
+    readonly external?: string[];
+    /**
+     * @stability stable
+     */
+    readonly loader?: {
+        [ext: string]: Loader;
+    };
+    /**
+     * @stability stable
+     */
+    readonly resolveExtensions?: string[];
+    /**
+     * @stability stable
+     */
+    readonly mainFields?: string[];
+    /**
+     * @stability stable
+     */
+    readonly conditions?: string[];
+    /**
+     * @stability stable
+     */
+    readonly write?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly allowOverwrite?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly tsconfig?: string;
+    /**
+     * @stability stable
+     */
+    readonly outExtension?: {
+        [ext: string]: string;
+    };
+    /**
+     * @stability stable
+     */
+    readonly publicPath?: string;
+    /**
+     * @stability stable
+     */
+    readonly entryNames?: string;
+    /**
+     * @stability stable
+     */
+    readonly chunkNames?: string;
+    /**
+     * @stability stable
+     */
+    readonly assetNames?: string;
+    /**
+     * @stability stable
+     */
+    readonly inject?: string[];
+    /**
+     * @stability stable
+     */
+    readonly banner?: {
+        [type: string]: string;
+    };
+    /**
+     * @stability stable
+     */
+    readonly footer?: {
+        [type: string]: string;
+    };
+    /**
+     * @stability stable
+     */
+    readonly incremental?: boolean;
+    /**
+     * @stability stable
+     */
+    readonly absWorkingDir?: string;
+    /**
+     * @stability stable
+     */
+    readonly nodePaths?: string[];
+}
+export interface WatchMode {
+    onRebuild?: (error: BuildFailure | null, result: BuildResult | null) => void;
+}
+export interface StdinOptions {
+    contents: string;
+    resolveDir?: string;
+    sourcefile?: string;
+    loader?: Loader;
+}
+export interface Message {
+    pluginName: string;
+    text: string;
+    location: Location | null;
+    notes: Note[];
+    detail: any;
+}
+export interface Note {
+    text: string;
+    location: Location | null;
+}
+export interface Location {
+    file: string;
+    namespace: string;
+    line: number;
+    column: number;
+    length: number;
+    lineText: string;
+    suggestion: string;
+}
+export interface OutputFile {
+    path: string;
+    contents: Uint8Array;
+    text: string;
+}
+export interface BuildInvalidate {
+    (): Promise<BuildIncremental>;
+    dispose(): void;
+}
+export interface BuildIncremental extends BuildResult {
+    rebuild: BuildInvalidate;
+}
+export interface BuildResult {
+    errors: Message[];
+    warnings: Message[];
+    outputFiles?: OutputFile[];
+    rebuild?: BuildInvalidate;
+    stop?: () => void;
+    metafile?: Metafile;
+}
+export interface BuildFailure extends Error {
+    errors: Message[];
+    warnings: Message[];
+}
+export interface ServeOptions {
+    port?: number;
+    host?: string;
+    servedir?: string;
+    onRequest?: (args: ServeOnRequestArgs) => void;
+}
+export interface ServeOnRequestArgs {
+    remoteAddress: string;
+    method: string;
+    path: string;
+    status: number;
+    timeInMS: number;
+}
+export interface ServeResult {
+    port: number;
+    host: string;
+    wait: Promise<void>;
+    stop: () => void;
+}
+/**
+ * @stability stable
+ */
+export interface TransformOptions extends CommonOptions {
+    /**
+     * @stability stable
+     */
+    readonly tsconfigRaw?: string;
+    /**
+     * @stability stable
+     */
+    readonly sourcefile?: string;
+    /**
+     * @stability stable
+     */
+    readonly loader?: Loader;
+    /**
+     * @stability stable
+     */
+    readonly banner?: string;
+    /**
+     * @stability stable
+     */
+    readonly footer?: string;
+}
+export interface TransformResult {
+    code: string;
+    map: string;
+    warnings: Message[];
+}
+export interface TransformFailure extends Error {
+    errors: Message[];
+    warnings: Message[];
+}
+export interface Plugin {
+    name: string;
+    setup: (build: PluginBuild) => (void | Promise<void>);
+}
+export interface PluginBuild {
+    initialOptions: BuildOptions;
+    onStart(callback: () => (OnStartResult | null | void | Promise<OnStartResult | null | void>)): void;
+    onEnd(callback: (result: BuildResult) => (void | Promise<void>)): void;
+    onResolve(options: OnResolveOptions, callback: (args: OnResolveArgs) => (OnResolveResult | null | undefined | Promise<OnResolveResult | null | undefined>)): void;
+    onLoad(options: OnLoadOptions, callback: (args: OnLoadArgs) => (OnLoadResult | null | undefined | Promise<OnLoadResult | null | undefined>)): void;
+}
+export interface OnStartResult {
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+}
+export interface OnResolveOptions {
+    filter: RegExp;
+    namespace?: string;
+}
+export interface OnResolveArgs {
+    path: string;
+    importer: string;
+    namespace: string;
+    resolveDir: string;
+    kind: ImportKind;
+    pluginData: any;
+}
+export declare type ImportKind = 'entry-point' | 'import-statement' | 'require-call' | 'dynamic-import' | 'require-resolve' | 'import-rule' | 'url-token';
+export interface OnResolveResult {
+    pluginName?: string;
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+    path?: string;
+    external?: boolean;
+    sideEffects?: boolean;
+    namespace?: string;
+    pluginData?: any;
+    watchFiles?: string[];
+    watchDirs?: string[];
+}
+export interface OnLoadOptions {
+    filter: RegExp;
+    namespace?: string;
+}
+export interface OnLoadArgs {
+    path: string;
+    namespace: string;
+    pluginData: any;
+}
+export interface OnLoadResult {
+    pluginName?: string;
+    errors?: PartialMessage[];
+    warnings?: PartialMessage[];
+    contents?: string | Uint8Array;
+    resolveDir?: string;
+    loader?: Loader;
+    pluginData?: any;
+    watchFiles?: string[];
+    watchDirs?: string[];
+}
+export interface PartialMessage {
+    pluginName?: string;
+    text?: string;
+    location?: Partial<Location> | null;
+    notes?: PartialNote[];
+    detail?: any;
+}
+export interface PartialNote {
+    text?: string;
+    location?: Partial<Location> | null;
+}
+export interface Metafile {
+    inputs: {
+        [path: string]: {
+            bytes: number;
+            imports: {
+                path: string;
+                kind: ImportKind;
+            }[];
+        };
+    };
+    outputs: {
+        [path: string]: {
+            bytes: number;
+            inputs: {
+                [path: string]: {
+                    bytesInOutput: number;
+                };
+            };
+            imports: {
+                path: string;
+                kind: ImportKind;
+            }[];
+            exports: string[];
+            entryPoint?: string;
+        };
+    };
+}
+export interface FormatMessagesOptions {
+    kind: 'error' | 'warning';
+    color?: boolean;
+    terminalWidth?: number;
+}
+export interface AnalyzeMetafileOptions {
+    color?: boolean;
+    verbose?: boolean;
+}
+export declare function build(options: BuildOptions & {
+    write: false;
+}): Promise<BuildResult & {
+    outputFiles: OutputFile[];
+}>;
+export declare function build(options: BuildOptions & {
+    incremental: true;
+}): Promise<BuildIncremental>;
+export declare function build(options: BuildOptions): Promise<BuildResult>;
+export declare function serve(serveOptions: ServeOptions, buildOptions: BuildOptions): Promise<ServeResult>;
+export declare function transform(input: string, options?: TransformOptions): Promise<TransformResult>;
+export declare function formatMessages(messages: PartialMessage[], options: FormatMessagesOptions): Promise<string[]>;
+export declare function analyzeMetafile(metafile: Metafile | string, options?: AnalyzeMetafileOptions): Promise<string>;
+export declare function buildSync(options: BuildOptions & {
+    write: false;
+}): BuildResult & {
+    outputFiles: OutputFile[];
+};
+export declare function buildSync(options: BuildOptions): BuildResult;
+export declare function transformSync(input: string, options?: TransformOptions): TransformResult;
+export declare function formatMessagesSync(messages: PartialMessage[], options: FormatMessagesOptions): string[];
+export declare function analyzeMetafileSync(metafile: Metafile | string, options?: AnalyzeMetafileOptions): string;
+export declare function initialize(options: InitializeOptions): Promise<void>;
+export interface InitializeOptions {
+    wasmURL?: string;
+    worker?: boolean;
+}
+export declare let version: string;
+export {};

package/lib/esbuild-types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esbuild-types.js","sourceRoot":"","sources":["../src/esbuild-types.ts"],"names":[],"mappings":"","sourcesContent":["export type Platform = 'browser' | 'node' | 'neutral';\nexport type Format = 'iife' | 'cjs' | 'esm';\nexport type Loader = 'js' | 'jsx' | 'ts' | 'tsx' | 'css' | 'json' | 'text' | 'base64' | 'file' | 'dataurl' | 'binary' | 'default';\nexport type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent';\nexport type Charset = 'ascii' | 'utf8';\n\ninterface CommonOptions {\n  readonly sourcemap?: boolean | 'inline' | 'external' | 'both';\n  readonly legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'external';\n  readonly sourceRoot?: string;\n  readonly sourcesContent?: boolean;\n\n  readonly format?: Format;\n  readonly globalName?: string;\n  readonly target?: string | string[];\n\n  readonly minify?: boolean;\n  readonly minifyWhitespace?: boolean;\n  readonly minifyIdentifiers?: boolean;\n  readonly minifySyntax?: boolean;\n  readonly charset?: Charset;\n  readonly treeShaking?: boolean;\n  readonly ignoreAnnotations?: boolean;\n\n  readonly jsx?: 'transform' | 'preserve';\n  readonly jsxFactory?: string;\n  readonly jsxFragment?: string;\n\n  readonly define?: { [key: string]: string };\n  readonly pure?: string[];\n  readonly keepNames?: boolean;\n\n  readonly color?: boolean;\n  readonly logLevel?: LogLevel;\n  readonly logLimit?: number;\n}\n\nexport interface BuildOptions extends CommonOptions {\n  readonly bundle?: boolean;\n  readonly splitting?: boolean;\n  readonly preserveSymlinks?: boolean;\n  readonly outfile?: string;\n  readonly metafile?: boolean;\n  readonly outdir?: string;\n  readonly outbase?: string;\n  readonly platform?: Platform;\n  readonly external?: string[];\n  readonly loader?: { [ext: string]: Loader };\n  readonly resolveExtensions?: string[];\n  readonly mainFields?: string[];\n  readonly conditions?: string[];\n  readonly write?: boolean;\n  readonly allowOverwrite?: boolean;\n  readonly tsconfig?: string;\n  readonly outExtension?: { [ext: string]: string };\n  readonly publicPath?: string;\n  readonly entryNames?: string;\n  readonly chunkNames?: string;\n  readonly assetNames?: string;\n  readonly inject?: string[];\n  readonly banner?: { [type: string]: string };\n  readonly footer?: { [type: string]: string };\n  readonly incremental?: boolean;\n  readonly absWorkingDir?: string;\n  readonly nodePaths?: string[]; // The \"NODE_PATH\" variable from Node.js\n}\n\nexport interface WatchMode {\n  onRebuild?: (error: BuildFailure | null, result: BuildResult | null) => void;\n}\n\nexport interface StdinOptions {\n  contents: string;\n  resolveDir?: string;\n  sourcefile?: string;\n  loader?: Loader;\n}\n\nexport interface Message {\n  pluginName: string;\n  text: string;\n  location: Location | null;\n  notes: Note[];\n\n  // Optional user-specified data that is passed through unmodified. You can\n  // use this to stash the original error, for example.\n  detail: any;\n}\n\nexport interface Note {\n  text: string;\n  location: Location | null;\n}\n\nexport interface Location {\n  file: string;\n  namespace: string;\n  line: number; // 1-based\n  column: number; // 0-based, in bytes\n  length: number; // in bytes\n  lineText: string;\n  suggestion: string;\n}\n\nexport interface OutputFile {\n  path: string;\n  contents: Uint8Array; // \"text\" as bytes\n  text: string; // \"contents\" as text\n}\n\nexport interface BuildInvalidate {\n  (): Promise<BuildIncremental>;\n  dispose(): void;\n}\n\nexport interface BuildIncremental extends BuildResult {\n  rebuild: BuildInvalidate;\n}\n\nexport interface BuildResult {\n  errors: Message[];\n  warnings: Message[];\n  outputFiles?: OutputFile[]; // Only when \"write: false\"\n  rebuild?: BuildInvalidate; // Only when \"incremental: true\"\n  stop?: () => void; // Only when \"watch: true\"\n  metafile?: Metafile; // Only when \"metafile: true\"\n}\n\nexport interface BuildFailure extends Error {\n  errors: Message[];\n  warnings: Message[];\n}\n\nexport interface ServeOptions {\n  port?: number;\n  host?: string;\n  servedir?: string;\n  onRequest?: (args: ServeOnRequestArgs) => void;\n}\n\nexport interface ServeOnRequestArgs {\n  remoteAddress: string;\n  method: string;\n  path: string;\n  status: number;\n  timeInMS: number; // The time to generate the response, not to send it\n}\n\nexport interface ServeResult {\n  port: number;\n  host: string;\n  wait: Promise<void>;\n  stop: () => void;\n}\n\nexport interface TransformOptions extends CommonOptions {\n  readonly tsconfigRaw?: string;\n  readonly sourcefile?: string;\n  readonly loader?: Loader;\n  readonly banner?: string;\n  readonly footer?: string;\n}\n\nexport interface TransformResult {\n  code: string;\n  map: string;\n  warnings: Message[];\n}\n\nexport interface TransformFailure extends Error {\n  errors: Message[];\n  warnings: Message[];\n}\n\nexport interface Plugin {\n  name: string;\n  setup: (build: PluginBuild) => (void | Promise<void>);\n}\n\nexport interface PluginBuild {\n  initialOptions: BuildOptions;\n  onStart(callback: () =>\n  (OnStartResult | null | void | Promise<OnStartResult | null | void>)): void;\n  onEnd(callback: (result: BuildResult) =>\n  (void | Promise<void>)): void;\n  onResolve(options: OnResolveOptions, callback: (args: OnResolveArgs) =>\n  (OnResolveResult | null | undefined | Promise<OnResolveResult | null | undefined>)): void;\n  onLoad(options: OnLoadOptions, callback: (args: OnLoadArgs) =>\n  (OnLoadResult | null | undefined | Promise<OnLoadResult | null | undefined>)): void;\n}\n\nexport interface OnStartResult {\n  errors?: PartialMessage[];\n  warnings?: PartialMessage[];\n}\n\nexport interface OnResolveOptions {\n  filter: RegExp;\n  namespace?: string;\n}\n\nexport interface OnResolveArgs {\n  path: string;\n  importer: string;\n  namespace: string;\n  resolveDir: string;\n  kind: ImportKind;\n  pluginData: any;\n}\n\nexport type ImportKind =\n  | 'entry-point'\n\n  // JS\n  | 'import-statement'\n  | 'require-call'\n  | 'dynamic-import'\n  | 'require-resolve'\n\n  // CSS\n  | 'import-rule'\n  | 'url-token'\n\nexport interface OnResolveResult {\n  pluginName?: string;\n\n  errors?: PartialMessage[];\n  warnings?: PartialMessage[];\n\n  path?: string;\n  external?: boolean;\n  sideEffects?: boolean;\n  namespace?: string;\n  pluginData?: any;\n\n  watchFiles?: string[];\n  watchDirs?: string[];\n}\n\nexport interface OnLoadOptions {\n  filter: RegExp;\n  namespace?: string;\n}\n\nexport interface OnLoadArgs {\n  path: string;\n  namespace: string;\n  pluginData: any;\n}\n\nexport interface OnLoadResult {\n  pluginName?: string;\n\n  errors?: PartialMessage[];\n  warnings?: PartialMessage[];\n\n  contents?: string | Uint8Array;\n  resolveDir?: string;\n  loader?: Loader;\n  pluginData?: any;\n\n  watchFiles?: string[];\n  watchDirs?: string[];\n}\n\nexport interface PartialMessage {\n  pluginName?: string;\n  text?: string;\n  location?: Partial<Location> | null;\n  notes?: PartialNote[];\n  detail?: any;\n}\n\nexport interface PartialNote {\n  text?: string;\n  location?: Partial<Location> | null;\n}\n\nexport interface Metafile {\n  inputs: {\n    [path: string]: {\n      bytes: number;\n      imports: {\n        path: string;\n        kind: ImportKind;\n      }[];\n    };\n  };\n  outputs: {\n    [path: string]: {\n      bytes: number;\n      inputs: {\n        [path: string]: {\n          bytesInOutput: number;\n        };\n      };\n      imports: {\n        path: string;\n        kind: ImportKind;\n      }[];\n      exports: string[];\n      entryPoint?: string;\n    };\n  };\n}\n\nexport interface FormatMessagesOptions {\n  kind: 'error' | 'warning';\n  color?: boolean;\n  terminalWidth?: number;\n}\n\nexport interface AnalyzeMetafileOptions {\n  color?: boolean;\n  verbose?: boolean;\n}\n\n// This function invokes the \"esbuild\" command-line tool for you. It returns a\n// promise that either resolves with a \"BuildResult\" object or rejects with a\n// \"BuildFailure\" object.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function build(options: BuildOptions & { write: false }): Promise<BuildResult & { outputFiles: OutputFile[] }>;\nexport declare function build(options: BuildOptions & { incremental: true }): Promise<BuildIncremental>;\nexport declare function build(options: BuildOptions): Promise<BuildResult>;\n\n// This function is similar to \"build\" but it serves the resulting files over\n// HTTP on a localhost address with the specified port.\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function serve(serveOptions: ServeOptions, buildOptions: BuildOptions): Promise<ServeResult>;\n\n// This function transforms a single JavaScript file. It can be used to minify\n// JavaScript, convert TypeScript/JSX to JavaScript, or convert newer JavaScript\n// to older JavaScript. It returns a promise that is either resolved with a\n// \"TransformResult\" object or rejected with a \"TransformFailure\" object.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function transform(input: string, options?: TransformOptions): Promise<TransformResult>;\n\n// Converts log messages to formatted message strings suitable for printing in\n// the terminal. This allows you to reuse the built-in behavior of esbuild's\n// log message formatter. This is a batch-oriented API for efficiency.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function formatMessages(messages: PartialMessage[], options: FormatMessagesOptions): Promise<string[]>;\n\n// Pretty-prints an analysis of the metafile JSON to a string. This is just for\n// convenience to be able to match esbuild's pretty-printing exactly. If you want\n// to customize it, you can just inspect the data in the metafile yourself.\n//\n// Works in node: yes\n// Works in browser: yes\nexport declare function analyzeMetafile(metafile: Metafile | string, options?: AnalyzeMetafileOptions): Promise<string>;\n\n// A synchronous version of \"build\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function buildSync(options: BuildOptions & { write: false }): BuildResult & { outputFiles: OutputFile[] };\nexport declare function buildSync(options: BuildOptions): BuildResult;\n\n// A synchronous version of \"transform\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function transformSync(input: string, options?: TransformOptions): TransformResult;\n\n// A synchronous version of \"formatMessages\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function formatMessagesSync(messages: PartialMessage[], options: FormatMessagesOptions): string[];\n\n// A synchronous version of \"analyzeMetafile\".\n//\n// Works in node: yes\n// Works in browser: no\nexport declare function analyzeMetafileSync(metafile: Metafile | string, options?: AnalyzeMetafileOptions): string;\n\n// This configures the browser-based version of esbuild. It is necessary to\n// call this first and wait for the returned promise to be resolved before\n// making other API calls when using esbuild in the browser.\n//\n// Works in node: yes\n// Works in browser: yes (\"options\" is required)\nexport declare function initialize(options: InitializeOptions): Promise<void>;\n\nexport interface InitializeOptions {\n  // The URL of the \"esbuild.wasm\" file. This must be provided when running\n  // esbuild in the browser.\n  wasmURL?: string;\n\n  // By default esbuild runs the WebAssembly-based browser API in a web worker\n  // to avoid blocking the UI thread. This can be disabled by setting \"worker\"\n  // to false.\n  worker?: boolean;\n}\n\nexport let version: string;\n"]}

package/lib/esbuild-wrapper.d.ts

@@ -0,0 +1,3 @@
+export declare const buildSync: any;
+export declare const formatMessagesSync: any;
+export declare const transformSync: any;

package/lib/esbuild-wrapper.js

@@ -0,0 +1,12 @@
+"use strict";
+/* eslint-disable import/no-extraneous-dependencies */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSync = exports.formatMessagesSync = exports.buildSync = void 0;
+function esbuild() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require('esbuild');
+}
+exports.buildSync = esbuild().buildSync;
+exports.formatMessagesSync = esbuild().formatMessagesSync;
+exports.transformSync = esbuild().transformSync;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNidWlsZC13cmFwcGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2VzYnVpbGQtd3JhcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsc0RBQXNEOzs7QUFFdEQsU0FBUyxPQUFPO0lBQ2QsaUVBQWlFO0lBQ2pFLE9BQU8sT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQzVCLENBQUM7QUFFWSxRQUFBLFNBQVMsR0FBRyxPQUFPLEVBQUUsQ0FBQyxTQUFTLENBQUM7QUFDaEMsUUFBQSxrQkFBa0IsR0FBRyxPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztBQUNsRCxRQUFBLGFBQWEsR0FBRyxPQUFPLEVBQUUsQ0FBQyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBpbXBvcnQvbm8tZXh0cmFuZW91cy1kZXBlbmRlbmNpZXMgKi9cblxuZnVuY3Rpb24gZXNidWlsZCgpIHtcbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby1yZXF1aXJlLWltcG9ydHNcbiAgcmV0dXJuIHJlcXVpcmUoJ2VzYnVpbGQnKTtcbn1cblxuZXhwb3J0IGNvbnN0IGJ1aWxkU3luYyA9IGVzYnVpbGQoKS5idWlsZFN5bmM7XG5leHBvcnQgY29uc3QgZm9ybWF0TWVzc2FnZXNTeW5jID0gZXNidWlsZCgpLmZvcm1hdE1lc3NhZ2VzU3luYztcbmV4cG9ydCBjb25zdCB0cmFuc2Zvcm1TeW5jID0gZXNidWlsZCgpLnRyYW5zZm9ybVN5bmM7XG4iXX0=

package/lib/formatMessages.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { BuildFailure, BuildResult, TransformFailure, TransformResult } from "esbuild";
-import { WriteStream } from "tty";
+import { WriteStream } from 'tty';
+import { BuildFailure, BuildResult, TransformFailure, TransformResult } from './esbuild-types';
 export declare function printBuildErrors(failure: TransformFailure | BuildFailure, { dest, color, prefix, }?: {
     dest?: WriteStream;
     color?: boolean;

package/lib/formatMessages.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printBuildMessages = exports.printBuildWarnings = exports.printBuildErrors = void 0;
-const esbuild_1 = require("esbuild");
-function printBuildErrors(failure, { dest = process.stdout, color = true, prefix = "", } = {}) {
-    const errors = (0, esbuild_1.formatMessagesSync)(failure.errors, {
-        kind: "error",
+const esbuild_wrapper_1 = require("./esbuild-wrapper");
+function printBuildErrors(failure, { dest = process.stdout, color = true, prefix = '', } = {}) {
+    const errors = esbuild_wrapper_1.formatMessagesSync(failure.errors, {
+        kind: 'error',
         color,
     });
     if (errors.length > 0) {
         dest.write(`${prefix}Errors:\n\n`);
-        dest.write(errors.join("\n\n"));
+        dest.write(errors.join('\n\n'));
     }
 }
 exports.printBuildErrors = printBuildErrors;
-function printBuildWarnings(failure, { dest = process.stdout, color = true, prefix = "", } = {}) {
-    const warnings = (0, esbuild_1.formatMessagesSync)(failure.warnings, {
-        kind: "warning",
+function printBuildWarnings(failure, { dest = process.stdout, color = true, prefix = '', } = {}) {
+    const warnings = esbuild_wrapper_1.formatMessagesSync(failure.warnings, {
+        kind: 'warning',
         color,
     });
     if (warnings.length > 0) {
         dest.write(`${prefix}Warning:\n\n`);
-        dest.write(warnings.join("\n\n"));
+        dest.write(warnings.join('\n\n'));
     }
 }
 exports.printBuildWarnings = printBuildWarnings;
@@ -31,4 +31,4 @@ function printBuildMessages(failure, props = {}) {
     }
 }
 exports.printBuildMessages = printBuildMessages;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -1,5 +1,6 @@
-export { EsbuildBundling, BundlerPriority } from "./bundling";
-export { JavaScriptAsset, TypeScriptAsset } from "./asset";
-export { JavaScriptCode, TypeScriptCode } from "./code";
-export { InlineJavaScriptCode, InlineJsxCode, InlineTypeScriptCode, InlineTsxCode, } from "./inline-code";
-export { JavaScriptSource, TypeScriptSource } from "./source";
+export { BuildOptions, TransformOptions } from './esbuild-types';
+export { EsbuildBundler, BundlerProps } from './bundler';
+export { JavaScriptAsset, TypeScriptAsset, AssetBaseProps, AssetProps } from './asset';
+export { JavaScriptCode, JavaScriptCodeProps, TypeScriptCode, TypeScriptCodeProps, CodeConfig, } from './code';
+export { InlineJavaScriptCode, InlineJsxCode, InlineTsxCode, InlineTypeScriptCode, } from './inline-code';
+export { JavaScriptSource, JavaScriptSourceProps, TypeScriptSource, TypeScriptSourceProps, } from './source';

package/lib/index.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeScriptSource = exports.JavaScriptSource = exports.InlineTsxCode = exports.InlineTypeScriptCode = exports.InlineJsxCode = exports.InlineJavaScriptCode = exports.TypeScriptCode = exports.JavaScriptCode = exports.TypeScriptAsset = exports.JavaScriptAsset = exports.BundlerPriority = exports.EsbuildBundling = void 0;
-var bundling_1 = require("./bundling");
-Object.defineProperty(exports, "EsbuildBundling", { enumerable: true, get: function () { return bundling_1.EsbuildBundling; } });
-Object.defineProperty(exports, "BundlerPriority", { enumerable: true, get: function () { return bundling_1.BundlerPriority; } });
+var bundler_1 = require("./bundler");
+Object.defineProperty(exports, "EsbuildBundler", { enumerable: true, get: function () { return bundler_1.EsbuildBundler; } });
 var asset_1 = require("./asset");
 Object.defineProperty(exports, "JavaScriptAsset", { enumerable: true, get: function () { return asset_1.JavaScriptAsset; } });
 Object.defineProperty(exports, "TypeScriptAsset", { enumerable: true, get: function () { return asset_1.TypeScriptAsset; } });
@@ -13,9 +11,9 @@ Object.defineProperty(exports, "TypeScriptCode", { enumerable: true, get: functi
 var inline_code_1 = require("./inline-code");
 Object.defineProperty(exports, "InlineJavaScriptCode", { enumerable: true, get: function () { return inline_code_1.InlineJavaScriptCode; } });
 Object.defineProperty(exports, "InlineJsxCode", { enumerable: true, get: function () { return inline_code_1.InlineJsxCode; } });
-Object.defineProperty(exports, "InlineTypeScriptCode", { enumerable: true, get: function () { return inline_code_1.InlineTypeScriptCode; } });
 Object.defineProperty(exports, "InlineTsxCode", { enumerable: true, get: function () { return inline_code_1.InlineTsxCode; } });
+Object.defineProperty(exports, "InlineTypeScriptCode", { enumerable: true, get: function () { return inline_code_1.InlineTypeScriptCode; } });
 var source_1 = require("./source");
 Object.defineProperty(exports, "JavaScriptSource", { enumerable: true, get: function () { return source_1.JavaScriptSource; } });
 Object.defineProperty(exports, "TypeScriptSource", { enumerable: true, get: function () { return source_1.TypeScriptSource; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1Q0FBOEQ7QUFBckQsMkdBQUEsZUFBZSxPQUFBO0FBQUUsMkdBQUEsZUFBZSxPQUFBO0FBRXpDLGlDQUEyRDtBQUFsRCx3R0FBQSxlQUFlLE9BQUE7QUFBRSx3R0FBQSxlQUFlLE9BQUE7QUFFekMsK0JBQXdEO0FBQS9DLHNHQUFBLGNBQWMsT0FBQTtBQUFFLHNHQUFBLGNBQWMsT0FBQTtBQUV2Qyw2Q0FLdUI7QUFKckIsbUhBQUEsb0JBQW9CLE9BQUE7QUFDcEIsNEdBQUEsYUFBYSxPQUFBO0FBQ2IsbUhBQUEsb0JBQW9CLE9BQUE7QUFDcEIsNEdBQUEsYUFBYSxPQUFBO0FBR2YsbUNBQThEO0FBQXJELDBHQUFBLGdCQUFnQixPQUFBO0FBQUUsMEdBQUEsZ0JBQWdCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBFc2J1aWxkQnVuZGxpbmcsIEJ1bmRsZXJQcmlvcml0eSB9IGZyb20gXCIuL2J1bmRsaW5nXCI7XG5cbmV4cG9ydCB7IEphdmFTY3JpcHRBc3NldCwgVHlwZVNjcmlwdEFzc2V0IH0gZnJvbSBcIi4vYXNzZXRcIjtcblxuZXhwb3J0IHsgSmF2YVNjcmlwdENvZGUsIFR5cGVTY3JpcHRDb2RlIH0gZnJvbSBcIi4vY29kZVwiO1xuXG5leHBvcnQge1xuICBJbmxpbmVKYXZhU2NyaXB0Q29kZSxcbiAgSW5saW5lSnN4Q29kZSxcbiAgSW5saW5lVHlwZVNjcmlwdENvZGUsXG4gIElubGluZVRzeENvZGUsXG59IGZyb20gXCIuL2lubGluZS1jb2RlXCI7XG5cbmV4cG9ydCB7IEphdmFTY3JpcHRTb3VyY2UsIFR5cGVTY3JpcHRTb3VyY2UgfSBmcm9tIFwiLi9zb3VyY2VcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxxQ0FBeUQ7QUFBaEQseUdBQUEsY0FBYyxPQUFBO0FBRXZCLGlDQUF1RjtBQUE5RSx3R0FBQSxlQUFlLE9BQUE7QUFBRSx3R0FBQSxlQUFlLE9BQUE7QUFFekMsK0JBTWdCO0FBTGQsc0dBQUEsY0FBYyxPQUFBO0FBRWQsc0dBQUEsY0FBYyxPQUFBO0FBS2hCLDZDQUt1QjtBQUpyQixtSEFBQSxvQkFBb0IsT0FBQTtBQUNwQiw0R0FBQSxhQUFhLE9BQUE7QUFDYiw0R0FBQSxhQUFhLE9BQUE7QUFDYixtSEFBQSxvQkFBb0IsT0FBQTtBQUd0QixtQ0FLa0I7QUFKaEIsMEdBQUEsZ0JBQWdCLE9BQUE7QUFFaEIsMEdBQUEsZ0JBQWdCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJcbmV4cG9ydCB7IEJ1aWxkT3B0aW9ucywgVHJhbnNmb3JtT3B0aW9ucyB9IGZyb20gJy4vZXNidWlsZC10eXBlcyc7XG5cbmV4cG9ydCB7IEVzYnVpbGRCdW5kbGVyLCBCdW5kbGVyUHJvcHMgfSBmcm9tICcuL2J1bmRsZXInO1xuXG5leHBvcnQgeyBKYXZhU2NyaXB0QXNzZXQsIFR5cGVTY3JpcHRBc3NldCwgQXNzZXRCYXNlUHJvcHMsIEFzc2V0UHJvcHMgfSBmcm9tICcuL2Fzc2V0JztcblxuZXhwb3J0IHtcbiAgSmF2YVNjcmlwdENvZGUsXG4gIEphdmFTY3JpcHRDb2RlUHJvcHMsXG4gIFR5cGVTY3JpcHRDb2RlLFxuICBUeXBlU2NyaXB0Q29kZVByb3BzLFxuICBDb2RlQ29uZmlnLFxufSBmcm9tICcuL2NvZGUnO1xuXG5leHBvcnQge1xuICBJbmxpbmVKYXZhU2NyaXB0Q29kZSxcbiAgSW5saW5lSnN4Q29kZSxcbiAgSW5saW5lVHN4Q29kZSxcbiAgSW5saW5lVHlwZVNjcmlwdENvZGUsXG59IGZyb20gJy4vaW5saW5lLWNvZGUnO1xuXG5leHBvcnQge1xuICBKYXZhU2NyaXB0U291cmNlLFxuICBKYXZhU2NyaXB0U291cmNlUHJvcHMsXG4gIFR5cGVTY3JpcHRTb3VyY2UsXG4gIFR5cGVTY3JpcHRTb3VyY2VQcm9wcyxcbn0gZnJvbSAnLi9zb3VyY2UnOyJdfQ==

package/lib/inline-code.d.ts

@@ -1,5 +1,5 @@
-import { InlineCode } from "@aws-cdk/aws-lambda";
-import { TransformOptions, Loader } from "esbuild";
+import { InlineCode } from '@aws-cdk/aws-lambda';
+import { TransformOptions, Loader } from './esbuild-types';
 declare abstract class BaseInlineCode extends InlineCode {
     constructor(code: string, loader: Loader, transformOptions?: TransformOptions);
 }
@@ -7,24 +7,36 @@ declare abstract class BaseInlineCode extends InlineCode {
  * @experimental
  */
 export declare class InlineJavaScriptCode extends BaseInlineCode {
+    /**
+     * @experimental
+     */
     constructor(code: string, transformOptions?: TransformOptions);
 }
 /**
  * @experimental
  */
 export declare class InlineJsxCode extends BaseInlineCode {
+    /**
+     * @experimental
+     */
     constructor(code: string, transformOptions?: TransformOptions);
 }
 /**
  * @experimental
  */
 export declare class InlineTypeScriptCode extends BaseInlineCode {
+    /**
+     * @experimental
+     */
     constructor(code: string, transformOptions?: TransformOptions);
 }
 /**
  * @experimental
  */
 export declare class InlineTsxCode extends BaseInlineCode {
+    /**
+     * @experimental
+     */
     constructor(code: string, transformOptions?: TransformOptions);
 }
 export {};