rolldown 1.0.0-beta.3-commit.306867e → 1.0.0-beta.3-commit.558ea78

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,
-};

package/dist/types/cli/commands/bundle.js

@@ -1,203 +0,0 @@
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { onExit } from 'signal-exit';
-import { colors } from '../colors';
-import { logger } from '../logger';
-import { arraify } from '../../utils/misc';
-import { rolldown } from '../../api/rolldown';
-import { watch as rolldownWatch } from '../../api/watch';
-import { loadConfig } from '../load-config';
-export async function bundleWithConfig(configPath, cliOptions) {
-    const config = await loadConfig(configPath);
-    if (!config) {
-        logger.error(`No configuration found at ${config}`);
-        process.exit(1);
-    }
-    // TODO: Could add more validation/diagnostics here to emit a nice error message
-    if (cliOptions.watch) {
-        await watchInner(config, cliOptions);
-    }
-    else {
-        await bundleInner(config, cliOptions);
-    }
-}
-export async function bundleWithCliOptions(cliOptions) {
-    if (cliOptions.output.dir || cliOptions.output.file) {
-        const operation = cliOptions.watch ? watchInner : bundleInner;
-        await operation({}, cliOptions);
-        return;
-    }
-    if (cliOptions.watch) {
-        logger.error('You must specify `output.dir` to use watch mode');
-        process.exit(1);
-    }
-    // Rolldown doesn't yet support the following syntax:
-    // await using build = await rolldown(cliOptions.input)
-    const build = await rolldown(cliOptions.input);
-    try {
-        const { output: outputs } = await build.generate(cliOptions.output);
-        if (outputs.length === 0) {
-            logger.error('No output generated');
-            process.exit(1);
-        }
-        for (const file of outputs) {
-            if (outputs.length > 1) {
-                logger.log(`\n${colors.cyan(colors.bold(`|→ ${file.fileName}:`))}\n`);
-            }
-            // avoid consola since it doesn't print it as raw string
-            // eslint-disable-next-line no-console
-            console.log(file.type === 'asset' ? file.source : file.code);
-        }
-    }
-    finally {
-        await build.close();
-    }
-}
-async function watchInner(config, cliOptions) {
-    // Only if watch is true in CLI can we use watch mode.
-    // We should not make it `await`, as it never ends.
-    let normalizedConfig = arraify(config).map((option) => {
-        return {
-            ...option,
-            ...cliOptions.input,
-            output: arraify(option.output || {}).map((output) => {
-                return {
-                    ...output,
-                    ...cliOptions.output,
-                };
-            }),
-        };
-    });
-    const watcher = await rolldownWatch(normalizedConfig);
-    onExit((code) => {
-        Promise.resolve(watcher.close()).finally(() => {
-            process.exit(typeof code === 'number' ? code : 0);
-        });
-        return true;
-    });
-    const changedFile = [];
-    watcher.on('change', (id, event) => {
-        if (event.event === 'update') {
-            changedFile.push(id);
-        }
-    });
-    watcher.on('event', (event) => {
-        switch (event.code) {
-            case 'BUNDLE_START':
-                if (changedFile.length > 0) {
-                    logger.log(`Found ${colors.bold(changedFile.map(relativeId).join(', '))} changed, rebuilding...`);
-                }
-                changedFile.length = 0;
-                break;
-            case 'BUNDLE_END':
-                logger.success(`Rebuilt ${colors.bold(relativeId(event.output[0]))} in ${colors.bold(ms(event.duration))}.`);
-                break;
-            case 'ERROR':
-                logger.error(event.error);
-                break;
-            default:
-                break;
-        }
-    });
-    logger.log(`Waiting for changes...`);
-}
-async function bundleInner(config, cliOptions) {
-    const startTime = performance.now();
-    const result = [];
-    const configList = arraify(config);
-    for (const config of configList) {
-        const outputList = arraify(config.output || {});
-        const build = await rolldown({ ...config, ...cliOptions.input });
-        for (const output of outputList) {
-            // run multiply instance at sequential
-            try {
-                result.push(await build.write({
-                    ...output,
-                    ...cliOptions.output,
-                }));
-            }
-            finally {
-                await build.close();
-            }
-        }
-    }
-    result.forEach(printBundleOutputPretty);
-    logger.log(``);
-    const endTime = performance.now();
-    const duration = endTime - startTime;
-    // If the build time is more than 1s, we should display it in seconds.
-    logger.success(`Finished in ${colors.bold(ms(duration))}`);
-}
-function printBundleOutputPretty(output) {
-    const outputEntries = collectOutputEntries(output.output);
-    const outputLayoutSizes = collectOutputLayoutAdjustmentSizes(outputEntries);
-    printOutputEntries(outputEntries, outputLayoutSizes, '<DIR>');
-}
-function collectOutputEntries(output) {
-    return output.map((chunk) => ({
-        type: chunk.type,
-        fileName: chunk.fileName,
-        size: chunk.type === 'chunk' ? chunk.code.length : chunk.source.length,
-    }));
-}
-function collectOutputLayoutAdjustmentSizes(entries) {
-    let longest = 0;
-    let biggestSize = 0;
-    for (const entry of entries) {
-        if (entry.fileName.length > longest) {
-            longest = entry.fileName.length;
-        }
-        if (entry.size > biggestSize) {
-            biggestSize = entry.size;
-        }
-    }
-    const sizePad = displaySize(biggestSize).length;
-    return {
-        longest,
-        biggestSize,
-        sizePad,
-    };
-}
-const numberFormatter = new Intl.NumberFormat('en', {
-    maximumFractionDigits: 2,
-    minimumFractionDigits: 2,
-});
-function displaySize(bytes) {
-    return `${numberFormatter.format(bytes / 1000)} kB`;
-}
-const CHUNK_GROUPS = [
-    { type: 'asset', color: 'green' },
-    { type: 'chunk', color: 'cyan' },
-];
-function printOutputEntries(entries, sizeAdjustment, distPath) {
-    for (const group of CHUNK_GROUPS) {
-        const filtered = entries.filter((e) => e.type === group.type);
-        if (!filtered.length) {
-            continue;
-        }
-        for (const entry of filtered.sort((a, z) => a.size - z.size)) {
-            // output format: `path/to/xxx type | size: y.yy kB`
-            let log = colors.dim(withTrailingSlash(distPath));
-            log += colors[group.color](entry.fileName.padEnd(sizeAdjustment.longest + 2));
-            log += colors.dim(entry.type);
-            log += colors.dim(` │ size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
-            logger.log(log);
-        }
-    }
-}
-function withTrailingSlash(path) {
-    if (path[path.length - 1] !== '/') {
-        return `${path}/`;
-    }
-    return path;
-}
-function ms(duration) {
-    return duration < 1000
-        ? `${duration.toFixed(2)} ms`
-        : `${(duration / 1000).toFixed(2)} s`;
-}
-function relativeId(id) {
-    if (!path.isAbsolute(id))
-        return id;
-    return path.relative(path.resolve(), id);
-}