rolldown 1.0.0-beta.2-commit.2666b23 → 1.0.0-beta.20

package/dist/types/utils/asset-source.d.ts

@@ -1,4 +0,0 @@
-import { BindingAssetSource } from '../binding';
-export type AssetSource = string | Uint8Array;
-export declare function transformAssetSource(bindingAssetSource: BindingAssetSource): AssetSource;
-export declare function bindingAssetSource(source: AssetSource): BindingAssetSource;

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

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

package/dist/types/utils/async-flatten.d.ts

@@ -1 +0,0 @@
-export declare function asyncFlatten<T>(array: T[]): Promise<T[]>;

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

@@ -1,7 +0,0 @@
-// 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.d.ts

@@ -1,7 +0,0 @@
-import type { RolldownPlugin } from '../plugin';
-import type { InputOptions } from '../options/input-options';
-import type { OutputOptions } from '../options/output-options';
-import type { BindingInputOptions } from '../binding';
-import { LogHandler } from '../types/misc';
-import { LogLevelOption } from '../log/logging';
-export declare function bindingifyInputOptions(rawPlugins: RolldownPlugin[], inputOptions: InputOptions, outputOptions: OutputOptions, onLog: LogHandler, logLevel: LogLevelOption): BindingInputOptions;

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

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

package/dist/types/utils/bindingify-output-options.d.ts

@@ -1,3 +0,0 @@
-import type { BindingOutputOptions } from '../binding';
-import type { OutputOptions } from '../options/output-options';
-export declare function bindingifyOutputOptions(outputOptions: OutputOptions): BindingOutputOptions;

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

@@ -1,92 +0,0 @@
-import { unimplemented } from './misc';
-import { transformRenderedChunk } from './transform-rendered-chunk';
-export function bindingifyOutputOptions(outputOptions) {
-    const { dir, format, exports, hashCharacters, sourcemap, sourcemapIgnoreList, sourcemapPathTransform, name, assetFileNames, entryFileNames, chunkFileNames, cssEntryFileNames, cssChunkFileNames, banner, footer, intro, outro, esModule, globals, file, } = outputOptions;
-    return {
-        dir,
-        // Handle case: rollup/test/sourcemaps/samples/sourcemap-file-hashed/_config.js
-        file: file == null ? undefined : file,
-        format: bindingifyFormat(format),
-        exports,
-        hashCharacters,
-        sourcemap: bindingifySourcemap(sourcemap),
-        sourcemapIgnoreList: bindingifySourcemapIgnoreList(sourcemapIgnoreList),
-        sourcemapPathTransform,
-        banner: bindingifyAddon(banner),
-        footer: bindingifyAddon(footer),
-        intro: bindingifyAddon(intro),
-        outro: bindingifyAddon(outro),
-        extend: outputOptions.extend,
-        globals,
-        esModule,
-        name,
-        assetFileNames,
-        entryFileNames,
-        chunkFileNames,
-        cssEntryFileNames,
-        cssChunkFileNames,
-        // TODO(sapphi-red): support parallel plugins
-        plugins: [],
-        minify: outputOptions.minify,
-        externalLiveBindings: outputOptions.externalLiveBindings,
-        inlineDynamicImports: outputOptions.inlineDynamicImports,
-        advancedChunks: outputOptions.advancedChunks,
-        polyfillRequire: outputOptions.polyfillRequire,
-        target: outputOptions.target,
-    };
-}
-function bindingifyAddon(configAddon) {
-    return async (chunk) => {
-        if (typeof configAddon === 'function') {
-            return configAddon(transformRenderedChunk(chunk));
-        }
-        return configAddon || '';
-    };
-}
-function bindingifyFormat(format) {
-    switch (format) {
-        case undefined:
-        case 'es':
-        case 'esm':
-        case 'module': {
-            return 'es';
-        }
-        case 'cjs':
-        case 'commonjs': {
-            return 'cjs';
-        }
-        case 'iife': {
-            return 'iife';
-        }
-        case 'umd': {
-            return 'umd';
-        }
-        case 'experimental-app': {
-            return 'app';
-        }
-        default:
-            unimplemented(`output.format: ${format}`);
-    }
-}
-function bindingifySourcemap(sourcemap) {
-    switch (sourcemap) {
-        case true:
-            return 'file';
-        case 'inline':
-            return 'inline';
-        case false:
-        case undefined:
-            return undefined;
-        case 'hidden':
-            return 'hidden';
-        default:
-            throw new Error(`unknown sourcemap: ${sourcemap}`);
-    }
-}
-function bindingifySourcemapIgnoreList(sourcemapIgnoreList) {
-    return typeof sourcemapIgnoreList === 'function'
-        ? sourcemapIgnoreList
-        : sourcemapIgnoreList === false
-            ? () => false
-            : (relativeSourcePath, _sourcemapPath) => relativeSourcePath.includes('node_modules');
-}

package/dist/types/utils/code-frame.d.ts

@@ -1 +0,0 @@
-export declare function getCodeFrame(source: string, line: number, column: number): string;

package/dist/types/utils/code-frame.js

@@ -1,46 +0,0 @@
-function spaces(index) {
-    let result = '';
-    while (index--)
-        result += ' ';
-    return result;
-}
-function tabsToSpaces(value) {
-    return value.replace(/^\t+/, (match) => match.split('\t').join('  '));
-}
-const LINE_TRUNCATE_LENGTH = 120;
-const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
-const ELLIPSIS = '...';
-export function getCodeFrame(source, line, column) {
-    let lines = source.split('\n');
-    // Needed if a plugin did not generate correct sourcemaps
-    if (line > lines.length)
-        return '';
-    const maxLineLength = Math.max(tabsToSpaces(lines[line - 1].slice(0, column)).length +
-        MIN_CHARACTERS_SHOWN_AFTER_LOCATION +
-        ELLIPSIS.length, LINE_TRUNCATE_LENGTH);
-    const frameStart = Math.max(0, line - 3);
-    let frameEnd = Math.min(line + 2, lines.length);
-    lines = lines.slice(frameStart, frameEnd);
-    while (!/\S/.test(lines[lines.length - 1])) {
-        lines.pop();
-        frameEnd -= 1;
-    }
-    const digits = String(frameEnd).length;
-    return lines
-        .map((sourceLine, index) => {
-        const isErrorLine = frameStart + index + 1 === line;
-        let lineNumber = String(index + frameStart + 1);
-        while (lineNumber.length < digits)
-            lineNumber = ` ${lineNumber}`;
-        let displayedLine = tabsToSpaces(sourceLine);
-        if (displayedLine.length > maxLineLength) {
-            displayedLine = `${displayedLine.slice(0, maxLineLength - ELLIPSIS.length)}${ELLIPSIS}`;
-        }
-        if (isErrorLine) {
-            const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + '^';
-            return `${lineNumber}: ${displayedLine}\n${indicator}`;
-        }
-        return `${lineNumber}: ${displayedLine}`;
-    })
-        .join('\n');
-}

package/dist/types/utils/compose-js-plugins.d.ts

@@ -1,2 +0,0 @@
-import { RolldownPlugin } from '../plugin';
-export declare function composeJsPlugins(plugins: RolldownPlugin[]): RolldownPlugin[];