rolldown 1.0.0-beta.2-commit.5deb279 → 1.0.0-beta.21

package/dist/types/plugin/bindingify-output-hooks.js

@@ -1,189 +0,0 @@
-import { normalizeHook } from '../utils/normalize-hook';
-import { collectChangedBundle, transformToOutputBundle, } from '../utils/transform-to-rollup-output';
-import { PluginContext } from './plugin-context';
-import { bindingifySourcemap } from '../types/sourcemap';
-import { bindingifyPluginHookMeta, } from './bindingify-plugin-hook-meta';
-import { NormalizedInputOptionsImpl } from '../options/normalized-input-options';
-import { NormalizedOutputOptionsImpl } from '../options/normalized-output-options';
-import { transformRenderedChunk } from '../utils/transform-rendered-chunk';
-import { normalizeErrors } from '../utils/error';
-export function bindingifyRenderStart(args) {
-    const hook = args.plugin.renderStart;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, opts) => {
-            handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedOutputOptionsImpl(opts), new NormalizedInputOptionsImpl(opts, args.onLog));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyRenderChunk(args) {
-    const hook = args.plugin.renderChunk;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, code, chunk, opts) => {
-            const ret = await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), code, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts));
-            if (ret == null) {
-                return;
-            }
-            if (typeof ret === 'string') {
-                return { code: ret };
-            }
-            if (!ret.map) {
-                return { code: ret.code };
-            }
-            return {
-                code: ret.code,
-                map: bindingifySourcemap(ret.map),
-            };
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyAugmentChunkHash(args) {
-    const hook = args.plugin.augmentChunkHash;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            return await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyRenderError(args) {
-    const hook = args.plugin.renderError;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, err) => {
-            handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), normalizeErrors(err));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyGenerateBundle(args) {
-    const hook = args.plugin.generateBundle;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, bundle, isWrite, opts) => {
-            const changed = {
-                updated: new Set(),
-                deleted: new Set(),
-            };
-            const output = transformToOutputBundle(bundle, changed);
-            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedOutputOptionsImpl(opts), output, isWrite);
-            return collectChangedBundle(changed, output);
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyWriteBundle(args) {
-    const hook = args.plugin.writeBundle;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, bundle, opts) => {
-            const changed = {
-                updated: new Set(),
-                deleted: new Set(),
-            };
-            const output = transformToOutputBundle(bundle, changed);
-            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedOutputOptionsImpl(opts), output);
-            return collectChangedBundle(changed, output);
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyCloseBundle(args) {
-    const hook = args.plugin.closeBundle;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx) => {
-            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyBanner(args) {
-    const hook = args.plugin.banner;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyFooter(args) {
-    const hook = args.plugin.footer;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyIntro(args) {
-    const hook = args.plugin.intro;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyOutro(args) {
-    const hook = args.plugin.outro;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}

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

@@ -1,8 +0,0 @@
-import { ObjectHookMeta } from '.';
-import { BindingPluginHookMeta } from '../binding';
-export declare function bindingifyPluginHookMeta(options: ObjectHookMeta): BindingPluginHookMeta;
-export type PluginHookWithBindingExt<T, F = undefined> = {
-    plugin?: T;
-    meta?: BindingPluginHookMeta;
-    filter?: F;
-};

package/dist/types/plugin/bindingify-plugin-hook-meta.js

@@ -1,19 +0,0 @@
-import { BindingPluginOrder } from '../binding';
-export function bindingifyPluginHookMeta(options) {
-    return {
-        order: bindingPluginOrder(options.order),
-    };
-}
-function bindingPluginOrder(order) {
-    switch (order) {
-        case 'post':
-            return BindingPluginOrder.Post;
-        case 'pre':
-            return BindingPluginOrder.Pre;
-        case null:
-        case undefined:
-            return undefined;
-        default:
-            throw new Error(`Unknown plugin order: ${order}`);
-    }
-}

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

@@ -1,15 +0,0 @@
-import type { BindingPluginOptions } from '../binding';
-import type { Plugin } from './index';
-import type { OutputOptions } from '../options/output-options';
-import { PluginContextData } from './plugin-context-data';
-import type { LogHandler, LogLevelOption } from '../types/misc';
-import type { InputOptions } from '../options/input-options';
-export interface BindingifyPluginArgs {
-    plugin: Plugin;
-    options: InputOptions;
-    outputOptions: OutputOptions;
-    pluginContextData: PluginContextData;
-    onLog: LogHandler;
-    logLevel: LogLevelOption;
-}
-export declare function bindingifyPlugin(plugin: Plugin, options: InputOptions, outputOptions: OutputOptions, pluginContextData: PluginContextData, onLog: LogHandler, logLevel: LogLevelOption): BindingPluginOptions;

package/dist/types/plugin/bindingify-plugin.js

@@ -1,124 +0,0 @@
-import { bindingifyBuildEnd, bindingifyBuildStart, bindingifyLoad, bindingifyModuleParsed, bindingifyResolveDynamicImport, bindingifyResolveId, bindingifyTransform, } from './bindingify-build-hooks';
-import { bindingifyRenderStart, bindingifyRenderChunk, bindingifyGenerateBundle, bindingifyWriteBundle, bindingifyRenderError, bindingifyAugmentChunkHash, bindingifyBanner, bindingifyFooter, bindingifyIntro, bindingifyOutro, bindingifyCloseBundle, } from './bindingify-output-hooks';
-import { bindingifyCloseWatcher, bindingifyWatchChange, } from './bindingify-watch-hooks';
-import { error, logPluginError } from '../log/logs';
-// Note: because napi not catch error, so we need to catch error and print error to debugger in adapter.
-export function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, onLog, logLevel) {
-    const args = {
-        plugin,
-        options,
-        outputOptions,
-        pluginContextData,
-        onLog,
-        logLevel,
-    };
-    const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(args);
-    const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter, } = bindingifyResolveId(args);
-    const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args);
-    const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args);
-    const { plugin: transform, meta: transformMeta, filter: transformFilter, } = bindingifyTransform(args);
-    const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args);
-    const { plugin: load, meta: loadMeta, filter: loadFilter, } = bindingifyLoad(args);
-    const { plugin: renderChunk, meta: renderChunkMeta } = bindingifyRenderChunk(args);
-    const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args);
-    const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args);
-    const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args);
-    const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(args);
-    const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(args);
-    const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(args);
-    const { plugin: banner, meta: bannerMeta } = bindingifyBanner(args);
-    const { plugin: footer, meta: footerMeta } = bindingifyFooter(args);
-    const { plugin: intro, meta: introMeta } = bindingifyIntro(args);
-    const { plugin: outro, meta: outroMeta } = bindingifyOutro(args);
-    const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(args);
-    const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args);
-    const result = {
-        // The plugin name already normalized at `normalizePlugins`, see `packages/rolldown/src/utils/normalize-plugin-option.ts`
-        name: plugin.name,
-        buildStart,
-        buildStartMeta,
-        resolveId,
-        resolveIdMeta,
-        // @ts-ignore
-        resolveIdFilter,
-        resolveDynamicImport,
-        resolveDynamicImportMeta,
-        buildEnd,
-        buildEndMeta,
-        transform,
-        transformMeta,
-        transformFilter,
-        moduleParsed,
-        moduleParsedMeta,
-        load,
-        loadMeta,
-        loadFilter,
-        renderChunk,
-        renderChunkMeta,
-        augmentChunkHash,
-        augmentChunkHashMeta,
-        renderStart,
-        renderStartMeta,
-        renderError,
-        renderErrorMeta,
-        generateBundle,
-        generateBundleMeta,
-        writeBundle,
-        writeBundleMeta,
-        closeBundle,
-        closeBundleMeta,
-        banner,
-        bannerMeta,
-        footer,
-        footerMeta,
-        intro,
-        introMeta,
-        outro,
-        outroMeta,
-        watchChange,
-        watchChangeMeta,
-        closeWatcher,
-        closeWatcherMeta,
-    };
-    return wrapHandlers(result);
-}
-function wrapHandlers(plugin) {
-    for (const hookName of [
-        'buildStart',
-        'resolveId',
-        'resolveDynamicImport',
-        'buildEnd',
-        'transform',
-        'moduleParsed',
-        'load',
-        'renderChunk',
-        'augmentChunkHash',
-        'renderStart',
-        'renderError',
-        'generateBundle',
-        'writeBundle',
-        'closeBundle',
-        'banner',
-        'footer',
-        'intro',
-        'outro',
-        'watchChange',
-        'closeWatcher',
-    ]) {
-        const handler = plugin[hookName];
-        if (handler) {
-            plugin[hookName] = async (...args) => {
-                try {
-                    return await handler(...args);
-                }
-                catch (e) {
-                    return error(logPluginError(e, plugin.name, {
-                        hook: hookName,
-                        id: hookName === 'transform' ? args[2] : undefined,
-                    }));
-                }
-            };
-        }
-    }
-    return plugin;
-}

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

@@ -1,5 +0,0 @@
-import type { BindingPluginOptions } from '../binding';
-import { PluginHookWithBindingExt } from './bindingify-plugin-hook-meta';
-import { BindingifyPluginArgs } from './bindingify-plugin';
-export declare function bindingifyWatchChange(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['watchChange']>;
-export declare function bindingifyCloseWatcher(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['closeWatcher']>;

package/dist/types/plugin/bindingify-watch-hooks.js

@@ -1,29 +0,0 @@
-import { normalizeHook } from '../utils/normalize-hook';
-import { PluginContext } from './plugin-context';
-import { bindingifyPluginHookMeta, } from './bindingify-plugin-hook-meta';
-export function bindingifyWatchChange(args) {
-    const hook = args.plugin.watchChange;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, id, event) => {
-            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), id, { event: event });
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyCloseWatcher(args) {
-    const hook = args.plugin.closeWatcher;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx) => {
-            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}

package/dist/types/plugin/hook-filter.d.ts

@@ -1,48 +0,0 @@
-import type { MaybeArray } from '../types/utils';
-import type { StringOrRegExp } from '../types/utils';
-import type { ModuleType } from '../index';
-export type StringFilter = MaybeArray<StringOrRegExp> | {
-    include?: MaybeArray<StringOrRegExp>;
-    exclude?: MaybeArray<StringOrRegExp>;
-};
-interface FormalModuleTypeFilter {
-    include?: ModuleType[];
-}
-type ModuleTypeFilter = ModuleType[] | FormalModuleTypeFilter;
-export interface HookFilter {
-    /**
-     * This filter is used to do a pre-test to determine whether the hook should be called.
-     * @example
-     * // Filter out all `id`s that contain `node_modules` in the path.
-     * ```js
-     * { id: 'node_modules' }
-     * ```
-     * @example
-     * // Filter out all `id`s that contain `node_modules` or `src` in the path.
-     * ```js
-     * { id: ['node_modules', 'src'] }
-     * ```
-     * @example
-     * // Filter out all `id`s that start with `http`
-     * ```js
-     * { id: /^http/ }
-     * ```
-     * @example
-     * // Exclude all `id`s that contain `node_modules` in the path.
-     * ```js
-     * { id: { exclude: 'node_modules' } }
-     * ```
-     * @example
-     * // Formal pattern
-     * ```
-     * { id : {
-     *   include: ["foo", /bar/],
-     *   exclude: ["baz", /qux/]
-     * }}
-     * ```
-     */
-    id?: StringFilter;
-    moduleType?: ModuleTypeFilter;
-    code?: StringFilter;
-}
-export {};

package/dist/types/plugin/hook-filter.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,126 +0,0 @@
-import type { BindingHookResolveIdExtraArgs, BindingTransformHookExtraArgs } from '../binding';
-import type { NormalizedInputOptions } from '../options/normalized-input-options';
-import type { NullValue, MaybePromise, PartialNull, MakeAsync } 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 './transform-plugin-context';
-import type { NormalizedOutputOptions } from '../options/normalized-output-options';
-import type { LogLevel } from '../log/logging';
-import type { RollupLog } from '../types/misc';
-import type { MinimalPluginContext } from './minimal-plugin-context';
-import type { InputOptions, OutputOptions } from '..';
-import type { BuiltinPlugin } from '../builtin-plugin/constructors';
-import type { ParallelPlugin } from './parallel-plugin';
-import type { DefinedHookNames } from '../constants/plugin';
-import type { DEFINED_HOOK_NAMES } from '../constants/plugin';
-import type { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
-import type { HookFilter } from './hook-filter';
-import { RenderedChunk } from '../types/rolldown-output';
-export type ModuleSideEffects = boolean | 'no-treeshake' | null;
-export type ModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
-export type ImportKind = BindingHookResolveIdExtraArgs['kind'];
-export interface CustomPluginOptions {
-    [plugin: string]: any;
-}
-export interface ModuleOptions {
-    moduleSideEffects: ModuleSideEffects;
-    meta: CustomPluginOptions;
-}
-export interface ResolvedId extends ModuleOptions {
-    external: boolean;
-    id: string;
-}
-export interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
-    external?: boolean;
-    id: string;
-}
-export interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
-    code: string;
-    map?: SourceMapInput;
-    moduleType?: ModuleType;
-}
-interface ResolveIdExtraOptions {
-    custom?: CustomPluginOptions;
-    isEntry: boolean;
-    kind: 'import' | 'dynamic-import' | 'require-call';
-}
-export interface PrivateResolveIdExtraOptions extends ResolveIdExtraOptions {
-    [SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]?: symbol;
-}
-export type ResolveIdResult = string | NullValue | false | PartialResolvedId;
-export type LoadResult = NullValue | string | SourceDescription;
-export type TransformResult = NullValue | string | Partial<SourceDescription>;
-export interface FunctionPluginHooks {
-    [DEFINED_HOOK_NAMES.onLog]: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => NullValue | boolean;
-    [DEFINED_HOOK_NAMES.options]: (this: MinimalPluginContext, options: InputOptions) => NullValue | InputOptions;
-    [DEFINED_HOOK_NAMES.outputOptions]: (this: null, options: OutputOptions) => NullValue | OutputOptions;
-    [DEFINED_HOOK_NAMES.buildStart]: (this: PluginContext, options: NormalizedInputOptions) => void;
-    [DEFINED_HOOK_NAMES.resolveId]: (this: PluginContext, source: string, importer: string | undefined, extraOptions: ResolveIdExtraOptions) => ResolveIdResult;
-    /**
-     * @deprecated
-     * This hook is only for rollup plugin compatibility. Please use `resolveId` instead.
-     */
-    [DEFINED_HOOK_NAMES.resolveDynamicImport]: (this: PluginContext, source: string, importer: string | undefined) => ResolveIdResult;
-    [DEFINED_HOOK_NAMES.load]: (this: PluginContext, id: string) => MaybePromise<LoadResult>;
-    [DEFINED_HOOK_NAMES.transform]: (this: TransformPluginContext, code: string, id: string, meta: BindingTransformHookExtraArgs & {
-        moduleType: ModuleType;
-    }) => TransformResult;
-    [DEFINED_HOOK_NAMES.moduleParsed]: (this: PluginContext, moduleInfo: ModuleInfo) => void;
-    [DEFINED_HOOK_NAMES.buildEnd]: (this: PluginContext, err?: Error) => void;
-    [DEFINED_HOOK_NAMES.renderStart]: (this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => void;
-    [DEFINED_HOOK_NAMES.renderChunk]: (this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) => NullValue | string | {
-        code: string;
-        map?: SourceMapInput;
-    };
-    [DEFINED_HOOK_NAMES.augmentChunkHash]: (this: PluginContext, chunk: RenderedChunk) => string | void;
-    [DEFINED_HOOK_NAMES.renderError]: (this: PluginContext, error: Error) => void;
-    [DEFINED_HOOK_NAMES.generateBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => void;
-    [DEFINED_HOOK_NAMES.writeBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => void;
-    [DEFINED_HOOK_NAMES.closeBundle]: (this: PluginContext) => void;
-    [DEFINED_HOOK_NAMES.watchChange]: (this: PluginContext, id: string, event: {
-        event: ChangeEvent;
-    }) => void;
-    [DEFINED_HOOK_NAMES.closeWatcher]: (this: PluginContext) => void;
-}
-export type ChangeEvent = 'create' | 'update' | 'delete';
-export type PluginOrder = 'pre' | 'post' | null;
-export type ObjectHookMeta = {
-    order?: PluginOrder;
-};
-export type ObjectHook<T, O = {}> = T | ({
-    handler: T;
-} & ObjectHookMeta & O);
-export type SyncPluginHooks = DefinedHookNames['augmentChunkHash' | 'onLog' | 'outputOptions'];
-export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
-export type FirstPluginHooks = DefinedHookNames['load' | 'resolveDynamicImport' | 'resolveId'];
-export type SequentialPluginHooks = DefinedHookNames['augmentChunkHash' | 'generateBundle' | 'onLog' | 'options' | 'outputOptions' | 'renderChunk' | 'transform'];
-export type AddonHooks = DefinedHookNames['banner' | 'footer' | 'intro' | 'outro'];
-export type OutputPluginHooks = DefinedHookNames['augmentChunkHash' | 'generateBundle' | 'outputOptions' | 'renderChunk' | 'renderError' | 'renderStart' | 'writeBundle'];
-export type ParallelPluginHooks = Exclude<keyof FunctionPluginHooks | AddonHooks, FirstPluginHooks | SequentialPluginHooks>;
-export type HookFilterExtension<K extends keyof FunctionPluginHooks> = K extends 'transform' ? {
-    filter?: HookFilter;
-} : K extends 'load' | 'resolveId' ? {
-    filter?: Pick<HookFilter, 'id'>;
-} : {};
-export type PluginHooks = {
-    [K in keyof FunctionPluginHooks]: ObjectHook<K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K], HookFilterExtension<K>>;
-};
-export type AddonHookFunction = (this: PluginContext, chunk: RenderedChunk) => string | Promise<string>;
-export type AddonHook = string | AddonHookFunction;
-export interface OutputPlugin extends Partial<{
-    [K in OutputPluginHooks]: PluginHooks[K];
-}>, Partial<{
-    [K in AddonHooks]: ObjectHook<AddonHook>;
-}> {
-    name: string;
-}
-export interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
-    api?: A;
-}
-export type RolldownPlugin<A = any> = Plugin<A> | BuiltinPlugin | ParallelPlugin;
-export type RolldownPluginOption<A = any> = MaybePromise<NullValue<RolldownPlugin<A>> | false | RolldownPluginOption[]>;
-export type RolldownOutputPlugin = OutputPlugin | BuiltinPlugin;
-export type RolldownOutputPluginOption = MaybePromise<NullValue<RolldownOutputPlugin> | false | RolldownOutputPluginOption[]>;
-export {};

package/dist/types/plugin/index.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,15 +0,0 @@
-import type { LoggingFunction, LogHandler, LogLevelOption, RollupError } from '../types/misc';
-export interface PluginContextMeta {
-    rollupVersion: string;
-    rolldownVersion: string;
-    watchMode: boolean;
-}
-export declare class MinimalPluginContext {
-    readonly pluginName: string;
-    info: LoggingFunction;
-    warn: LoggingFunction;
-    debug: LoggingFunction;
-    meta: PluginContextMeta;
-    constructor(onLog: LogHandler, logLevel: LogLevelOption, pluginName: string);
-    error(e: RollupError | string): never;
-}

package/dist/types/plugin/minimal-plugin-context.js

@@ -1,25 +0,0 @@
-import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN } from '../log/logging';
-import { error, logPluginError } from '../log/logs';
-import { getLogHandler, normalizeLog } from '../log/logHandler';
-import { VERSION } from '..';
-export class MinimalPluginContext {
-    pluginName;
-    info;
-    warn;
-    debug;
-    meta;
-    constructor(onLog, logLevel, pluginName) {
-        this.pluginName = pluginName;
-        this.debug = getLogHandler(LOG_LEVEL_DEBUG, 'PLUGIN_LOG', onLog, pluginName, logLevel);
-        this.info = getLogHandler(LOG_LEVEL_INFO, 'PLUGIN_LOG', onLog, pluginName, logLevel);
-        this.warn = getLogHandler(LOG_LEVEL_WARN, 'PLUGIN_WARNING', onLog, pluginName, logLevel);
-        this.meta = {
-            rollupVersion: '4.23.0',
-            rolldownVersion: VERSION,
-            watchMode: false,
-        };
-    }
-    error(e) {
-        return error(logPluginError(normalizeLog(e), this.pluginName));
-    }
-}

package/dist/types/plugin/parallel-plugin-implementation.d.ts

@@ -1,10 +0,0 @@
-import type { MaybePromise } from '../types/utils';
-import type { Plugin } from './index';
-export type ParallelPluginImplementation = Plugin;
-export type Context = {
-    /**
-     * Thread number
-     */
-    threadNumber: number;
-};
-export declare function defineParallelPluginImplementation<Options>(plugin: (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>): (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>;

package/dist/types/plugin/parallel-plugin-implementation.js

@@ -1,3 +0,0 @@
-export function defineParallelPluginImplementation(plugin) {
-    return plugin;
-}

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

@@ -1,9 +0,0 @@
-export type ParallelPlugin = {
-    /** @internal */
-    _parallel: {
-        fileUrl: string;
-        options: unknown;
-    };
-};
-export type DefineParallelPluginResult<Options> = (options: Options) => ParallelPlugin;
-export declare function defineParallelPlugin<Options>(pluginPath: string): DefineParallelPluginResult<Options>;

package/dist/types/plugin/parallel-plugin.js

@@ -1,6 +0,0 @@
-import { pathToFileURL } from 'node:url';
-export function defineParallelPlugin(pluginPath) {
-    return (options) => {
-        return { _parallel: { fileUrl: pathToFileURL(pluginPath).href, options } };
-    };
-}