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

package/dist/types/utils/initialize-parallel-plugins.js

@@ -0,0 +1,54 @@
+import { Worker } from 'node:worker_threads';
+import { availableParallelism } from 'node:os';
+import { ParallelJsPluginRegistry } from '../binding';
+export async function initializeParallelPlugins(plugins) {
+    const pluginInfos = [];
+    for (const [index, plugin] of plugins.entries()) {
+        if ('_parallel' in plugin) {
+            const { fileUrl, options } = plugin._parallel;
+            pluginInfos.push({ index, fileUrl, options });
+        }
+    }
+    if (pluginInfos.length <= 0) {
+        return undefined;
+    }
+    const count = Math.min(availableParallelism(), 8);
+    const parallelJsPluginRegistry = new ParallelJsPluginRegistry(count);
+    const registryId = parallelJsPluginRegistry.id;
+    const workers = await initializeWorkers(registryId, count, pluginInfos);
+    const stopWorkers = async () => {
+        await Promise.all(workers.map((worker) => worker.terminate()));
+    };
+    return { registry: parallelJsPluginRegistry, stopWorkers };
+}
+export function initializeWorkers(registryId, count, pluginInfos) {
+    return Promise.all(Array.from({ length: count }, (_, i) => initializeWorker(registryId, pluginInfos, i)));
+}
+async function initializeWorker(registryId, pluginInfos, threadNumber) {
+    const urlString = import.meta.resolve('#parallel-plugin-worker');
+    const workerData = {
+        registryId,
+        pluginInfos,
+        threadNumber,
+    };
+    let worker;
+    try {
+        worker = new Worker(new URL(urlString), { workerData });
+        worker.unref();
+        await new Promise((resolve, reject) => {
+            worker.once('message', async (message) => {
+                if (message.type === 'error') {
+                    reject(message.error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        return worker;
+    }
+    catch (e) {
+        worker?.terminate();
+        throw e;
+    }
+}

package/dist/types/utils/misc.js

@@ -0,0 +1,22 @@
+export function arraify(value) {
+    return Array.isArray(value) ? value : [value];
+}
+export function isNullish(value) {
+    return value === null || value === undefined;
+}
+export function unimplemented(info) {
+    if (info) {
+        throw new Error(`unimplemented: ${info}`);
+    }
+    throw new Error('unimplemented');
+}
+export function unreachable(info) {
+    if (info) {
+        throw new Error(`unreachable: ${info}`);
+    }
+    throw new Error('unreachable');
+}
+export function unsupported(info) {
+    throw new Error(`UNSUPPORTED: ${info}`);
+}
+export function noop(..._args) { }

package/dist/types/utils/normalize-hook.js

@@ -0,0 +1,21 @@
+import { unreachable } from './misc';
+export function normalizeHook(hook) {
+    if (typeof hook === 'function' || typeof hook === 'string') {
+        return {
+            handler: hook,
+            options: {},
+            meta: {},
+        };
+    }
+    if (typeof hook === 'object' && hook !== null) {
+        const { handler, order, ...options } = hook;
+        return {
+            handler,
+            options,
+            meta: {
+                order,
+            },
+        };
+    }
+    unreachable('Invalid hook type');
+}

package/dist/types/utils/normalize-plugin-option.js

@@ -0,0 +1,35 @@
+import { asyncFlatten } from './async-flatten';
+import { ENUMERATED_INPUT_PLUGIN_HOOK_NAMES } from '../constants/plugin';
+import { logInputHookInOutputPlugin } from '../log/logs';
+import { LOG_LEVEL_WARN } from '../log/logging';
+import { BuiltinPlugin } from '../builtin-plugin/constructors';
+export const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+export function checkOutputPluginOption(plugins, onLog) {
+    for (const plugin of plugins) {
+        for (const hook of ENUMERATED_INPUT_PLUGIN_HOOK_NAMES) {
+            if (hook in plugin) {
+                // remove the hook from the plugin if it is not an output plugin hook, avoid the plugin to be called
+                // @ts-expect-error Here the plugin typing should be RolldownPlugin
+                delete plugin[hook];
+                onLog(LOG_LEVEL_WARN, logInputHookInOutputPlugin(plugin.name, hook));
+            }
+        }
+    }
+    return plugins;
+}
+export function normalizePlugins(plugins, anonymousPrefix) {
+    for (const [index, plugin] of plugins.entries()) {
+        if ('_parallel' in plugin) {
+            continue;
+        }
+        if (plugin instanceof BuiltinPlugin) {
+            continue;
+        }
+        if (!plugin.name) {
+            plugin.name = `${anonymousPrefix}${index + 1}`;
+        }
+    }
+    return plugins;
+}
+export const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+export const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';

package/dist/types/utils/normalize-string-or-regex.js

@@ -0,0 +1,14 @@
+/*
+ * Normalize single or multiple string or regex patterns to an array of BindingStringOrRegex
+ * convert a type that is dx friendly to a type that is friendly for binding usage
+ *
+ * */
+export function normalizedStringOrRegex(pattern) {
+    if (!pattern) {
+        return undefined;
+    }
+    if (!Array.isArray(pattern)) {
+        pattern = [pattern];
+    }
+    return pattern;
+}

package/dist/types/utils/plugin/index.js

@@ -0,0 +1,7 @@
+import { ENUMERATED_PLUGIN_HOOK_NAMES, } from '../../constants/plugin';
+export const isPluginHookName = (function () {
+    const PLUGIN_HOOK_NAMES_SET = new Set(ENUMERATED_PLUGIN_HOOK_NAMES);
+    return function isPluginHookName(hookName) {
+        return PLUGIN_HOOK_NAMES_SET.has(hookName);
+    };
+})();

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

@@ -0,0 +1,19 @@
+import { unsupported } from './misc';
+export function transformModuleInfo(info, option) {
+    return {
+        get ast() {
+            return unsupported('ModuleInfo#ast');
+        },
+        get code() {
+            return info.code;
+        },
+        id: info.id,
+        importers: info.importers,
+        dynamicImporters: info.dynamicImporters,
+        importedIds: info.importedIds,
+        dynamicallyImportedIds: info.dynamicallyImportedIds,
+        exports: info.exports,
+        isEntry: info.isEntry,
+        ...option,
+    };
+}

package/dist/types/utils/transform-rendered-chunk.js

@@ -0,0 +1,43 @@
+import { transformToRenderedModule } from './transform-rendered-module';
+export function transformRenderedChunk(chunk) {
+    return {
+        get name() {
+            return chunk.name;
+        },
+        get isEntry() {
+            return chunk.isEntry;
+        },
+        get isDynamicEntry() {
+            return chunk.isDynamicEntry;
+        },
+        get facadeModuleId() {
+            return chunk.facadeModuleId;
+        },
+        get moduleIds() {
+            return chunk.moduleIds;
+        },
+        get exports() {
+            return chunk.exports;
+        },
+        get fileName() {
+            return chunk.fileName;
+        },
+        get imports() {
+            return chunk.imports;
+        },
+        get dynamicImports() {
+            return chunk.dynamicImports;
+        },
+        get modules() {
+            return transformChunkModules(chunk.modules);
+        },
+    };
+}
+export function transformChunkModules(modules) {
+    const result = {};
+    for (const [id, index] of Object.entries(modules.idToIndex)) {
+        let mod = modules.value[index];
+        result[id] = transformToRenderedModule(mod);
+    }
+    return result;
+}

package/dist/types/utils/transform-rendered-module.js

@@ -0,0 +1,10 @@
+export function transformToRenderedModule(bindingRenderedModule) {
+    return {
+        get code() {
+            return bindingRenderedModule.code;
+        },
+        get renderedLength() {
+            return bindingRenderedModule.code?.length || 0;
+        },
+    };
+}

package/dist/types/utils/transform-side-effects.js

@@ -0,0 +1,16 @@
+import { BindingHookSideEffects } from '../binding';
+export function bindingifySideEffects(sideEffects) {
+    switch (sideEffects) {
+        case true:
+            return BindingHookSideEffects.True;
+        case false:
+            return BindingHookSideEffects.False;
+        case 'no-treeshake':
+            return BindingHookSideEffects.NoTreeshake;
+        case null:
+        case undefined:
+            return undefined;
+        default:
+            throw new Error(`Unexpected side effects: ${sideEffects}`);
+    }
+}

package/dist/types/utils/transform-sourcemap.js

@@ -0,0 +1,29 @@
+export function isEmptySourcemapFiled(array) {
+    if (!array) {
+        return true;
+    }
+    if (array.length === 0 || !array[0] /* null or '' */) {
+        return true;
+    }
+    return false;
+}
+export function normalizeTransformHookSourcemap(id, originalCode, rawMap) {
+    if (!rawMap) {
+        return;
+    }
+    // If sourcemap hasn't `sourcesContent` and `sources`, using original code to fill it.
+    // The rust side already has the feature at `crates/rolldown_plugin/src/plugin_driver/build_hooks.rs#transform`.
+    // but it could be failed at `rolldown_sourcemap::SourceMap::from_json`, because the map is invalid.
+    let map = typeof rawMap === 'object'
+        ? rawMap
+        : JSON.parse(rawMap);
+    if (isEmptySourcemapFiled(map.sourcesContent)) {
+        map.sourcesContent = [originalCode];
+    }
+    if (isEmptySourcemapFiled(map.sources) ||
+        (map.sources && map.sources.length === 1 && map.sources[0] !== id) // the transform sourcemaps maybe contain multiple sources
+    ) {
+        map.sources = [id];
+    }
+    return map;
+}

package/dist/types/utils/transform-to-rollup-output.js

@@ -0,0 +1,165 @@
+import { bindingAssetSource, transformAssetSource, } from './asset-source';
+import { bindingifySourcemap } from '../types/sourcemap';
+import { normalizeErrors } from './error';
+import { transformChunkModules } from './transform-rendered-chunk';
+import { Buffer } from 'node:buffer';
+function transformToRollupSourceMap(map) {
+    const parsed = JSON.parse(map);
+    const obj = {
+        ...parsed,
+        toString() {
+            return JSON.stringify(obj);
+        },
+        toUrl() {
+            return `data:application/json;charset=utf-8;base64,${Buffer.from(obj.toString(), 'utf-8').toString('base64')}`;
+        },
+    };
+    return obj;
+}
+function transformToRollupOutputChunk(bindingChunk, changed) {
+    const chunk = {
+        type: 'chunk',
+        get code() {
+            return bindingChunk.code;
+        },
+        fileName: bindingChunk.fileName,
+        name: bindingChunk.name,
+        get modules() {
+            return transformChunkModules(bindingChunk.modules);
+        },
+        get imports() {
+            return bindingChunk.imports;
+        },
+        get dynamicImports() {
+            return bindingChunk.dynamicImports;
+        },
+        exports: bindingChunk.exports,
+        isEntry: bindingChunk.isEntry,
+        facadeModuleId: bindingChunk.facadeModuleId || null,
+        isDynamicEntry: bindingChunk.isDynamicEntry,
+        get moduleIds() {
+            return bindingChunk.moduleIds;
+        },
+        get map() {
+            return bindingChunk.map
+                ? transformToRollupSourceMap(bindingChunk.map)
+                : null;
+        },
+        sourcemapFileName: bindingChunk.sourcemapFileName || null,
+        preliminaryFileName: bindingChunk.preliminaryFileName,
+    };
+    const cache = {};
+    return new Proxy(chunk, {
+        get(target, p) {
+            if (p in cache) {
+                return cache[p];
+            }
+            return target[p];
+        },
+        set(target, p, newValue) {
+            cache[p] = newValue;
+            changed?.updated.add(bindingChunk.fileName);
+            return true;
+        },
+    });
+}
+function transformToRollupOutputAsset(bindingAsset, changed) {
+    const asset = {
+        type: 'asset',
+        fileName: bindingAsset.fileName,
+        originalFileName: bindingAsset.originalFileName || null,
+        originalFileNames: bindingAsset.originalFileNames,
+        get source() {
+            return transformAssetSource(bindingAsset.source);
+        },
+        name: bindingAsset.name ?? undefined,
+        names: bindingAsset.names,
+    };
+    const cache = {};
+    return new Proxy(asset, {
+        get(target, p) {
+            if (p in cache) {
+                return cache[p];
+            }
+            return target[p];
+        },
+        set(target, p, newValue) {
+            cache[p] = newValue;
+            changed?.updated.add(bindingAsset.fileName);
+            return true;
+        },
+    });
+}
+export function transformToRollupOutput(output, changed) {
+    handleOutputErrors(output);
+    const { chunks, assets } = output;
+    return {
+        output: [
+            ...chunks.map((chunk) => transformToRollupOutputChunk(chunk, changed)),
+            ...assets.map((asset) => transformToRollupOutputAsset(asset, changed)),
+        ],
+    };
+}
+export function handleOutputErrors(output) {
+    const rawErrors = output.errors;
+    if (rawErrors.length > 0) {
+        throw normalizeErrors(rawErrors);
+    }
+}
+export function transformToOutputBundle(output, changed) {
+    const bundle = Object.fromEntries(transformToRollupOutput(output, changed).output.map((item) => [
+        item.fileName,
+        item,
+    ]));
+    return new Proxy(bundle, {
+        deleteProperty(target, property) {
+            if (typeof property === 'string') {
+                changed.deleted.add(property);
+            }
+            return true;
+        },
+    });
+}
+// TODO find a way only transfer the changed part to rust side.
+export function collectChangedBundle(changed, bundle) {
+    const assets = [];
+    const chunks = [];
+    for (const key in bundle) {
+        if (changed.deleted.has(key) || !changed.updated.has(key)) {
+            continue;
+        }
+        const item = bundle[key];
+        if (item.type === 'asset') {
+            assets.push({
+                filename: item.fileName,
+                originalFileNames: item.originalFileNames,
+                source: bindingAssetSource(item.source),
+                names: item.names,
+            });
+        }
+        else {
+            // not all properties modifications are reflected to rust side
+            chunks.push({
+                code: item.code,
+                filename: item.fileName,
+                name: item.name,
+                isEntry: item.isEntry,
+                exports: item.exports,
+                modules: {},
+                imports: item.imports,
+                dynamicImports: item.dynamicImports,
+                facadeModuleId: item.facadeModuleId || undefined,
+                isDynamicEntry: item.isDynamicEntry,
+                moduleIds: item.moduleIds,
+                map: bindingifySourcemap(item.map),
+                sourcemapFilename: item.sourcemapFileName || undefined,
+                preliminaryFilename: item.preliminaryFileName,
+            });
+        }
+    }
+    return {
+        assets,
+        chunks,
+        deleted: Array.from(changed.deleted),
+    };
+}