diff --git a/packages/cli/binding/index.cjs b/packages/cli/binding/index.cjs index 7651973572..05ab0f1180 100644 --- a/packages/cli/binding/index.cjs +++ b/packages/cli/binding/index.cjs @@ -765,6 +765,72 @@ if (!nativeBinding) { } module.exports = nativeBinding; +module.exports.minify = nativeBinding.minify; +module.exports.minifySync = nativeBinding.minifySync; +module.exports.Severity = nativeBinding.Severity; +module.exports.ParseResult = nativeBinding.ParseResult; +module.exports.ExportExportNameKind = nativeBinding.ExportExportNameKind; +module.exports.ExportImportNameKind = nativeBinding.ExportImportNameKind; +module.exports.ExportLocalNameKind = nativeBinding.ExportLocalNameKind; +module.exports.ImportNameKind = nativeBinding.ImportNameKind; +module.exports.parse = nativeBinding.parse; +module.exports.parseSync = nativeBinding.parseSync; +module.exports.rawTransferSupported = nativeBinding.rawTransferSupported; +module.exports.ResolverFactory = nativeBinding.ResolverFactory; +module.exports.EnforceExtension = nativeBinding.EnforceExtension; +module.exports.ModuleType = nativeBinding.ModuleType; +module.exports.sync = nativeBinding.sync; +module.exports.HelperMode = nativeBinding.HelperMode; +module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration; +module.exports.isolatedDeclarationSync = nativeBinding.isolatedDeclarationSync; +module.exports.moduleRunnerTransform = nativeBinding.moduleRunnerTransform; +module.exports.moduleRunnerTransformSync = nativeBinding.moduleRunnerTransformSync; +module.exports.transform = nativeBinding.transform; +module.exports.transformSync = nativeBinding.transformSync; +module.exports.BindingBundleEndEventData = nativeBinding.BindingBundleEndEventData; +module.exports.BindingBundleErrorEventData = nativeBinding.BindingBundleErrorEventData; +module.exports.BindingBundler = nativeBinding.BindingBundler; +module.exports.BindingCallableBuiltinPlugin = nativeBinding.BindingCallableBuiltinPlugin; +module.exports.BindingChunkingContext = nativeBinding.BindingChunkingContext; +module.exports.BindingDecodedMap = nativeBinding.BindingDecodedMap; +module.exports.BindingDevEngine = nativeBinding.BindingDevEngine; +module.exports.BindingLoadPluginContext = nativeBinding.BindingLoadPluginContext; +module.exports.BindingMagicString = nativeBinding.BindingMagicString; +module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo; +module.exports.BindingNormalizedOptions = nativeBinding.BindingNormalizedOptions; +module.exports.BindingOutputAsset = nativeBinding.BindingOutputAsset; +module.exports.BindingOutputChunk = nativeBinding.BindingOutputChunk; +module.exports.BindingPluginContext = nativeBinding.BindingPluginContext; +module.exports.BindingRenderedChunk = nativeBinding.BindingRenderedChunk; +module.exports.BindingRenderedChunkMeta = nativeBinding.BindingRenderedChunkMeta; +module.exports.BindingRenderedModule = nativeBinding.BindingRenderedModule; +module.exports.BindingSourceMap = nativeBinding.BindingSourceMap; +module.exports.BindingTransformPluginContext = nativeBinding.BindingTransformPluginContext; +module.exports.BindingWatcher = nativeBinding.BindingWatcher; +module.exports.BindingWatcherBundler = nativeBinding.BindingWatcherBundler; +module.exports.BindingWatcherChangeData = nativeBinding.BindingWatcherChangeData; +module.exports.BindingWatcherEvent = nativeBinding.BindingWatcherEvent; +module.exports.ParallelJsPluginRegistry = nativeBinding.ParallelJsPluginRegistry; +module.exports.ScheduledBuild = nativeBinding.ScheduledBuild; +module.exports.TraceSubscriberGuard = nativeBinding.TraceSubscriberGuard; +module.exports.TsconfigCache = nativeBinding.TsconfigCache; +module.exports.BindingAttachDebugInfo = nativeBinding.BindingAttachDebugInfo; +module.exports.BindingBuiltinPluginName = nativeBinding.BindingBuiltinPluginName; +module.exports.BindingChunkModuleOrderBy = nativeBinding.BindingChunkModuleOrderBy; +module.exports.BindingLogLevel = nativeBinding.BindingLogLevel; +module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder; +module.exports.BindingPropertyReadSideEffects = nativeBinding.BindingPropertyReadSideEffects; +module.exports.BindingPropertyWriteSideEffects = nativeBinding.BindingPropertyWriteSideEffects; +module.exports.BindingRebuildStrategy = nativeBinding.BindingRebuildStrategy; +module.exports.collapseSourcemaps = nativeBinding.collapseSourcemaps; +module.exports.enhancedTransform = nativeBinding.enhancedTransform; +module.exports.enhancedTransformSync = nativeBinding.enhancedTransformSync; +module.exports.FilterTokenKind = nativeBinding.FilterTokenKind; +module.exports.initTraceSubscriber = nativeBinding.initTraceSubscriber; +module.exports.registerPlugins = nativeBinding.registerPlugins; +module.exports.resolveTsconfig = nativeBinding.resolveTsconfig; +module.exports.shutdownAsyncRuntime = nativeBinding.shutdownAsyncRuntime; +module.exports.startAsyncRuntime = nativeBinding.startAsyncRuntime; module.exports.detectWorkspace = nativeBinding.detectWorkspace; module.exports.downloadPackageManager = nativeBinding.downloadPackageManager; module.exports.mergeJsonConfig = nativeBinding.mergeJsonConfig; diff --git a/packages/cli/binding/index.d.cts b/packages/cli/binding/index.d.cts index 91ab22b273..1c3377ef11 100644 --- a/packages/cli/binding/index.d.cts +++ b/packages/cli/binding/index.d.cts @@ -1,5 +1,3129 @@ /* auto-generated by NAPI-RS */ /* eslint-disable */ +export interface CodegenOptions { + /** + * Remove whitespace. + * + * @default true + */ + removeWhitespace?: boolean; +} + +export interface CompressOptions { + /** + * Set desired EcmaScript standard version for output. + * + * Set `esnext` to enable all target highering. + * + * Example: + * + * * `'es2015'` + * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']` + * + * @default 'esnext' + * + * @see [esbuild#target](https://esbuild.github.io/api/#target) + */ + target?: string | Array; + /** + * Pass true to discard calls to `console.*`. + * + * @default false + */ + dropConsole?: boolean; + /** + * Remove `debugger;` statements. + * + * @default true + */ + dropDebugger?: boolean; + /** + * Pass `true` to drop unreferenced functions and variables. + * + * Simple direct variable assignments do not count as references unless set to `keep_assign`. + * @default true + */ + unused?: boolean | 'keep_assign'; + /** Keep function / class names. */ + keepNames?: CompressOptionsKeepNames; + /** + * Join consecutive var, let and const statements. + * + * @default true + */ + joinVars?: boolean; + /** + * Join consecutive simple statements using the comma operator. + * + * `a; b` -> `a, b` + * + * @default true + */ + sequences?: boolean; + /** + * Set of label names to drop from the code. + * + * Labeled statements matching these names will be removed during minification. + * + * @default [] + */ + dropLabels?: Array; + /** Limit the maximum number of iterations for debugging purpose. */ + maxIterations?: number; + /** Treeshake options. */ + treeshake?: TreeShakeOptions; +} + +export interface CompressOptionsKeepNames { + /** + * Keep function names so that `Function.prototype.name` is preserved. + * + * This does not guarantee that the `undefined` name is preserved. + * + * @default false + */ + function: boolean; + /** + * Keep class names so that `Class.prototype.name` is preserved. + * + * This does not guarantee that the `undefined` name is preserved. + * + * @default false + */ + class: boolean; +} + +export interface MangleOptions { + /** + * Pass `true` to mangle names declared in the top level scope. + * + * @default true for modules and commonjs, otherwise false + */ + toplevel?: boolean; + /** + * Preserve `name` property for functions and classes. + * + * @default false + */ + keepNames?: boolean | MangleOptionsKeepNames; + /** Debug mangled names. */ + debug?: boolean; +} + +export interface MangleOptionsKeepNames { + /** + * Preserve `name` property for functions. + * + * @default false + */ + function: boolean; + /** + * Preserve `name` property for classes. + * + * @default false + */ + class: boolean; +} + +/** + * Minify asynchronously. + * + * Note: This function can be slower than `minifySync` due to the overhead of spawning a thread. + */ +export declare function minify( + filename: string, + sourceText: string, + options?: MinifyOptions | undefined | null, +): Promise; + +export interface MinifyOptions { + /** Use when minifying an ES module. */ + module?: boolean; + compress?: boolean | CompressOptions; + mangle?: boolean | MangleOptions; + codegen?: boolean | CodegenOptions; + sourcemap?: boolean; +} + +export interface MinifyResult { + code: string; + map?: SourceMap; + errors: Array; +} + +/** Minify synchronously. */ +export declare function minifySync( + filename: string, + sourceText: string, + options?: MinifyOptions | undefined | null, +): MinifyResult; + +export interface TreeShakeOptions { + /** + * Whether to respect the pure annotations. + * + * Pure annotations are comments that mark an expression as pure. + * For example: @__PURE__ or #__NO_SIDE_EFFECTS__. + * + * @default true + */ + annotations?: boolean; + /** + * Whether to treat this function call as pure. + * + * This function is called for normal function calls, new calls, and + * tagged template calls. + */ + manualPureFunctions?: Array; + /** + * Whether property read accesses have side effects. + * + * @default 'always' + */ + propertyReadSideEffects?: boolean | 'always'; + /** + * Whether accessing a global variable has side effects. + * + * Accessing a non-existing global variable will throw an error. + * Global variable may be a getter that has side effects. + * + * @default true + */ + unknownGlobalSideEffects?: boolean; + /** + * Whether invalid import statements have side effects. + * + * Accessing a non-existing import name will throw an error. + * Also import statements that cannot be resolved will throw an error. + * + * @default true + */ + invalidImportSideEffects?: boolean; +} +export interface Comment { + type: 'Line' | 'Block'; + value: string; + start: number; + end: number; +} + +export interface ErrorLabel { + message: string | null; + start: number; + end: number; +} + +export interface OxcError { + severity: Severity; + message: string; + labels: Array; + helpMessage: string | null; + codeframe: string | null; +} + +export declare const enum Severity { + Error = 'Error', + Warning = 'Warning', + Advice = 'Advice', +} +export declare class ParseResult { + get program(): import('@oxc-project/types').Program; + get module(): EcmaScriptModule; + get comments(): Array; + get errors(): Array; +} + +export interface DynamicImport { + start: number; + end: number; + moduleRequest: Span; +} + +export interface EcmaScriptModule { + /** + * Has ESM syntax. + * + * i.e. `import` and `export` statements, and `import.meta`. + * + * Dynamic imports `import('foo')` are ignored since they can be used in non-ESM files. + */ + hasModuleSyntax: boolean; + /** Import statements. */ + staticImports: Array; + /** Export statements. */ + staticExports: Array; + /** Dynamic import expressions. */ + dynamicImports: Array; + /** Span positions` of `import.meta` */ + importMetas: Array; +} + +export interface ExportExportName { + kind: ExportExportNameKind; + name: string | null; + start: number | null; + end: number | null; +} + +export declare const enum ExportExportNameKind { + /** `export { name } */ + Name = 'Name', + /** `export default expression` */ + Default = 'Default', + /** `export * from "mod" */ + None = 'None', +} + +export interface ExportImportName { + kind: ExportImportNameKind; + name: string | null; + start: number | null; + end: number | null; +} + +export declare const enum ExportImportNameKind { + /** `export { name } */ + Name = 'Name', + /** `export * as ns from "mod"` */ + All = 'All', + /** `export * from "mod"` */ + AllButDefault = 'AllButDefault', + /** Does not have a specifier. */ + None = 'None', +} + +export interface ExportLocalName { + kind: ExportLocalNameKind; + name: string | null; + start: number | null; + end: number | null; +} + +export declare const enum ExportLocalNameKind { + /** `export { name } */ + Name = 'Name', + /** `export default expression` */ + Default = 'Default', + /** + * If the exported value is not locally accessible from within the module. + * `export default function () {}` + */ + None = 'None', +} + +export interface ImportName { + kind: ImportNameKind; + name: string | null; + start: number | null; + end: number | null; +} + +export declare const enum ImportNameKind { + /** `import { x } from "mod"` */ + Name = 'Name', + /** `import * as ns from "mod"` */ + NamespaceObject = 'NamespaceObject', + /** `import defaultExport from "mod"` */ + Default = 'Default', +} + +/** + * Parse JS/TS source asynchronously on a separate thread. + * + * Note that not all of the workload can happen on a separate thread. + * Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects + * has to happen on current thread. This synchronous deserialization work typically outweighs + * the asynchronous parsing by a factor of between 3 and 20. + * + * i.e. the majority of the workload cannot be parallelized by using this method. + * + * Generally `parseSync` is preferable to use as it does not have the overhead of spawning a thread. + * If you need to parallelize parsing multiple files, it is recommended to use worker threads. + */ +export declare function parse( + filename: string, + sourceText: string, + options?: ParserOptions | undefined | null, +): Promise; + +export interface ParserOptions { + /** Treat the source text as `js`, `jsx`, `ts`, `tsx` or `dts`. */ + lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts'; + /** Treat the source text as `script` or `module` code. */ + sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined; + /** + * Return an AST which includes TypeScript-related properties, or excludes them. + * + * `'js'` is default for JS / JSX files. + * `'ts'` is default for TS / TSX files. + * The type of the file is determined from `lang` option, or extension of provided `filename`. + */ + astType?: 'js' | 'ts'; + /** + * Controls whether the `range` property is included on AST nodes. + * The `range` property is a `[number, number]` which indicates the start/end offsets + * of the node in the file contents. + * + * @default false + */ + range?: boolean; + /** + * Emit `ParenthesizedExpression` and `TSParenthesizedType` in AST. + * + * If this option is true, parenthesized expressions are represented by + * (non-standard) `ParenthesizedExpression` and `TSParenthesizedType` nodes that + * have a single `expression` property containing the expression inside parentheses. + * + * @default true + */ + preserveParens?: boolean; + /** + * Produce semantic errors with an additional AST pass. + * Semantic errors depend on symbols and scopes, where the parser does not construct. + * This adds a small performance overhead. + * + * @default false + */ + showSemanticErrors?: boolean; +} + +/** + * Parse JS/TS source synchronously on current thread. + * + * This is generally preferable over `parse` (async) as it does not have the overhead + * of spawning a thread, and the majority of the workload cannot be parallelized anyway + * (see `parse` documentation for details). + * + * If you need to parallelize parsing multiple files, it is recommended to use worker threads + * with `parseSync` rather than using `parse`. + */ +export declare function parseSync( + filename: string, + sourceText: string, + options?: ParserOptions | undefined | null, +): ParseResult; + +/** Returns `true` if raw transfer is supported on this platform. */ +export declare function rawTransferSupported(): boolean; + +export interface Span { + start: number; + end: number; +} + +export interface StaticExport { + start: number; + end: number; + entries: Array; +} + +export interface StaticExportEntry { + start: number; + end: number; + moduleRequest: ValueSpan | null; + /** The name under which the desired binding is exported by the module`. */ + importName: ExportImportName; + /** The name used to export this binding by this module. */ + exportName: ExportExportName; + /** The name that is used to locally access the exported value from within the importing module. */ + localName: ExportLocalName; + /** + * Whether the export is a TypeScript `export type`. + * + * Examples: + * + * ```ts + * export type * from 'mod'; + * export type * as ns from 'mod'; + * export type { foo }; + * export { type foo }: + * export type { foo } from 'mod'; + * ``` + */ + isType: boolean; +} + +export interface StaticImport { + /** Start of import statement. */ + start: number; + /** End of import statement. */ + end: number; + /** + * Import source. + * + * ```js + * import { foo } from "mod"; + * // ^^^ + * ``` + */ + moduleRequest: ValueSpan; + /** + * Import specifiers. + * + * Empty for `import "mod"`. + */ + entries: Array; +} + +export interface StaticImportEntry { + /** + * The name under which the desired binding is exported by the module. + * + * ```js + * import { foo } from "mod"; + * // ^^^ + * import { foo as bar } from "mod"; + * // ^^^ + * ``` + */ + importName: ImportName; + /** + * The name that is used to locally access the imported value from within the importing module. + * ```js + * import { foo } from "mod"; + * // ^^^ + * import { foo as bar } from "mod"; + * // ^^^ + * ``` + */ + localName: ValueSpan; + /** + * Whether this binding is for a TypeScript type-only import. + * + * `true` for the following imports: + * ```ts + * import type { foo } from "mod"; + * import { type foo } from "mod"; + * ``` + */ + isType: boolean; +} + +export interface ValueSpan { + value: string; + start: number; + end: number; +} +export declare class ResolverFactory { + constructor(options?: NapiResolveOptions | undefined | null); + static default(): ResolverFactory; + /** Clone the resolver using the same underlying cache. */ + cloneWithOptions(options: NapiResolveOptions): ResolverFactory; + /** + * Clear the underlying cache. + * + * Warning: The caller must ensure that there're no ongoing resolution operations when calling this method. Otherwise, it may cause those operations to return an incorrect result. + */ + clearCache(): void; + /** Synchronously resolve `specifier` at an absolute path to a `directory`. */ + sync(directory: string, request: string): ResolveResult; + /** Asynchronously resolve `specifier` at an absolute path to a `directory`. */ + async(directory: string, request: string): Promise; + /** + * Synchronously resolve `specifier` at an absolute path to a `file`. + * + * This method automatically discovers tsconfig.json by traversing parent directories. + */ + resolveFileSync(file: string, request: string): ResolveResult; + /** + * Asynchronously resolve `specifier` at an absolute path to a `file`. + * + * This method automatically discovers tsconfig.json by traversing parent directories. + */ + resolveFileAsync(file: string, request: string): Promise; + /** + * Synchronously resolve `specifier` for TypeScript declaration files. + * + * `file` is the absolute path to the containing file. + * Uses TypeScript's `moduleResolution: "bundler"` algorithm. + */ + resolveDtsSync(file: string, request: string): ResolveResult; + /** + * Asynchronously resolve `specifier` for TypeScript declaration files. + * + * `file` is the absolute path to the containing file. + * Uses TypeScript's `moduleResolution: "bundler"` algorithm. + */ + resolveDtsAsync(file: string, request: string): Promise; +} + +/** Node.js builtin module when `Options::builtin_modules` is enabled. */ +export interface Builtin { + /** + * Resolved module. + * + * Always prefixed with "node:" in compliance with the ESM specification. + */ + resolved: string; + /** + * Whether the request was prefixed with `node:` or not. + * `fs` -> `false`. + * `node:fs` returns `true`. + */ + isRuntimeModule: boolean; +} + +export declare const enum EnforceExtension { + Auto = 0, + Enabled = 1, + Disabled = 2, +} + +export declare const enum ModuleType { + Module = 'module', + CommonJs = 'commonjs', + Json = 'json', + Wasm = 'wasm', + Addon = 'addon', +} + +/** + * Module Resolution Options + * + * Options are directly ported from [enhanced-resolve](https://github.com/webpack/enhanced-resolve#resolver-options). + * + * See [webpack resolve](https://webpack.js.org/configuration/resolve/) for information and examples + */ +export interface NapiResolveOptions { + /** + * Discover tsconfig automatically or use the specified tsconfig.json path. + * + * Default `None` + */ + tsconfig?: 'auto' | TsconfigOptions; + /** + * Alias for [ResolveOptions::alias] and [ResolveOptions::fallback]. + * + * For the second value of the tuple, `None -> AliasValue::Ignore`, Some(String) -> + * AliasValue::Path(String)` + * Create aliases to import or require certain modules more easily. + * A trailing $ can also be added to the given object's keys to signify an exact match. + * Default `{}` + */ + alias?: Record>; + /** + * A list of alias fields in description files. + * Specify a field, such as `browser`, to be parsed according to [this specification](https://github.com/defunctzombie/package-browser-field-spec). + * Can be a path to json object such as `["path", "to", "exports"]`. + * + * Default `[]` + */ + aliasFields?: (string | string[])[]; + /** + * Condition names for exports field which defines entry points of a package. + * The key order in the exports field is significant. During condition matching, earlier entries have higher priority and take precedence over later entries. + * + * Default `[]` + */ + conditionNames?: Array; + /** + * If true, it will not allow extension-less files. + * So by default `require('./foo')` works if `./foo` has a `.js` extension, + * but with this enabled only `require('./foo.js')` will work. + * + * Default to `true` when [ResolveOptions::extensions] contains an empty string. + * Use `Some(false)` to disable the behavior. + * See + * + * Default None, which is the same as `Some(false)` when the above empty rule is not applied. + */ + enforceExtension?: EnforceExtension; + /** + * A list of exports fields in description files. + * Can be a path to json object such as `["path", "to", "exports"]`. + * + * Default `[["exports"]]`. + */ + exportsFields?: (string | string[])[]; + /** + * Fields from `package.json` which are used to provide the internal requests of a package + * (requests starting with # are considered internal). + * + * Can be a path to a JSON object such as `["path", "to", "imports"]`. + * + * Default `[["imports"]]`. + */ + importsFields?: (string | string[])[]; + /** + * An object which maps extension to extension aliases. + * + * Default `{}` + */ + extensionAlias?: Record>; + /** + * Attempt to resolve these extensions in order. + * If multiple files share the same name but have different extensions, + * will resolve the one with the extension listed first in the array and skip the rest. + * + * Default `[".js", ".json", ".node"]` + */ + extensions?: Array; + /** + * Redirect module requests when normal resolving fails. + * + * Default `{}` + */ + fallback?: Record>; + /** + * Request passed to resolve is already fully specified and extensions or main files are not resolved for it (they are still resolved for internal requests). + * + * See also webpack configuration [resolve.fullySpecified](https://webpack.js.org/configuration/module/#resolvefullyspecified) + * + * Default `false` + */ + fullySpecified?: boolean; + /** + * A list of main fields in description files + * + * Default `["main"]`. + */ + mainFields?: string | string[]; + /** + * The filename to be used while resolving directories. + * + * Default `["index"]` + */ + mainFiles?: Array; + /** + * A list of directories to resolve modules from, can be absolute path or folder name. + * + * Default `["node_modules"]` + */ + modules?: string | string[]; + /** + * Resolve to a context instead of a file. + * + * Default `false` + */ + resolveToContext?: boolean; + /** + * Prefer to resolve module requests as relative requests instead of using modules from node_modules directories. + * + * Default `false` + */ + preferRelative?: boolean; + /** + * Prefer to resolve server-relative urls as absolute paths before falling back to resolve in ResolveOptions::roots. + * + * Default `false` + */ + preferAbsolute?: boolean; + /** + * A list of resolve restrictions to restrict the paths that a request can be resolved on. + * + * Default `[]` + */ + restrictions?: Array; + /** + * A list of directories where requests of server-relative URLs (starting with '/') are resolved. + * On non-Windows systems these requests are resolved as an absolute path first. + * + * Default `[]` + */ + roots?: Array; + /** + * Whether to resolve symlinks to their symlinked location. + * When enabled, symlinked resources are resolved to their real path, not their symlinked location. + * Note that this may cause module resolution to fail when using tools that symlink packages (like npm link). + * + * Default `true` + */ + symlinks?: boolean; + /** + * Whether to read the `NODE_PATH` environment variable and append its entries to `modules`. + * + * `NODE_PATH` is a deprecated Node.js feature that is not part of ESM resolution. + * Set this to `false` to disable the behavior. + * + * Default `true` + */ + nodePath?: boolean; + /** + * Whether to parse [module.builtinModules](https://nodejs.org/api/module.html#modulebuiltinmodules) or not. + * For example, "zlib" will throw [crate::ResolveError::Builtin] when set to true. + * + * Default `false` + */ + builtinModules?: boolean; + /** + * Resolve [ResolveResult::moduleType]. + * + * Default `false` + */ + moduleType?: boolean; + /** + * Allow `exports` field in `require('../directory')`. + * + * This is not part of the spec but some vite projects rely on this behavior. + * See + * * + * * + * + * Default: `false` + */ + allowPackageExportsInDirectoryResolve?: boolean; +} + +export interface ResolveResult { + path?: string; + error?: string; + builtin?: Builtin; + /** + * Module type for this path. + * + * Enable with `ResolveOptions#moduleType`. + * + * The module type is computed `ESM_FILE_FORMAT` from the [ESM resolution algorithm specification](https://nodejs.org/docs/latest/api/esm.html#resolution-algorithm-specification). + * + * The algorithm uses the file extension or finds the closest `package.json` with the `type` field. + */ + moduleType?: ModuleType; + /** `package.json` path for the given module. */ + packageJsonPath?: string; +} + +/** + * Alias Value for [ResolveOptions::alias] and [ResolveOptions::fallback]. + * Use struct because napi don't support structured union now + */ +export interface Restriction { + path?: string; + regex?: string; +} + +export declare function sync(path: string, request: string): ResolveResult; + +/** + * Tsconfig Options + * + * Derived from [tsconfig-paths-webpack-plugin](https://github.com/dividab/tsconfig-paths-webpack-plugin#options) + */ +export interface TsconfigOptions { + /** + * Allows you to specify where to find the TypeScript configuration file. + * You may provide + * * a relative path to the configuration file. It will be resolved relative to cwd. + * * an absolute path to the configuration file. + */ + configFile: string; + /** + * Support for Typescript Project References. + * + * * `'auto'`: use the `references` field from tsconfig of `config_file`. + */ + references?: 'auto'; +} +export interface SourceMap { + file?: string; + mappings: string; + names: Array; + sourceRoot?: string; + sources: Array; + sourcesContent?: Array; + version: number; + x_google_ignoreList?: Array; +} +export interface ArrowFunctionsOptions { + /** + * This option enables the following: + * * Wrap the generated function in .bind(this) and keeps uses of this inside the function as-is, instead of using a renamed this. + * * Add a runtime check to ensure the functions are not instantiated. + * * Add names to arrow functions. + * + * @default false + */ + spec?: boolean; +} + +export interface CompilerAssumptions { + ignoreFunctionLength?: boolean; + noDocumentAll?: boolean; + objectRestNoSymbols?: boolean; + pureGetters?: boolean; + /** + * When using public class fields, assume that they don't shadow any getter in the current class, + * in its subclasses or in its superclass. Thus, it's safe to assign them rather than using + * `Object.defineProperty`. + * + * For example: + * + * Input: + * ```js + * class Test { + * field = 2; + * + * static staticField = 3; + * } + * ``` + * + * When `set_public_class_fields` is `true`, the output will be: + * ```js + * class Test { + * constructor() { + * this.field = 2; + * } + * } + * Test.staticField = 3; + * ``` + * + * Otherwise, the output will be: + * ```js + * import _defineProperty from "@oxc-project/runtime/helpers/defineProperty"; + * class Test { + * constructor() { + * _defineProperty(this, "field", 2); + * } + * } + * _defineProperty(Test, "staticField", 3); + * ``` + * + * NOTE: For TypeScript, if you wanted behavior is equivalent to `useDefineForClassFields: false`, you should + * set both `set_public_class_fields` and [`crate::TypeScriptOptions::remove_class_fields_without_initializer`] + * to `true`. + */ + setPublicClassFields?: boolean; +} + +export interface DecoratorOptions { + /** + * Enables experimental support for decorators, which is a version of decorators that predates the TC39 standardization process. + * + * Decorators are a language feature which hasn’t yet been fully ratified into the JavaScript specification. + * This means that the implementation version in TypeScript may differ from the implementation in JavaScript when it it decided by TC39. + * + * @see https://www.typescriptlang.org/tsconfig/#experimentalDecorators + * @default false + */ + legacy?: boolean; + /** + * Enables emitting decorator metadata. + * + * This option the same as [emitDecoratorMetadata](https://www.typescriptlang.org/tsconfig/#emitDecoratorMetadata) + * in TypeScript, and it only works when `legacy` is true. + * + * @see https://www.typescriptlang.org/tsconfig/#emitDecoratorMetadata + * @default false + */ + emitDecoratorMetadata?: boolean; +} + +export interface Es2015Options { + /** Transform arrow functions into function expressions. */ + arrowFunction?: ArrowFunctionsOptions; +} + +export declare const enum HelperMode { + /** + * Runtime mode (default): Helper functions are imported from a runtime package. + * + * Example: + * + * ```js + * import helperName from "@oxc-project/runtime/helpers/helperName"; + * helperName(...arguments); + * ``` + */ + Runtime = 'Runtime', + /** + * External mode: Helper functions are accessed from a global `babelHelpers` object. + * + * Example: + * + * ```js + * babelHelpers.helperName(...arguments); + * ``` + */ + External = 'External', +} + +export interface Helpers { + mode?: HelperMode; +} + +/** + * TypeScript Isolated Declarations for Standalone DTS Emit (async) + * + * Note: This function can be slower than `isolatedDeclarationSync` due to the overhead of spawning a thread. + */ +export declare function isolatedDeclaration( + filename: string, + sourceText: string, + options?: IsolatedDeclarationsOptions | undefined | null, +): Promise; + +export interface IsolatedDeclarationsOptions { + /** + * Do not emit declarations for code that has an @internal annotation in its JSDoc comment. + * This is an internal compiler option; use at your own risk, because the compiler does not check that the result is valid. + * + * Default: `false` + * + * See + */ + stripInternal?: boolean; + sourcemap?: boolean; +} + +export interface IsolatedDeclarationsResult { + code: string; + map?: SourceMap; + errors: Array; +} + +/** TypeScript Isolated Declarations for Standalone DTS Emit */ +export declare function isolatedDeclarationSync( + filename: string, + sourceText: string, + options?: IsolatedDeclarationsOptions | undefined | null, +): IsolatedDeclarationsResult; + +/** + * Configure how TSX and JSX are transformed. + * + * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx} + */ +export interface JsxOptions { + /** + * Decides which runtime to use. + * + * - 'automatic' - auto-import the correct JSX factories + * - 'classic' - no auto-import + * + * @default 'automatic' + */ + runtime?: 'classic' | 'automatic'; + /** + * Emit development-specific information, such as `__source` and `__self`. + * + * @default false + */ + development?: boolean; + /** + * Toggles whether or not to throw an error if an XML namespaced tag name + * is used. + * + * Though the JSX spec allows this, it is disabled by default since React's + * JSX does not currently have support for it. + * + * @default true + */ + throwIfNamespace?: boolean; + /** + * Mark JSX elements and top-level React method calls as pure for tree shaking. + * + * @default true + */ + pure?: boolean; + /** + * Replaces the import source when importing functions. + * + * @default 'react' + */ + importSource?: string; + /** + * Replace the function used when compiling JSX expressions. It should be a + * qualified name (e.g. `React.createElement`) or an identifier (e.g. + * `createElement`). + * + * Only used for `classic` {@link runtime}. + * + * @default 'React.createElement' + */ + pragma?: string; + /** + * Replace the component used when compiling JSX fragments. It should be a + * valid JSX tag name. + * + * Only used for `classic` {@link runtime}. + * + * @default 'React.Fragment' + */ + pragmaFrag?: string; + /** + * Enable React Fast Refresh . + * + * Conforms to the implementation in {@link https://github.com/facebook/react/tree/v18.3.1/packages/react-refresh} + * + * @default false + */ + refresh?: boolean | ReactRefreshOptions; +} + +/** + * Transform JavaScript code to a Vite Node runnable module. + * + * @param filename The name of the file being transformed. + * @param sourceText the source code itself + * @param options The options for the transformation. See {@link + * ModuleRunnerTransformOptions} for more information. + * + * @returns an object containing the transformed code, source maps, and any + * errors that occurred during parsing or transformation. + * + * Note: This function can be slower than `moduleRunnerTransformSync` due to the overhead of spawning a thread. + * + * @deprecated Only works for Vite. + */ +export declare function moduleRunnerTransform( + filename: string, + sourceText: string, + options?: ModuleRunnerTransformOptions | undefined | null, +): Promise; + +export interface ModuleRunnerTransformOptions { + /** + * Enable source map generation. + * + * When `true`, the `sourceMap` field of transform result objects will be populated. + * + * @default false + * + * @see {@link SourceMap} + */ + sourcemap?: boolean; +} + +export interface ModuleRunnerTransformResult { + /** + * The transformed code. + * + * If parsing failed, this will be an empty string. + */ + code: string; + /** + * The source map for the transformed code. + * + * This will be set if {@link TransformOptions#sourcemap} is `true`. + */ + map?: SourceMap; + deps: Array; + dynamicDeps: Array; + /** + * Parse and transformation errors. + * + * Oxc's parser recovers from common syntax errors, meaning that + * transformed code may still be available even if there are errors in this + * list. + */ + errors: Array; +} + +/** @deprecated Only works for Vite. */ +export declare function moduleRunnerTransformSync( + filename: string, + sourceText: string, + options?: ModuleRunnerTransformOptions | undefined | null, +): ModuleRunnerTransformResult; + +export interface PluginsOptions { + styledComponents?: StyledComponentsOptions; + taggedTemplateEscape?: boolean; +} + +export interface ReactRefreshOptions { + /** + * Specify the identifier of the refresh registration variable. + * + * @default `$RefreshReg$`. + */ + refreshReg?: string; + /** + * Specify the identifier of the refresh signature variable. + * + * @default `$RefreshSig$`. + */ + refreshSig?: string; + emitFullSignatures?: boolean; +} + +/** + * Configure how styled-components are transformed. + * + * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins#styled-components} + */ +export interface StyledComponentsOptions { + /** + * Enhances the attached CSS class name on each component with richer output to help + * identify your components in the DOM without React DevTools. + * + * @default true + */ + displayName?: boolean; + /** + * Controls whether the `displayName` of a component will be prefixed with the filename + * to make the component name as unique as possible. + * + * @default true + */ + fileName?: boolean; + /** + * Adds a unique identifier to every styled component to avoid checksum mismatches + * due to different class generation on the client and server during server-side rendering. + * + * @default true + */ + ssr?: boolean; + /** + * Transpiles styled-components tagged template literals to a smaller representation + * than what Babel normally creates, helping to reduce bundle size. + * + * @default true + */ + transpileTemplateLiterals?: boolean; + /** + * Minifies CSS content by removing all whitespace and comments from your CSS, + * keeping valuable bytes out of your bundles. + * + * @default true + */ + minify?: boolean; + /** + * Enables transformation of JSX `css` prop when using styled-components. + * + * **Note: This feature is not yet implemented in oxc.** + * + * @default true + */ + cssProp?: boolean; + /** + * Enables "pure annotation" to aid dead code elimination by bundlers. + * + * @default false + */ + pure?: boolean; + /** + * Adds a namespace prefix to component identifiers to ensure class names are unique. + * + * Example: With `namespace: "my-app"`, generates `componentId: "my-app__sc-3rfj0a-1"` + */ + namespace?: string; + /** + * List of file names that are considered meaningless for component naming purposes. + * + * When the `fileName` option is enabled and a component is in a file with a name + * from this list, the directory name will be used instead of the file name for + * the component's display name. + * + * @default `["index"]` + */ + meaninglessFileNames?: Array; + /** + * Import paths to be considered as styled-components imports at the top level. + * + * **Note: This feature is not yet implemented in oxc.** + */ + topLevelImportPaths?: Array; +} + +/** + * Transpile a JavaScript or TypeScript into a target ECMAScript version, asynchronously. + * + * Note: This function can be slower than `transform` due to the overhead of spawning a thread. + * + * @param filename The name of the file being transformed. If this is a + * relative path, consider setting the {@link TransformOptions#cwd} option. + * @param sourceText the source code itself + * @param options The options for the transformation. See {@link + * TransformOptions} for more information. + * + * @returns a promise that resolves to an object containing the transformed code, + * source maps, and any errors that occurred during parsing or transformation. + */ +export declare function transform( + filename: string, + sourceText: string, + options?: TransformOptions | undefined | null, +): Promise; + +/** + * Options for transforming a JavaScript or TypeScript file. + * + * @see {@link transform} + */ +export interface TransformOptions { + /** Treat the source text as `js`, `jsx`, `ts`, `tsx`, or `dts`. */ + lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts'; + /** Treat the source text as `script` or `module` code. */ + sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined; + /** + * The current working directory. Used to resolve relative paths in other + * options. + */ + cwd?: string; + /** + * Enable source map generation. + * + * When `true`, the `sourceMap` field of transform result objects will be populated. + * + * @default false + * + * @see {@link SourceMap} + */ + sourcemap?: boolean; + /** Set assumptions in order to produce smaller output. */ + assumptions?: CompilerAssumptions; + /** + * Configure how TypeScript is transformed. + * @see {@link https://oxc.rs/docs/guide/usage/transformer/typescript} + */ + typescript?: TypeScriptOptions; + /** + * Configure how TSX and JSX are transformed. + * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx} + */ + jsx?: 'preserve' | JsxOptions; + /** + * Sets the target environment for the generated JavaScript. + * + * The lowest target is `es2015`. + * + * Example: + * + * * `'es2015'` + * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']` + * + * @default `esnext` (No transformation) + * + * @see {@link https://oxc.rs/docs/guide/usage/transformer/lowering#target} + */ + target?: string | Array; + /** Behaviour for runtime helpers. */ + helpers?: Helpers; + /** + * Define Plugin + * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#define} + */ + define?: Record; + /** + * Inject Plugin + * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#inject} + */ + inject?: Record; + /** Decorator plugin */ + decorator?: DecoratorOptions; + /** + * Third-party plugins to use. + * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins} + */ + plugins?: PluginsOptions; +} + +export interface TransformResult { + /** + * The transformed code. + * + * If parsing failed, this will be an empty string. + */ + code: string; + /** + * The source map for the transformed code. + * + * This will be set if {@link TransformOptions#sourcemap} is `true`. + */ + map?: SourceMap; + /** + * The `.d.ts` declaration file for the transformed code. Declarations are + * only generated if `declaration` is set to `true` and a TypeScript file + * is provided. + * + * If parsing failed and `declaration` is set, this will be an empty string. + * + * @see {@link TypeScriptOptions#declaration} + * @see [declaration tsconfig option](https://www.typescriptlang.org/tsconfig/#declaration) + */ + declaration?: string; + /** + * Declaration source map. Only generated if both + * {@link TypeScriptOptions#declaration declaration} and + * {@link TransformOptions#sourcemap sourcemap} are set to `true`. + */ + declarationMap?: SourceMap; + /** + * Helpers used. + * + * @internal + * + * Example: + * + * ```text + * { "_objectSpread": "@oxc-project/runtime/helpers/objectSpread2" } + * ``` + */ + helpersUsed: Record; + /** + * Parse and transformation errors. + * + * Oxc's parser recovers from common syntax errors, meaning that + * transformed code may still be available even if there are errors in this + * list. + */ + errors: Array; +} + +/** + * Transpile a JavaScript or TypeScript into a target ECMAScript version. + * + * @param filename The name of the file being transformed. If this is a + * relative path, consider setting the {@link TransformOptions#cwd} option.. + * @param sourceText the source code itself + * @param options The options for the transformation. See {@link + * TransformOptions} for more information. + * + * @returns an object containing the transformed code, source maps, and any + * errors that occurred during parsing or transformation. + */ +export declare function transformSync( + filename: string, + sourceText: string, + options?: TransformOptions | undefined | null, +): TransformResult; + +export interface TypeScriptOptions { + jsxPragma?: string; + jsxPragmaFrag?: string; + onlyRemoveTypeImports?: boolean; + allowNamespaces?: boolean; + /** + * When enabled, type-only class fields are only removed if they are prefixed with the declare modifier: + * + * @deprecated + * + * Allowing `declare` fields is built-in support in Oxc without any option. If you want to remove class fields + * without initializer, you can use `remove_class_fields_without_initializer: true` instead. + */ + allowDeclareFields?: boolean; + /** + * When enabled, class fields without initializers are removed. + * + * For example: + * ```ts + * class Foo { + * x: number; + * y: number = 0; + * } + * ``` + * // transform into + * ```js + * class Foo { + * x: number; + * } + * ``` + * + * The option is used to align with the behavior of TypeScript's `useDefineForClassFields: false` option. + * When you want to enable this, you also need to set [`crate::CompilerAssumptions::set_public_class_fields`] + * to `true`. The `set_public_class_fields: true` + `remove_class_fields_without_initializer: true` is + * equivalent to `useDefineForClassFields: false` in TypeScript. + * + * When `set_public_class_fields` is true and class-properties plugin is enabled, the above example transforms into: + * + * ```js + * class Foo { + * constructor() { + * this.y = 0; + * } + * } + * ``` + * + * Defaults to `false`. + */ + removeClassFieldsWithoutInitializer?: boolean; + /** + * Also generate a `.d.ts` declaration file for TypeScript files. + * + * The source file must be compliant with all + * [`isolatedDeclarations`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#isolated-declarations) + * requirements. + * + * @default false + */ + declaration?: IsolatedDeclarationsOptions; + /** + * Rewrite or remove TypeScript import/export declaration extensions. + * + * - When set to `rewrite`, it will change `.ts`, `.mts`, `.cts` extensions to `.js`, `.mjs`, `.cjs` respectively. + * - When set to `remove`, it will remove `.ts`/`.mts`/`.cts`/`.tsx` extension entirely. + * - When set to `true`, it's equivalent to `rewrite`. + * - When set to `false` or omitted, no changes will be made to the extensions. + * + * @default false + */ + rewriteImportExtensions?: 'rewrite' | 'remove' | boolean; +} +export declare class BindingBundleEndEventData { + output: string; + duration: number; + get result(): BindingWatcherBundler; +} + +export declare class BindingBundleErrorEventData { + get result(): BindingWatcherBundler; + get error(): Array; +} + +export declare class BindingBundler { + constructor(); + generate(options: BindingBundlerOptions): Promise>; + write(options: BindingBundlerOptions): Promise>; + scan(options: BindingBundlerOptions): Promise>; + close(): Promise; + get closed(): boolean; + getWatchFiles(): Array; +} + +export declare class BindingCallableBuiltinPlugin { + constructor(plugin: BindingBuiltinPlugin); + getOrder(hookName: string): string | null; + resolveId( + id: string, + importer?: string | undefined | null, + options?: BindingHookJsResolveIdOptions | undefined | null, + ): Promise; + load(id: string): Promise; + transform( + code: string, + id: string, + options: BindingTransformHookExtraArgs, + ): Promise; + watchChange(path: string, event: BindingJsWatchChangeEvent): Promise; +} + +export declare class BindingChunkingContext { + getModuleInfo(moduleId: string): BindingModuleInfo | null; +} + +/** A decoded source map with mappings as an array of arrays instead of VLQ-encoded string. */ +export declare class BindingDecodedMap { + /** The source map version (always 3). */ + get version(): number; + /** The generated file name. */ + get file(): string | null; + /** The list of original source files. */ + get sources(): Array; + /** The original source contents (if `includeContent` was true). */ + get sourcesContent(): Array; + /** The list of symbol names used in mappings. */ + get names(): Array; + /** + * The decoded mappings as an array of line arrays. + * Each line is an array of segments, where each segment is [generatedColumn, sourceIndex, originalLine, originalColumn, nameIndex?]. + */ + get mappings(): Array>>; + /** The list of source indices that should be excluded from debugging. */ + get x_google_ignoreList(): Array | null; +} + +export declare class BindingDevEngine { + constructor(options: BindingBundlerOptions, devOptions?: BindingDevOptions | undefined | null); + run(): Promise; + ensureCurrentBuildFinish(): Promise; + getBundleState(): Promise; + ensureLatestBuildOutput(): Promise; + invalidate( + caller: string, + firstInvalidatedBy?: string | undefined | null, + ): Promise>; + registerModules(clientId: string, modules: Array): Promise; + removeClient(clientId: string): Promise; + close(): Promise; + /** + * Compile a lazy entry module and return HMR-style patch code. + * + * This is called when a dynamically imported module is first requested at runtime. + * The module was previously stubbed with a proxy, and now we need to compile the + * actual module and its dependencies. + */ + compileEntry(moduleId: string, clientId: string): Promise; +} + +export declare class BindingLoadPluginContext { + inner(): BindingPluginContext; + addWatchFile(file: string): void; +} + +export declare class BindingMagicString { + constructor(source: string, options?: BindingMagicStringOptions | undefined | null); + get original(): string; + get filename(): string | null; + get indentExclusionRanges(): Array> | Array | null; + get ignoreList(): boolean; + get offset(): number; + set offset(offset: number); + replace(from: string, to: string): this; + replaceAll(from: string, to: string): this; + /** + * Returns the UTF-16 offset past the last match, or -1 if no match was found. + * The JS wrapper uses this to update `lastIndex` on the caller's RegExp. + * Global/sticky behavior is derived from the regex's own flags. + */ + replaceRegex(from: RegExp, to: string): number; + prepend(content: string): this; + append(content: string): this; + prependLeft(index: number, content: string): this; + prependRight(index: number, content: string): this; + appendLeft(index: number, content: string): this; + appendRight(index: number, content: string): this; + overwrite( + start: number, + end: number, + content: string, + options?: BindingOverwriteOptions | undefined | null, + ): this; + toString(): string; + hasChanged(): boolean; + length(): number; + isEmpty(): boolean; + remove(start: number, end: number): this; + update( + start: number, + end: number, + content: string, + options?: BindingUpdateOptions | undefined | null, + ): this; + relocate(start: number, end: number, to: number): this; + /** + * Alias for `relocate` to match the original magic-string API. + * Moves the characters from `start` to `end` to `index`. + * Returns `this` for method chaining. + */ + move(start: number, end: number, index: number): this; + indent( + indentor?: string | undefined | null, + options?: BindingIndentOptions | undefined | null, + ): this; + /** Trims whitespace or specified characters from the start and end. */ + trim(charType?: string | undefined | null): this; + /** Trims whitespace or specified characters from the start. */ + trimStart(charType?: string | undefined | null): this; + /** Trims whitespace or specified characters from the end. */ + trimEnd(charType?: string | undefined | null): this; + /** Trims newlines from the start and end. */ + trimLines(): this; + /** + * Deprecated method that throws an error directing users to use prependRight or appendLeft. + * This matches the original magic-string API which deprecated this method. + */ + insert(index: number, content: string): void; + /** Returns a clone of the MagicString instance. */ + clone(): BindingMagicString; + /** Returns the last character of the generated string, or an empty string if empty. */ + lastChar(): string; + /** Returns the content after the last newline in the generated string. */ + lastLine(): string; + /** Returns the guessed indentation string, or `\t` if none is found. */ + getIndentString(): string; + /** Returns a clone with content outside the specified range removed. */ + snip(start: number, end: number): BindingMagicString; + /** + * Resets the portion of the string from `start` to `end` to its original content. + * This undoes any modifications made to that range. + * Supports negative indices (counting from the end). + */ + reset(start: number, end: number): this; + /** + * Returns the content between the specified UTF-16 code unit positions (JS string indices). + * Supports negative indices (counting from the end). + * + * When an index falls in the middle of a surrogate pair, the lone surrogate is + * included in the result (matching the original magic-string / JS behavior). + * This is done by returning a UTF-16 encoded JS string via `napi_create_string_utf16`. + */ + slice(start?: number | undefined | null, end?: number | undefined | null): string; + /** + * Generates a source map for the transformations applied to this MagicString. + * Returns a BindingSourceMap object with version, file, sources, sourcesContent, names, mappings. + */ + generateMap(options?: BindingSourceMapOptions | undefined | null): BindingSourceMap; + /** + * Generates a decoded source map for the transformations applied to this MagicString. + * Returns a BindingDecodedMap object with mappings as an array of arrays. + */ + generateDecodedMap(options?: BindingSourceMapOptions | undefined | null): BindingDecodedMap; +} + +export declare class BindingModuleInfo { + id: string; + importers: Array; + dynamicImporters: Array; + importedIds: Array; + dynamicallyImportedIds: Array; + exports: Array; + isEntry: boolean; + inputFormat: 'es' | 'cjs' | 'unknown'; + get code(): string | null; +} + +export declare class BindingNormalizedOptions { + get input(): Array | Record; + get cwd(): string; + get platform(): 'node' | 'browser' | 'neutral'; + get shimMissingExports(): boolean; + get name(): string | null; + get entryFilenames(): string | undefined; + get chunkFilenames(): string | undefined; + get assetFilenames(): string | undefined; + get dir(): string | null; + get file(): string | null; + get format(): 'es' | 'cjs' | 'iife' | 'umd'; + get exports(): 'default' | 'named' | 'none' | 'auto'; + get esModule(): boolean | 'if-default-prop'; + get codeSplitting(): boolean; + get dynamicImportInCjs(): boolean; + get sourcemap(): boolean | 'inline' | 'hidden'; + get sourcemapBaseUrl(): string | null; + get banner(): string | undefined | null | undefined; + get footer(): string | undefined | null | undefined; + get intro(): string | undefined | null | undefined; + get outro(): string | undefined | null | undefined; + get postBanner(): string | undefined | null | undefined; + get postFooter(): string | undefined | null | undefined; + get externalLiveBindings(): boolean; + get extend(): boolean; + get globals(): Record | undefined; + get hashCharacters(): 'base64' | 'base36' | 'hex'; + get sourcemapDebugIds(): boolean; + get sourcemapExcludeSources(): boolean; + get polyfillRequire(): boolean; + get minify(): false | 'dce-only' | MinifyOptions; + get legalComments(): 'none' | 'inline'; + get comments(): BindingCommentsOptions; + get preserveModules(): boolean; + get preserveModulesRoot(): string | undefined; + get virtualDirname(): string; + get topLevelVar(): boolean; + get minifyInternalExports(): boolean; + get context(): string; +} + +export declare class BindingOutputAsset { + dropInner(): ExternalMemoryStatus; + getFileName(): string; + getOriginalFileName(): string | null; + getOriginalFileNames(): Array; + getSource(): BindingAssetSource; + getName(): string | null; + getNames(): Array; +} + +export declare class BindingOutputChunk { + dropInner(): ExternalMemoryStatus; + getIsEntry(): boolean; + getIsDynamicEntry(): boolean; + getFacadeModuleId(): string | null; + getModuleIds(): Array; + getExports(): Array; + getFileName(): string; + getModules(): BindingModules; + getImports(): Array; + getDynamicImports(): Array; + getCode(): string; + getMap(): string | null; + getSourcemapFileName(): string | null; + getPreliminaryFileName(): string; + getName(): string; +} + +export declare class BindingPluginContext { + load( + specifier: string, + sideEffects: boolean | 'no-treeshake' | undefined, + packageJsonPath?: string, + ): Promise; + resolve( + specifier: string, + importer?: string | undefined | null, + extraOptions?: BindingPluginContextResolveOptions | undefined | null, + ): Promise; + emitFile( + file: BindingEmittedAsset, + assetFilename?: string | undefined | null, + fnSanitizedFileName?: string | undefined | null, + ): string; + emitChunk(file: BindingEmittedChunk): string; + emitPrebuiltChunk(file: BindingEmittedPrebuiltChunk): string; + getFileName(referenceId: string): string; + getModuleInfo(moduleId: string): BindingModuleInfo | null; + getModuleIds(): Array; + addWatchFile(file: string): void; +} + +export declare class BindingRenderedChunk { + get name(): string; + get isEntry(): boolean; + get isDynamicEntry(): boolean; + get facadeModuleId(): string | null; + get moduleIds(): Array; + get exports(): Array; + get fileName(): string; + get modules(): BindingModules; + get imports(): Array; + get dynamicImports(): Array; +} + +export declare class BindingRenderedChunkMeta { + get chunks(): Record; +} + +export declare class BindingRenderedModule { + get code(): string | null; + get renderedExports(): Array; +} + +/** A source map object with properties matching the SourceMap V3 specification. */ +export declare class BindingSourceMap { + /** The source map version (always 3). */ + get version(): number; + /** The generated file name. */ + get file(): string | null; + /** The list of original source files. */ + get sources(): Array; + /** The original source contents (if `includeContent` was true). */ + get sourcesContent(): Array; + /** The list of symbol names used in mappings. */ + get names(): Array; + /** The VLQ-encoded mappings string. */ + get mappings(): string; + /** The list of source indices that should be excluded from debugging. */ + get x_google_ignoreList(): Array | null; + /** Returns the source map as a JSON string. */ + toString(): string; + /** Returns the source map as a base64-encoded data URL. */ + toUrl(): string; +} + +export declare class BindingTransformPluginContext { + getCombinedSourcemap(): string; + inner(): BindingPluginContext; + addWatchFile(file: string): void; + sendMagicString(magicString: BindingMagicString): string | null; +} + +export declare class BindingWatcher { + constructor(options: BindingBundlerOptions[], listener: (data: BindingWatcherEvent) => void); + run(): Promise; + /** + * Gives consumers a reliable way to await the watcher's completion. + * The Node.js layer relies on the pending Promise to keep the process from exiting. + */ + waitForClose(): Promise; + close(): Promise; +} + +/** + * Minimal wrapper around a `BundleHandle` for watcher events. + * This is returned from watcher event data to allow calling `result.close()`. + */ +export declare class BindingWatcherBundler { + close(): Promise; +} + +export declare class BindingWatcherChangeData { + path: string; + kind: string; +} + +export declare class BindingWatcherEvent { + eventKind(): string; + bundleEventKind(): string; + bundleEndData(): BindingBundleEndEventData; + bundleErrorData(): BindingBundleErrorEventData; + watchChangeData(): BindingWatcherChangeData; +} + +export declare class ParallelJsPluginRegistry { + id: number; + workerCount: number; + constructor(workerCount: number); +} + +export declare class ScheduledBuild { + wait(): Promise; + alreadyScheduled(): boolean; +} + +export declare class TraceSubscriberGuard { + close(): void; +} + +export declare class TsconfigCache { + /** Create a new transform cache with auto tsconfig discovery enabled. */ + constructor(yarnPnp: boolean); + /** + * Clear the cache. + * + * Call this when tsconfig files have changed to ensure fresh resolution. + */ + clear(): void; + /** Get the number of cached entries. */ + size(): number; +} + +export interface AliasItem { + find: string; + replacements: Array; +} + +export interface BindingAssetSource { + inner: string | Uint8Array; +} + +export declare const enum BindingAttachDebugInfo { + None = 0, + Simple = 1, + Full = 2, +} + +export interface BindingBuiltinPlugin { + __name: BindingBuiltinPluginName; + options?: unknown; +} + +export declare const enum BindingBuiltinPluginName { + BundleAnalyzer = 'builtin:bundle-analyzer', + EsmExternalRequire = 'builtin:esm-external-require', + IsolatedDeclaration = 'builtin:isolated-declaration', + Replace = 'builtin:replace', + ViteAlias = 'builtin:vite-alias', + ViteBuildImportAnalysis = 'builtin:vite-build-import-analysis', + ViteDynamicImportVars = 'builtin:vite-dynamic-import-vars', + ViteImportGlob = 'builtin:vite-import-glob', + ViteJson = 'builtin:vite-json', + ViteLoadFallback = 'builtin:vite-load-fallback', + ViteManifest = 'builtin:vite-manifest', + ViteModulePreloadPolyfill = 'builtin:vite-module-preload-polyfill', + ViteReactRefreshWrapper = 'builtin:vite-react-refresh-wrapper', + ViteReporter = 'builtin:vite-reporter', + ViteResolve = 'builtin:vite-resolve', + ViteTransform = 'builtin:vite-transform', + ViteWasmFallback = 'builtin:vite-wasm-fallback', + ViteWebWorkerPost = 'builtin:vite-web-worker-post', + OxcRuntime = 'builtin:oxc-runtime', +} + +export interface BindingBundleAnalyzerPluginConfig { + /** Output filename for the bundle analysis data (default: "analyze-data.json") */ + fileName?: string; + /** Output format: "json" (default) or "md" for LLM-friendly markdown */ + format?: 'json' | 'md'; +} + +export interface BindingBundlerOptions { + inputOptions: BindingInputOptions; + outputOptions: BindingOutputOptions; + parallelPluginsRegistry?: ParallelJsPluginRegistry; +} + +export interface BindingBundleState { + lastFullBuildFailed: boolean; + hasStaleOutput: boolean; +} + +export interface BindingChecksOptions { + circularDependency?: boolean; + eval?: boolean; + missingGlobalName?: boolean; + missingNameOptionForIifeExport?: boolean; + mixedExports?: boolean; + unresolvedEntry?: boolean; + unresolvedImport?: boolean; + filenameConflict?: boolean; + commonJsVariableInEsm?: boolean; + importIsUndefined?: boolean; + emptyImportMeta?: boolean; + toleratedTransform?: boolean; + cannotCallNamespace?: boolean; + configurationFieldConflict?: boolean; + preferBuiltinFeature?: boolean; + couldNotCleanDirectory?: boolean; + pluginTimings?: boolean; + duplicateShebang?: boolean; + unsupportedTsconfigOption?: boolean; + ineffectiveDynamicImport?: boolean; +} + +export interface BindingChunkImportMap { + baseUrl?: string; + fileName?: string; +} + +export declare const enum BindingChunkModuleOrderBy { + ModuleId = 0, + ExecOrder = 1, +} + +export interface BindingClientHmrUpdate { + clientId: string; + update: BindingHmrUpdate; +} + +export interface BindingCommentsOptions { + legal?: boolean; + annotation?: boolean; + jsdoc?: boolean; +} + +export interface BindingCompilerOptions { + baseUrl?: string; + paths?: Record>; + experimentalDecorators?: boolean; + emitDecoratorMetadata?: boolean; + useDefineForClassFields?: boolean; + rewriteRelativeImportExtensions?: boolean; + jsx?: string; + jsxFactory?: string; + jsxFragmentFactory?: string; + jsxImportSource?: string; + verbatimModuleSyntax?: boolean; + preserveValueImports?: boolean; + importsNotUsedAsValues?: string; + target?: string; + module?: string; + allowJs?: boolean; + rootDirs?: Array; +} + +export interface BindingDeferSyncScanData { + /** ModuleId */ + id: string; + sideEffects?: boolean | 'no-treeshake'; +} + +export interface BindingDevOptions { + onHmrUpdates?: + | undefined + | ((result: BindingResult<[BindingClientHmrUpdate[], string[]]>) => void | Promise); + onOutput?: undefined | ((result: BindingResult) => void | Promise); + rebuildStrategy?: BindingRebuildStrategy; + watch?: BindingDevWatchOptions; +} + +export interface BindingDevtoolsOptions { + sessionId?: string; +} + +export interface BindingDevWatchOptions { + skipWrite?: boolean; + usePolling?: boolean; + pollInterval?: number; + useDebounce?: boolean; + debounceDuration?: number; + compareContentsForPolling?: boolean; + debounceTickRate?: number; +} + +export interface BindingEmittedAsset { + name?: string; + fileName?: string; + originalFileName?: string; + source: BindingAssetSource; +} + +export interface BindingEmittedChunk { + name?: string; + fileName?: string; + id: string; + importer?: string; + preserveEntrySignatures?: BindingPreserveEntrySignatures; +} + +export interface BindingEmittedPrebuiltChunk { + fileName: string; + name?: string; + code: string; + exports?: Array; + map?: BindingSourcemap; + sourcemapFileName?: string; + facadeModuleId?: string; + isEntry?: boolean; + isDynamicEntry?: boolean; +} + +/** Enhanced transform options with tsconfig and inputMap support. */ +export interface BindingEnhancedTransformOptions { + /** Treat the source text as 'js', 'jsx', 'ts', 'tsx', or 'dts'. */ + lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts'; + /** Treat the source text as 'script', 'module', 'commonjs', or 'unambiguous'. */ + sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined; + /** + * The current working directory. Used to resolve relative paths in other + * options. + */ + cwd?: string; + /** + * Enable source map generation. + * + * When `true`, the `sourceMap` field of transform result objects will be populated. + * + * @default false + */ + sourcemap?: boolean; + /** Set assumptions in order to produce smaller output. */ + assumptions?: CompilerAssumptions; + /** + * Configure how TypeScript is transformed. + * @see {@link https://oxc.rs/docs/guide/usage/transformer/typescript} + */ + typescript?: TypeScriptOptions; + /** + * Configure how TSX and JSX are transformed. + * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx} + */ + jsx?: 'preserve' | JsxOptions; + /** + * Sets the target environment for the generated JavaScript. + * + * The lowest target is `es2015`. + * + * Example: + * + * * `'es2015'` + * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']` + * + * @default `esnext` (No transformation) + * + * @see {@link https://oxc.rs/docs/guide/usage/transformer/lowering#target} + */ + target?: string | Array; + /** Behaviour for runtime helpers. */ + helpers?: Helpers; + /** + * Define Plugin + * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#define} + */ + define?: Record; + /** + * Inject Plugin + * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#inject} + */ + inject?: Record; + /** Decorator plugin */ + decorator?: DecoratorOptions; + /** + * Third-party plugins to use. + * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins} + */ + plugins?: PluginsOptions; + /** + * Configure tsconfig handling. + * - true: Auto-discover and load the nearest tsconfig.json + * - TsconfigRawOptions: Use the provided inline tsconfig options + */ + tsconfig?: boolean | BindingTsconfigRawOptions; + /** An input source map to collapse with the output source map. */ + inputMap?: SourceMap; +} + +/** Result of the enhanced transform API. */ +export interface BindingEnhancedTransformResult { + /** + * The transformed code. + * + * If parsing failed, this will be an empty string. + */ + code: string; + /** + * The source map for the transformed code. + * + * This will be set if {@link BindingEnhancedTransformOptions#sourcemap} is `true`. + */ + map?: SourceMap; + /** + * The `.d.ts` declaration file for the transformed code. Declarations are + * only generated if `declaration` is set to `true` and a TypeScript file + * is provided. + * + * If parsing failed and `declaration` is set, this will be an empty string. + * + * @see {@link TypeScriptOptions#declaration} + * @see [declaration tsconfig option](https://www.typescriptlang.org/tsconfig/#declaration) + */ + declaration?: string; + /** + * Declaration source map. Only generated if both + * {@link TypeScriptOptions#declaration declaration} and + * {@link BindingEnhancedTransformOptions#sourcemap sourcemap} are set to `true`. + */ + declarationMap?: SourceMap; + /** + * Helpers used. + * + * @internal + * + * Example: + * + * ```text + * { "_objectSpread": "@oxc-project/runtime/helpers/objectSpread2" } + * ``` + */ + helpersUsed: Record; + /** Parse and transformation errors. */ + errors: Array; + /** Parse and transformation warnings. */ + warnings: Array; + /** Paths to tsconfig files that were loaded during transformation. */ + tsconfigFilePaths: Array; +} + +export type BindingError = + | { type: 'JsError'; field0: Error } + | { type: 'NativeError'; field0: NativeError }; + +export interface BindingErrors { + errors: Array; + isBindingErrors: boolean; +} + +export interface BindingEsmExternalRequirePluginConfig { + external: Array; + skipDuplicateCheck?: boolean; +} + +export interface BindingExperimentalDevModeOptions { + host?: string; + port?: number; + implement?: string; + lazy?: boolean; +} + +export interface BindingExperimentalOptions { + viteMode?: boolean; + resolveNewUrlToAsset?: boolean; + devMode?: BindingExperimentalDevModeOptions; + attachDebugInfo?: BindingAttachDebugInfo; + chunkModulesOrder?: BindingChunkModuleOrderBy; + chunkImportMap?: boolean | BindingChunkImportMap; + onDemandWrapping?: boolean; + incrementalBuild?: boolean; + nativeMagicString?: boolean; + chunkOptimization?: boolean; + lazyBarrel?: boolean; +} + +export interface BindingFilterToken { + kind: FilterTokenKind; + payload?: BindingStringOrRegex | number | boolean; +} + +export interface BindingGeneratedCodeOptions { + symbols?: boolean; + preset?: string; +} + +export type BindingGenerateHmrPatchReturn = + | { type: 'Ok'; field0: Array } + | { type: 'Error'; field0: Array }; + +export interface BindingHmrBoundaryOutput { + boundary: string; + acceptedVia: string; +} + +export type BindingHmrUpdate = + | { + type: 'Patch'; + code: string; + filename: string; + sourcemap?: string; + sourcemapFilename?: string; + hmrBoundaries: Array; + } + | { type: 'FullReload'; reason?: string } + | { type: 'Noop' }; + +export interface BindingHookFilter { + value?: Array>; +} + +export interface BindingHookJsLoadOutput { + code: string; + map?: string; + moduleSideEffects?: boolean | 'no-treeshake'; +} + +export interface BindingHookJsResolveIdOptions { + isEntry?: boolean; + scan?: boolean; + custom?: BindingVitePluginCustom; +} + +export interface BindingHookJsResolveIdOutput { + id: string; + external?: boolean | 'absolute' | 'relative'; + moduleSideEffects?: boolean | 'no-treeshake'; +} + +export interface BindingHookLoadOutput { + code: string; + moduleSideEffects?: boolean | 'no-treeshake'; + map?: BindingSourcemap; + moduleType?: string; +} + +export interface BindingHookRenderChunkOutput { + code: string; + map?: BindingSourcemap; +} + +export interface BindingHookResolveIdExtraArgs { + custom?: number; + isEntry: boolean; + /** + * - `import-statement`: `import { foo } from './lib.js';` + * - `dynamic-import`: `import('./lib.js')` + * - `require-call`: `require('./lib.js')` + * - `import-rule`: `@import 'bg-color.css'` + * - `url-token`: `url('./icon.png')` + * - `new-url`: `new URL('./worker.js', import.meta.url)` + * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})` + */ + kind: + | 'import-statement' + | 'dynamic-import' + | 'require-call' + | 'import-rule' + | 'url-token' + | 'new-url' + | 'hot-accept'; +} + +export interface BindingHookResolveIdOutput { + id: string; + external?: BindingResolvedExternal; + normalizeExternalId?: boolean; + moduleSideEffects?: boolean | 'no-treeshake'; + /** + * @internal Used to store package json path resolved by oxc resolver, + * we could get the related package json object via the path string. + */ + packageJsonPath?: string | null; +} + +export type BindingHookSideEffects = boolean | string; + +export interface BindingHookTransformOutput { + code?: string; + moduleSideEffects?: BindingHookSideEffects; + map?: BindingSourcemap; + moduleType?: string; +} + +export interface BindingIndentOptions { + exclude?: Array> | Array; +} + +export interface BindingInjectImportNamed { + tagNamed: true; + imported: string; + alias?: string; + from: string; +} + +export interface BindingInjectImportNamespace { + tagNamespace: true; + alias: string; + from: string; +} + +export interface BindingInlineConstConfig { + mode?: string; + pass?: number; +} + +export interface BindingInputItem { + name?: string; + import: string; +} + +export interface BindingInputOptions { + external?: + | Array + | ((source: string, importer: string | undefined, isResolved: boolean) => boolean); + input: Array; + plugins: (BindingBuiltinPlugin | BindingPluginOptions | undefined)[]; + resolve?: BindingResolveOptions; + shimMissingExports?: boolean; + platform?: 'node' | 'browser' | 'neutral'; + logLevel: BindingLogLevel; + onLog: (logLevel: 'debug' | 'warn' | 'info', log: BindingLog) => Promise; + cwd: string; + treeshake?: BindingTreeshake; + moduleTypes?: Record; + define?: Array<[string, string]>; + dropLabels?: Array; + inject?: Array; + experimental?: BindingExperimentalOptions; + profilerNames?: boolean; + transform?: TransformOptions; + watch?: BindingWatchOption; + keepNames?: boolean; + checks?: BindingChecksOptions; + deferSyncScanData?: undefined | (() => BindingDeferSyncScanData[]); + makeAbsoluteExternalsRelative?: BindingMakeAbsoluteExternalsRelative; + devtools?: BindingDevtoolsOptions; + invalidateJsSideCache?: () => void; + preserveEntrySignatures?: BindingPreserveEntrySignatures; + optimization?: BindingOptimization; + context?: string; + tsconfig?: boolean | string; +} + +export interface BindingIsolatedDeclarationPluginConfig { + stripInternal?: boolean; +} + +export interface BindingJsonSourcemap { + file?: string; + mappings?: string; + sourceRoot?: string; + sources?: Array; + sourcesContent?: Array; + names?: Array; + debugId?: string; + x_google_ignoreList?: Array; +} + +export interface BindingJsWatchChangeEvent { + event: string; +} + +export interface BindingLog { + message: string; + id?: string; + code?: string; + exporter?: string; + plugin?: string; + /** Location information (line, column, file) */ + loc?: BindingLogLocation; + /** Position in the source file in UTF-16 code units */ + pos?: number; + /** List of module IDs (used for CIRCULAR_DEPENDENCY warnings) */ + ids?: Array; +} + +export declare const enum BindingLogLevel { + Silent = 0, + Warn = 1, + Info = 2, + Debug = 3, +} + +export interface BindingLogLocation { + /** 1-based */ + line: number; + /** 0-based position in the line in UTF-16 code units */ + column: number; + file?: string; +} + +export interface BindingMagicStringOptions { + filename?: string; + offset?: number; + indentExclusionRanges?: Array> | Array; + ignoreList?: boolean; +} + +export type BindingMakeAbsoluteExternalsRelative = + | { type: 'Bool'; field0: boolean } + | { type: 'IfRelativeSource' }; + +export interface BindingManualCodeSplittingOptions { + includeDependenciesRecursively?: boolean; + minSize?: number; + minShareCount?: number; + groups?: Array; + maxSize?: number; + minModuleSize?: number; + maxModuleSize?: number; +} + +export interface BindingMatchGroup { + name: string | ((id: string, ctx: BindingChunkingContext) => VoidNullable); + test?: string | RegExp | ((id: string) => VoidNullable); + priority?: number; + minSize?: number; + minShareCount?: number; + minModuleSize?: number; + maxModuleSize?: number; + maxSize?: number; + entriesAware?: boolean; + entriesAwareMergeThreshold?: number; + tags?: Array; +} + +export interface BindingModulePreloadOptions { + polyfill: boolean; + resolveDependencies?: ( + filename: string, + deps: string[], + context: { hostId: string; hostType: 'html' | 'js' }, + ) => string[]; +} + +export interface BindingModules { + values: Array; + keys: Array; +} + +export interface BindingModuleSideEffectsRule { + test?: RegExp | undefined; + sideEffects: boolean; + external?: boolean | undefined; +} + +export interface BindingOptimization { + inlineConst?: boolean | BindingInlineConstConfig; + pifeForModuleWrappers?: boolean; +} + +export interface BindingOutputOptions { + name?: string; + assetFileNames?: string | ((chunk: BindingPreRenderedAsset) => string); + entryFileNames?: string | ((chunk: PreRenderedChunk) => string); + chunkFileNames?: string | ((chunk: PreRenderedChunk) => string); + sanitizeFileName?: boolean | ((name: string) => string); + banner?: string | ((chunk: BindingRenderedChunk) => MaybePromise>); + postBanner?: string | ((chunk: BindingRenderedChunk) => MaybePromise>); + footer?: string | ((chunk: BindingRenderedChunk) => MaybePromise>); + postFooter?: string | ((chunk: BindingRenderedChunk) => MaybePromise>); + dir?: string; + file?: string; + esModule?: boolean | 'if-default-prop'; + exports?: 'default' | 'named' | 'none' | 'auto'; + extend?: boolean; + externalLiveBindings?: boolean; + format?: 'es' | 'cjs' | 'iife' | 'umd'; + generatedCode?: BindingGeneratedCodeOptions; + globals?: Record | ((name: string) => string); + hashCharacters?: 'base64' | 'base36' | 'hex'; + inlineDynamicImports?: boolean; + dynamicImportInCjs?: boolean; + intro?: string | ((chunk: BindingRenderedChunk) => MaybePromise>); + outro?: string | ((chunk: BindingRenderedChunk) => MaybePromise>); + paths?: Record | ((id: string) => string); + plugins: (BindingBuiltinPlugin | BindingPluginOptions | undefined)[]; + sourcemap?: 'file' | 'inline' | 'hidden'; + sourcemapBaseUrl?: string; + sourcemapIgnoreList?: + | boolean + | string + | RegExp + | ((source: string, sourcemapPath: string) => boolean); + sourcemapDebugIds?: boolean; + sourcemapPathTransform?: (source: string, sourcemapPath: string) => string; + sourcemapExcludeSources?: boolean; + strict?: boolean | 'auto'; + minify?: boolean | 'dce-only' | MinifyOptions; + manualCodeSplitting?: BindingManualCodeSplittingOptions; + legalComments?: 'none' | 'inline'; + comments?: boolean | BindingCommentsOptions; + polyfillRequire?: boolean; + preserveModules?: boolean; + virtualDirname?: string; + preserveModulesRoot?: string; + topLevelVar?: boolean; + minifyInternalExports?: boolean; + cleanDir?: boolean; + strictExecutionOrder?: boolean; +} + +export interface BindingOutputs { + chunks: Array; + assets: Array; +} + +export interface BindingOverwriteOptions { + contentOnly?: boolean; +} + +export interface BindingPluginContextResolvedId { + id: string; + packageJsonPath?: string; + external: boolean | 'absolute' | 'relative'; + moduleSideEffects?: boolean | 'no-treeshake'; +} + +export interface BindingPluginContextResolveOptions { + /** + * - `import-statement`: `import { foo } from './lib.js';` + * - `dynamic-import`: `import('./lib.js')` + * - `require-call`: `require('./lib.js')` + * - `import-rule`: `@import 'bg-color.css'` + * - `url-token`: `url('./icon.png')` + * - `new-url`: `new URL('./worker.js', import.meta.url)` + * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})` + */ + importKind?: + | 'import-statement' + | 'dynamic-import' + | 'require-call' + | 'import-rule' + | 'url-token' + | 'new-url' + | 'hot-accept'; + isEntry?: boolean; + skipSelf?: boolean; + custom?: number; + vitePluginCustom?: BindingVitePluginCustom; +} + +export interface BindingPluginHookMeta { + order?: BindingPluginOrder; +} + +export interface BindingPluginOptions { + name: string; + hookUsage: number; + buildStart?: ( + ctx: BindingPluginContext, + opts: BindingNormalizedOptions, + ) => MaybePromise; + buildStartMeta?: BindingPluginHookMeta; + resolveId?: ( + ctx: BindingPluginContext, + specifier: string, + importer: Nullable, + options: BindingHookResolveIdExtraArgs, + ) => MaybePromise>; + resolveIdMeta?: BindingPluginHookMeta; + resolveIdFilter?: BindingHookFilter; + resolveDynamicImport?: ( + ctx: BindingPluginContext, + specifier: string, + importer: Nullable, + ) => MaybePromise>; + resolveDynamicImportMeta?: BindingPluginHookMeta; + load?: ( + ctx: BindingLoadPluginContext, + id: string, + ) => MaybePromise>; + loadMeta?: BindingPluginHookMeta; + loadFilter?: BindingHookFilter; + transform?: ( + ctx: BindingTransformPluginContext, + id: string, + code: string, + module_type: BindingTransformHookExtraArgs, + ) => MaybePromise>; + transformMeta?: BindingPluginHookMeta; + transformFilter?: BindingHookFilter; + moduleParsed?: ( + ctx: BindingPluginContext, + module: BindingModuleInfo, + ) => MaybePromise; + moduleParsedMeta?: BindingPluginHookMeta; + buildEnd?: (ctx: BindingPluginContext, error?: BindingError[]) => MaybePromise; + buildEndMeta?: BindingPluginHookMeta; + renderChunk?: ( + ctx: BindingPluginContext, + code: string, + chunk: BindingRenderedChunk, + opts: BindingNormalizedOptions, + meta: BindingRenderedChunkMeta, + ) => MaybePromise>; + renderChunkMeta?: BindingPluginHookMeta; + renderChunkFilter?: BindingHookFilter; + augmentChunkHash?: ( + ctx: BindingPluginContext, + chunk: BindingRenderedChunk, + ) => MaybePromise; + augmentChunkHashMeta?: BindingPluginHookMeta; + renderStart?: (ctx: BindingPluginContext, opts: BindingNormalizedOptions) => void; + renderStartMeta?: BindingPluginHookMeta; + renderError?: (ctx: BindingPluginContext, error: BindingError[]) => void; + renderErrorMeta?: BindingPluginHookMeta; + generateBundle?: ( + ctx: BindingPluginContext, + bundle: BindingErrorsOr, + isWrite: boolean, + opts: BindingNormalizedOptions, + ) => MaybePromise>; + generateBundleMeta?: BindingPluginHookMeta; + writeBundle?: ( + ctx: BindingPluginContext, + bundle: BindingErrorsOr, + opts: BindingNormalizedOptions, + ) => MaybePromise>; + writeBundleMeta?: BindingPluginHookMeta; + closeBundle?: (ctx: BindingPluginContext, error?: BindingError[]) => MaybePromise; + closeBundleMeta?: BindingPluginHookMeta; + watchChange?: ( + ctx: BindingPluginContext, + path: string, + event: string, + ) => MaybePromise; + watchChangeMeta?: BindingPluginHookMeta; + closeWatcher?: (ctx: BindingPluginContext) => MaybePromise; + closeWatcherMeta?: BindingPluginHookMeta; + banner?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void; + bannerMeta?: BindingPluginHookMeta; + footer?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void; + footerMeta?: BindingPluginHookMeta; + intro?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void; + introMeta?: BindingPluginHookMeta; + outro?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void; + outroMeta?: BindingPluginHookMeta; +} + +export declare const enum BindingPluginOrder { + Pre = 0, + Post = 1, +} + +export interface BindingPluginWithIndex { + index: number; + plugin: BindingPluginOptions; +} + +export interface BindingPreRenderedAsset { + name?: string; + names: Array; + originalFileName?: string; + originalFileNames: Array; + source: BindingAssetSource; +} + +export type BindingPreserveEntrySignatures = + | { type: 'Bool'; field0: boolean } + | { type: 'String'; field0: string }; + +export declare const enum BindingPropertyReadSideEffects { + Always = 0, + False = 1, +} + +export declare const enum BindingPropertyWriteSideEffects { + Always = 0, + False = 1, +} + +export declare const enum BindingRebuildStrategy { + Always = 0, + Auto = 1, + Never = 2, +} + +export interface BindingRenderBuiltUrlConfig { + ssr: boolean; + type: 'asset' | 'public'; + hostId: string; + hostType: 'js' | 'css' | 'html'; +} + +export interface BindingRenderBuiltUrlRet { + relative?: boolean; + runtime?: string; +} + +export interface BindingReplacePluginConfig { + values: Record; + delimiters?: [string, string]; + preventAssignment?: boolean; + objectGuards?: boolean; + sourcemap?: boolean; +} + +export interface BindingResolveDependenciesContext { + hostId: string; + hostType: string; +} + +export type BindingResolvedExternal = boolean | string; + +export interface BindingResolveOptions { + alias?: Array; + aliasFields?: Array>; + conditionNames?: Array; + exportsFields?: Array>; + extensions?: Array; + extensionAlias?: Array; + mainFields?: Array; + mainFiles?: Array; + modules?: Array; + symlinks?: boolean; + yarnPnp?: boolean; +} + +export interface BindingSourcemap { + inner: string | BindingJsonSourcemap; +} + +export interface BindingSourceMapOptions { + /** The filename for the generated file (goes into `map.file`) */ + file?: string; + /** The filename of the original source (goes into `map.sources`) */ + source?: string; + includeContent?: boolean; + /** + * Accepts boolean or string: true, false, "boundary" + * - true: high-resolution sourcemaps (character-level) + * - false: low-resolution sourcemaps (line-level) - default + * - "boundary": high-resolution only at word boundaries + */ + hires?: boolean | string; +} + +export interface BindingTransformHookExtraArgs { + moduleType: string; +} + +export interface BindingTreeshake { + moduleSideEffects: + | boolean + | ReadonlyArray + | BindingModuleSideEffectsRule[] + | ((id: string, external: boolean) => boolean | undefined); + annotations?: boolean; + manualPureFunctions?: ReadonlyArray; + unknownGlobalSideEffects?: boolean; + invalidImportSideEffects?: boolean; + commonjs?: boolean; + propertyReadSideEffects?: BindingPropertyReadSideEffects; + propertyWriteSideEffects?: BindingPropertyWriteSideEffects; +} + +export interface BindingTsconfig { + files?: Array; + include?: Array; + exclude?: Array; + compilerOptions: BindingCompilerOptions; +} + +/** + * TypeScript compiler options for inline tsconfig configuration. + * + * @category Utilities + */ +export interface BindingTsconfigCompilerOptions { + /** Specifies the JSX factory function to use. */ + jsx?: 'react' | 'react-jsx' | 'react-jsxdev' | 'preserve' | 'react-native'; + /** Specifies the JSX factory function. */ + jsxFactory?: string; + /** Specifies the JSX fragment factory function. */ + jsxFragmentFactory?: string; + /** Specifies the module specifier for JSX imports. */ + jsxImportSource?: string; + /** Enables experimental decorators. */ + experimentalDecorators?: boolean; + /** Enables decorator metadata emission. */ + emitDecoratorMetadata?: boolean; + /** Preserves module structure of imports/exports. */ + verbatimModuleSyntax?: boolean; + /** Configures how class fields are emitted. */ + useDefineForClassFields?: boolean; + /** The ECMAScript target version. */ + target?: string; + /** @deprecated Use verbatimModuleSyntax instead. */ + preserveValueImports?: boolean; + /** @deprecated Use verbatimModuleSyntax instead. */ + importsNotUsedAsValues?: 'remove' | 'preserve' | 'error'; +} + +/** + * Raw tsconfig options for inline configuration. + * + * @category Utilities + */ +export interface BindingTsconfigRawOptions { + /** TypeScript compiler options. */ + compilerOptions?: BindingTsconfigCompilerOptions; +} + +export interface BindingTsconfigResult { + tsconfig: BindingTsconfig; + tsconfigFilePaths: Array; +} + +export interface BindingUpdateOptions { + overwrite?: boolean; +} + +export interface BindingViteAliasPluginAlias { + find: BindingStringOrRegex; + replacement: string; +} + +export interface BindingViteAliasPluginConfig { + entries: Array; +} + +export interface BindingViteBuildImportAnalysisPluginConfig { + preloadCode: string; + insertPreload: boolean; + optimizeModulePreloadRelativePaths: boolean; + renderBuiltUrl: boolean; + isRelativeBase: boolean; + v2?: BindingViteBuildImportAnalysisPluginV2Config; +} + +export interface BindingViteBuildImportAnalysisPluginV2Config { + isSsr: boolean; + urlBase: string; + decodedBase: string; + modulePreload: false | BindingModulePreloadOptions; + renderBuiltUrl?: ( + filename: string, + type: BindingRenderBuiltUrlConfig, + ) => undefined | string | BindingRenderBuiltUrlRet; +} + +export interface BindingViteDynamicImportVarsPluginConfig { + sourcemap?: boolean; + include?: Array; + exclude?: Array; + resolver?: (id: string, importer: string) => MaybePromise; +} + +export interface BindingViteImportGlobPluginConfig { + root?: string; + sourcemap?: boolean; + restoreQueryExtension?: boolean; +} + +export interface BindingViteJsonPluginConfig { + minify?: boolean; + namedExports?: boolean; + stringify?: BindingViteJsonPluginStringify; +} + +export type BindingViteJsonPluginStringify = boolean | string; + +export interface BindingViteManifestPluginConfig { + root: string; + outPath: string; + isEnableV2?: boolean; + isLegacy?: (args: BindingNormalizedOptions) => boolean; + cssEntries: () => Record; +} + +export interface BindingViteModulePreloadPolyfillPluginConfig { + isServer?: boolean; +} + +export interface BindingVitePluginCustom { + 'vite:import-glob'?: ViteImportGlobMeta; +} + +export interface BindingViteReactRefreshWrapperPluginConfig { + cwd: string; + include?: Array; + exclude?: Array; + jsxImportSource: string; + reactRefreshHost: string; +} + +export interface BindingViteReporterPluginConfig { + root: string; + isTty: boolean; + isLib: boolean; + assetsDir: string; + chunkLimit: number; + warnLargeChunks: boolean; + reportCompressedSize: boolean; + logInfo?: (msg: string) => void; +} + +export interface BindingViteResolvePluginConfig { + resolveOptions: BindingViteResolvePluginResolveOptions; + environmentConsumer: string; + environmentName: string; + builtins: Array; + external: true | string[]; + noExternal: true | Array; + dedupe: Array; + disableCache?: boolean; + legacyInconsistentCjsInterop?: boolean; + finalizeBareSpecifier?: ( + resolvedId: string, + rawId: string, + importer: string | null | undefined, + ) => VoidNullable; + finalizeOtherSpecifiers?: (resolvedId: string, rawId: string) => VoidNullable; + resolveSubpathImports: ( + id: string, + importer: string, + isRequire: boolean, + scan: boolean, + ) => VoidNullable; + onWarn?: (message: string) => void; + onDebug?: (message: string) => void; + yarnPnp: boolean; +} + +export interface BindingViteResolvePluginResolveOptions { + isBuild: boolean; + isProduction: boolean; + asSrc: boolean; + preferRelative: boolean; + isRequire?: boolean; + root: string; + scan: boolean; + mainFields: Array; + conditions: Array; + externalConditions: Array; + extensions: Array; + tryIndex: boolean; + tryPrefix?: string; + preserveSymlinks: boolean; + tsconfigPaths: boolean; +} + +export interface BindingViteTransformPluginConfig { + root: string; + include?: Array; + exclude?: Array; + jsxRefreshInclude?: Array; + jsxRefreshExclude?: Array; + isServerConsumer?: boolean; + jsxInject?: string; + transformOptions?: TransformOptions; + yarnPnp?: boolean; +} + +export interface BindingWatchOption { + skipWrite?: boolean; + include?: Array; + exclude?: Array; + buildDelay?: number; + usePolling?: boolean; + pollInterval?: number; + compareContentsForPolling?: boolean; + useDebounce?: boolean; + debounceDelay?: number; + debounceTickRate?: number; + onInvalidate?: ((id: string) => void) | undefined; +} + +export declare function collapseSourcemaps( + sourcemapChain: Array, +): BindingJsonSourcemap; + +export declare function enhancedTransform( + filename: string, + sourceText: string, + options: BindingEnhancedTransformOptions | undefined | null, + cache: TsconfigCache | undefined | null, + yarnPnp: boolean, +): Promise; + +export declare function enhancedTransformSync( + filename: string, + sourceText: string, + options: BindingEnhancedTransformOptions | undefined | null, + cache: TsconfigCache | undefined | null, + yarnPnp: boolean, +): BindingEnhancedTransformResult; + +export interface ExtensionAliasItem { + target: string; + replacements: Array; +} + +export interface ExternalMemoryStatus { + freed: boolean; + reason?: string; +} + +export declare const enum FilterTokenKind { + Id = 'Id', + ImporterId = 'ImporterId', + Code = 'Code', + ModuleType = 'ModuleType', + And = 'And', + Or = 'Or', + Not = 'Not', + Include = 'Include', + Exclude = 'Exclude', + CleanUrl = 'CleanUrl', + QueryKey = 'QueryKey', + QueryValue = 'QueryValue', +} + +export declare function initTraceSubscriber(): TraceSubscriberGuard | null; + +export interface JsChangedOutputs { + deleted: Set; + changes: Record; +} + +export interface JsOutputAsset { + names: Array; + originalFileNames: Array; + filename: string; + source: BindingAssetSource; +} + +export interface JsOutputChunk { + name: string; + isEntry: boolean; + isDynamicEntry: boolean; + facadeModuleId?: string; + moduleIds: Array; + exports: Array; + filename: string; + modules: Record; + imports: Array; + dynamicImports: Array; + code: string; + map?: BindingSourcemap; + sourcemapFilename?: string; + preliminaryFilename: string; +} + +/** Error emitted from native side, it only contains kind and message, no stack trace. */ +export interface NativeError { + kind: string; + message: string; + /** The id of the file associated with the error */ + id?: string; + /** The exporter associated with the error (for import/export errors) */ + exporter?: string; + /** Location information (line, column, file) */ + loc?: BindingLogLocation; + /** Position in the source file in UTF-16 code units */ + pos?: number; +} + +export interface PreRenderedChunk { + /** The name of this chunk, which is used in naming patterns. */ + name: string; + /** Whether this chunk is a static entry point. */ + isEntry: boolean; + /** Whether this chunk is a dynamic entry point. */ + isDynamicEntry: boolean; + /** The id of a module that this chunk corresponds to. */ + facadeModuleId?: string; + /** The list of ids of modules included in this chunk. */ + moduleIds: Array; + /** Exported variable names from this chunk. */ + exports: Array; +} + +export declare function registerPlugins(id: number, plugins: Array): void; + +export declare function resolveTsconfig( + filename: string, + cache: TsconfigCache | undefined | null, + yarnPnp: boolean, +): BindingTsconfigResult | null; + +/** + * Shutdown the tokio runtime manually. + * + * This is required for the wasm target with `tokio_unstable` cfg. + * In the wasm runtime, the `park` threads will hang there until the tokio::Runtime is shutdown. + */ +export declare function shutdownAsyncRuntime(): void; + +/** + * Start the async runtime manually. + * + * This is required when the async runtime is shutdown manually. + * Usually it's used in test. + */ +export declare function startAsyncRuntime(): void; + +export interface ViteImportGlobMeta { + isSubImportsPattern?: boolean; +} /** Error from batch import rewriting */ export interface BatchRewriteError { /** The file path that had an error */