From e231e14fa89f88d23ce26dda5afe1c12609dd8d0 Mon Sep 17 00:00:00 2001 From: Yunfei Date: Thu, 7 Mar 2024 04:12:26 +0800 Subject: [PATCH] feat: rely on the standalone copy of rollup types. Closes #439 --- package.json | 2 +- packages/node/package.json | 1 - packages/node/src/rollup-types.ts | 2 +- packages/node/src/rollup.d.ts | 1010 ++++++++++++++++++++++++++++ packages/rollup-tests/package.json | 2 +- web/docs/package.json | 2 +- web/playground/package.json | 2 +- yarn.lock | 3 +- 8 files changed, 1016 insertions(+), 8 deletions(-) create mode 100644 packages/node/src/rollup.d.ts diff --git a/package.json b/package.json index 81b4a9b085..db2aa87247 100644 --- a/package.json +++ b/package.json @@ -74,4 +74,4 @@ "engines": { "node": ">=18.18.0" } -} \ No newline at end of file +} diff --git a/packages/node/package.json b/packages/node/package.json index 17c92ea7d6..a7544c394f 100644 --- a/packages/node/package.json +++ b/packages/node/package.json @@ -33,7 +33,6 @@ }, "devDependencies": { "@types/node": "^18.14.0", - "rollup": "^3.17.2", "typescript": "^5.0.0", "unbuild": "^2.0.0", "vitest": "^0.34.6" diff --git a/packages/node/src/rollup-types.ts b/packages/node/src/rollup-types.ts index f36a621af3..b6f636e712 100644 --- a/packages/node/src/rollup-types.ts +++ b/packages/node/src/rollup-types.ts @@ -11,4 +11,4 @@ export type { OutputAsset, OutputBundle, SourceMapInput -} from 'rollup' +} from './rollup' diff --git a/packages/node/src/rollup.d.ts b/packages/node/src/rollup.d.ts new file mode 100644 index 0000000000..d7ed0d25cc --- /dev/null +++ b/packages/node/src/rollup.d.ts @@ -0,0 +1,1010 @@ +// utils +type NullValue = null | undefined | void; +type MaybeArray = T | T[]; +type MaybePromise = T | Promise; + +type PartialNull = { + [P in keyof T]: T[P] | null; +}; + +export interface RollupError extends RollupLog { + name?: string; + stack?: string; + watchFiles?: string[]; +} + +export type RollupWarning = RollupLog; + +export interface RollupLog { + binding?: string; + cause?: unknown; + code?: string; + exporter?: string; + frame?: string; + hook?: string; + id?: string; + ids?: string[]; + loc?: { + column: number; + file?: string; + line: number; + }; + message: string; + meta?: any; + names?: string[]; + plugin?: string; + pluginCode?: unknown; + pos?: number; + reexporter?: string; + stack?: string; + url?: string; +} + +export type LogLevel = 'warn' | 'info' | 'debug'; +export type LogLevelOption = LogLevel | 'silent'; + +export type SourceMapSegment = + | [number] + | [number, number, number, number] + | [number, number, number, number, number]; + +export interface ExistingDecodedSourceMap { + file?: string; + readonly mappings: SourceMapSegment[][]; + names: string[]; + sourceRoot?: string; + sources: string[]; + sourcesContent?: (string | null)[]; + version: number; + x_google_ignoreList?: number[]; +} + +export interface ExistingRawSourceMap { + file?: string; + mappings: string; + names: string[]; + sourceRoot?: string; + sources: string[]; + sourcesContent?: (string | null)[]; + version: number; + x_google_ignoreList?: number[]; +} + +export type DecodedSourceMapOrMissing = + | { + missing: true; + plugin: string; + } + | (ExistingDecodedSourceMap & { missing?: false }); + +export interface SourceMap { + file: string; + mappings: string; + names: string[]; + sources: string[]; + sourcesContent: (string | null)[]; + version: number; + toString(): string; + toUrl(): string; +} + +export type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' }; + +interface ModuleOptions { + assertions: Record; + meta: CustomPluginOptions; + moduleSideEffects: boolean | 'no-treeshake'; + syntheticNamedExports: boolean | string; +} + +export interface SourceDescription extends Partial> { + ast?: AcornNode; + code: string; + map?: SourceMapInput; +} + +export interface TransformModuleJSON { + ast?: AcornNode; + code: string; + // note if plugins use new this.cache to opt-out auto transform cache + customTransformCache: boolean; + originalCode: string; + originalSourcemap: ExistingDecodedSourceMap | null; + sourcemapChain: DecodedSourceMapOrMissing[]; + transformDependencies: string[]; +} + +export interface ModuleJSON extends TransformModuleJSON, ModuleOptions { + ast: AcornNode; + dependencies: string[]; + id: string; + resolvedIds: ResolvedIdMap; + transformFiles: EmittedFile[] | undefined; +} + +export interface PluginCache { + delete(id: string): boolean; + get(id: string): T; + has(id: string): boolean; + set(id: string, value: T): void; +} + +export type LoggingFunction = (log: RollupLog | string | (() => RollupLog | string)) => void; + +export interface MinimalPluginContext { + debug: LoggingFunction; + error: (error: RollupError | string) => never; + info: LoggingFunction; + meta: PluginContextMeta; + warn: LoggingFunction; +} + +export interface EmittedAsset { + fileName?: string; + name?: string; + needsCodeReference?: boolean; + source?: string | Uint8Array; + type: 'asset'; +} + +export interface EmittedChunk { + fileName?: string; + id: string; + implicitlyLoadedAfterOneOf?: string[]; + importer?: string; + name?: string; + preserveSignature?: PreserveEntrySignaturesOption; + type: 'chunk'; +} + +export interface EmittedPrebuiltChunk { + code: string; + exports?: string[]; + fileName: string; + map?: SourceMap; + sourcemapFileName?: string; + type: 'prebuilt-chunk'; +} + +export type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk; + +export type EmitFile = (emittedFile: EmittedFile) => string; + +interface ModuleInfo extends ModuleOptions { + ast: AcornNode | null; + code: string | null; + dynamicImporters: readonly string[]; + dynamicallyImportedIdResolutions: readonly ResolvedId[]; + dynamicallyImportedIds: readonly string[]; + exportedBindings: Record | null; + exports: string[] | null; + hasDefaultExport: boolean | null; + /** @deprecated Use `moduleSideEffects` instead */ + hasModuleSideEffects: boolean | 'no-treeshake'; + id: string; + implicitlyLoadedAfterOneOf: readonly string[]; + implicitlyLoadedBefore: readonly string[]; + importedIdResolutions: readonly ResolvedId[]; + importedIds: readonly string[]; + importers: readonly string[]; + isEntry: boolean; + isExternal: boolean; + isIncluded: boolean | null; +} + +export type GetModuleInfo = (moduleId: string) => ModuleInfo | null; + +export interface CustomPluginOptions { + [plugin: string]: any; +} + +type LoggingFunctionWithPosition = ( + log: RollupLog | string | (() => RollupLog | string), + pos?: number | { column: number; line: number } +) => void; + +export interface PluginContext extends MinimalPluginContext { + addWatchFile: (id: string) => void; + cache: PluginCache; + debug: LoggingFunction; + emitFile: EmitFile; + error: (error: RollupError | string) => never; + getFileName: (fileReferenceId: string) => string; + getModuleIds: () => IterableIterator; + getModuleInfo: GetModuleInfo; + getWatchFiles: () => string[]; + info: LoggingFunction; + load: ( + options: { id: string; resolveDependencies?: boolean } & Partial> + ) => Promise; + /** @deprecated Use `this.getModuleIds` instead */ + moduleIds: IterableIterator; + parse: (input: string, options?: any) => AcornNode; + resolve: ( + source: string, + importer?: string, + options?: { + assertions?: Record; + custom?: CustomPluginOptions; + isEntry?: boolean; + skipSelf?: boolean; + } + ) => Promise; + setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void; + warn: LoggingFunction; +} + +export interface PluginContextMeta { + rollupVersion: string; + watchMode: boolean; +} + +export interface ResolvedId extends ModuleOptions { + external: boolean | 'absolute'; + id: string; + resolvedBy: string; +} + +export interface ResolvedIdMap { + [key: string]: ResolvedId; +} + +interface PartialResolvedId extends Partial> { + external?: boolean | 'absolute' | 'relative'; + id: string; + resolvedBy?: string; +} + +export type ResolveIdResult = string | NullValue | false | PartialResolvedId; + +export type ResolveIdResultWithoutNullValue = string | false | PartialResolvedId; + +export type ResolveIdHook = ( + this: PluginContext, + source: string, + importer: string | undefined, + options: { assertions: Record; custom?: CustomPluginOptions; isEntry: boolean } +) => ResolveIdResult; + +export type ShouldTransformCachedModuleHook = ( + this: PluginContext, + options: { + ast: AcornNode; + code: string; + id: string; + meta: CustomPluginOptions; + moduleSideEffects: boolean | 'no-treeshake'; + resolvedSources: ResolvedIdMap; + syntheticNamedExports: boolean | string; + } +) => boolean | NullValue; + +export type IsExternal = ( + source: string, + importer: string | undefined, + isResolved: boolean +) => boolean; + +export type IsPureModule = (id: string) => boolean | NullValue; + +export type HasModuleSideEffects = (id: string, external: boolean) => boolean; + +export type LoadResult = SourceDescription | string | NullValue; + +export type LoadHook = (this: PluginContext, id: string) => LoadResult; + +export interface TransformPluginContext extends PluginContext { + debug: LoggingFunctionWithPosition; + error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never; + getCombinedSourcemap: () => SourceMap; + info: LoggingFunctionWithPosition; + warn: LoggingFunctionWithPosition; +} + +export type TransformResult = string | NullValue | Partial; + +export type TransformHook = ( + this: TransformPluginContext, + code: string, + id: string +) => TransformResult; + +export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void; + +export type RenderChunkHook = ( + this: PluginContext, + code: string, + chunk: RenderedChunk, + options: NormalizedOutputOptions, + meta: { chunks: Record } +) => { code: string; map?: SourceMapInput } | string | NullValue; + +export type ResolveDynamicImportHook = ( + this: PluginContext, + specifier: string | AcornNode, + importer: string, + options: { assertions: Record } +) => ResolveIdResult; + +export type ResolveImportMetaHook = ( + this: PluginContext, + property: string | null, + options: { chunkId: string; format: InternalModuleFormat; moduleId: string } +) => string | NullValue; + +export type ResolveFileUrlHook = ( + this: PluginContext, + options: { + chunkId: string; + fileName: string; + format: InternalModuleFormat; + moduleId: string; + referenceId: string; + relativePath: string; + } +) => string | NullValue; + +export type AddonHookFunction = ( + this: PluginContext, + chunk: RenderedChunk +) => string | Promise; +export type AddonHook = string | AddonHookFunction; + +export type ChangeEvent = 'create' | 'update' | 'delete'; +export type WatchChangeHook = ( + this: PluginContext, + id: string, + change: { event: ChangeEvent } +) => void; + +/** + * use this type for plugin annotation + * @example + * ```ts + * interface Options { + * ... + * } + * const myPlugin: PluginImpl = (options = {}) => { ... } + * ``` + */ +// eslint-disable-next-line @typescript-eslint/ban-types +export type PluginImpl = (options?: O) => Plugin; + +export interface OutputBundle { + [fileName: string]: OutputAsset | OutputChunk; +} + +export interface FunctionPluginHooks { + augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void; + buildEnd: (this: PluginContext, error?: Error) => void; + buildStart: (this: PluginContext, options: NormalizedInputOptions) => void; + closeBundle: (this: PluginContext) => void; + closeWatcher: (this: PluginContext) => void; + generateBundle: ( + this: PluginContext, + options: NormalizedOutputOptions, + bundle: OutputBundle, + isWrite: boolean + ) => void; + load: LoadHook; + moduleParsed: ModuleParsedHook; + onLog: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => boolean | NullValue; + options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | NullValue; + outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | NullValue; + renderChunk: RenderChunkHook; + renderDynamicImport: ( + this: PluginContext, + options: { + customResolution: string | null; + format: InternalModuleFormat; + moduleId: string; + targetModuleId: string | null; + } + ) => { left: string; right: string } | NullValue; + renderError: (this: PluginContext, error?: Error) => void; + renderStart: ( + this: PluginContext, + outputOptions: NormalizedOutputOptions, + inputOptions: NormalizedInputOptions + ) => void; + resolveDynamicImport: ResolveDynamicImportHook; + resolveFileUrl: ResolveFileUrlHook; + resolveId: ResolveIdHook; + resolveImportMeta: ResolveImportMetaHook; + shouldTransformCachedModule: ShouldTransformCachedModuleHook; + transform: TransformHook; + watchChange: WatchChangeHook; + writeBundle: ( + this: PluginContext, + options: NormalizedOutputOptions, + bundle: OutputBundle + ) => void; +} + +export type OutputPluginHooks = + | 'augmentChunkHash' + | 'generateBundle' + | 'outputOptions' + | 'renderChunk' + | 'renderDynamicImport' + | 'renderError' + | 'renderStart' + | 'resolveFileUrl' + | 'resolveImportMeta' + | 'writeBundle'; + +export type InputPluginHooks = Exclude; + +export type SyncPluginHooks = + | 'augmentChunkHash' + | 'onLog' + | 'outputOptions' + | 'renderDynamicImport' + | 'resolveFileUrl' + | 'resolveImportMeta'; + +export type AsyncPluginHooks = Exclude; + +export type FirstPluginHooks = + | 'load' + | 'renderDynamicImport' + | 'resolveDynamicImport' + | 'resolveFileUrl' + | 'resolveId' + | 'resolveImportMeta' + | 'shouldTransformCachedModule'; + +export type SequentialPluginHooks = + | 'augmentChunkHash' + | 'generateBundle' + | 'onLog' + | 'options' + | 'outputOptions' + | 'renderChunk' + | 'transform'; + +export type ParallelPluginHooks = Exclude< + keyof FunctionPluginHooks | AddonHooks, + FirstPluginHooks | SequentialPluginHooks +>; + +export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro'; + +type MakeAsync = Function_ extends ( + this: infer This, + ...parameters: infer Arguments +) => infer Return + ? (this: This, ...parameters: Arguments) => Return | Promise + : never; + +// eslint-disable-next-line @typescript-eslint/ban-types +type ObjectHook = T | ({ handler: T; order?: 'pre' | 'post' | null } & O); + +export type PluginHooks = { + [K in keyof FunctionPluginHooks]: ObjectHook< + K extends AsyncPluginHooks ? MakeAsync : FunctionPluginHooks[K], + // eslint-disable-next-line @typescript-eslint/ban-types + K extends ParallelPluginHooks ? { sequential?: boolean } : {} + >; +}; + +export interface OutputPlugin + extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>, + Partial<{ [K in AddonHooks]: ObjectHook }> { + cacheKey?: string; + name: string; + version?: string; +} + +export interface Plugin extends OutputPlugin, Partial { + // for inter-plugin communication + api?: A; +} + +export type TreeshakingPreset = 'smallest' | 'safest' | 'recommended'; + +export interface NormalizedTreeshakingOptions { + annotations: boolean; + correctVarValueBeforeDeclaration: boolean; + manualPureFunctions: readonly string[]; + moduleSideEffects: HasModuleSideEffects; + propertyReadSideEffects: boolean | 'always'; + tryCatchDeoptimization: boolean; + unknownGlobalSideEffects: boolean; +} + +export interface TreeshakingOptions + extends Partial> { + moduleSideEffects?: ModuleSideEffectsOption; + preset?: TreeshakingPreset; +} + +interface ManualChunkMeta { + getModuleIds: () => IterableIterator; + getModuleInfo: GetModuleInfo; +} +export type GetManualChunk = (id: string, meta: ManualChunkMeta) => string | NullValue; + +export type ExternalOption = + | (string | RegExp)[] + | string + | RegExp + | ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue); + +export type GlobalsOption = { [name: string]: string } | ((name: string) => string); + +export type InputOption = string | string[] | { [entryAlias: string]: string }; + +export type ManualChunksOption = { [chunkAlias: string]: string[] } | GetManualChunk; + +export type LogHandlerWithDefault = ( + level: LogLevel, + log: RollupLog, + defaultHandler: LogOrStringHandler +) => void; + +export type LogOrStringHandler = (level: LogLevel | 'error', log: RollupLog | string) => void; + +export type LogHandler = (level: LogLevel, log: RollupLog) => void; + +export type ModuleSideEffectsOption = boolean | 'no-external' | string[] | HasModuleSideEffects; + +export type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only'; + +export type SourcemapPathTransformOption = ( + relativeSourcePath: string, + sourcemapPath: string +) => string; + +export type SourcemapIgnoreListOption = ( + relativeSourcePath: string, + sourcemapPath: string +) => boolean; + +export type InputPluginOption = MaybePromise; + +export interface InputOptions { + acorn?: Record; + acornInjectPlugins?: ((...arguments_: any[]) => unknown)[] | ((...arguments_: any[]) => unknown); + cache?: boolean | RollupCache; + context?: string; + experimentalCacheExpiry?: number; + experimentalLogSideEffects?: boolean; + external?: ExternalOption; + /** @deprecated Use the "inlineDynamicImports" output option instead. */ + inlineDynamicImports?: boolean; + input?: InputOption; + logLevel?: LogLevelOption; + makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource'; + /** @deprecated Use the "manualChunks" output option instead. */ + manualChunks?: ManualChunksOption; + maxParallelFileOps?: number; + /** @deprecated Use the "maxParallelFileOps" option instead. */ + maxParallelFileReads?: number; + moduleContext?: ((id: string) => string | NullValue) | { [id: string]: string }; + onLog?: LogHandlerWithDefault; + onwarn?: WarningHandlerWithDefault; + perf?: boolean; + plugins?: InputPluginOption; + preserveEntrySignatures?: PreserveEntrySignaturesOption; + /** @deprecated Use the "preserveModules" output option instead. */ + preserveModules?: boolean; + preserveSymlinks?: boolean; + shimMissingExports?: boolean; + strictDeprecations?: boolean; + treeshake?: boolean | TreeshakingPreset | TreeshakingOptions; + watch?: WatcherOptions | false; +} + +export interface InputOptionsWithPlugins extends InputOptions { + plugins: Plugin[]; +} + +export interface NormalizedInputOptions { + acorn: Record; + acornInjectPlugins: (() => unknown)[]; + cache: false | undefined | RollupCache; + context: string; + experimentalCacheExpiry: number; + experimentalLogSideEffects: boolean; + external: IsExternal; + /** @deprecated Use the "inlineDynamicImports" output option instead. */ + inlineDynamicImports: boolean | undefined; + input: string[] | { [entryAlias: string]: string }; + logLevel: LogLevelOption; + makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource'; + /** @deprecated Use the "manualChunks" output option instead. */ + manualChunks: ManualChunksOption | undefined; + maxParallelFileOps: number; + /** @deprecated Use the "maxParallelFileOps" option instead. */ + maxParallelFileReads: number; + moduleContext: (id: string) => string; + onLog: LogHandler; + onwarn: (warning: RollupLog) => void; + perf: boolean; + plugins: Plugin[]; + preserveEntrySignatures: PreserveEntrySignaturesOption; + /** @deprecated Use the "preserveModules" output option instead. */ + preserveModules: boolean | undefined; + preserveSymlinks: boolean; + shimMissingExports: boolean; + strictDeprecations: boolean; + treeshake: false | NormalizedTreeshakingOptions; +} + +export type InternalModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd'; + +export type ModuleFormat = InternalModuleFormat | 'commonjs' | 'esm' | 'module' | 'systemjs'; + +type GeneratedCodePreset = 'es5' | 'es2015'; + +interface NormalizedGeneratedCodeOptions { + arrowFunctions: boolean; + constBindings: boolean; + objectShorthand: boolean; + reservedNamesAsProps: boolean; + symbols: boolean; +} + +interface GeneratedCodeOptions extends Partial { + preset?: GeneratedCodePreset; +} + +export type OptionsPaths = Record | ((id: string) => string); + +export type InteropType = 'compat' | 'auto' | 'esModule' | 'default' | 'defaultOnly'; + +export type GetInterop = (id: string | null) => InteropType; + +export type AmdOptions = ( + | { + autoId?: false; + id: string; + } + | { + autoId: true; + basePath?: string; + id?: undefined; + } + | { + autoId?: false; + id?: undefined; + } +) & { + define?: string; + forceJsExtensionForImports?: boolean; +}; + +export type NormalizedAmdOptions = ( + | { + autoId: false; + id?: string; + } + | { + autoId: true; + basePath: string; + } +) & { + define: string; + forceJsExtensionForImports: boolean; +}; + +type AddonFunction = (chunk: RenderedChunk) => string | Promise; + +type OutputPluginOption = MaybePromise; + +export interface OutputOptions { + amd?: AmdOptions; + assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string); + banner?: string | AddonFunction; + chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string); + compact?: boolean; + // only required for bundle.write + dir?: string; + /** @deprecated Use the "renderDynamicImport" plugin hook instead. */ + dynamicImportFunction?: string; + dynamicImportInCjs?: boolean; + entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string); + esModule?: boolean | 'if-default-prop'; + /** @deprecated This option is no longer needed and ignored. */ + experimentalDeepDynamicChunkOptimization?: boolean; + experimentalMinChunkSize?: number; + exports?: 'default' | 'named' | 'none' | 'auto'; + extend?: boolean; + externalImportAssertions?: boolean; + externalLiveBindings?: boolean; + // only required for bundle.write + file?: string; + footer?: string | AddonFunction; + format?: ModuleFormat; + freeze?: boolean; + generatedCode?: GeneratedCodePreset | GeneratedCodeOptions; + globals?: GlobalsOption; + hoistTransitiveImports?: boolean; + indent?: string | boolean; + inlineDynamicImports?: boolean; + interop?: InteropType | GetInterop; + intro?: string | AddonFunction; + manualChunks?: ManualChunksOption; + minifyInternalExports?: boolean; + name?: string; + /** @deprecated Use "generatedCode.symbols" instead. */ + namespaceToStringTag?: boolean; + noConflict?: boolean; + outro?: string | AddonFunction; + paths?: OptionsPaths; + plugins?: OutputPluginOption; + /** @deprecated Use "generatedCode.constBindings" instead. */ + preferConst?: boolean; + preserveModules?: boolean; + preserveModulesRoot?: string; + sanitizeFileName?: boolean | ((fileName: string) => string); + sourcemap?: boolean | 'inline' | 'hidden'; + sourcemapBaseUrl?: string; + sourcemapExcludeSources?: boolean; + sourcemapFile?: string; + sourcemapFileNames?: string | ((chunkInfo: PreRenderedChunk) => string); + sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption; + sourcemapPathTransform?: SourcemapPathTransformOption; + strict?: boolean; + systemNullSetters?: boolean; + validate?: boolean; +} + +export interface NormalizedOutputOptions { + amd: NormalizedAmdOptions; + assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string); + banner: AddonFunction; + chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string); + compact: boolean; + dir: string | undefined; + /** @deprecated Use the "renderDynamicImport" plugin hook instead. */ + dynamicImportFunction: string | undefined; + dynamicImportInCjs: boolean; + entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string); + esModule: boolean | 'if-default-prop'; + /** @deprecated This option is no longer needed and ignored. */ + experimentalDeepDynamicChunkOptimization: boolean; + experimentalMinChunkSize: number; + exports: 'default' | 'named' | 'none' | 'auto'; + extend: boolean; + externalImportAssertions: boolean; + externalLiveBindings: boolean; + file: string | undefined; + footer: AddonFunction; + format: InternalModuleFormat; + freeze: boolean; + generatedCode: NormalizedGeneratedCodeOptions; + globals: GlobalsOption; + hoistTransitiveImports: boolean; + indent: true | string; + inlineDynamicImports: boolean; + interop: GetInterop; + intro: AddonFunction; + manualChunks: ManualChunksOption; + minifyInternalExports: boolean; + name: string | undefined; + /** @deprecated Use "generatedCode.symbols" instead. */ + namespaceToStringTag: boolean; + noConflict: boolean; + outro: AddonFunction; + paths: OptionsPaths; + plugins: OutputPlugin[]; + /** @deprecated Use "generatedCode.constBindings" instead. */ + preferConst: boolean; + preserveModules: boolean; + preserveModulesRoot: string | undefined; + sanitizeFileName: (fileName: string) => string; + sourcemap: boolean | 'inline' | 'hidden'; + sourcemapBaseUrl: string | undefined; + sourcemapExcludeSources: boolean; + sourcemapFile: string | undefined; + sourcemapFileNames: string | ((chunkInfo: PreRenderedChunk) => string) | undefined; + sourcemapIgnoreList: SourcemapIgnoreListOption; + sourcemapPathTransform: SourcemapPathTransformOption | undefined; + strict: boolean; + systemNullSetters: boolean; + validate: boolean; +} + +export type WarningHandlerWithDefault = ( + warning: RollupLog, + defaultHandler: LoggingFunction +) => void; + +export interface SerializedTimings { + [label: string]: [number, number, number]; +} + +export interface PreRenderedAsset { + name: string | undefined; + source: string | Uint8Array; + type: 'asset'; +} + +export interface OutputAsset extends PreRenderedAsset { + fileName: string; + needsCodeReference: boolean; +} + +export interface RenderedModule { + readonly code: string | null; + originalLength: number; + removedExports: string[]; + renderedExports: string[]; + renderedLength: number; +} + +export interface PreRenderedChunk { + exports: string[]; + facadeModuleId: string | null; + isDynamicEntry: boolean; + isEntry: boolean; + isImplicitEntry: boolean; + moduleIds: string[]; + name: string; + type: 'chunk'; +} + +export interface RenderedChunk extends PreRenderedChunk { + dynamicImports: string[]; + fileName: string; + implicitlyLoadedBefore: string[]; + importedBindings: { + [imported: string]: string[]; + }; + imports: string[]; + modules: { + [id: string]: RenderedModule; + }; + referencedFiles: string[]; +} + +export interface OutputChunk extends RenderedChunk { + code: string; + map: SourceMap | null; + sourcemapFileName: string | null; + preliminaryFileName: string; +} + +export interface SerializablePluginCache { + [key: string]: [number, any]; +} + +export interface RollupCache { + modules: ModuleJSON[]; + plugins?: Record; +} + +export interface RollupOutput { + output: [OutputChunk, ...(OutputChunk | OutputAsset)[]]; +} + +export interface RollupBuild { + cache: RollupCache | undefined; + close: () => Promise; + closed: boolean; + generate: (outputOptions: OutputOptions) => Promise; + getTimings?: () => SerializedTimings; + watchFiles: string[]; + write: (options: OutputOptions) => Promise; +} + +export interface RollupOptions extends InputOptions { + // This is included for compatibility with config files but ignored by rollup.rollup + output?: OutputOptions | OutputOptions[]; +} + +export interface MergedRollupOptions extends InputOptionsWithPlugins { + output: OutputOptions[]; +} + +export function rollup(options: RollupOptions): Promise; + +export interface ChokidarOptions { + alwaysStat?: boolean; + atomic?: boolean | number; + awaitWriteFinish?: + | { + pollInterval?: number; + stabilityThreshold?: number; + } + | boolean; + binaryInterval?: number; + cwd?: string; + depth?: number; + disableGlobbing?: boolean; + followSymlinks?: boolean; + ignoreInitial?: boolean; + ignorePermissionErrors?: boolean; + ignored?: any; + interval?: number; + persistent?: boolean; + useFsEvents?: boolean; + usePolling?: boolean; +} + +export type RollupWatchHooks = 'onError' | 'onStart' | 'onBundleStart' | 'onBundleEnd' | 'onEnd'; + +export interface WatcherOptions { + buildDelay?: number; + chokidar?: ChokidarOptions; + clearScreen?: boolean; + exclude?: string | RegExp | (string | RegExp)[]; + include?: string | RegExp | (string | RegExp)[]; + skipWrite?: boolean; +} + +export interface RollupWatchOptions extends InputOptions { + output?: OutputOptions | OutputOptions[]; + watch?: WatcherOptions | false; +} + +export type AwaitedEventListener< + T extends { [event: string]: (...parameters: any) => any }, + K extends keyof T +> = (...parameters: Parameters) => void | Promise; + +export interface AwaitingEventEmitter any }> { + close(): Promise; + emit(event: K, ...parameters: Parameters): Promise; + /** + * Removes an event listener. + */ + off(event: K, listener: AwaitedEventListener): this; + /** + * Registers an event listener that will be awaited before Rollup continues. + * All listeners will be awaited in parallel while rejections are tracked via + * Promise.all. + */ + on(event: K, listener: AwaitedEventListener): this; + /** + * Registers an event listener that will be awaited before Rollup continues. + * All listeners will be awaited in parallel while rejections are tracked via + * Promise.all. + * Listeners are removed automatically when removeListenersForCurrentRun is + * called, which happens automatically after each run. + */ + onCurrentRun( + event: K, + listener: (...parameters: Parameters) => Promise> + ): this; + removeAllListeners(): this; + removeListenersForCurrentRun(): this; +} + +export type RollupWatcherEvent = + | { code: 'START' } + | { code: 'BUNDLE_START'; input?: InputOption; output: readonly string[] } + | { + code: 'BUNDLE_END'; + duration: number; + input?: InputOption; + output: readonly string[]; + result: RollupBuild; + } + | { code: 'END' } + | { code: 'ERROR'; error: RollupError; result: RollupBuild | null }; + +export type RollupWatcher = AwaitingEventEmitter<{ + change: (id: string, change: { event: ChangeEvent }) => void; + close: () => void; + event: (event: RollupWatcherEvent) => void; + restart: () => void; +}>; + +export function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher; + +interface AcornNode { + end: number; + start: number; + type: string; +} + +export function defineConfig(options: RollupOptions): RollupOptions; +export function defineConfig(options: RollupOptions[]): RollupOptions[]; +export function defineConfig(optionsFunction: RollupOptionsFunction): RollupOptionsFunction; + +export type RollupOptionsFunction = ( + commandLineArguments: Record +) => MaybePromise; diff --git a/packages/rollup-tests/package.json b/packages/rollup-tests/package.json index 569e17489d..d486e612a9 100644 --- a/packages/rollup-tests/package.json +++ b/packages/rollup-tests/package.json @@ -28,4 +28,4 @@ "@types/node": "^18.7.23", "source-map": "^0.7.4" } -} \ No newline at end of file +} diff --git a/web/docs/package.json b/web/docs/package.json index ac19dfb357..2fde2386e5 100644 --- a/web/docs/package.json +++ b/web/docs/package.json @@ -10,4 +10,4 @@ "devDependencies": { "vitepress": "^1.0.0-rc.44" } -} \ No newline at end of file +} diff --git a/web/playground/package.json b/web/playground/package.json index 3c8e4de04b..d0c8767acf 100644 --- a/web/playground/package.json +++ b/web/playground/package.json @@ -28,4 +28,4 @@ "vue": "^3.3.8", "vue-codemirror": "^6.1.1" } -} \ No newline at end of file +} diff --git a/yarn.lock b/yarn.lock index d9c3b66fae..96b5e6bc50 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1869,7 +1869,6 @@ __metadata: dependencies: "@rolldown/node-binding": "workspace:*" "@types/node": "npm:^18.14.0" - rollup: "npm:^3.17.2" typescript: "npm:^5.0.0" unbuild: "npm:^2.0.0" vitest: "npm:^0.34.6" @@ -10894,7 +10893,7 @@ __metadata: languageName: unknown linkType: soft -"rollup@npm:^3.17.2, rollup@npm:^3.17.3, rollup@npm:^3.28.1": +"rollup@npm:^3.17.3, rollup@npm:^3.28.1": version: 3.29.4 resolution: "rollup@npm:3.29.4" dependencies: