rolldown 0.10.4 → 0.10.5

package/dist/shared/rolldown-1SJPa4fg.cjs

@@ -0,0 +1,547 @@
+"use strict";
+
+const { __toESM } = require("./chunk-eib2uzZZ.cjs");
+const { LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARN, arraify, bindingifyPlugin, error, getLogHandler, logLevelPriority, logPluginError, normalizeHook, normalizeLog, require_binding, transformToRollupOutput, unimplemented } = require("./bindingify_plugin-sRZqfDBJ.cjs");
+const { default: nodePath, default: path } = __toESM(require("node:path"));
+const { Worker } = __toESM(require("node:worker_threads"));
+const { availableParallelism } = __toESM(require("node:os"));
+const { isRegExp } = __toESM(require("node:util/types"));
+
+//#region src/utils/async-flatten.ts
+async function asyncFlatten(array) {
+	do {
+		array = (await Promise.all(array)).flat(Infinity);
+	}while(array.some(v => v?.then));
+	return array;
+}
+
+//#endregion
+//#region src/utils/normalize-plugin-option.ts
+const normalizePluginOption = async plugins => (await asyncFlatten([plugins])).filter(Boolean);
+
+//#endregion
+//#region src/plugin/bindingify-builtin-plugin.ts
+var import_binding$3 = __toESM(require_binding());
+class BuiltinPlugin {
+	constructor(name, options){
+		this.name = name;
+		this.options = options;
+		this.name = name;
+		this.options = options;
+	}
+}
+class BuiltinWasmPlugin extends BuiltinPlugin {
+	constructor(options){
+		super(import_binding$3.BindingBuiltinPluginName.WasmPlugin, options);
+	}
+}
+function bindingifyBuiltInPlugin(plugin) {
+	return {
+		name:plugin.name,
+		options:plugin.options
+	};
+}
+
+//#endregion
+//#region src/options/bindingify-input-options.ts
+var import_binding$2 = __toESM(require_binding());
+function bindingifyInputOptions(options, outputOptions) {
+	return {
+		input:bindingifyInput(options.input),
+		plugins:options.plugins.map(plugin => {
+			if ('_parallel'in  plugin) {
+				return undefined;
+			}
+			if (plugin instanceof  BuiltinPlugin) {
+				return bindingifyBuiltInPlugin(plugin);
+			}
+			return bindingifyPlugin(plugin, options, outputOptions);
+		}),
+		cwd:options.cwd ?? process.cwd(),
+		external:options.external ? function bindingifyExternal() {
+			const external = options.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;
+				});
+			};
+		}() : undefined,
+		resolve:options.resolve ? function bindingifyResolve() {
+			const {alias,...rest} = options.resolve;
+			return {
+				alias:alias ? Object.entries(alias).map(([name,replacement]) => ({
+					find:name,
+					replacements:[replacement]
+				})) : undefined,
+				...rest
+			};
+		}() : undefined,
+		platform:options.platform,
+		shimMissingExports:options.shimMissingExports,
+		logLevel:bindingifyLogLevel(options.logLevel),
+		onLog:(level, log) => {
+			options.onLog(level, {
+				code:log.code,
+				message:log.message
+			});
+		},
+		treeshake:options.treeshake,
+		moduleTypes:options.moduleTypes
+	};
+}
+function bindingifyLogLevel(logLevel) {
+	switch(logLevel){
+		case 'silent':
+			return import_binding$2.BindingLogLevel.Silent;
+		case 'warn':
+			return import_binding$2.BindingLogLevel.Warn;
+		case 'info':
+			return import_binding$2.BindingLogLevel.Info;
+		case 'debug':
+			return import_binding$2.BindingLogLevel.Debug;
+		default:
+			throw new Error(`Unexpected log level: ${logLevel}`);
+	}
+}
+function bindingifyInput(input) {
+	if (Array.isArray(input)) {
+		return input.map(src => {
+			const name = nodePath.parse(src).name;
+			return {
+				name,
+				import:src
+			};
+		});
+	} else {
+		return Object.entries(input).map(value => {
+			return {
+				name:value[0],
+				import:value[1]
+			};
+		});
+	}
+}
+
+//#endregion
+//#region src/utils/initialize-parallel-plugins.ts
+var import_binding$1 = __toESM(require_binding());
+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 import_binding$1.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
+	};
+}
+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 = undefined('#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;
+	}}
+
+//#endregion
+//#region src/log/logger.ts
+function getLogger(plugins, onLog, logLevel) {
+	const minimalPriority = logLevelPriority[logLevel];
+	const logger = (level, log, skipped=new Set()) => {
+		const logPriority = logLevelPriority[level];
+		if (logPriority < minimalPriority) {
+			return;
+		}
+		for (const plugin of  plugins) 		{
+			if (skipped.has(plugin)) 			continue;
+
+			const {onLog:pluginOnLog} = plugin;
+			if (pluginOnLog) {
+				const getLogHandler$1 = level$1 => {
+					if (logLevelPriority[level$1] < minimalPriority) {
+						return () => {
+						};
+					}
+					return log$1 => logger(level$1, normalizeLog(log$1), new Set(skipped).add(plugin));
+				};
+				const handler = 'handler'in  pluginOnLog ? pluginOnLog.handler : pluginOnLog;
+				if (handler.call({
+					debug:getLogHandler$1(LOG_LEVEL_DEBUG),
+					error:log$1 => error(normalizeLog(log$1)),
+					info:getLogHandler$1(LOG_LEVEL_INFO),
+					warn:getLogHandler$1(LOG_LEVEL_WARN)
+				}, level, log) === false) {
+					return;
+				}
+			}
+		}
+		onLog(level, log);
+	};
+	return logger;
+}
+const getOnLog = (config, logLevel, printLog=defaultPrintLog) => {
+	const {onwarn, onLog} = config;
+	const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+	if (onLog) {
+		const minimalPriority = logLevelPriority[logLevel];
+		return (level, log) => onLog(level, addLogToString(log), (level$1, handledLog) => {
+			if (level$1 === LOG_LEVEL_ERROR) {
+				return error(normalizeLog(handledLog));
+			}
+			if (logLevelPriority[level$1] >= minimalPriority) {
+				defaultOnLog(level$1, normalizeLog(handledLog));
+			}
+		});
+	}
+	return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn ? (level, log) => {
+	if (level === LOG_LEVEL_WARN) {
+		onwarn(addLogToString(log), warning => printLog(LOG_LEVEL_WARN, normalizeLog(warning)));
+	} else {
+		printLog(level, log);
+	}
+} : printLog;
+const addLogToString = log => {
+	Object.defineProperty(log, 'toString', {
+		value:() => getExtendedLogMessage(log),
+		writable:true
+	});
+	return log;
+};
+const defaultPrintLog = (level, log) => {
+	const message = getExtendedLogMessage(log);
+	switch(level){
+		case LOG_LEVEL_WARN:
+			{
+				return console.warn(message);
+			}
+		case LOG_LEVEL_DEBUG:
+			{
+				return console.debug(message);
+			}
+		default:
+			{
+				return console.info(message);
+			}
+	}
+};
+const getExtendedLogMessage = log => {
+	let prefix = '';
+	if (log.plugin) {
+		prefix += `(${log.plugin} plugin) `;
+	}
+	if (log.loc) {
+		prefix += `${relativeId(log.loc.file)} (${log.loc.line}:${log.loc.column}) `;
+	}
+	return prefix + log.message;
+};
+function relativeId(id) {
+	if ( !path.isAbsolute(id)) 	return id;
+
+	return path.relative(path.resolve(), id);
+}
+
+//#endregion
+//#region src/plugin/plugin-driver.ts
+class PluginDriver {
+	async callOptionsHook(inputOptions){
+		const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
+		const plugins = getObjectPlugins(inputOptions.plugins ?? []);
+		const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), logLevel);
+		for (const plugin of  plugins) 		{
+			const name = plugin.name || 'unknown';
+			const options = plugin.options;
+			if (options) {
+				const [handler,_optionsIgnoredSofar] = normalizeHook(options);
+				const result = await handler.call({
+					debug:getLogHandler(LOG_LEVEL_DEBUG, 'PLUGIN_LOG', logger, name, logLevel),
+					error:e => error(logPluginError(normalizeLog(e), name, {
+						hook:'onLog'
+					})),
+					info:getLogHandler(LOG_LEVEL_INFO, 'PLUGIN_LOG', logger, name, logLevel),
+					warn:getLogHandler(LOG_LEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel)
+				}, inputOptions);
+				if (result) {
+					inputOptions = result;
+				}
+			}
+		}
+		return inputOptions;
+	}
+	async callOutputOptionsHook(inputOptions, outputOptions){
+		const plugins = getObjectPlugins(inputOptions.plugins);
+		for (const plugin of  plugins) 		{
+			const options = plugin.outputOptions;
+			if (options) {
+				const [handler,_optionsIgnoredSofar] = normalizeHook(options);
+				const result = await handler.call(null, outputOptions);
+				if (result) {
+					outputOptions = result;
+				}
+			}
+		}
+		return outputOptions;
+	}
+}
+function getObjectPlugins(plugins) {
+	return plugins.filter(plugin => {
+		if ('_parallel'in  plugin) {
+			return undefined;
+		}
+		if (plugin instanceof  BuiltinPlugin) {
+			return undefined;
+		}
+		return plugin;
+	});
+}
+
+//#endregion
+//#region src/utils/normalize-tree-shake.ts
+function normalizeTreeshakeOptions(config) {
+	if (config === false) {
+		return undefined;
+	}
+	if (config === true || config === undefined) {
+		return {
+			moduleSideEffects:'true'
+		};
+	}
+	if (config.moduleSideEffects === undefined) {
+		config.moduleSideEffects = 'true';
+	} else if (isRegExp(config.moduleSideEffects)) {
+		config.moduleSideEffects = config.moduleSideEffects.source;
+	} else {
+		config.moduleSideEffects = config.moduleSideEffects.toString();
+	}
+	return config;
+}
+
+//#endregion
+//#region src/utils/normalize-input-options.ts
+async function normalizeInputOptions(config) {
+	const {input,...rest} = config;
+	const plugins = await normalizePluginOption(config.plugins);
+	const treeshake = normalizeTreeshakeOptions(config.treeshake);
+	const logLevel = config.logLevel || LOG_LEVEL_INFO;
+	const onLog = getLogger(getObjectPlugins(plugins), getOnLog(config, logLevel), logLevel);
+	return {
+		...rest,
+		input:input ? typeof input === 'string' ? [input] : input : [],
+		plugins,
+		logLevel,
+		onLog,
+		treeshake
+	};
+}
+
+//#endregion
+//#region src/utils/normalize-output-options.ts
+function normalizeOutputOptions(opts) {
+	const {dir, format, exports, sourcemap, sourcemapIgnoreList, sourcemapPathTransform, entryFileNames, chunkFileNames, assetFileNames} = opts;
+	return {
+		dir:dir,
+		format:getFormat(format),
+		exports:exports ?? 'named',
+		sourcemap:sourcemap ?? false,
+		sourcemapIgnoreList:typeof sourcemapIgnoreList === 'function' ? sourcemapIgnoreList : sourcemapIgnoreList === false ? () => false : (relativeSourcePath, sourcemapPath) => relativeSourcePath.includes('node_modules'),
+		sourcemapPathTransform,
+		banner:getAddon(opts, 'banner'),
+		footer:getAddon(opts, 'footer'),
+		entryFileNames:entryFileNames ?? '[name].js',
+		chunkFileNames:chunkFileNames ?? '[name]-[hash].js',
+		assetFileNames:assetFileNames ?? 'assets/[name]-[hash][extname]',
+		plugins:[]
+	};
+}
+function getFormat(format) {
+	switch(format){
+		case undefined:
+		case 'es':
+		case 'esm':
+		case 'module':
+			{
+				return 'es';
+			}
+		case 'cjs':
+		case 'commonjs':
+			{
+				return 'cjs';
+			}
+		default:
+			unimplemented(`output.format: ${format}`);
+	}
+}
+const getAddon = (config, name) => {
+	const configAddon = config[name];
+	if (typeof configAddon === 'function') {
+		return configAddon;
+	}
+	return async() => configAddon || '';
+};
+
+//#endregion
+//#region src/options/bindingify-output-options.ts
+function bindingifyOutputOptions(outputOptions) {
+	const {dir, format, exports, sourcemap, sourcemapIgnoreList, sourcemapPathTransform, entryFileNames, chunkFileNames, assetFileNames, banner, footer} = outputOptions;
+	return {
+		dir,
+		format:function() {
+			switch(format){
+				case 'es':
+					return 'es';
+				case 'cjs':
+					return 'cjs';
+			}
+		}(),
+		exports,
+		sourcemap:bindingifySourcemap(sourcemap),
+		sourcemapIgnoreList,
+		sourcemapPathTransform,
+		banner,
+		footer,
+		entryFileNames,
+		chunkFileNames,
+		assetFileNames,
+		plugins:[]
+	};
+}
+function bindingifySourcemap(sourcemap) {
+	switch(sourcemap){
+		case true:
+			return 'file';
+		case 'inline':
+			return 'inline';
+		case false:
+		case undefined:
+		case 'hidden':
+			return 'hidden';
+		default:
+			throw new Error(`unknown sourcemap: ${sourcemap}`);
+	}
+}
+
+//#endregion
+//#region src/utils/create-bundler.ts
+var import_binding = __toESM(require_binding());
+async function createBundler(inputOptions, outputOptions) {
+	const pluginDriver = new PluginDriver();
+	inputOptions = await pluginDriver.callOptionsHook(inputOptions);
+	const normalizedInputOptions = await normalizeInputOptions(inputOptions);
+	const parallelPluginInitResult = await initializeParallelPlugins(normalizedInputOptions.plugins);
+	try{
+		outputOptions = await pluginDriver.callOutputOptionsHook(normalizedInputOptions, outputOptions);
+		const normalizedOutputOptions = normalizeOutputOptions(outputOptions);
+		const bindingInputOptions = bindingifyInputOptions(normalizedInputOptions, normalizedOutputOptions);
+		return {
+			bundler:new import_binding.Bundler(bindingInputOptions, bindingifyOutputOptions(normalizedOutputOptions), parallelPluginInitResult?.registry),
+			stopWorkers:parallelPluginInitResult?.stopWorkers
+		};
+	}catch(e){
+		await parallelPluginInitResult?.stopWorkers();
+		throw e;
+	}}
+
+//#endregion
+//#region src/rolldown-build.ts
+class RolldownBuild {
+	#inputOptions;
+
+	#bundler;
+
+	#stopWorkers;
+
+	constructor(inputOptions){
+		this.#inputOptions = inputOptions;
+	}
+	async #getBundler(outputOptions){
+		if (typeof this.#bundler === 'undefined') {
+			const {bundler, stopWorkers} = await createBundler(this.#inputOptions, outputOptions);
+			this.#bundler = bundler;
+			this.#stopWorkers = stopWorkers;
+		}
+		return this.#bundler;
+	}
+	async generate(outputOptions={}){
+		const bundler = await this.#getBundler(outputOptions);
+		const output = await bundler.generate();
+		return transformToRollupOutput(output);
+	}
+	async write(outputOptions={}){
+		const bundler = await this.#getBundler(outputOptions);
+		const output = await bundler.write();
+		return transformToRollupOutput(output);
+	}
+	async destroy(){
+		await this.#stopWorkers?.();
+	}
+}
+
+//#endregion
+//#region src/rolldown.ts
+const rolldown = async input => {
+	return new RolldownBuild(input);
+};
+const experimental_scan = async input => {
+	const {bundler, stopWorkers} = await createBundler(input, {});
+	await bundler.scan();
+	await stopWorkers?.();
+};
+
+//#endregion
+exports.BuiltinWasmPlugin = BuiltinWasmPlugin;
+exports.experimental_scan = experimental_scan;
+exports.rolldown = rolldown;