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

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

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

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

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

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

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

@@ -0,0 +1,55 @@
+import { transformModuleInfo } from '../utils/transform-module-info';
+export class PluginContextData {
+    moduleOptionMap = new Map();
+    resolveOptionsMap = new Map();
+    loadModulePromiseMap = new Map();
+    updateModuleOption(id, option) {
+        const existing = this.moduleOptionMap.get(id);
+        if (existing) {
+            if (option.moduleSideEffects != null) {
+                existing.moduleSideEffects = option.moduleSideEffects;
+            }
+            if (option.meta != null) {
+                Object.assign(existing.meta, option.meta);
+            }
+        }
+        else {
+            this.moduleOptionMap.set(id, option);
+        }
+    }
+    getModuleOption(id) {
+        const option = this.moduleOptionMap.get(id);
+        if (!option) {
+            const raw = {
+                moduleSideEffects: null,
+                meta: {},
+            };
+            this.moduleOptionMap.set(id, raw);
+            return raw;
+        }
+        return option;
+    }
+    getModuleInfo(id, context) {
+        const bindingInfo = context.getModuleInfo(id);
+        if (bindingInfo) {
+            const info = transformModuleInfo(bindingInfo, this.getModuleOption(id));
+            return info;
+        }
+        return null;
+    }
+    getModuleIds(context) {
+        const moduleIds = context.getModuleIds();
+        return moduleIds.values();
+    }
+    saveResolveOptions(options) {
+        const index = this.resolveOptionsMap.size;
+        this.resolveOptionsMap.set(index, options);
+        return index;
+    }
+    getSavedResolveOptions(receipt) {
+        return this.resolveOptionsMap.get(receipt);
+    }
+    removeSavedResolveOptions(receipt) {
+        this.resolveOptionsMap.delete(receipt);
+    }
+}

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

@@ -0,0 +1,108 @@
+import { MinimalPluginContext } from '../plugin/minimal-plugin-context';
+import { bindingAssetSource } from '../utils/asset-source';
+import { unimplemented, unsupported } from '../utils/misc';
+import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
+import { bindingifySideEffects } from '../utils/transform-side-effects';
+import { LOG_LEVEL_WARN } from '../log/logging';
+import { logCycleLoading } from '../log/logs';
+export class PluginContext extends MinimalPluginContext {
+    context;
+    data;
+    onLog;
+    currentLoadingModule;
+    constructor(context, plugin, data, onLog, logLevel, currentLoadingModule) {
+        super(onLog, logLevel, plugin.name);
+        this.context = context;
+        this.data = data;
+        this.onLog = onLog;
+        this.currentLoadingModule = currentLoadingModule;
+    }
+    async load(options) {
+        const id = options.id;
+        if (id === this.currentLoadingModule) {
+            this.onLog(LOG_LEVEL_WARN, logCycleLoading(this.pluginName, this.currentLoadingModule));
+        }
+        // resolveDependencies always true at rolldown
+        const moduleInfo = this.data.getModuleInfo(id, this.context);
+        if (moduleInfo && moduleInfo.code !== null /* module already parsed */) {
+            return moduleInfo;
+        }
+        const rawOptions = {
+            meta: options.meta || {},
+            moduleSideEffects: options.moduleSideEffects || null,
+        };
+        this.data.updateModuleOption(id, rawOptions);
+        async function createLoadModulePromise(context, data) {
+            const loadPromise = data.loadModulePromiseMap.get(id);
+            if (loadPromise) {
+                return loadPromise;
+            }
+            let resolveFn;
+            // TODO: If is not resolved, we need to set a time to avoid waiting.
+            const promise = new Promise((resolve, _) => {
+                resolveFn = resolve;
+            });
+            data.loadModulePromiseMap.set(id, promise);
+            try {
+                await context.load(id, bindingifySideEffects(options.moduleSideEffects), resolveFn);
+            }
+            finally {
+                // If the load module has failed, avoid it re-load using unresolved promise.
+                data.loadModulePromiseMap.delete(id);
+            }
+            return promise;
+        }
+        // Here using one promise to avoid pass more callback to rust side, it only accept one callback, other will be ignored.
+        await createLoadModulePromise(this.context, this.data);
+        return this.data.getModuleInfo(id, this.context);
+    }
+    async resolve(source, importer, options) {
+        let receipt = undefined;
+        if (options != null) {
+            receipt = this.data.saveResolveOptions(options);
+        }
+        const res = await this.context.resolve(source, importer, {
+            custom: receipt,
+            skipSelf: options?.skipSelf,
+        });
+        if (receipt != null) {
+            this.data.removeSavedResolveOptions(receipt);
+        }
+        if (res == null)
+            return null;
+        const info = this.data.getModuleOption(res.id) || {};
+        return { ...res, ...info };
+    }
+    emitFile(file) {
+        // @ts-expect-error
+        if (file.type === 'prebuilt-chunk') {
+            return unimplemented('PluginContext.emitFile with type prebuilt-chunk');
+        }
+        if (file.type === 'chunk') {
+            return this.context.emitChunk(file);
+        }
+        return this.context.emitFile({
+            ...file,
+            originalFileName: file.originalFileName || undefined,
+            source: bindingAssetSource(file.source),
+        });
+    }
+    getFileName(referenceId) {
+        return this.context.getFileName(referenceId);
+    }
+    getModuleInfo(id) {
+        return this.data.getModuleInfo(id, this.context);
+    }
+    getModuleIds() {
+        return this.data.getModuleIds(this.context);
+    }
+    addWatchFile(id) {
+        this.context.addWatchFile(id);
+    }
+    /**
+     * @deprecated This rollup API won't be supported by rolldown. Using this API will cause runtime error.
+     */
+    parse(_input, _options) {
+        unsupported('`PluginContext#parse` is not supported by rolldown.');
+    }
+}

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

@@ -0,0 +1,88 @@
+import { getLogHandler, normalizeLog } from '../log/logHandler';
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN } from '../log/logging';
+import { error, logPluginError } from '../log/logs';
+import { normalizeHook } from '../utils/normalize-hook';
+import { VERSION } from '..';
+import { getLogger, getOnLog } from '../log/logger';
+import { BuiltinPlugin } from '../builtin-plugin/constructors';
+import { normalizePluginOption } from '../utils/normalize-plugin-option';
+export class PluginDriver {
+    static async callOptionsHook(inputOptions) {
+        const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
+        const plugins = getSortedPlugins('options', getObjectPlugins(await normalizePluginOption(inputOptions.plugins)));
+        const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), logLevel);
+        for (const plugin of plugins) {
+            const name = plugin.name || 'unknown';
+            const options = plugin.options;
+            if (options) {
+                const { handler } = normalizeHook(options);
+                const result = await handler.call({
+                    debug: getLogHandler(LOG_LEVEL_DEBUG, 'PLUGIN_LOG', logger, name, logLevel),
+                    error: (e) => error(logPluginError(normalizeLog(e), name, { hook: 'onLog' })),
+                    info: getLogHandler(LOG_LEVEL_INFO, 'PLUGIN_LOG', logger, name, logLevel),
+                    meta: {
+                        rollupVersion: '4.23.0',
+                        rolldownVersion: VERSION,
+                        watchMode: false,
+                    },
+                    warn: getLogHandler(LOG_LEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel),
+                    pluginName: name,
+                }, inputOptions);
+                if (result) {
+                    inputOptions = result;
+                }
+            }
+        }
+        return inputOptions;
+    }
+    static callOutputOptionsHook(rawPlugins, outputOptions) {
+        const sortedPlugins = getSortedPlugins('outputOptions', getObjectPlugins(rawPlugins));
+        for (const plugin of sortedPlugins) {
+            const options = plugin.outputOptions;
+            if (options) {
+                const { handler } = normalizeHook(options);
+                const result = handler.call(null, outputOptions);
+                if (result) {
+                    outputOptions = result;
+                }
+            }
+        }
+        return outputOptions;
+    }
+}
+export function getObjectPlugins(plugins) {
+    return plugins.filter((plugin) => {
+        if (!plugin) {
+            return undefined;
+        }
+        if ('_parallel' in plugin) {
+            return undefined;
+        }
+        if (plugin instanceof BuiltinPlugin) {
+            return undefined;
+        }
+        return plugin;
+    });
+}
+export function getSortedPlugins(hookName, plugins) {
+    const pre = [];
+    const normal = [];
+    const post = [];
+    for (const plugin of plugins) {
+        const hook = plugin[hookName];
+        if (hook) {
+            if (typeof hook === 'object') {
+                if (hook.order === 'pre') {
+                    pre.push(plugin);
+                    continue;
+                }
+                if (hook.order === 'post') {
+                    post.push(plugin);
+                    continue;
+                }
+            }
+            normal.push(plugin);
+        }
+    }
+    return [...pre, ...normal, ...post];
+}

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

@@ -0,0 +1,37 @@
+import { normalizeLog } from '../log/logHandler';
+import { PluginContext } from './plugin-context';
+import { augmentCodeLocation, error, logPluginError } from '../log/logs';
+export class TransformPluginContext extends PluginContext {
+    inner;
+    moduleId;
+    moduleSource;
+    constructor(context, plugin, data, inner, moduleId, moduleSource, onLog, LogLevelOption) {
+        super(context, plugin, data, onLog, LogLevelOption, moduleId);
+        this.inner = inner;
+        this.moduleId = moduleId;
+        this.moduleSource = moduleSource;
+        const getLogHandler = (handler) => (log, pos) => {
+            log = normalizeLog(log);
+            if (pos)
+                augmentCodeLocation(log, pos, moduleSource, moduleId);
+            log.id = moduleId;
+            log.hook = 'transform';
+            handler(log);
+        };
+        this.debug = getLogHandler(this.debug);
+        this.warn = getLogHandler(this.warn);
+        this.info = getLogHandler(this.info);
+    }
+    error(e, pos) {
+        if (typeof e === 'string')
+            e = { message: e };
+        if (pos)
+            augmentCodeLocation(e, pos, this.moduleSource, this.moduleId);
+        e.id = this.moduleId;
+        e.hook = 'transform';
+        return error(logPluginError(normalizeLog(e), this.pluginName));
+    }
+    getCombinedSourcemap() {
+        return JSON.parse(this.inner.getCombinedSourcemap());
+    }
+}

package/dist/types/types/assert.js

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

package/dist/types/types/config-export.js

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

package/dist/types/types/misc.js

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

package/dist/types/types/module-info.js

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

package/dist/types/types/module-side-effects.js

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

package/dist/types/types/output-bundle.js

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

package/dist/types/types/rolldown-options.js

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

package/dist/types/types/rolldown-output.js

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

package/dist/types/types/schema.js

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

package/dist/types/types/sourcemap.js

@@ -0,0 +1,16 @@
+export function bindingifySourcemap(map) {
+    if (map == null)
+        return;
+    return {
+        inner: typeof map === 'string'
+            ? map
+            : {
+                file: map.file ?? undefined,
+                mappings: map.mappings,
+                sourceRoot: map.sourceRoot,
+                sources: map.sources?.map((s) => s ?? undefined),
+                sourcesContent: map.sourcesContent?.map((s) => s ?? undefined),
+                names: map.names,
+            },
+    };
+}

package/dist/types/types/utils.js

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

package/dist/types/utils/asset-source.js

@@ -0,0 +1,8 @@
+export function transformAssetSource(bindingAssetSource) {
+    return bindingAssetSource.inner;
+}
+export function bindingAssetSource(source) {
+    return {
+        inner: source,
+    };
+}

package/dist/types/utils/async-flatten.js

@@ -0,0 +1,7 @@
+// Copied from https://github.com/rollup/rollup/blob/3b560f7c889a63968dabc9b6970aabf52a77d3fd/src/utils/asyncFlatten.ts
+export async function asyncFlatten(array) {
+    do {
+        array = (await Promise.all(array)).flat(Infinity);
+    } while (array.some((v) => v?.then));
+    return array;
+}

package/dist/types/utils/bindingify-input-options.js

@@ -0,0 +1,225 @@
+import { BindingLogLevel } from '../binding';
+import { bindingifyPlugin } from '../plugin/bindingify-plugin';
+import { PluginContextData } from '../plugin/plugin-context-data';
+import { bindingifyBuiltInPlugin } from '../builtin-plugin/utils';
+import { BuiltinPlugin } from '../builtin-plugin/constructors';
+import { arraify, unsupported } from './misc';
+import { normalizedStringOrRegex } from './normalize-string-or-regex';
+export function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, onLog, logLevel) {
+    const pluginContextData = new PluginContextData();
+    const plugins = rawPlugins.map((plugin) => {
+        if ('_parallel' in plugin) {
+            return undefined;
+        }
+        if (plugin instanceof BuiltinPlugin) {
+            return bindingifyBuiltInPlugin(plugin);
+        }
+        return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData, onLog, logLevel);
+    });
+    return {
+        input: bindingifyInput(inputOptions.input),
+        plugins,
+        cwd: inputOptions.cwd ?? process.cwd(),
+        external: bindingifyExternal(inputOptions.external),
+        resolve: bindingifyResolve(inputOptions.resolve),
+        platform: inputOptions.platform,
+        shimMissingExports: inputOptions.shimMissingExports,
+        logLevel: bindingifyLogLevel(logLevel),
+        onLog,
+        // After normalized, `false` will be converted to `undefined`, otherwise, default value will be assigned
+        // Because it is hard to represent Enum in napi, ref: https://github.com/napi-rs/napi-rs/issues/507
+        // So we use `undefined | NormalizedTreeshakingOptions` (or Option<NormalizedTreeshakingOptions> in rust side), to represent `false | NormalizedTreeshakingOptions`
+        treeshake: bindingifyTreeshakeOptions(inputOptions.treeshake),
+        moduleTypes: inputOptions.moduleTypes,
+        define: inputOptions.define
+            ? Object.entries(inputOptions.define)
+            : undefined,
+        inject: bindingifyInject(inputOptions.inject),
+        experimental: {
+            strictExecutionOrder: inputOptions.experimental?.strictExecutionOrder,
+            disableLiveBindings: inputOptions.experimental?.disableLiveBindings,
+            viteMode: inputOptions.experimental?.viteMode,
+            resolveNewUrlToAsset: inputOptions.experimental?.resolveNewUrlToAsset,
+        },
+        profilerNames: inputOptions?.profilerNames,
+        jsx: bindingifyJsx(inputOptions.jsx),
+        watch: bindingifyWatch(inputOptions.watch),
+        dropLabels: inputOptions.dropLabels,
+        keepNames: inputOptions.keepNames,
+        checks: inputOptions.checks,
+    };
+}
+function bindingifyExternal(external) {
+    if (external) {
+        if (typeof external === 'function') {
+            return (id, importer, isResolved) => {
+                if (id.startsWith('\0'))
+                    return false;
+                return external(id, importer, isResolved) ?? false;
+            };
+        }
+        const externalArr = arraify(external);
+        return (id, _importer, _isResolved) => {
+            return externalArr.some((pat) => {
+                if (pat instanceof RegExp) {
+                    return pat.test(id);
+                }
+                return id === pat;
+            });
+        };
+    }
+}
+function bindingifyResolve(resolve) {
+    if (resolve) {
+        const { alias, extensionAlias, ...rest } = resolve;
+        return {
+            alias: alias
+                ? Object.entries(alias).map(([name, replacement]) => ({
+                    find: name,
+                    replacements: arraify(replacement),
+                }))
+                : undefined,
+            extensionAlias: extensionAlias
+                ? Object.entries(extensionAlias).map(([name, value]) => ({
+                    target: name,
+                    replacements: value,
+                }))
+                : undefined,
+            ...rest,
+        };
+    }
+}
+function bindingifyInject(inject) {
+    if (inject) {
+        return Object.entries(inject).map(([alias, item]) => {
+            if (Array.isArray(item)) {
+                // import * as fs from 'node:fs'
+                // fs: ['node:fs', '*' ],
+                if (item[1] === '*') {
+                    return {
+                        tagNamespace: true,
+                        alias,
+                        from: item[0],
+                    };
+                }
+                // import { Promise } from 'es6-promise'
+                // Promise: [ 'es6-promise', 'Promise' ],
+                // import { Promise as P } from 'es6-promise'
+                // P: [ 'es6-promise', 'Promise' ],
+                return {
+                    tagNamed: true,
+                    alias,
+                    from: item[0],
+                    imported: item[1],
+                };
+            }
+            else {
+                // import $ from 'jquery'
+                // $: 'jquery',
+                // 'Object.assign': path.resolve( 'src/helpers/object-assign.js' ),
+                return {
+                    tagNamed: true,
+                    imported: 'default',
+                    alias,
+                    from: item,
+                };
+            }
+        });
+    }
+}
+function bindingifyLogLevel(logLevel) {
+    switch (logLevel) {
+        case 'silent':
+            return BindingLogLevel.Silent;
+        case 'debug':
+            return BindingLogLevel.Debug;
+        case 'warn':
+            return BindingLogLevel.Warn;
+        case 'info':
+            return BindingLogLevel.Info;
+        default:
+            throw new Error(`Unexpected log level: ${logLevel}`);
+    }
+}
+function bindingifyInput(input) {
+    if (input === undefined) {
+        return [];
+    }
+    if (typeof input === 'string') {
+        return [{ import: input }];
+    }
+    if (Array.isArray(input)) {
+        return input.map((src) => ({ import: src }));
+    }
+    return Object.entries(input).map((value) => {
+        return { name: value[0], import: value[1] };
+    });
+}
+// The `automatic` is most user usages, so it is different rollup's default value `false`
+function bindingifyJsx(input) {
+    if (input === false) {
+        return { type: 'Disable' };
+    }
+    if (input) {
+        if (input.mode === 'preserve') {
+            return { type: 'Preserve' };
+        }
+        const mode = input.mode ?? 'automatic';
+        return {
+            type: 'Enable',
+            field0: {
+                runtime: mode,
+                importSource: mode === 'classic'
+                    ? input.importSource
+                    : mode === 'automatic'
+                        ? input.jsxImportSource
+                        : undefined,
+                pragma: input.factory,
+                pragmaFrag: input.fragment,
+                development: input.development,
+                refresh: input.refresh,
+            },
+        };
+    }
+}
+function bindingifyWatch(watch) {
+    if (watch) {
+        let value = {
+            skipWrite: watch.skipWrite,
+            include: normalizedStringOrRegex(watch.include),
+            exclude: normalizedStringOrRegex(watch.exclude),
+        };
+        if (watch.chokidar) {
+            unsupported('The watch chokidar option is deprecated, please use notify options instead of it.');
+        }
+        return value;
+    }
+}
+function bindingifyTreeshakeOptions(config) {
+    if (config === false) {
+        return undefined;
+    }
+    if (config === true || config === undefined) {
+        return {
+            moduleSideEffects: true,
+            annotations: true,
+        };
+    }
+    let normalizedConfig = {
+        moduleSideEffects: true,
+    };
+    if (config.moduleSideEffects === undefined) {
+        normalizedConfig.moduleSideEffects = true;
+    }
+    else if (config.moduleSideEffects === 'no-external') {
+        normalizedConfig.moduleSideEffects = [
+            { external: true, sideEffects: false },
+            { external: false, sideEffects: true },
+        ];
+    }
+    else {
+        normalizedConfig.moduleSideEffects = config.moduleSideEffects;
+    }
+    normalizedConfig.annotations = config.annotations ?? true;
+    return normalizedConfig;
+}