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

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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,48 @@
+/**
+ * @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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,203 @@
+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);
+}

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

@@ -0,0 +1,88 @@
+import { logger } from '../logger';
+import { version, description, } from '../../../package.json' assert { type: 'json' };
+import { colors } from '../colors';
+import { options } from '../arguments';
+import { camelCaseToKebabCase } from '../arguments/utils';
+const introduction = `${colors.gray(`${description} (rolldown v${version})`)}
+
+${colors.bold(colors.underline('USAGE'))} ${colors.cyan('rolldown -c <config>')} or ${colors.cyan('rolldown <input> <options>')}`;
+const examples = [
+    {
+        title: 'Bundle with a config file `rolldown.config.mjs`',
+        command: 'rolldown -c rolldown.config.mjs',
+    },
+    {
+        title: 'Bundle the `src/main.ts` to `dist` with `cjs` format',
+        command: 'rolldown src/main.ts -d dist -f cjs',
+    },
+    {
+        title: 'Bundle the `src/main.ts` and handle the `.png` assets to Data URL',
+        command: 'rolldown src/main.ts -d dist --moduleTypes .png=dataurl',
+    },
+    {
+        title: 'Bundle the `src/main.tsx` and minify the output with sourcemap',
+        command: 'rolldown src/main.tsx -d dist -m -s',
+    },
+    {
+        title: 'Create self-executing IIFE using external jQuery as `$` and `_`',
+        command: 'rolldown src/main.ts -d dist -n bundle -f iife -e jQuery,window._ -g jQuery=$',
+    },
+];
+const notes = [
+    'Due to the API limitation, you need to pass `-s` for `.map` sourcemap file as the last argument.',
+    'If you are using the configuration, please pass the `-c` as the last argument if you ignore the default configuration file.',
+    'CLI options will override the configuration file.',
+    'For more information, please visit https://rolldown.rs/.',
+];
+export function showHelp() {
+    logger.log(introduction);
+    logger.log('');
+    logger.log(`${colors.bold(colors.underline('OPTIONS'))}`);
+    logger.log('');
+    logger.log(Object.entries(options)
+        .sort(([a], [b]) => {
+        // 1. If one of them has a short option, prioritize it.
+        if (options[a].short && !options[b].short) {
+            return -1;
+        }
+        if (!options[a].short && options[b].short) {
+            return 1;
+        }
+        // 2. If both of them have a short option, sort by the short letter.
+        if (options[a].short && options[b].short) {
+            return options[a].short.localeCompare(options[b].short);
+        }
+        // 3. If none of them has a short option, sort by the long option.
+        return a.localeCompare(b);
+    })
+        .map(([option, { type, short, hint, description }]) => {
+        let optionStr = `  --${option} `;
+        option = camelCaseToKebabCase(option);
+        if (short) {
+            optionStr += `-${short}, `;
+        }
+        if (type === 'string') {
+            optionStr += `<${hint ?? option}>`;
+        }
+        if (description && description.length > 0) {
+            description = description[0].toUpperCase() + description.slice(1);
+        }
+        return (colors.cyan(optionStr.padEnd(30)) +
+            description +
+            (description && description?.endsWith('.') ? '' : '.'));
+    })
+        .join('\n'));
+    logger.log('');
+    logger.log(`${colors.bold(colors.underline('EXAMPLES'))}`);
+    logger.log('');
+    examples.forEach(({ title, command }, ord) => {
+        logger.log(`  ${ord + 1}. ${title}:`);
+        logger.log(`    ${colors.cyan(command)}`);
+        logger.log('');
+    });
+    logger.log(`${colors.bold(colors.underline('NOTES'))}`);
+    logger.log('');
+    notes.forEach((note) => {
+        logger.log(`  * ${colors.gray(note)}`);
+    });
+}

package/dist/types/cli/index.js

@@ -0,0 +1,27 @@
+import process from 'node:process';
+import { bundleWithCliOptions, bundleWithConfig } from './commands/bundle';
+import { logger } from './logger';
+import { parseCliArguments } from './arguments';
+import { showHelp } from './commands/help';
+import { version } from '../../package.json';
+async function main() {
+    const cliOptions = parseCliArguments();
+    if (cliOptions.config || cliOptions.config === '') {
+        await bundleWithConfig(cliOptions.config, cliOptions);
+        return;
+    }
+    if ('input' in cliOptions.input) {
+        // If input is specified, we will bundle with the input options
+        await bundleWithCliOptions(cliOptions);
+        return;
+    }
+    if (cliOptions.version) {
+        logger.log(`rolldown v${version}`);
+        return;
+    }
+    showHelp();
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/types/cli/load-config.js

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cwd } from 'node:process';
+import { readdir } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { rolldown } from '../api/rolldown';
+async function bundleTsConfig(configFile) {
+    const dirnameVarName = 'injected_original_dirname';
+    const filenameVarName = 'injected_original_filename';
+    const importMetaUrlVarName = 'injected_original_import_meta_url';
+    const bundle = await rolldown({
+        input: configFile,
+        platform: 'node',
+        resolve: {
+            mainFields: ['main'],
+        },
+        define: {
+            __dirname: dirnameVarName,
+            __filename: filenameVarName,
+            'import.meta.url': importMetaUrlVarName,
+            'import.meta.dirname': dirnameVarName,
+            'import.meta.filename': filenameVarName,
+        },
+        treeshake: false,
+        external: [/^[\w@][^:]/], // external bare imports
+        plugins: [
+            {
+                name: 'inject-file-scope-variables',
+                transform: {
+                    filter: { id: /\.[cm]?[jt]s$/ },
+                    async handler(code, id) {
+                        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};` +
+                            `const ${filenameVarName} = ${JSON.stringify(id)};` +
+                            `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};`;
+                        return { code: injectValues + code, map: null };
+                    },
+                },
+            },
+        ],
+    });
+    const outputDir = path.dirname(configFile);
+    const result = await bundle.write({
+        dir: outputDir,
+        format: 'esm',
+        sourcemap: 'inline',
+        entryFileNames: 'rolldown.config.[hash].js',
+    });
+    const fileName = result.output.find((chunk) => chunk.type === 'chunk' && chunk.isEntry).fileName;
+    return path.join(outputDir, fileName);
+}
+const SUPPORTED_JS_CONFIG_FORMATS = ['.js', '.mjs', '.cjs'];
+const SUPPORTED_TS_CONFIG_FORMATS = ['.ts', '.mts', '.cts'];
+const SUPPORTED_CONFIG_FORMATS = [
+    ...SUPPORTED_JS_CONFIG_FORMATS,
+    ...SUPPORTED_TS_CONFIG_FORMATS,
+];
+const DEFAULT_CONFIG_BASE = 'rolldown.config';
+async function findConfigFileNameInCwd() {
+    const filesInWorkingDirectory = new Set(await readdir(cwd()));
+    for (const extension of SUPPORTED_CONFIG_FORMATS) {
+        const fileName = `${DEFAULT_CONFIG_BASE}${extension}`;
+        if (filesInWorkingDirectory.has(fileName))
+            return fileName;
+    }
+    throw new Error('No `rolldown.config` configuration file found.');
+}
+export async function loadTsConfig(configFile) {
+    const file = await bundleTsConfig(configFile);
+    try {
+        return (await import(pathToFileURL(file).href)).default;
+    }
+    finally {
+        fs.unlink(file, () => { }); // Ignore errors
+    }
+}
+export async function loadConfig(configPath) {
+    const ext = path.extname((configPath = configPath || (await findConfigFileNameInCwd())));
+    try {
+        if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext) ||
+            (process.env.NODE_OPTIONS?.includes('--import=tsx') &&
+                SUPPORTED_TS_CONFIG_FORMATS.includes(ext))) {
+            return (await import(pathToFileURL(configPath).href)).default;
+        }
+        else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) {
+            const rawConfigPath = path.resolve(configPath);
+            return await loadTsConfig(rawConfigPath);
+        }
+        else {
+            throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(',')}\` but got \`${ext}\``);
+        }
+    }
+    catch (err) {
+        throw new Error('Error happened while loading config.', { cause: err });
+    }
+}