rolldown 0.10.4 → 0.10.5

package/dist/types/binding.d.ts

@@ -0,0 +1,256 @@
+type MaybePromise<T> = T | Promise<T>
+type Nullable<T> = T | null | undefined
+type VoidNullable<T = void> = T | null | undefined | void
+export class BindingLog {
+  code: string
+  message: string
+}
+
+export class BindingModuleInfo {
+  id: string
+  importers: Array<string>
+  dynamicImporters: Array<string>
+  importedIds: Array<string>
+  dynamicallyImportedIds: Array<string>
+  isEntry: boolean
+  get code(): string | null
+}
+
+export class BindingOutputAsset {
+  get fileName(): string
+  get source(): BindingAssetSource
+  set source(source: BindingAssetSource)
+}
+
+export class BindingOutputChunk {
+  get isEntry(): boolean
+  get isDynamicEntry(): boolean
+  get facadeModuleId(): string | null
+  get moduleIds(): Array<string>
+  get exports(): Array<string>
+  get fileName(): string
+  get modules(): Record<string, BindingRenderedModule>
+  get imports(): Array<string>
+  set imports(imports: Array<string>)
+  get dynamicImports(): Array<string>
+  get code(): string
+  set code(code: string)
+  get map(): string | null
+  set map(map: string)
+  get sourcemapFileName(): string | null
+  get preliminaryFileName(): string
+  get name(): string
+}
+
+/** The `BindingOutputs` owner `Vec<Output>` the mutable reference, it avoid `Clone` at call `writeBundle/generateBundle` hook, and make it mutable. */
+export class BindingOutputs {
+  get chunks(): Array<BindingOutputChunk>
+  get assets(): Array<BindingOutputAsset>
+  delete(fileName: string): void
+}
+
+export class BindingPluginContext {
+  resolve(specifier: string, importer?: string | undefined | null, extraOptions?: BindingPluginContextResolveOptions | undefined | null): Promise<BindingPluginContextResolvedId | null>
+  emitFile(file: BindingEmittedAsset): string
+  getFileName(referenceId: string): string
+}
+
+export class BindingTransformPluginContext {
+  inner(): BindingPluginContext
+}
+
+export class Bundler {
+  constructor(inputOptions: BindingInputOptions, outputOptions: BindingOutputOptions, parallelPluginsRegistry?: ParallelJsPluginRegistry | undefined | null)
+  write(): Promise<FinalBindingOutputs>
+  generate(): Promise<FinalBindingOutputs>
+  scan(): Promise<void>
+}
+
+/**
+ * The `FinalBindingOutputs` is used at `write()` or `generate()`, it is similar to `BindingOutputs`, if using `BindingOutputs` has unexpected behavior.
+ * TODO find a way to export it gracefully.
+ */
+export class FinalBindingOutputs {
+  get chunks(): Array<BindingOutputChunk>
+  get assets(): Array<BindingOutputAsset>
+}
+
+export class ParallelJsPluginRegistry {
+  id: number
+  workerCount: number
+  constructor(workerCount: number)
+}
+
+export interface AliasItem {
+  find: string
+  replacements: Array<string>
+}
+
+export interface BindingAssetSource {
+  inner: string | Uint8Array
+}
+
+export interface BindingBuiltinPlugin {
+  name: BindingBuiltinPluginName
+  options?: unknown
+}
+
+export enum BindingBuiltinPluginName {
+  WasmPlugin = 0
+}
+
+export interface BindingEmittedAsset {
+  name?: string
+  fileName?: string
+  source: BindingAssetSource
+}
+
+export interface BindingHookLoadOutput {
+  code: string
+  sideEffects?: BindingHookSideEffects
+  map?: BindingSourcemap
+}
+
+export interface BindingHookRenderChunkOutput {
+  code: string
+  map?: BindingSourcemap
+}
+
+export interface BindingHookResolveIdExtraOptions {
+  isEntry: boolean
+  kind: 'import' | 'dynamic-import' | 'require-call'
+}
+
+export interface BindingHookResolveIdOutput {
+  id: string
+  external?: boolean
+  sideEffects?: BindingHookSideEffects
+}
+
+export enum BindingHookSideEffects {
+  True = 0,
+  False = 1,
+  NoTreeshake = 2
+}
+
+export interface BindingInputItem {
+  name?: string
+  import: string
+}
+
+export interface BindingInputOptions {
+  external?: undefined | ((source: string, importer: string | undefined, isResolved: boolean) => boolean)
+  input: Array<BindingInputItem>
+  plugins: (BindingBuiltinPlugin | BindingPluginOptions | undefined)[]
+  resolve?: BindingResolveOptions
+  shimMissingExports?: boolean
+  platform?: 'node' | 'browser' | 'neutral'
+  logLevel?: BindingLogLevel
+  onLog: (logLevel: 'debug' | 'warn' | 'info', log: BindingLog) => void
+  cwd: string
+  treeshake?: BindingTreeshake
+  moduleTypes?: Record<string, string>
+}
+
+export interface BindingJsonSourcemap {
+  file?: string
+  mappings?: string
+  sourceRoot?: string
+  sources?: Array<string | undefined | null>
+  sourcesContent?: Array<string | undefined | null>
+  names?: Array<string>
+}
+
+export enum BindingLogLevel {
+  Silent = 0,
+  Warn = 1,
+  Info = 2,
+  Debug = 3
+}
+
+export interface BindingOutputOptions {
+  entryFileNames?: string
+  chunkFileNames?: string
+  assetFileNames?: string
+  banner?: (chunk: RenderedChunk) => MaybePromise<VoidNullable<string>>
+  dir?: string
+  exports?: 'default' | 'named' | 'none' | 'auto'
+  footer?: (chunk: RenderedChunk) => MaybePromise<VoidNullable<string>>
+  format?: 'es' | 'cjs'
+  plugins: (BindingBuiltinPlugin | BindingPluginOptions | undefined)[]
+  sourcemap?: 'file' | 'inline' | 'hidden'
+  sourcemapIgnoreList?: (source: string, sourcemapPath: string) => boolean
+  sourcemapPathTransform?: (source: string, sourcemapPath: string) => string
+}
+
+export interface BindingPluginContextResolvedId {
+  id: string
+  external: boolean
+}
+
+export interface BindingPluginContextResolveOptions {
+  importKind?: 'import' | 'dynamic-import' | 'require-call'
+}
+
+export interface BindingPluginOptions {
+  name: string
+  buildStart?: (ctx: BindingPluginContext) => MaybePromise<VoidNullable>
+  resolveId?: (ctx: BindingPluginContext, specifier: string, importer: Nullable<string>, options: BindingHookResolveIdExtraOptions) => MaybePromise<VoidNullable<BindingHookResolveIdOutput>>
+  resolveDynamicImport?: (ctx: BindingPluginContext, specifier: string, importer: Nullable<string>) => MaybePromise<VoidNullable<BindingHookResolveIdOutput>>
+  load?: (ctx: BindingPluginContext, id: string) => MaybePromise<VoidNullable<BindingHookLoadOutput>>
+  transform?: (ctx:  BindingTransformPluginContext, id: string, code: string) => MaybePromise<VoidNullable<BindingHookLoadOutput>>
+  moduleParsed?: (ctx: BindingPluginContext, module: BindingModuleInfo) => MaybePromise<VoidNullable>
+  buildEnd?: (ctx: BindingPluginContext, error: Nullable<string>) => MaybePromise<VoidNullable>
+  renderChunk?: (ctx: BindingPluginContext, code: string, chunk: RenderedChunk) => MaybePromise<VoidNullable<BindingHookRenderChunkOutput>>
+  augmentChunkHash?: (ctx: BindingPluginContext, chunk: RenderedChunk) => MaybePromise<void | string>
+  renderStart?: (ctx: BindingPluginContext) => void
+  renderError?: (ctx: BindingPluginContext, error: string) => void
+  generateBundle?: (ctx: BindingPluginContext, bundle: BindingOutputs, isWrite: boolean) => MaybePromise<VoidNullable>
+  writeBundle?: (ctx: BindingPluginContext, bundle: BindingOutputs) => MaybePromise<VoidNullable>
+}
+
+export interface BindingPluginWithIndex {
+  index: number
+  plugin: BindingPluginOptions
+}
+
+export interface BindingRenderedModule {
+  code?: string
+}
+
+export interface BindingResolveOptions {
+  alias?: Array<AliasItem>
+  aliasFields?: Array<Array<string>>
+  conditionNames?: Array<string>
+  exportsFields?: Array<Array<string>>
+  extensions?: Array<string>
+  mainFields?: Array<string>
+  mainFiles?: Array<string>
+  modules?: Array<string>
+  symlinks?: boolean
+  tsconfigFilename?: string
+}
+
+export interface BindingSourcemap {
+  inner: string | BindingJSONSourcemap
+}
+
+export interface BindingTreeshake {
+  moduleSideEffects: string
+}
+
+export function registerPlugins(id: number, plugins: Array<BindingPluginWithIndex>): void
+
+export interface RenderedChunk {
+  name: string
+  isEntry: boolean
+  isDynamicEntry: boolean
+  facadeModuleId?: string
+  moduleIds: Array<string>
+  exports: Array<string>
+  fileName: string
+  modules: Record<string, BindingRenderedModule>
+  imports: Array<string>
+  dynamicImports: Array<string>
+}
+

package/dist/types/index.d.ts

@@ -1,12 +1,26 @@
-import { RolldownOutput, RolldownOutputChunk } from './types/rolldown-output';
-import type { InputOptions } from './options/input-options';
-import type { OutputOptions } from './options/output-options';
+import { RolldownOutput, RolldownOutputAsset, RolldownOutputChunk, SourceMap } from './types/rolldown-output';
+import type { ExternalOption, InputOption, InputOptions } from './options/input-options';
+import type { ModuleFormat, OutputOptions } from './options/output-options';
 import type { RolldownOptions } from './types/rolldown-options';
-import type { Plugin } from './plugin';
+import type { AsyncPluginHooks, CustomPluginOptions, FunctionPluginHooks, ImportKind, LoadResult, ModuleOptions, ObjectHook, ParallelPluginHooks, PartialResolvedId, Plugin, ResolveIdResult, ResolvedId, SourceDescription, TransformResult } from './plugin';
 import { defineParallelPlugin, DefineParallelPluginResult } from './plugin';
 import { defineConfig } from './utils/define-config';
 import { rolldown, experimental_scan } from './rolldown';
 import { ConfigExport } from './types/config-export';
-export { defineConfig, defineParallelPlugin, rolldown, experimental_scan };
-export type { RolldownOutputChunk, RolldownOptions, RolldownOutput, InputOptions, OutputOptions, Plugin, DefineParallelPluginResult, ConfigExport, };
-export type { RolldownOutput as RollupOutput, RolldownOptions as RollupOptions };
+import { BuiltinWasmPlugin } from './plugin/bindingify-builtin-plugin';
+import { RolldownBuild } from './rolldown-build';
+import { InternalModuleFormat } from './options/bindingify-output-options';
+import { EmittedAsset, EmittedFile, PluginContext } from './plugin/plugin-context';
+import { TransformPluginContext } from './plugin/transfrom-plugin-context';
+import { NormalizedOutputOptions } from './options/normalized-output-options';
+import { RenderedChunk } from './binding';
+import { PartialNull } from './types/utils';
+import { NormalizedInputOptions } from './options/normalized-input-options';
+import { ModuleInfo } from './types/module-info';
+import { MinimalPluginContext } from './log/logger';
+import { ExistingRawSourceMap, SourceMapInput } from './types/sourcemap';
+import { OutputBundle } from './types/output-bundle';
+export { defineConfig, defineParallelPlugin, rolldown, experimental_scan, BuiltinWasmPlugin, };
+export type { RolldownOutputChunk, RolldownOptions, RolldownOutput, RolldownBuild, InputOptions, NormalizedInputOptions, OutputOptions, NormalizedOutputOptions, Plugin, DefineParallelPluginResult, ConfigExport, ImportKind, InputOption, ExternalOption, ModuleFormat, InternalModuleFormat, LoadResult, TransformResult, ResolveIdResult, PluginContext, TransformPluginContext, ObjectHook, RenderedChunk, SourceMap, SourceDescription, PartialNull, PartialResolvedId, ResolvedId, ModuleOptions, ModuleInfo, MinimalPluginContext, EmittedFile, EmittedAsset, CustomPluginOptions, AsyncPluginHooks, ParallelPluginHooks, FunctionPluginHooks, ExistingRawSourceMap, SourceMapInput, OutputBundle, };
+export type { RolldownOutput as RollupOutput, RolldownOptions as RollupOptions, RolldownBuild as RollupBuild, RolldownOutputChunk as OutputChunk, RolldownOutputAsset as OutputAsset, };
+export type { RollupError, RollupLog, LoggingFunction } from './rollup';

package/dist/types/options/bindingify-input-options.d.ts

@@ -1,4 +1,4 @@
-import type { BindingInputOptions } from '../binding';
+import { BindingInputOptions } from '../binding';
 import type { NormalizedInputOptions } from './normalized-input-options';
 import type { NormalizedOutputOptions } from './normalized-output-options';
 export declare function bindingifyInputOptions(options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingInputOptions;

package/dist/types/options/bindingify-output-options.d.ts

@@ -1,3 +1,4 @@
 import type { BindingOutputOptions } from '../binding';
 import type { NormalizedOutputOptions } from './normalized-output-options';
+export type InternalModuleFormat = 'es' | 'cjs';
 export declare function bindingifyOutputOptions(outputOptions: NormalizedOutputOptions): BindingOutputOptions;

package/dist/types/options/input-options.d.ts

@@ -1,9 +1,12 @@
-import type { Plugin, ParallelPlugin } from '../plugin';
+import type { RolldownPlugin } from '../plugin';
 import { z } from 'zod';
+import { TreeshakingOptions } from '../treeshake';
+declare const inputOptionSchema: z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodRecord<z.ZodString, z.ZodString>]>;
+declare const externalSchema: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">]>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>, z.ZodBoolean], z.ZodUnknown>, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodVoid, z.ZodNull]>, z.ZodUndefined]>, z.ZodBoolean]>>]>;
 declare const inputOptionsSchema: z.ZodObject<{
     input: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-    plugins: z.ZodOptional<z.ZodArray<z.ZodType<Plugin | ParallelPlugin, z.ZodTypeDef, Plugin | ParallelPlugin>, "many">>;
-    external: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">]>, z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>, z.ZodBoolean], z.ZodUnknown>, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodVoid, z.ZodNull]>, z.ZodUndefined]>, z.ZodBoolean]>>>]>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodType<RolldownPlugin, z.ZodTypeDef, RolldownPlugin>, "many">>;
+    external: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">]>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>, z.ZodBoolean], z.ZodUnknown>, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodVoid, z.ZodNull]>, z.ZodUndefined]>, z.ZodBoolean]>>]>>;
     resolve: z.ZodOptional<z.ZodObject<{
         alias: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         aliasFields: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
@@ -41,12 +44,22 @@ declare const inputOptionsSchema: z.ZodObject<{
     cwd: z.ZodOptional<z.ZodString>;
     platform: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"node">, z.ZodLiteral<"browser">]>, z.ZodLiteral<"neutral">]>>;
     shimMissingExports: z.ZodOptional<z.ZodBoolean>;
+    treeshake: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<z.objectUtil.extendShape<{
+        moduleSideEffects: z.ZodUnion<[z.ZodBoolean, z.ZodString]>;
+    }, {
+        moduleSideEffects: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    }>, "strict", z.ZodTypeAny, {
+        moduleSideEffects?: string | boolean | undefined;
+    }, {
+        moduleSideEffects?: string | boolean | undefined;
+    }>]>>;
     logLevel: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodLiteral<"silent">]>>;
     onLog: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodAny, z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodLiteral<"error">]>, z.ZodUnion<[z.ZodAny, z.ZodString]>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodUnknown>>;
     onwarn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodUnion<[z.ZodAny, z.ZodString]>, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodAny, z.ZodString]>>]>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodUnknown>>;
+    moduleTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"js">, z.ZodLiteral<"jsx">]>, z.ZodLiteral<"ts">]>, z.ZodLiteral<"tsx">]>, z.ZodLiteral<"empty">]>, z.ZodLiteral<"json">]>, z.ZodLiteral<"text">]>, z.ZodLiteral<"base64">]>, z.ZodLiteral<"binary">]>, z.ZodLiteral<"empty">]>>>;
 }, "strict", z.ZodTypeAny, {
     input?: string | string[] | Record<string, string> | undefined;
-    plugins?: (Plugin | ParallelPlugin)[] | undefined;
+    plugins?: RolldownPlugin[] | undefined;
     external?: string | RegExp | (string | RegExp)[] | ((args_0: string, args_1: string | undefined, args_2: boolean, ...args_3: unknown[]) => boolean | void | null | undefined) | undefined;
     resolve?: {
         modules?: string[] | undefined;
@@ -63,12 +76,16 @@ declare const inputOptionsSchema: z.ZodObject<{
     cwd?: string | undefined;
     platform?: "node" | "browser" | "neutral" | undefined;
     shimMissingExports?: boolean | undefined;
+    treeshake?: boolean | {
+        moduleSideEffects?: string | boolean | undefined;
+    } | undefined;
     logLevel?: "info" | "debug" | "warn" | "silent" | undefined;
     onLog?: ((args_0: "info" | "debug" | "warn", args_1: any, args_2: (args_0: "info" | "debug" | "warn" | "error", args_1: any, ...args_2: unknown[]) => unknown, ...args_3: unknown[]) => unknown) | undefined;
     onwarn?: ((args_0: any, args_1: (args_0: any, ...args_1: unknown[]) => unknown, ...args_2: unknown[]) => unknown) | undefined;
+    moduleTypes?: Record<string, "js" | "jsx" | "ts" | "tsx" | "empty" | "json" | "text" | "base64" | "binary"> | undefined;
 }, {
     input?: string | string[] | Record<string, string> | undefined;
-    plugins?: (Plugin | ParallelPlugin)[] | undefined;
+    plugins?: RolldownPlugin[] | undefined;
     external?: string | RegExp | (string | RegExp)[] | ((args_0: string, args_1: string | undefined, args_2: boolean, ...args_3: unknown[]) => boolean | void | null | undefined) | undefined;
     resolve?: {
         modules?: string[] | undefined;
@@ -85,9 +102,17 @@ declare const inputOptionsSchema: z.ZodObject<{
     cwd?: string | undefined;
     platform?: "node" | "browser" | "neutral" | undefined;
     shimMissingExports?: boolean | undefined;
+    treeshake?: boolean | {
+        moduleSideEffects?: string | boolean | undefined;
+    } | undefined;
     logLevel?: "info" | "debug" | "warn" | "silent" | undefined;
     onLog?: ((args_0: "info" | "debug" | "warn", args_1: any, args_2: (args_0: "info" | "debug" | "warn" | "error", args_1: any, ...args_2: unknown[]) => unknown, ...args_3: unknown[]) => unknown) | undefined;
     onwarn?: ((args_0: any, args_1: (args_0: any, ...args_1: unknown[]) => unknown, ...args_2: unknown[]) => unknown) | undefined;
+    moduleTypes?: Record<string, "js" | "jsx" | "ts" | "tsx" | "empty" | "json" | "text" | "base64" | "binary"> | undefined;
 }>;
-export type InputOptions = z.infer<typeof inputOptionsSchema>;
+export type InputOption = z.infer<typeof inputOptionSchema>;
+export type ExternalOption = z.infer<typeof externalSchema>;
+export type InputOptions = Omit<z.infer<typeof inputOptionsSchema>, 'treeshake'> & {
+    treeshake?: boolean | TreeshakingOptions;
+};
 export {};

package/dist/types/options/normalized-input-options.d.ts

@@ -1,10 +1,12 @@
 import type { LogLevelOption, RollupLog, NormalizedInputOptions as RollupNormalizedInputOptions } from '../rollup';
 import type { InputOptions } from './input-options';
-import type { Plugin, ParallelPlugin } from '../plugin';
+import type { RolldownPlugin } from '../plugin';
 import type { LogLevel } from '../log/logging';
+import { NormalizedTreeshakingOptions } from '../../src/treeshake';
 export interface NormalizedInputOptions extends InputOptions {
     input: RollupNormalizedInputOptions['input'];
-    plugins: (Plugin | ParallelPlugin)[];
+    plugins: RolldownPlugin[];
     onLog: (level: LogLevel, log: RollupLog) => void;
     logLevel: LogLevelOption;
+    treeshake?: NormalizedTreeshakingOptions;
 }

package/dist/types/options/normalized-output-options.d.ts

@@ -1,7 +1,7 @@
 import type { SourcemapIgnoreListOption, SourcemapPathTransformOption } from '../rollup';
 import type { OutputOptions } from './output-options';
 import type { Plugin, ParallelPlugin } from '../plugin';
-import type { RenderedChunk } from '@src/binding';
+import type { RenderedChunk } from '../binding';
 type InternalModuleFormat = 'es' | 'cjs';
 type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
 export interface NormalizedOutputOptions extends OutputOptions {
@@ -16,5 +16,6 @@ export interface NormalizedOutputOptions extends OutputOptions {
     footer: AddonFunction;
     entryFileNames: string;
     chunkFileNames: string;
+    assetFileNames: string;
 }
 export {};

package/dist/types/options/output-options.d.ts

@@ -1,9 +1,10 @@
 import type { RenderedChunk } from '../binding';
 import { z } from 'zod';
+declare const ModuleFormatSchema: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"es">, z.ZodLiteral<"cjs">]>, z.ZodLiteral<"esm">]>, z.ZodLiteral<"module">]>, z.ZodLiteral<"commonjs">]>>;
 declare const outputOptionsSchema: z.ZodObject<{
     dir: z.ZodOptional<z.ZodString>;
     exports: z.ZodOptional<z.ZodLiteral<"named">>;
-    format: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"es">, z.ZodLiteral<"cjs">]>, z.ZodLiteral<"es">]>, z.ZodLiteral<"esm">]>, z.ZodLiteral<"module">]>, z.ZodLiteral<"commonjs">]>>;
+    format: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"es">, z.ZodLiteral<"cjs">]>, z.ZodLiteral<"esm">]>, z.ZodLiteral<"module">]>, z.ZodLiteral<"commonjs">]>>;
     sourcemap: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"inline">]>, z.ZodLiteral<"hidden">]>>;
     sourcemapIgnoreList: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodType<SourcemapIgnoreListOption, z.ZodTypeDef, SourcemapIgnoreListOption>]>>;
     sourcemapPathTransform: z.ZodOptional<z.ZodType<SourcemapPathTransformOption, z.ZodTypeDef, SourcemapPathTransformOption>>;
@@ -11,30 +12,34 @@ declare const outputOptionsSchema: z.ZodObject<{
     footer: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<RenderedChunk, z.ZodTypeDef, RenderedChunk>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
     entryFileNames: z.ZodOptional<z.ZodString>;
     chunkFileNames: z.ZodOptional<z.ZodString>;
+    assetFileNames: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     exports?: "named" | undefined;
-    banner?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
-    footer?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
     dir?: string | undefined;
     format?: "es" | "cjs" | "esm" | "module" | "commonjs" | undefined;
     sourcemap?: boolean | "inline" | "hidden" | undefined;
     sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption | undefined;
     sourcemapPathTransform?: SourcemapPathTransformOption | undefined;
+    banner?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
+    footer?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
     entryFileNames?: string | undefined;
     chunkFileNames?: string | undefined;
+    assetFileNames?: string | undefined;
 }, {
     exports?: "named" | undefined;
-    banner?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
-    footer?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
     dir?: string | undefined;
     format?: "es" | "cjs" | "esm" | "module" | "commonjs" | undefined;
     sourcemap?: boolean | "inline" | "hidden" | undefined;
     sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption | undefined;
     sourcemapPathTransform?: SourcemapPathTransformOption | undefined;
+    banner?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
+    footer?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
     entryFileNames?: string | undefined;
     chunkFileNames?: string | undefined;
+    assetFileNames?: string | undefined;
 }>;
 export type OutputOptions = z.infer<typeof outputOptionsSchema>;
 export type SourcemapIgnoreListOption = (relativeSourcePath: string, sourcemapPath: string) => boolean;
 export type SourcemapPathTransformOption = (relativeSourcePath: string, sourcemapPath: string) => string;
+export type ModuleFormat = z.infer<typeof ModuleFormatSchema>;
 export {};

package/dist/types/plugin/bindingify-builtin-plugin.d.ts

@@ -0,0 +1,10 @@
+import { BindingBuiltinPlugin, BindingBuiltinPluginName } from '../binding';
+export declare class BuiltinPlugin {
+    name: BindingBuiltinPluginName;
+    options?: unknown;
+    constructor(name: BindingBuiltinPluginName, options?: unknown);
+}
+export declare class BuiltinWasmPlugin extends BuiltinPlugin {
+    constructor(options?: unknown);
+}
+export declare function bindingifyBuiltInPlugin(plugin: BuiltinPlugin): BindingBuiltinPlugin;

package/dist/types/plugin/bindingify-output-hooks.d.ts

@@ -1,7 +1,7 @@
 import type { BindingPluginOptions } from '../binding';
 import type { NormalizedInputOptions } from '../options/normalized-input-options';
 import type { Plugin } from './index';
-import { NormalizedOutputOptions } from '@src/options/normalized-output-options';
+import { NormalizedOutputOptions } from '../options/normalized-output-options';
 export declare function bindingifyRenderStart(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions['renderStart'];
 export declare function bindingifyRenderChunk(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions['renderChunk'];
 export declare function bindingifyAugmentChunkHash(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['augmentChunkHash'];

package/dist/types/plugin/bindingify-plugin.d.ts

@@ -1,5 +1,5 @@
 import type { BindingPluginOptions } from '../binding';
 import type { Plugin } from './index';
 import type { NormalizedInputOptions } from '../options/normalized-input-options';
-import type { NormalizedOutputOptions } from '@src/options/normalized-output-options';
+import type { NormalizedOutputOptions } from '../options/normalized-output-options';
 export declare function bindingifyPlugin(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions;

package/dist/types/plugin/index.d.ts

@@ -1,57 +1,69 @@
 import type { BindingHookResolveIdExtraOptions, RenderedChunk } from '../binding';
 import type { NormalizedInputOptions } from '../options/normalized-input-options';
-import type { AnyFn, AnyObj, NullValue, MaybePromise } from '../types/utils';
+import type { AnyFn, AnyObj, NullValue, MaybePromise, PartialNull } from '../types/utils';
 import type { SourceMapInput } from '../types/sourcemap';
 import type { ModuleInfo } from '../types/module-info';
 import type { OutputBundle } from '../types/output-bundle';
 import type { PluginContext } from './plugin-context';
 import type { TransformPluginContext } from './transfrom-plugin-context';
-import type { NormalizedOutputOptions } from '@src/options/normalized-output-options';
+import type { NormalizedOutputOptions } from '../options/normalized-output-options';
 import type { LogLevel } from '../log/logging';
 import type { RollupLog } from '../rollup';
 import type { MinimalPluginContext } from '../log/logger';
+import { InputOptions, OutputOptions } from '..';
+import { BuiltinPlugin } from './bindingify-builtin-plugin';
 type FormalHook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = {
     handler: Handler;
 } & HookOptions;
-export type Hook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = FormalHook<Handler, HookOptions> | Handler;
+export type ObjectHook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = FormalHook<Handler, HookOptions> | Handler;
 export type ModuleSideEffects = boolean | 'no-treeshake' | null;
-export type ResolveIdResult = string | NullValue | false | {
+export type ImportKind = BindingHookResolveIdExtraOptions['kind'];
+export interface CustomPluginOptions {
+    [plugin: string]: any;
+}
+export interface ModuleOptions {
+    moduleSideEffects: ModuleSideEffects;
+}
+export interface ResolvedId extends ModuleOptions {
+    external: boolean;
     id: string;
+}
+export interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
     external?: boolean;
-    moduleSideEffects?: ModuleSideEffects;
-};
+    id: string;
+}
+export interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+    code: string;
+    map?: SourceMapInput;
+}
+export type ResolveIdResult = string | NullValue | false | PartialResolvedId;
+export type LoadResult = NullValue | string | SourceDescription;
+export type TransformResult = NullValue | string | SourceDescription;
 export interface Plugin {
     name?: string;
-    onLog?: Hook<(this: MinimalPluginContext, level: LogLevel, log: RollupLog) => NullValue | boolean>;
-    options?: Hook<(this: MinimalPluginContext, options: NormalizedInputOptions) => NullValue>;
-    buildStart?: Hook<(this: PluginContext, options: NormalizedInputOptions) => MaybePromise<NullValue>>;
-    resolveId?: Hook<(this: PluginContext, source: string, importer: string | undefined, extraOptions: BindingHookResolveIdExtraOptions) => MaybePromise<ResolveIdResult>>;
+    onLog?: ObjectHook<(this: MinimalPluginContext, level: LogLevel, log: RollupLog) => NullValue | boolean>;
+    options?: ObjectHook<(this: MinimalPluginContext, options: InputOptions) => MaybePromise<NullValue | InputOptions>>;
+    outputOptions?: ObjectHook<(this: null, options: OutputOptions) => MaybePromise<NullValue | OutputOptions>>;
+    buildStart?: ObjectHook<(this: PluginContext, options: NormalizedInputOptions) => MaybePromise<NullValue>>;
+    resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, extraOptions: BindingHookResolveIdExtraOptions) => MaybePromise<ResolveIdResult>>;
     /**
      * @deprecated
      * This hook is only for rollup plugin compatibility. Please use `resolveId` instead.
      */
-    resolveDynamicImport?: Hook<(this: PluginContext, source: string, importer: string | undefined) => MaybePromise<ResolveIdResult>>;
-    load?: Hook<(this: PluginContext, id: string) => MaybePromise<NullValue | string | {
+    resolveDynamicImport?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined) => MaybePromise<ResolveIdResult>>;
+    load?: ObjectHook<(this: PluginContext, id: string) => MaybePromise<LoadResult>>;
+    transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string) => MaybePromise<TransformResult>>;
+    moduleParsed?: ObjectHook<(this: PluginContext, moduleInfo: ModuleInfo) => MaybePromise<NullValue>>;
+    buildEnd?: ObjectHook<(this: PluginContext, err?: Error) => MaybePromise<NullValue>>;
+    renderStart?: ObjectHook<(this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => MaybePromise<NullValue>>;
+    renderChunk?: ObjectHook<(this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) => MaybePromise<NullValue | string | {
         code: string;
         map?: SourceMapInput;
-        moduleSideEffects?: ModuleSideEffects;
-    }>>;
-    transform?: Hook<(this: TransformPluginContext, code: string, id: string) => MaybePromise<NullValue | string | {
-        code: string;
-        map?: string | null | SourceMapInput;
-        moduleSideEffects?: ModuleSideEffects;
-    }>>;
-    moduleParsed?: Hook<(this: PluginContext, moduleInfo: ModuleInfo) => MaybePromise<NullValue>>;
-    buildEnd?: Hook<(this: PluginContext, err?: Error) => MaybePromise<NullValue>>;
-    renderStart?: Hook<(this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => MaybePromise<NullValue>>;
-    renderChunk?: Hook<(this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) => MaybePromise<NullValue | string | {
-        code: string;
-        map?: string | null | SourceMapInput;
     }>>;
-    augmentChunkHash?: Hook<(this: PluginContext, chunk: RenderedChunk) => MaybePromise<string | void>>;
-    renderError?: Hook<(this: PluginContext, error: Error) => MaybePromise<NullValue>>;
-    generateBundle?: Hook<(this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => MaybePromise<NullValue>>;
-    writeBundle?: Hook<(this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => MaybePromise<NullValue>>;
+    augmentChunkHash?: ObjectHook<(this: PluginContext, chunk: RenderedChunk) => MaybePromise<string | void>>;
+    renderError?: ObjectHook<(this: PluginContext, error: Error) => MaybePromise<NullValue>>;
+    generateBundle?: ObjectHook<(this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => MaybePromise<NullValue>>;
+    writeBundle?: ObjectHook<(this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => MaybePromise<NullValue>>;
 }
 export type ParallelPlugin = {
     /** @internal */
@@ -60,6 +72,14 @@ export type ParallelPlugin = {
         options: unknown;
     };
 };
+export type RolldownPlugin = Plugin | ParallelPlugin | BuiltinPlugin;
 export type DefineParallelPluginResult<Options> = (options: Options) => ParallelPlugin;
 export declare function defineParallelPlugin<Options>(pluginPath: string): DefineParallelPluginResult<Options>;
+export type FunctionPluginHooks = Plugin;
+export type SyncPluginHooks = 'augmentChunkHash' | 'onLog' | 'outputOptions' | 'renderDynamicImport' | 'resolveFileUrl' | 'resolveImportMeta';
+export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
+export type FirstPluginHooks = 'load' | 'renderDynamicImport' | 'resolveDynamicImport' | 'resolveFileUrl' | 'resolveId' | 'resolveImportMeta' | 'shouldTransformCachedModule';
+export type SequentialPluginHooks = 'augmentChunkHash' | 'generateBundle' | 'onLog' | 'options' | 'outputOptions' | 'renderChunk' | 'transform';
+export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro';
+export type ParallelPluginHooks = Exclude<keyof FunctionPluginHooks | AddonHooks, FirstPluginHooks | SequentialPluginHooks>;
 export {};

package/dist/types/plugin/plugin-context.d.ts

@@ -2,11 +2,25 @@ import type { RollupError, LoggingFunction } from '../rollup';
 import type { BindingPluginContext } from '../binding';
 import type { NormalizedInputOptions } from '../options/normalized-input-options';
 import type { Plugin } from './index';
+import { AssetSource } from '../utils/asset-source';
+export interface EmittedAsset {
+    type: 'asset';
+    name?: string;
+    fileName?: string;
+    source: AssetSource;
+}
+export type EmittedFile = EmittedAsset;
 export declare class PluginContext {
     debug: LoggingFunction;
     info: LoggingFunction;
     warn: LoggingFunction;
     error: (error: RollupError | string) => never;
     resolve: BindingPluginContext['resolve'];
+    emitFile: (file: EmittedAsset) => string;
+    getFileName: (referenceId: string) => string;
+    /**
+     * @deprecated This rollup API won't be supported by rolldown. Using this API will cause runtime error.
+     */
+    parse: (input: string, options?: any) => any;
     constructor(options: NormalizedInputOptions, context: BindingPluginContext, plugin: Plugin);
 }