rollup 3.1.0 → 3.2.1

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.1.0
-	Wed, 12 Oct 2022 08:54:50 GMT - commit f7b768992209a970c240799cdff12a4fa437c0d4
+	Rollup.js v3.2.1
+	Sun, 16 Oct 2022 04:44:52 GMT - commit 46e1eaaaf05e0c2efa0ed395d7a3cfa99ef25fb5
 
 	https://github.com/rollup/rollup
 
@@ -25,13 +25,12 @@ require('util');
 require('stream');
 require('path');
 require('os');
-require('./mergeOptions.js');
 require('node:path');
 require('node:perf_hooks');
 require('node:crypto');
 require('node:events');
-require('node:url');
 require('tty');
+require('node:url');
 
 function timeZone(date = new Date()) {
 	const offset = date.getTimezoneOffset();
@@ -350,12 +349,12 @@ function getResetScreen(configs, allowClearScreen) {
         }
     }
     if (clearScreen) {
-        return (heading) => loadConfigFile_js.stderr(CLEAR_SCREEN + heading);
+        return (heading) => rollup.stderr(CLEAR_SCREEN + heading);
     }
     let firstRun = true;
     return (heading) => {
         if (firstRun) {
-            loadConfigFile_js.stderr(heading);
+            rollup.stderr(heading);
             firstRun = false;
         }
     };
@@ -366,7 +365,7 @@ function extractWatchHooks(command) {
         return {};
     return command.watch
         .filter(value => typeof value === 'object')
-        .reduce((acc, keyValueOption) => ({ ...acc, ...keyValueOption }), {});
+        .reduce((accumulator, keyValueOption) => ({ ...accumulator, ...keyValueOption }), {});
 }
 function createWatchHooks(command) {
     const watchHooks = extractWatchHooks(command);
@@ -374,15 +373,15 @@ function createWatchHooks(command) {
         if (watchHooks[hook]) {
             const cmd = watchHooks[hook];
             if (!command.silent) {
-                loadConfigFile_js.stderr(loadConfigFile_js.cyan(`watch.${hook} ${loadConfigFile_js.bold(`$ ${cmd}`)}`));
+                rollup.stderr(rollup.cyan(`watch.${hook} ${rollup.bold(`$ ${cmd}`)}`));
             }
             try {
                 // !! important - use stderr for all writes from execSync
                 const stdio = [process.stdin, process.stderr, process.stderr];
                 node_child_process.execSync(cmd, { stdio: command.silent ? 'ignore' : stdio });
             }
-            catch (e) {
-                loadConfigFile_js.stderr(e.message);
+            catch (error) {
+                rollup.stderr(error.message);
             }
         }
     };
@@ -417,7 +416,7 @@ async function watch(command) {
                 configFileRevision++;
                 const currentConfigFileRevision = configFileRevision;
                 if (configFileData) {
-                    loadConfigFile_js.stderr(`\nReloading updated config...`);
+                    rollup.stderr(`\nReloading updated config...`);
                 }
                 configFileData = newConfigFileData;
                 const { options, warnings } = await loadConfigFile_js.loadConfigFile(configFile, command);
@@ -429,8 +428,8 @@ async function watch(command) {
                 }
                 start(options, warnings);
             }
-            catch (err) {
-                loadConfigFile_js.handleError(err, true);
+            catch (error) {
+                rollup.handleError(error, true);
             }
         }
     }
@@ -439,32 +438,29 @@ async function watch(command) {
     }
     else {
         const { options, warnings } = await cli.loadConfigFromCommand(command);
-        start(options, warnings);
+        await start(options, warnings);
     }
-    function start(configs, warnings) {
-        try {
-            watcher = rollup.watch(configs);
-        }
-        catch (err) {
-            return loadConfigFile_js.handleError(err);
-        }
+    async function start(configs, warnings) {
+        watcher = rollup.watch(configs);
         watcher.on('event', event => {
             switch (event.code) {
-                case 'ERROR':
+                case 'ERROR': {
                     warnings.flush();
-                    loadConfigFile_js.handleError(event.error, true);
+                    rollup.handleError(event.error, true);
                     runWatchHook('onError');
                     break;
-                case 'START':
+                }
+                case 'START': {
                     if (!silent) {
                         if (!resetScreen) {
                             resetScreen = getResetScreen(configs, isTTY);
                         }
-                        resetScreen(loadConfigFile_js.underline(`rollup v${rollup.version}`));
+                        resetScreen(rollup.underline(`rollup v${rollup.version}`));
                     }
                     runWatchHook('onStart');
                     break;
-                case 'BUNDLE_START':
+                }
+                case 'BUNDLE_START': {
                     if (!silent) {
                         let input = event.input;
                         if (typeof input !== 'string') {
@@ -472,27 +468,30 @@ async function watch(command) {
                                 ? input.join(', ')
                                 : Object.values(input).join(', ');
                         }
-                        loadConfigFile_js.stderr(loadConfigFile_js.cyan(`bundles ${loadConfigFile_js.bold(input)} → ${loadConfigFile_js.bold(event.output.map(rollup.relativeId).join(', '))}...`));
+                        rollup.stderr(rollup.cyan(`bundles ${rollup.bold(input)} → ${rollup.bold(event.output.map(rollup.relativeId).join(', '))}...`));
                     }
                     runWatchHook('onBundleStart');
                     break;
-                case 'BUNDLE_END':
+                }
+                case 'BUNDLE_END': {
                     warnings.flush();
                     if (!silent)
-                        loadConfigFile_js.stderr(loadConfigFile_js.green(`created ${loadConfigFile_js.bold(event.output.map(rollup.relativeId).join(', '))} in ${loadConfigFile_js.bold(cli.prettyMilliseconds(event.duration))}`));
+                        rollup.stderr(rollup.green(`created ${rollup.bold(event.output.map(rollup.relativeId).join(', '))} in ${rollup.bold(cli.prettyMilliseconds(event.duration))}`));
                     runWatchHook('onBundleEnd');
                     if (event.result && event.result.getTimings) {
                         cli.printTimings(event.result.getTimings());
                     }
                     break;
-                case 'END':
+                }
+                case 'END': {
                     runWatchHook('onEnd');
                     if (!silent && isTTY) {
-                        loadConfigFile_js.stderr(`\n[${dateTime()}] waiting for changes...`);
+                        rollup.stderr(`\n[${dateTime()}] waiting for changes...`);
                     }
+                }
             }
             if ('result' in event && event.result) {
-                event.result.close().catch(error => loadConfigFile_js.handleError(error, true));
+                event.result.close().catch(error => rollup.handleError(error, true));
             }
         });
     }
@@ -505,6 +504,7 @@ async function watch(command) {
         if (configWatcher)
             configWatcher.close();
         if (code) {
+            // eslint-disable-next-line unicorn/no-process-exit
             process$2.exit(code);
         }
     }

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.1.0
-	Wed, 12 Oct 2022 08:54:50 GMT - commit f7b768992209a970c240799cdff12a4fa437c0d4
+	Rollup.js v3.2.1
+	Sun, 16 Oct 2022 04:44:52 GMT - commit 46e1eaaaf05e0c2efa0ed395d7a3cfa99ef25fb5
 
 	https://github.com/rollup/rollup
 
@@ -14,7 +14,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const node_path = require('node:path');
 const process = require('node:process');
 const rollup = require('./rollup.js');
-const mergeOptions = require('./mergeOptions.js');
 const node_os = require('node:os');
 const index = require('./index.js');
 require('path');
@@ -22,6 +21,7 @@ require('node:perf_hooks');
 require('node:crypto');
 require('node:fs');
 require('node:events');
+require('tty');
 require('fs');
 require('util');
 require('stream');
@@ -101,7 +101,7 @@ const eventsRewrites = {
     }
 };
 class Watcher {
-    constructor(configs, emitter) {
+    constructor(optionsList, emitter) {
         this.buildDelay = 0;
         this.buildTimeout = null;
         this.closed = false;
@@ -110,10 +110,12 @@ class Watcher {
         this.running = true;
         this.emitter = emitter;
         emitter.close = this.close.bind(this);
-        this.tasks = configs.map(config => new Task(this, config));
-        this.buildDelay = configs.reduce((buildDelay, { watch }) => watch && typeof watch.buildDelay === 'number'
-            ? Math.max(buildDelay, watch.buildDelay)
-            : buildDelay, this.buildDelay);
+        this.tasks = optionsList.map(options => new Task(this, options));
+        for (const { watch } of optionsList) {
+            if (watch && typeof watch.buildDelay === 'number') {
+                this.buildDelay = Math.max(this.buildDelay, watch.buildDelay);
+            }
+        }
         process.nextTick(() => this.run());
     }
     async close() {
@@ -130,8 +132,8 @@ class Watcher {
     }
     invalidate(file) {
         if (file) {
-            const prevEvent = this.invalidatedIds.get(file.id);
-            const event = prevEvent ? eventsRewrites[prevEvent][file.event] : file.event;
+            const previousEvent = this.invalidatedIds.get(file.id);
+            const event = previousEvent ? eventsRewrites[previousEvent][file.event] : file.event;
             if (event === 'buggy') {
                 //TODO: throws or warn? Currently just ignore, uses new event
                 this.invalidatedIds.set(file.id, file.event);
@@ -190,15 +192,15 @@ class Watcher {
     }
 }
 class Task {
-    constructor(watcher, config) {
+    constructor(watcher, options) {
         this.cache = { modules: [] };
         this.watchFiles = [];
         this.closed = false;
         this.invalidated = true;
         this.watched = new Set();
         this.watcher = watcher;
-        this.skipWrite = Boolean(config.watch && config.watch.skipWrite);
-        this.options = mergeOptions.mergeOptions(config);
+        this.options = options;
+        this.skipWrite = Boolean(options.watch && options.watch.skipWrite);
         this.outputs = this.options.output;
         this.outputFiles = this.outputs.map(output => {
             if (output.file || output.dir)
@@ -300,7 +302,7 @@ class Task {
         if (!this.filter(id))
             return;
         this.watched.add(id);
-        if (this.outputFiles.some(file => file === id)) {
+        if (this.outputFiles.includes(id)) {
             throw new Error('Cannot import the generated bundle');
         }
         // this is necessary to ensure that any 'renamed' files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "description": "Next-generation ES module bundler",
   "main": "dist/rollup.js",
   "module": "dist/es/rollup.js",
@@ -87,6 +87,7 @@
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-unicorn": "^44.0.2",
     "fixturify": "^2.1.1",
     "fs-extra": "^10.1.0",
     "github-api": "^3.4.0",

package/dist/shared/mergeOptions.js

@@ -1,182 +0,0 @@
-/*
-  @license
-	Rollup.js v3.1.0
-	Wed, 12 Oct 2022 08:54:50 GMT - commit f7b768992209a970c240799cdff12a4fa437c0d4
-
-	https://github.com/rollup/rollup
-
-	Released under the MIT License.
-*/
-'use strict';
-
-const rollup = require('./rollup.js');
-
-const commandAliases = {
-    c: 'config',
-    d: 'dir',
-    e: 'external',
-    f: 'format',
-    g: 'globals',
-    h: 'help',
-    i: 'input',
-    m: 'sourcemap',
-    n: 'name',
-    o: 'file',
-    p: 'plugin',
-    v: 'version',
-    w: 'watch'
-};
-function mergeOptions(config, rawCommandOptions = { external: [], globals: undefined }, defaultOnWarnHandler = rollup.defaultOnWarn) {
-    const command = getCommandOptions(rawCommandOptions);
-    const inputOptions = mergeInputOptions(config, command, defaultOnWarnHandler);
-    const warn = inputOptions.onwarn;
-    if (command.output) {
-        Object.assign(command, command.output);
-    }
-    const outputOptionsArray = rollup.ensureArray(config.output);
-    if (outputOptionsArray.length === 0)
-        outputOptionsArray.push({});
-    const outputOptions = outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, warn));
-    rollup.warnUnknownOptions(command, Object.keys(inputOptions).concat(Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapPathTransform'), Object.keys(commandAliases), 'bundleConfigAsCjs', 'config', 'environment', 'plugin', 'silent', 'failAfterWarnings', 'stdin', 'waitForBundleInput', 'configPlugin'), 'CLI flags', warn, /^_$|output$|config/);
-    inputOptions.output = outputOptions;
-    return inputOptions;
-}
-function getCommandOptions(rawCommandOptions) {
-    const external = rawCommandOptions.external && typeof rawCommandOptions.external === 'string'
-        ? rawCommandOptions.external.split(',')
-        : [];
-    return {
-        ...rawCommandOptions,
-        external,
-        globals: typeof rawCommandOptions.globals === 'string'
-            ? rawCommandOptions.globals.split(',').reduce((globals, globalDefinition) => {
-                const [id, variableName] = globalDefinition.split(':');
-                globals[id] = variableName;
-                if (!external.includes(id)) {
-                    external.push(id);
-                }
-                return globals;
-            }, Object.create(null))
-            : undefined
-    };
-}
-function mergeInputOptions(config, overrides, defaultOnWarnHandler) {
-    const getOption = (name) => overrides[name] ?? config[name];
-    const inputOptions = {
-        acorn: getOption('acorn'),
-        acornInjectPlugins: config.acornInjectPlugins,
-        cache: config.cache,
-        context: getOption('context'),
-        experimentalCacheExpiry: getOption('experimentalCacheExpiry'),
-        external: getExternal(config, overrides),
-        inlineDynamicImports: getOption('inlineDynamicImports'),
-        input: getOption('input') || [],
-        makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
-        manualChunks: getOption('manualChunks'),
-        maxParallelFileOps: getOption('maxParallelFileOps'),
-        maxParallelFileReads: getOption('maxParallelFileReads'),
-        moduleContext: getOption('moduleContext'),
-        onwarn: getOnWarn(config, defaultOnWarnHandler),
-        perf: getOption('perf'),
-        plugins: rollup.normalizePluginOption(config.plugins),
-        preserveEntrySignatures: getOption('preserveEntrySignatures'),
-        preserveModules: getOption('preserveModules'),
-        preserveSymlinks: getOption('preserveSymlinks'),
-        shimMissingExports: getOption('shimMissingExports'),
-        strictDeprecations: getOption('strictDeprecations'),
-        treeshake: getObjectOption(config, overrides, 'treeshake', rollup.objectifyOptionWithPresets(rollup.treeshakePresets, 'treeshake', 'false, true, ')),
-        watch: getWatch(config, overrides)
-    };
-    rollup.warnUnknownOptions(config, Object.keys(inputOptions), 'input options', inputOptions.onwarn, /^output$/);
-    return inputOptions;
-}
-const getExternal = (config, overrides) => {
-    const configExternal = config.external;
-    return typeof configExternal === 'function'
-        ? (source, importer, isResolved) => configExternal(source, importer, isResolved) || overrides.external.includes(source)
-        : rollup.ensureArray(configExternal).concat(overrides.external);
-};
-const getOnWarn = (config, defaultOnWarnHandler) => config.onwarn
-    ? warning => config.onwarn(warning, defaultOnWarnHandler)
-    : defaultOnWarnHandler;
-const getObjectOption = (config, overrides, name, objectifyValue = rollup.objectifyOption) => {
-    const commandOption = normalizeObjectOptionValue(overrides[name], objectifyValue);
-    const configOption = normalizeObjectOptionValue(config[name], objectifyValue);
-    if (commandOption !== undefined) {
-        return commandOption && { ...configOption, ...commandOption };
-    }
-    return configOption;
-};
-const getWatch = (config, overrides) => config.watch !== false && getObjectOption(config, overrides, 'watch');
-const isWatchEnabled = (optionValue) => {
-    if (Array.isArray(optionValue)) {
-        return optionValue.reduce((result, value) => (typeof value === 'boolean' ? value : result), false);
-    }
-    return optionValue === true;
-};
-const normalizeObjectOptionValue = (optionValue, objectifyValue) => {
-    if (!optionValue) {
-        return optionValue;
-    }
-    if (Array.isArray(optionValue)) {
-        return optionValue.reduce((result, value) => value && result && { ...result, ...objectifyValue(value) }, {});
-    }
-    return objectifyValue(optionValue);
-};
-function mergeOutputOptions(config, overrides, warn) {
-    const getOption = (name) => overrides[name] ?? config[name];
-    const outputOptions = {
-        amd: getObjectOption(config, overrides, 'amd'),
-        assetFileNames: getOption('assetFileNames'),
-        banner: getOption('banner'),
-        chunkFileNames: getOption('chunkFileNames'),
-        compact: getOption('compact'),
-        dir: getOption('dir'),
-        dynamicImportFunction: getOption('dynamicImportFunction'),
-        dynamicImportInCjs: getOption('dynamicImportInCjs'),
-        entryFileNames: getOption('entryFileNames'),
-        esModule: getOption('esModule'),
-        exports: getOption('exports'),
-        extend: getOption('extend'),
-        externalImportAssertions: getOption('externalImportAssertions'),
-        externalLiveBindings: getOption('externalLiveBindings'),
-        file: getOption('file'),
-        footer: getOption('footer'),
-        format: getOption('format'),
-        freeze: getOption('freeze'),
-        generatedCode: getObjectOption(config, overrides, 'generatedCode', rollup.objectifyOptionWithPresets(rollup.generatedCodePresets, 'output.generatedCode', '')),
-        globals: getOption('globals'),
-        hoistTransitiveImports: getOption('hoistTransitiveImports'),
-        indent: getOption('indent'),
-        inlineDynamicImports: getOption('inlineDynamicImports'),
-        interop: getOption('interop'),
-        intro: getOption('intro'),
-        manualChunks: getOption('manualChunks'),
-        minifyInternalExports: getOption('minifyInternalExports'),
-        name: getOption('name'),
-        namespaceToStringTag: getOption('namespaceToStringTag'),
-        noConflict: getOption('noConflict'),
-        outro: getOption('outro'),
-        paths: getOption('paths'),
-        plugins: rollup.normalizePluginOption(config.plugins),
-        preferConst: getOption('preferConst'),
-        preserveModules: getOption('preserveModules'),
-        preserveModulesRoot: getOption('preserveModulesRoot'),
-        sanitizeFileName: getOption('sanitizeFileName'),
-        sourcemap: getOption('sourcemap'),
-        sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
-        sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
-        sourcemapFile: getOption('sourcemapFile'),
-        sourcemapPathTransform: getOption('sourcemapPathTransform'),
-        strict: getOption('strict'),
-        systemNullSetters: getOption('systemNullSetters'),
-        validate: getOption('validate')
-    };
-    rollup.warnUnknownOptions(config, Object.keys(outputOptions), 'output options', warn);
-    return outputOptions;
-}
-
-exports.commandAliases = commandAliases;
-exports.isWatchEnabled = isWatchEnabled;
-exports.mergeOptions = mergeOptions;
-//# sourceMappingURL=mergeOptions.js.map