rolldown 1.0.0-beta.3-commit.306867e → 1.0.0-beta.3-commit.f65bde3

package/dist/types/api/experimental.js

@@ -1,13 +0,0 @@
-import { createBundler } from '../utils/create-bundler';
-import { handleOutputErrors } from '../utils/transform-to-rollup-output';
-/**
- * This is an experimental API. It's behavior may change in the future.
- *
- * Calling this API will only execute the scan stage of rolldown.
- */
-export const experimental_scan = async (input) => {
-    const { bundler, stopWorkers } = await createBundler(input, {});
-    const output = await bundler.scan();
-    handleOutputErrors(output);
-    await stopWorkers?.();
-};

package/dist/types/api/rolldown/index.js

@@ -1,7 +0,0 @@
-import { PluginDriver } from '../../plugin/plugin-driver';
-import { RolldownBuild } from './rolldown-build';
-// `async` here is intentional to be compatible with `rollup.rollup`.
-export const rolldown = async (input) => {
-    const inputOptions = await PluginDriver.callOptionsHook(input);
-    return new RolldownBuild(inputOptions);
-};

package/dist/types/api/rolldown/rolldown-build.js

@@ -1,43 +0,0 @@
-import { transformToRollupOutput } from '../../utils/transform-to-rollup-output';
-import { createBundler, } from '../../utils/create-bundler';
-// @ts-expect-error TS2540: the polyfill of `asyncDispose`.
-Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
-export class RolldownBuild {
-    #inputOptions;
-    #bundler;
-    constructor(inputOptions) {
-        // TODO: Check if `inputOptions.output` is set. If so, throw an warning that it is ignored.
-        this.#inputOptions = inputOptions;
-    }
-    get closed() {
-        // If the bundler has not yet been created, it is not closed.
-        return this.#bundler ? this.#bundler.bundler.closed : false;
-    }
-    // Create bundler for each `bundle.write/generate`
-    async #getBundlerWithStopWorker(outputOptions) {
-        if (this.#bundler) {
-            this.#bundler.stopWorkers?.();
-        }
-        return (this.#bundler = await createBundler(this.#inputOptions, outputOptions));
-    }
-    async generate(outputOptions = {}) {
-        const { bundler } = await this.#getBundlerWithStopWorker(outputOptions);
-        const output = await bundler.generate();
-        return transformToRollupOutput(output);
-    }
-    async write(outputOptions = {}) {
-        const { bundler } = await this.#getBundlerWithStopWorker(outputOptions);
-        const output = await bundler.write();
-        return transformToRollupOutput(output);
-    }
-    async close() {
-        const { bundler, stopWorkers } = await this.#getBundlerWithStopWorker({});
-        await stopWorkers?.();
-        await bundler.close();
-    }
-    async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-}
-function _assert() {
-}

package/dist/types/api/watch/index.js

@@ -1,8 +0,0 @@
-import { WatcherEmitter } from './watch-emitter';
-import { createWatcher } from './watcher';
-// Compat to `rollup.watch`
-export const watch = (input) => {
-    const emitter = new WatcherEmitter();
-    createWatcher(emitter, input);
-    return emitter;
-};

package/dist/types/api/watch/watch-emitter.js

@@ -1,69 +0,0 @@
-import { normalizeErrors } from '../../utils/error';
-export class WatcherEmitter {
-    listeners = new Map();
-    timer;
-    constructor() {
-        // The rust side already create a thread for watcher, but it isn't at main thread.
-        // So here we need to avoid main process exit util the user call `watcher.close()`.
-        this.timer = setInterval(() => { }, 1e9 /* Low power usage */);
-    }
-    on(event, listener) {
-        const listeners = this.listeners.get(event);
-        if (listeners) {
-            listeners.push(listener);
-        }
-        else {
-            this.listeners.set(event, [listener]);
-        }
-        return this;
-    }
-    async onEvent(event) {
-        const listeners = this.listeners.get(event.eventKind());
-        if (listeners) {
-            switch (event.eventKind()) {
-                case 'close':
-                case 'restart':
-                    for (const listener of listeners) {
-                        await listener();
-                    }
-                    break;
-                case 'event':
-                    for (const listener of listeners) {
-                        const code = event.bundleEventKind();
-                        switch (code) {
-                            case 'BUNDLE_END':
-                                const { duration, output } = event.bundleEndData();
-                                await listener({
-                                    code: 'BUNDLE_END',
-                                    duration,
-                                    output: [output], // rolldown doesn't support arraying configure output
-                                });
-                                break;
-                            case 'ERROR':
-                                const errors = event.errors();
-                                await listener({
-                                    code: 'ERROR',
-                                    error: normalizeErrors(errors),
-                                });
-                                break;
-                            default:
-                                await listener({ code });
-                                break;
-                        }
-                    }
-                    break;
-                case 'change':
-                    for (const listener of listeners) {
-                        const { path, kind } = event.watchChangeData();
-                        await listener(path, { event: kind });
-                    }
-                    break;
-                default:
-                    throw new Error(`Unknown event: ${event}`);
-            }
-        }
-    }
-    async close() {
-        clearInterval(this.timer);
-    }
-}

package/dist/types/api/watch/watcher.js

@@ -1,66 +0,0 @@
-import { BindingWatcher } from '../../binding';
-import { LOG_LEVEL_WARN } from '../../log/logging';
-import { logMultiplyNotifyOption } from '../../log/logs';
-import { PluginDriver } from '../../plugin/plugin-driver';
-import { createBundlerOptions, } from '../../utils/create-bundler-option';
-import { arraify } from '../../utils/misc';
-export class Watcher {
-    closed;
-    inner;
-    emitter;
-    stopWorkers;
-    constructor(emitter, inner, stopWorkers) {
-        this.closed = false;
-        this.inner = inner;
-        this.emitter = emitter;
-        const originClose = emitter.close.bind(emitter);
-        emitter.close = async () => {
-            await this.close();
-            originClose();
-        };
-        this.stopWorkers = stopWorkers;
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        for (const stop of this.stopWorkers) {
-            await stop?.();
-        }
-        await this.inner.close();
-    }
-    start() {
-        // run first build after listener is attached
-        process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
-    }
-}
-export async function createWatcher(emitter, input) {
-    const options = arraify(input);
-    const bundlerOptions = await Promise.all(options
-        .map((option) => arraify(option.output || {}).map(async (output) => {
-        const inputOptions = await PluginDriver.callOptionsHook(option);
-        return createBundlerOptions(inputOptions, output);
-    }))
-        .flat());
-    const notifyOptions = getValidNotifyOption(bundlerOptions);
-    const bindingWatcher = new BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions);
-    const watcher = new Watcher(emitter, bindingWatcher, bundlerOptions.map((option) => option.stopWorkers));
-    watcher.start();
-}
-function getValidNotifyOption(bundlerOptions) {
-    let result;
-    for (const option of bundlerOptions) {
-        if (option.inputOptions.watch) {
-            const notifyOption = option.inputOptions.watch.notify;
-            if (notifyOption) {
-                if (result) {
-                    option.onLog(LOG_LEVEL_WARN, logMultiplyNotifyOption());
-                    return result;
-                }
-                else {
-                    result = notifyOption;
-                }
-            }
-        }
-    }
-}

package/dist/types/builtin-plugin/alias-plugin.js

@@ -1,4 +0,0 @@
-import { BuiltinPlugin } from './constructors';
-export function aliasPlugin(config) {
-    return new BuiltinPlugin('builtin:alias', config);
-}

package/dist/types/builtin-plugin/constructors.js

@@ -1,68 +0,0 @@
-import { makeBuiltinPluginCallable } from './utils';
-export class BuiltinPlugin {
-    name;
-    _options;
-    constructor(name, 
-    // NOTE: has `_` to avoid conflict with `options` hook
-    _options) {
-        this.name = name;
-        this._options = _options;
-        this.name = name;
-        this._options = _options;
-    }
-}
-export function modulePreloadPolyfillPlugin(config) {
-    return new BuiltinPlugin('builtin:module-preload-polyfill', config);
-}
-export function dynamicImportVarsPlugin() {
-    return new BuiltinPlugin('builtin:dynamic-import-vars');
-}
-export function importGlobPlugin(config) {
-    return new BuiltinPlugin('builtin:import-glob', config);
-}
-export function manifestPlugin(config) {
-    return new BuiltinPlugin('builtin:manifest', config);
-}
-export function wasmHelperPlugin() {
-    return new BuiltinPlugin('builtin:wasm-helper');
-}
-export function wasmFallbackPlugin() {
-    return new BuiltinPlugin('builtin:wasm-fallback');
-}
-export function loadFallbackPlugin() {
-    return new BuiltinPlugin('builtin:load-fallback');
-}
-export function jsonPlugin(config) {
-    return new BuiltinPlugin('builtin:json', config);
-}
-export function buildImportAnalysisPlugin(config) {
-    return new BuiltinPlugin('builtin:build-import-analysis', config);
-}
-export function viteResolvePlugin(config) {
-    const builtinPlugin = new BuiltinPlugin('builtin:vite-resolve', {
-        ...config,
-        runtime: process.versions.deno
-            ? 'deno'
-            : process.versions.bun
-                ? 'bun'
-                : 'node',
-    });
-    return makeBuiltinPluginCallable(builtinPlugin);
-}
-export function moduleFederationPlugin(config) {
-    return new BuiltinPlugin('builtin:module-federation', {
-        ...config,
-        remotes: config.remotes &&
-            Object.entries(config.remotes).map(([name, remote]) => {
-                if (typeof remote === 'string') {
-                    const [entryGlobalName] = remote.split('@');
-                    const entry = remote.replace(entryGlobalName + '@', '');
-                    return { entry, name };
-                }
-                return {
-                    ...remote,
-                    name: remote.name ?? name,
-                };
-            }),
-    });
-}

package/dist/types/builtin-plugin/replace-plugin.js

@@ -1,29 +0,0 @@
-import { BuiltinPlugin } from './constructors';
-/**
- * Replaces targeted strings in files while bundling.
- *
- * @example
- * // Basic usage
- * ```js
- * replacePlugin({
- *   'process.env.NODE_ENV': JSON.stringify('production'),
- *    __buildDate__: () => JSON.stringify(new Date()),
- *    __buildVersion: 15
- * })
- * ```
- * @example
- * // With options
- * ```js
- * replacePlugin({
- *   'process.env.NODE_ENV': JSON.stringify('production'),
- *   __buildDate__: () => JSON.stringify(new Date()),
- *   __buildVersion: 15
- * }, {
- *   preventAssignment: false,
- * })
- * ```
- *
- */
-export function replacePlugin(values = {}, options = {}) {
-    return new BuiltinPlugin('builtin:replace', { ...options, values });
-}

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

@@ -1,16 +0,0 @@
-import { BuiltinPlugin } from './constructors';
-import { normalizedStringOrRegex } from '../utils/normalize-string-or-regex';
-function normalizeEcmaTransformPluginConfig(config) {
-    if (!config) {
-        return undefined;
-    }
-    let normalizedConfig = {
-        ...config,
-        exclude: normalizedStringOrRegex(config.exclude),
-        include: normalizedStringOrRegex(config.include),
-    };
-    return normalizedConfig;
-}
-export function transformPlugin(config) {
-    return new BuiltinPlugin('builtin:transform', normalizeEcmaTransformPluginConfig(config));
-}

package/dist/types/builtin-plugin/utils.js

@@ -1,19 +0,0 @@
-import { BindingCallableBuiltinPlugin } from '../binding';
-export function makeBuiltinPluginCallable(plugin) {
-    let callablePlugin = new BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
-    const wrappedPlugin = plugin;
-    for (const key in callablePlugin) {
-        // @ts-expect-error
-        wrappedPlugin[key] = function (...args) {
-            // @ts-expect-error
-            return callablePlugin[key](...args);
-        };
-    }
-    return wrappedPlugin;
-}
-export function bindingifyBuiltInPlugin(plugin) {
-    return {
-        __name: plugin.name,
-        options: plugin._options,
-    };
-}

package/dist/types/cli/arguments/alias.js

@@ -1,63 +0,0 @@
-export const alias = {
-    config: {
-        abbreviation: 'c',
-        hint: 'filename',
-    },
-    help: {
-        abbreviation: 'h',
-    },
-    version: {
-        abbreviation: 'v',
-    },
-    watch: {
-        abbreviation: 'w',
-    },
-    dir: {
-        abbreviation: 'd',
-    },
-    file: {
-        abbreviation: 'o',
-    },
-    external: {
-        abbreviation: 'e',
-    },
-    format: {
-        abbreviation: 'f',
-    },
-    name: {
-        abbreviation: 'n',
-    },
-    globals: {
-        abbreviation: 'g',
-    },
-    sourcemap: {
-        abbreviation: 's',
-        default: true,
-    },
-    minify: {
-        abbreviation: 'm',
-    },
-    platform: {
-        abbreviation: 'p',
-    },
-    assetFileNames: {
-        hint: 'name',
-    },
-    chunkFileNames: {
-        hint: 'name',
-    },
-    entryFileNames: {
-        hint: 'name',
-    },
-    externalLiveBindings: {
-        default: true,
-        reverse: true,
-    },
-    treeshake: {
-        default: true,
-        reverse: true,
-    },
-    moduleTypes: {
-        hint: 'types',
-    },
-};

package/dist/types/cli/arguments/index.js

@@ -1,127 +0,0 @@
-import { alias } from './alias';
-import { camelCaseToKebabCase, flattenSchema, getSchemaType, kebabCaseToCamelCase, } from './utils';
-import { parseArgs } from 'node:util';
-import { normalizeCliOptions } from './normalize';
-import { logger } from '../logger';
-import { getJsonSchema } from '../../utils/validator';
-const objectSchema = getJsonSchema();
-export const flattenedSchema = flattenSchema(objectSchema.properties);
-export const options = Object.fromEntries(Object.entries(flattenedSchema).map(([key, schema]) => {
-    const config = Object.getOwnPropertyDescriptor(alias, key)?.value;
-    const type = getSchemaType(schema);
-    const result = {
-        type: type === 'boolean' ? 'boolean' : 'string',
-        // We only support comma separated mode right now.
-        // multiple: type === 'object' || type === 'array',
-        description: schema?.description ?? config?.description ?? '',
-        hint: config?.hint,
-    };
-    if (config && config?.abbreviation) {
-        result.short = config?.abbreviation;
-    }
-    if (config && config.reverse) {
-        if (result.description.startsWith('enable')) {
-            result.description = result.description.replace('enable', 'disable');
-        }
-        else {
-            result.description = `disable ${result.description}`;
-        }
-    }
-    key = camelCaseToKebabCase(key);
-    // add 'no-' prefix for need reverse options
-    return [config?.reverse ? `no-${key}` : key, result];
-}));
-export function parseCliArguments() {
-    const { values, tokens, positionals } = parseArgs({
-        options,
-        tokens: true,
-        allowPositionals: true,
-        // We can't use `strict` mode because we should handle the default config file name.
-        strict: false,
-    });
-    tokens
-        .filter((token) => token.kind === 'option')
-        .forEach((option) => {
-        let negative = false;
-        if (option.name.startsWith('no-')) {
-            // stripe `no-` prefix
-            const name = kebabCaseToCamelCase(option.name.substring(3));
-            if (name in flattenedSchema) {
-                // Remove the `no-` in values
-                delete values[option.name];
-                option.name = name;
-                negative = true;
-            }
-        }
-        delete values[option.name]; // Strip the kebab-case options.
-        option.name = kebabCaseToCamelCase(option.name);
-        let originalType = flattenedSchema[option.name];
-        if (!originalType) {
-            logger.error(`Invalid option: ${option.rawName}. We will ignore this option.`);
-            // We will refuse to handle the invalid option, as it may cause unexpected behavior.
-            process.exit(1);
-        }
-        let type = getSchemaType(originalType);
-        if (type === 'string' && typeof option.value !== 'string') {
-            let opt = option;
-            // We should use the default value.
-            let defaultValue = Object.getOwnPropertyDescriptor(alias, opt.name)
-                ?.value;
-            Object.defineProperty(values, opt.name, {
-                value: defaultValue.default ?? '',
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-        else if (type === 'object' && typeof option.value === 'string') {
-            const [key, value] = option.value.split(',').map((x) => x.split('='))[0];
-            if (!values[option.name]) {
-                Object.defineProperty(values, option.name, {
-                    value: {},
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                });
-            }
-            if (key && value) {
-                // TODO support multiple entries.
-                Object.defineProperty(values[option.name], key, {
-                    value,
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                });
-            }
-        }
-        else if (type === 'array' && typeof option.value === 'string') {
-            if (!values[option.name]) {
-                Object.defineProperty(values, option.name, {
-                    value: [],
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                });
-            }
-            ;
-            values[option.name].push(option.value);
-        }
-        else if (type === 'boolean') {
-            Object.defineProperty(values, option.name, {
-                value: !negative,
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-        else {
-            Object.defineProperty(values, option.name, {
-                value: option.value ?? '',
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-    });
-    return normalizeCliOptions(values, positionals);
-}

package/dist/types/cli/arguments/normalize.js

@@ -1,48 +0,0 @@
-/**
- * @description This file is used for normalize the options.
- * In CLI, the input options and output options are mixed together. We need to tell them apart.
- */
-import { logger } from '../logger';
-import { setNestedProperty } from './utils';
-import { getInputCliKeys, getOutputCliKeys, validateCliOptions, } from '../../utils/validator';
-export function normalizeCliOptions(cliOptions, positionals) {
-    const [data, errors] = validateCliOptions(cliOptions);
-    if (errors?.length) {
-        errors.forEach((error) => {
-            logger.error(`Invalid value for option ${error}. You can use \`rolldown -h\` to see the help.`);
-        });
-        process.exit(1);
-    }
-    const options = data ?? {};
-    const result = {
-        input: {},
-        output: {},
-        help: options.help ?? false,
-        version: options.version ?? false,
-        watch: options.watch ?? false,
-    };
-    if (typeof options.config === 'string') {
-        result.config = options.config;
-    }
-    const keysOfInput = getInputCliKeys();
-    const keysOfOutput = getOutputCliKeys();
-    const reservedKeys = ['help', 'version', 'config', 'watch'];
-    for (let [key, value] of Object.entries(options)) {
-        const keys = key.split('.');
-        const [primary] = keys;
-        if (keysOfInput.includes(primary)) {
-            setNestedProperty(result.input, key, value);
-        }
-        else if (keysOfOutput.includes(primary)) {
-            setNestedProperty(result.output, key, value);
-        }
-        else if (!reservedKeys.includes(key)) {
-            logger.error(`Unknown option: ${key}`);
-            process.exit(1);
-        }
-    }
-    if (!result.config && positionals.length > 0) {
-        result.input.input = positionals;
-    }
-    return result;
-}

package/dist/types/cli/arguments/utils.js

@@ -1,67 +0,0 @@
-const priority = [
-    'object',
-    'array',
-    'string',
-    'number',
-    'boolean',
-];
-export function getSchemaType(schema) {
-    if ('anyOf' in schema) {
-        const types = schema.anyOf.map(getSchemaType);
-        // Order: object > array > string > number > boolean
-        let result = priority.find((type) => types.includes(type));
-        if (result) {
-            return result;
-        }
-    }
-    if ('type' in schema) {
-        return schema.type;
-    }
-    if ('const' in schema) {
-        return typeof schema.const;
-    }
-    return 'object';
-}
-export function flattenSchema(schema, base = {}, parent = '') {
-    if (schema === undefined) {
-        return base;
-    }
-    for (const [k, value] of Object.entries(schema)) {
-        const key = parent ? `${parent}.${k}` : k;
-        if (getSchemaType(value) === 'object') {
-            if ('properties' in value) {
-                flattenSchema(value.properties, base, key);
-            }
-            else {
-                base[key] = value;
-            }
-        }
-        else {
-            base[key] = value;
-        }
-    }
-    return base;
-}
-export function setNestedProperty(obj, path, value) {
-    const keys = path.split('.');
-    let current = obj;
-    for (let i = 0; i < keys.length - 1; i++) {
-        if (!current[keys[i]]) {
-            current[keys[i]] = {};
-        }
-        current = current[keys[i]];
-    }
-    const finalKey = keys[keys.length - 1];
-    Object.defineProperty(current, finalKey, {
-        value: value,
-        writable: true,
-        enumerable: true,
-        configurable: true,
-    });
-}
-export function camelCaseToKebabCase(str) {
-    return str.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
-}
-export function kebabCaseToCamelCase(str) {
-    return str.replace(/-./g, (match) => match[1].toUpperCase());
-}

package/dist/types/cli/colors.js

@@ -1,17 +0,0 @@
-import { env } from 'node:process';
-import { createColors } from 'colorette';
-// @see https://no-color.org
-// @see https://www.npmjs.com/package/chalk
-const { bold, cyan, dim, gray, green, red, underline, yellow, } = createColors({
-    useColor: env.FORCE_COLOR !== '0' && !env.NO_COLOR,
-});
-export const colors = {
-    bold,
-    cyan,
-    dim,
-    gray,
-    green,
-    red,
-    underline,
-    yellow,
-};