rollup 2.57.0

package/dist/shared/watch.js

@@ -0,0 +1,304 @@
+/*
+  @license
+	Rollup.js v2.57.0
+	Wed, 22 Sep 2021 04:43:07 GMT - commit b67ef301e8e44f9e0d9b144c0cce441e2a41c3da
+
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+var path = require('path');
+var rollup = require('./rollup.js');
+var mergeOptions = require('./mergeOptions.js');
+var require$$2 = require('os');
+var index = require('./index.js');
+require('crypto');
+require('fs');
+require('events');
+require('util');
+require('stream');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return n;
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+class FileWatcher {
+    constructor(task, chokidarOptions) {
+        this.transformWatchers = new Map();
+        this.chokidarOptions = chokidarOptions;
+        this.task = task;
+        this.watcher = this.createWatcher(null);
+    }
+    close() {
+        this.watcher.close();
+        for (const watcher of this.transformWatchers.values()) {
+            watcher.close();
+        }
+    }
+    unwatch(id) {
+        this.watcher.unwatch(id);
+        const transformWatcher = this.transformWatchers.get(id);
+        if (transformWatcher) {
+            this.transformWatchers.delete(id);
+            transformWatcher.close();
+        }
+    }
+    watch(id, isTransformDependency) {
+        if (isTransformDependency) {
+            const watcher = this.transformWatchers.get(id) || this.createWatcher(id);
+            watcher.add(id);
+            this.transformWatchers.set(id, watcher);
+        }
+        else {
+            this.watcher.add(id);
+        }
+    }
+    createWatcher(transformWatcherId) {
+        const task = this.task;
+        const isLinux = require$$2.platform() === 'linux';
+        const isTransformDependency = transformWatcherId !== null;
+        const handleChange = (id, event) => {
+            const changedId = transformWatcherId || id;
+            if (isLinux) {
+                // unwatching and watching fixes an issue with chokidar where on certain systems,
+                // a file that was unlinked and immediately recreated would create a change event
+                // but then no longer any further events
+                watcher.unwatch(changedId);
+                watcher.add(changedId);
+            }
+            task.invalidate(changedId, { event, isTransformDependency });
+        };
+        const watcher = index.chokidar
+            .watch([], this.chokidarOptions)
+            .on('add', id => handleChange(id, 'create'))
+            .on('change', id => handleChange(id, 'update'))
+            .on('unlink', id => handleChange(id, 'delete'));
+        return watcher;
+    }
+}
+
+const eventsRewrites = {
+    create: {
+        create: 'buggy',
+        delete: null,
+        update: 'create'
+    },
+    delete: {
+        create: 'update',
+        delete: 'buggy',
+        update: 'buggy'
+    },
+    update: {
+        create: 'buggy',
+        delete: 'delete',
+        update: 'update'
+    }
+};
+class Watcher {
+    constructor(configs, emitter) {
+        this.buildDelay = 0;
+        this.buildTimeout = null;
+        this.invalidatedIds = new Map();
+        this.rerun = false;
+        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);
+        process.nextTick(() => this.run());
+    }
+    close() {
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        for (const task of this.tasks) {
+            task.close();
+        }
+        this.emitter.emit('close');
+        this.emitter.removeAllListeners();
+    }
+    invalidate(file) {
+        if (file) {
+            const prevEvent = this.invalidatedIds.get(file.id);
+            const event = prevEvent ? eventsRewrites[prevEvent][file.event] : file.event;
+            if (event === 'buggy') {
+                //TODO: throws or warn? Currently just ignore, uses new event
+                this.invalidatedIds.set(file.id, file.event);
+            }
+            else if (event === null) {
+                this.invalidatedIds.delete(file.id);
+            }
+            else {
+                this.invalidatedIds.set(file.id, event);
+            }
+        }
+        if (this.running) {
+            this.rerun = true;
+            return;
+        }
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        this.buildTimeout = setTimeout(() => {
+            this.buildTimeout = null;
+            for (const [id, event] of this.invalidatedIds.entries()) {
+                this.emitter.emit('change', id, { event });
+            }
+            this.invalidatedIds.clear();
+            this.emitter.emit('restart');
+            this.run();
+        }, this.buildDelay);
+    }
+    async run() {
+        this.running = true;
+        this.emitter.emit('event', {
+            code: 'START'
+        });
+        for (const task of this.tasks) {
+            await task.run();
+        }
+        this.running = false;
+        this.emitter.emit('event', {
+            code: 'END'
+        });
+        if (this.rerun) {
+            this.rerun = false;
+            this.invalidate();
+        }
+    }
+}
+class Task {
+    constructor(watcher, config) {
+        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.outputs = this.options.output;
+        this.outputFiles = this.outputs.map(output => {
+            if (output.file || output.dir)
+                return path__namespace.resolve(output.file || output.dir);
+            return undefined;
+        });
+        const watchOptions = this.options.watch || {};
+        this.filter = rollup.createFilter(watchOptions.include, watchOptions.exclude);
+        this.fileWatcher = new FileWatcher(this, {
+            ...watchOptions.chokidar,
+            disableGlobbing: true,
+            ignoreInitial: true
+        });
+    }
+    close() {
+        this.closed = true;
+        this.fileWatcher.close();
+    }
+    invalidate(id, details) {
+        this.invalidated = true;
+        if (details.isTransformDependency) {
+            for (const module of this.cache.modules) {
+                if (module.transformDependencies.indexOf(id) === -1)
+                    continue;
+                // effective invalidation
+                module.originalCode = null;
+            }
+        }
+        this.watcher.invalidate({ event: details.event, id });
+    }
+    async run() {
+        if (!this.invalidated)
+            return;
+        this.invalidated = false;
+        const options = {
+            ...this.options,
+            cache: this.cache
+        };
+        const start = Date.now();
+        this.watcher.emitter.emit('event', {
+            code: 'BUNDLE_START',
+            input: this.options.input,
+            output: this.outputFiles
+        });
+        let result = null;
+        try {
+            result = await rollup.rollupInternal(options, this.watcher.emitter);
+            if (this.closed) {
+                return;
+            }
+            this.updateWatchedFiles(result);
+            this.skipWrite || (await Promise.all(this.outputs.map(output => result.write(output))));
+            this.watcher.emitter.emit('event', {
+                code: 'BUNDLE_END',
+                duration: Date.now() - start,
+                input: this.options.input,
+                output: this.outputFiles,
+                result
+            });
+        }
+        catch (error) {
+            if (!this.closed) {
+                if (Array.isArray(error.watchFiles)) {
+                    for (const id of error.watchFiles) {
+                        this.watchFile(id);
+                    }
+                }
+                if (error.id) {
+                    this.cache.modules = this.cache.modules.filter(module => module.id !== error.id);
+                }
+            }
+            this.watcher.emitter.emit('event', {
+                code: 'ERROR',
+                error,
+                result
+            });
+        }
+    }
+    updateWatchedFiles(result) {
+        const previouslyWatched = this.watched;
+        this.watched = new Set();
+        this.watchFiles = result.watchFiles;
+        this.cache = result.cache;
+        for (const id of this.watchFiles) {
+            this.watchFile(id);
+        }
+        for (const module of this.cache.modules) {
+            for (const depId of module.transformDependencies) {
+                this.watchFile(depId, true);
+            }
+        }
+        for (const id of previouslyWatched) {
+            if (!this.watched.has(id)) {
+                this.fileWatcher.unwatch(id);
+            }
+        }
+    }
+    watchFile(id, isTransformDependency = false) {
+        if (!this.filter(id))
+            return;
+        this.watched.add(id);
+        if (this.outputFiles.some(file => file === id)) {
+            throw new Error('Cannot import the generated bundle');
+        }
+        // this is necessary to ensure that any 'renamed' files
+        // continue to be watched following an error
+        this.fileWatcher.watch(id, isTransformDependency);
+    }
+}
+
+exports.Task = Task;
+exports.Watcher = Watcher;
+//# sourceMappingURL=watch.js.map

package/package.json

@@ -0,0 +1,142 @@
+{
+  "name": "rollup",
+  "version": "2.57.0",
+  "description": "Next-generation ES module bundler",
+  "main": "dist/rollup.js",
+  "module": "dist/es/rollup.js",
+  "typings": "dist/rollup.d.ts",
+  "bin": {
+    "rollup": "dist/bin/rollup"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && git rev-parse HEAD > .commithash && rollup --config rollup.config.ts --configPlugin typescript && shx cp src/rollup/types.d.ts dist/rollup.d.ts && shx chmod a+x dist/bin/rollup",
+    "build:cjs": "shx rm -rf dist && rollup --config rollup.config.ts --configPlugin typescript --configTest && shx cp src/rollup/types.d.ts dist/rollup.d.ts && shx chmod a+x dist/bin/rollup",
+    "build:bootstrap": "node dist/bin/rollup --config rollup.config.ts --configPlugin typescript && shx cp src/rollup/types.d.ts dist/rollup.d.ts && shx chmod a+x dist/bin/rollup",
+    "ci:lint": "npm run lint:nofix",
+    "ci:test": "npm run build:cjs && npm run build:bootstrap && npm run test:all",
+    "ci:test:only": "npm run build:cjs && npm run build:bootstrap && npm run test:only",
+    "ci:coverage": "npm run build:cjs && npm run build:bootstrap && nyc --reporter lcovonly mocha",
+    "lint": "eslint . --fix --cache && prettier --write \"**/*.md\"",
+    "lint:nofix": "eslint . && prettier --check \"**/*.md\"",
+    "lint:markdown": "prettier --write \"**/*.md\"",
+    "perf": "npm run build:cjs && node --expose-gc scripts/perf.js",
+    "perf:debug": "node --inspect-brk scripts/perf-debug.js",
+    "perf:init": "node scripts/perf-init.js",
+    "_postinstall": "husky install",
+    "postpublish": "pinst --enable && git push && git push --tags",
+    "prepare": "husky install && npm run build",
+    "prepublishOnly": "pinst --disable && npm ci && npm run lint:nofix && npm run security && npm run build:bootstrap && npm run test:all",
+    "security": "npm audit",
+    "test": "npm run build && npm run test:all",
+    "test:cjs": "npm run build:cjs && npm run test:only",
+    "test:quick": "mocha -b test/test.js",
+    "test:all": "npm run test:only && npm run test:browser && npm run test:typescript && npm run test:leak && npm run test:package",
+    "test:coverage": "npm run build:cjs && shx rm -rf coverage/* && nyc --reporter html mocha test/test.js",
+    "test:coverage:browser": "npm run build && shx rm -rf coverage/* && nyc mocha test/browser/index.js",
+    "test:leak": "node --expose-gc test/leak/index.js",
+    "test:package": "node scripts/test-package.js",
+    "test:only": "mocha test/test.js",
+    "test:typescript": "shx rm -rf test/typescript/dist && shx cp -r dist test/typescript/ && tsc --noEmit -p test/typescript && tsc --noEmit",
+    "test:browser": "mocha test/browser/index.js",
+    "watch": "rollup --config rollup.config.ts --configPlugin typescript --watch"
+  },
+  "repository": "rollup/rollup",
+  "keywords": [
+    "modules",
+    "bundler",
+    "bundling",
+    "es6",
+    "optimizer"
+  ],
+  "author": "Rich Harris",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rollup/rollup/issues"
+  },
+  "homepage": "https://rollupjs.org/",
+  "optionalDependencies": {
+    "fsevents": "~2.3.2"
+  },
+  "devDependencies": {
+    "@rollup/plugin-alias": "^3.1.5",
+    "@rollup/plugin-buble": "^0.21.3",
+    "@rollup/plugin-commonjs": "^20.0.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.4",
+    "@rollup/plugin-replace": "^3.0.0",
+    "@rollup/plugin-typescript": "^8.2.5",
+    "@rollup/pluginutils": "^4.1.1",
+    "@types/node": "^10.17.60",
+    "@types/require-relative": "^0.8.0",
+    "@types/signal-exit": "^3.0.1",
+    "@types/yargs-parser": "^20.2.1",
+    "@typescript-eslint/eslint-plugin": "^4.31.2",
+    "@typescript-eslint/parser": "^4.31.2",
+    "acorn": "^8.5.0",
+    "acorn-jsx": "^5.3.2",
+    "acorn-walk": "^8.2.0",
+    "buble": "^0.20.0",
+    "chokidar": "^3.5.2",
+    "colorette": "^1.4.0",
+    "core-js": "^3.18.0",
+    "date-time": "^4.0.0",
+    "es5-shim": "^4.6.2",
+    "es6-shim": "^0.35.6",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-prettier": "^3.4.1",
+    "execa": "^5.1.1",
+    "fixturify": "^2.1.1",
+    "hash.js": "^1.1.7",
+    "husky": "^6.0.0",
+    "is-reference": "^3.0.0",
+    "lint-staged": "^10.5.4",
+    "locate-character": "^2.0.5",
+    "magic-string": "^0.25.7",
+    "mocha": "^8.4.0",
+    "nyc": "^15.1.0",
+    "pinst": "^2.1.6",
+    "prettier": "^2.4.1",
+    "pretty-bytes": "^5.6.0",
+    "pretty-ms": "^7.0.1",
+    "require-relative": "^0.8.7",
+    "requirejs": "^2.3.6",
+    "rollup": "^2.56.3",
+    "rollup-plugin-license": "^2.5.0",
+    "rollup-plugin-string": "^3.0.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-thatworks": "^1.0.4",
+    "sander": "^0.6.0",
+    "shx": "^0.3.3",
+    "signal-exit": "^3.0.4",
+    "source-map": "^0.7.3",
+    "source-map-support": "^0.5.20",
+    "sourcemap-codec": "^1.4.8",
+    "systemjs": "^6.10.3",
+    "terser": "^5.8.0",
+    "tslib": "^2.3.1",
+    "typescript": "^4.4.3",
+    "weak-napi": "^2.0.2",
+    "yargs-parser": "^20.2.9"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/*.d.ts",
+    "dist/bin/rollup",
+    "dist/rollup.browser.js.map"
+  ],
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "exports": {
+    ".": {
+      "node": {
+        "require": "./dist/rollup.js",
+        "import": "./dist/es/rollup.js"
+      },
+      "default": "./dist/es/rollup.browser.js"
+    },
+    "./dist/": "./dist/"
+  }
+}