rolldown 1.0.0-beta.1-commit.7c52c94 → 1.0.0-beta.2-commit.f069c5d

package/dist/types/parse-ast-index.js

@@ -0,0 +1,73 @@
+import { parseSync, parseAsync } from './binding';
+import { locate } from './log/locate-character';
+import { error, logParseError } from './log/logs';
+import { getCodeFrame } from './utils/code-frame';
+// The oxc program is a string in the result, we need to parse it to a object.
+// Copy from https://github.com/oxc-project/oxc/blob/main/napi/parser/index.js#L12
+function wrap(result, sourceText) {
+    let program, module, comments, errors, magicString;
+    return {
+        get program() {
+            if (!errors)
+                errors = result.errors;
+            if (errors.length > 0) {
+                return normalizeParseError(sourceText, errors);
+            }
+            // @ts-expect-error the result.program typing is `Program`
+            if (!program)
+                program = JSON.parse(result.program);
+            return program;
+        },
+        get module() {
+            if (!module)
+                module = result.module;
+            return module;
+        },
+        get comments() {
+            if (!comments)
+                comments = result.comments;
+            return comments;
+        },
+        get errors() {
+            if (!errors)
+                errors = result.errors;
+            return errors;
+        },
+        get magicString() {
+            if (!magicString)
+                magicString = result.magicString;
+            return magicString;
+        },
+    };
+}
+function normalizeParseError(sourceText, errors) {
+    let message = `Parse failed with ${errors.length} error${errors.length < 2 ? '' : 's'}:\n`;
+    for (let i = 0; i < errors.length; i++) {
+        if (i >= 5) {
+            message += '\n...';
+            break;
+        }
+        const e = errors[i];
+        message +=
+            e.message +
+                '\n' +
+                e.labels
+                    .map((label) => {
+                    const location = locate(sourceText, label.start, { offsetLine: 1 });
+                    if (!location) {
+                        return;
+                    }
+                    return getCodeFrame(sourceText, location.line, location.column);
+                })
+                    .filter(Boolean)
+                    .join('\n');
+    }
+    return error(logParseError(message));
+}
+// The api compat to rollup `parseAst` and `parseAstAsync`.
+export function parseAst(filename, sourceText, options) {
+    return wrap(parseSync(filename, sourceText, options), sourceText);
+}
+export async function parseAstAsync(filename, sourceText, options) {
+    return wrap(await parseAsync(filename, sourceText, options), sourceText);
+}

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

@@ -0,0 +1,213 @@
+import { normalizeHook } from '../utils/normalize-hook';
+import { isEmptySourcemapFiled, normalizeTransformHookSourcemap, } from '../utils/transform-sourcemap';
+import { transformModuleInfo } from '../utils/transform-module-info';
+import path from 'node:path';
+import { bindingifySourcemap } from '../types/sourcemap';
+import { PluginContext, } from './plugin-context';
+import { TransformPluginContext } from './transform-plugin-context';
+import { bindingifySideEffects } from '../utils/transform-side-effects';
+import { bindingifyPluginHookMeta, } from './bindingify-plugin-hook-meta';
+import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
+import { bindingifyLoadFilter, bindingifyResolveIdFilter, bindingifyTransformFilter, } from './bindingify-hook-filter';
+import { NormalizedInputOptionsImpl } from '../options/normalized-input-options';
+import { normalizeErrors } from '../utils/error';
+export function bindingifyBuildStart(args) {
+    const hook = args.plugin.buildStart;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, opts) => {
+            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedInputOptionsImpl(opts, args.onLog));
+        },
+        meta: bindingifyPluginHookMeta(meta),
+    };
+}
+export function bindingifyBuildEnd(args) {
+    const hook = args.plugin.buildEnd;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, err) => {
+            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), err ? normalizeErrors(err) : undefined);
+        },
+        meta: bindingifyPluginHookMeta(meta),
+    };
+}
+export function bindingifyResolveId(args) {
+    const hook = args.plugin.resolveId;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta, options } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, specifier, importer, extraOptions) => {
+            const contextResolveOptions = extraOptions.custom != null
+                ? args.pluginContextData.getSavedResolveOptions(extraOptions.custom)
+                : undefined;
+            const newExtraOptions = {
+                ...extraOptions,
+                custom: contextResolveOptions?.custom,
+                [SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]: contextResolveOptions?.[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF],
+            };
+            const ret = await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), specifier, importer ?? undefined, newExtraOptions);
+            if (ret == null) {
+                return;
+            }
+            if (ret === false) {
+                return {
+                    id: specifier,
+                    external: true,
+                };
+            }
+            if (typeof ret === 'string') {
+                return {
+                    id: ret,
+                };
+            }
+            args.pluginContextData.updateModuleOption(ret.id, {
+                meta: ret.meta || {},
+                moduleSideEffects: ret.moduleSideEffects || null,
+            });
+            return {
+                id: ret.id,
+                external: ret.external,
+                sideEffects: bindingifySideEffects(ret.moduleSideEffects),
+            };
+        },
+        meta: bindingifyPluginHookMeta(meta),
+        filter: bindingifyResolveIdFilter(options.filter),
+    };
+}
+export function bindingifyResolveDynamicImport(args) {
+    const hook = args.plugin.resolveDynamicImport;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, specifier, importer) => {
+            const ret = await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), specifier, importer ?? undefined);
+            if (ret == null) {
+                return;
+            }
+            if (ret === false) {
+                return {
+                    id: specifier,
+                    external: true,
+                };
+            }
+            if (typeof ret === 'string') {
+                return {
+                    id: ret,
+                };
+            }
+            const result = {
+                id: ret.id,
+                external: ret.external,
+            };
+            if (ret.moduleSideEffects !== null) {
+                result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
+            }
+            args.pluginContextData.updateModuleOption(ret.id, {
+                meta: ret.meta || {},
+                moduleSideEffects: ret.moduleSideEffects || null,
+            });
+            return result;
+        },
+        meta: bindingifyPluginHookMeta(meta),
+    };
+}
+export function bindingifyTransform(args) {
+    const hook = args.plugin.transform;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta, options } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, code, id, meta) => {
+            const ret = await handler.call(new TransformPluginContext(ctx.inner(), args.plugin, args.pluginContextData, ctx, id, code, args.onLog, args.logLevel), code, id, meta);
+            if (ret == null) {
+                return undefined;
+            }
+            if (typeof ret === 'string') {
+                return { code: ret };
+            }
+            args.pluginContextData.updateModuleOption(id, {
+                meta: ret.meta || {},
+                moduleSideEffects: ret.moduleSideEffects || null,
+            });
+            return {
+                code: ret.code,
+                map: bindingifySourcemap(normalizeTransformHookSourcemap(id, code, ret.map)),
+                sideEffects: bindingifySideEffects(ret.moduleSideEffects),
+                moduleType: ret.moduleType,
+            };
+        },
+        meta: bindingifyPluginHookMeta(meta),
+        filter: bindingifyTransformFilter(options.filter),
+    };
+}
+export function bindingifyLoad(args) {
+    const hook = args.plugin.load;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta, options } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, id) => {
+            const ret = await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, id), id);
+            if (ret == null) {
+                return;
+            }
+            if (typeof ret === 'string') {
+                return { code: ret };
+            }
+            args.pluginContextData.updateModuleOption(id, {
+                meta: ret.meta || {},
+                moduleSideEffects: ret.moduleSideEffects || null,
+            });
+            let map = preProcessSourceMap(ret, id);
+            return {
+                code: ret.code,
+                map: bindingifySourcemap(map),
+                moduleType: ret.moduleType,
+                sideEffects: bindingifySideEffects(ret.moduleSideEffects),
+            };
+        },
+        meta: bindingifyPluginHookMeta(meta),
+        filter: bindingifyLoadFilter(options.filter),
+    };
+}
+function preProcessSourceMap(ret, id) {
+    if (!ret.map) {
+        return;
+    }
+    let map = typeof ret.map === 'object'
+        ? ret.map
+        : JSON.parse(ret.map);
+    if (!isEmptySourcemapFiled(map.sources)) {
+        // normalize original sourcemap sources
+        // Port form https://github.com/rollup/rollup/blob/master/src/utils/collapseSourcemaps.ts#L180-L188.
+        const directory = path.dirname(id) || '.';
+        const sourceRoot = map.sourceRoot || '.';
+        map.sources = map.sources.map((source) => path.resolve(directory, sourceRoot, source));
+    }
+    return map;
+}
+export function bindingifyModuleParsed(args) {
+    const hook = args.plugin.moduleParsed;
+    if (!hook) {
+        return {};
+    }
+    const { handler, meta } = normalizeHook(hook);
+    return {
+        plugin: async (ctx, moduleInfo) => {
+            await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformModuleInfo(moduleInfo, args.pluginContextData.getModuleOption(moduleInfo.id)));
+        },
+        meta: bindingifyPluginHookMeta(meta),
+    };
+}

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

@@ -0,0 +1,39 @@
+import { arraify } from '../utils/misc';
+export function bindingifyStringFilter(matcher) {
+    if (typeof matcher === 'string' || matcher instanceof RegExp) {
+        return { include: [matcher] };
+    }
+    if (Array.isArray(matcher)) {
+        return { include: matcher };
+    }
+    return {
+        include: matcher.include ? arraify(matcher.include) : undefined,
+        exclude: matcher.exclude ? arraify(matcher.exclude) : undefined,
+    };
+}
+export function bindingifyResolveIdFilter(filterOption) {
+    return filterOption?.id ? bindingifyStringFilter(filterOption.id) : undefined;
+}
+export function bindingifyLoadFilter(filterOption) {
+    return filterOption?.id ? bindingifyStringFilter(filterOption.id) : undefined;
+}
+export function bindingifyTransformFilter(filterOption) {
+    if (!filterOption) {
+        return undefined;
+    }
+    const { id, code, moduleType } = filterOption;
+    let moduleTypeRet;
+    if (moduleType) {
+        if (Array.isArray(moduleType)) {
+            moduleTypeRet = moduleType;
+        }
+        else {
+            moduleTypeRet = moduleType.include;
+        }
+    }
+    return {
+        id: id ? bindingifyStringFilter(id) : undefined,
+        code: code ? bindingifyStringFilter(code) : undefined,
+        moduleType: moduleTypeRet,
+    };
+}

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

@@ -0,0 +1,189 @@
+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.js

@@ -0,0 +1,19 @@
+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.js

@@ -0,0 +1,124 @@
+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.js

@@ -0,0 +1,29 @@
+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.js

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

package/dist/types/plugin/index.js

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