feat(run): use resolved input if file exists

packages/run/package.json

@@ -50,6 +50,7 @@
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^3.0.0",
+    "@rollup/plugin-virtual": "^2.0.1",
     "del": "^5.1.0",
     "rollup": "^2.0.0",
     "sinon": "8.0.4"

packages/run/rollup.config.js

@@ -5,7 +5,7 @@ import pkg from './package.json';
 export default {
   input: 'src/index.ts',
   plugins: [typescript()],
-  external: Object.keys(pkg.dependencies).concat(['path', 'child_process']),
+  external: Object.keys(pkg.dependencies).concat(['path', 'child_process', 'fs']),
   output: [
     { format: 'cjs', file: pkg.main },
     { format: 'esm', file: pkg.module }

packages/run/src/index.ts

@@ -1,5 +1,6 @@
 import { ChildProcess, fork } from 'child_process';
 import * as path from 'path';
+import * as fs from 'fs';
 
 import { Plugin, RenderedChunk } from 'rollup';
 
@@ -31,7 +32,13 @@ export default function run(opts: RollupRunOptions = {}): Plugin {
         throw new Error(`@rollup/plugin-run only works with a single entry point`);
       }
 
-      input = path.resolve(inputs[0]);
+      // eslint-disable-next-line prefer-destructuring
+      input = inputs[0];
+
+      const resolvedInputPath = path.resolve(input);
+      if (fs.existsSync(resolvedInputPath)) {
+        input = resolvedInputPath;
+      }
     },
 
     generateBundle(_outputOptions, _bundle, isWrite) {

packages/run/test/test.js

@@ -14,6 +14,8 @@ const sinon = require('sinon');
 
 const run = require('../');
 
+const virtual = require('../../virtual');
+
 const cwd = join(__dirname, 'fixtures/');
 const file = join(cwd, 'output/bundle.js');
 const input = join(cwd, 'input.js');
@@ -55,6 +57,20 @@ test('takes input from the latest options', async (t) => {
   t.true(mockChildProcess.calledWithExactly(outputOptions.file, [], {}));
 });
 
+test('uses resolved input path if it refers to an existing file', async (t) => {
+  const bundle = await rollup({
+    input: 'entry',
+    plugins: [
+      virtual({
+        entry: 'console.log("No real path example")'
+      }),
+      run()
+    ]
+  });
+  await bundle.write(outputOptions);
+  t.true(mockChildProcess.calledWithExactly(outputOptions.file, [], {}));
+});
+
 test('checks entry point facade module', async (t) => {
   const bundle = await rollup({
     input: join(cwd, 'facade-entry/index.js'),

packages/virtual/README.md

@@ -43,12 +43,12 @@ Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/
 import virtual from '@rollup/plugin-virtual';
 
 export default {
-  entry: 'src/entry.js',
+  input: 'src/input.js',
   // ...
   plugins: [
     virtual({
-      batman: `export default 'na na na na na'`,
-      'src/robin.js': `export default 'batmannnnn'`
+      batman: `export default 'na na na na na';`,
+      'src/robin.js': `export default 'batmannnnn';`
     })
   ]
 };
@@ -73,9 +73,9 @@ export default {
   plugins: [
     virtual({
       entry: `
-import batman from 'batcave';
-console.log(batman);
-`
+        import batman from 'batcave';
+        console.log(batman);
+      `
     })
   ]
 };

packages/virtual/src/index.js

@@ -4,6 +4,7 @@ import path from 'path';
 const PREFIX = `\0virtual:`;
 
 export default function virtual(modules) {
+  const virtualInputIds = [];
   const resolvedIds = new Map();
 
   Object.keys(modules).forEach((id) => {
@@ -13,7 +14,49 @@ export default function virtual(modules) {
   return {
     name: 'virtual',
 
+    options(options) {
+      let updatedInput = options.input;
+
+      if (typeof updatedInput === 'string' && updatedInput in modules) {
+        const virtualId = PREFIX + updatedInput;
+        virtualInputIds.push(virtualId);
+        updatedInput = virtualId;
+      }
+
+      if (typeof updatedInput === 'object') {
+        if (Array.isArray(updatedInput)) {
+          updatedInput = updatedInput.map((id) => {
+            if (id in modules) {
+              const virtualId = PREFIX + id;
+              virtualInputIds.push(virtualId);
+              return virtualId;
+            }
+            return id;
+          });
+        } else {
+          updatedInput = Object.keys(updatedInput).reduce((nextUpdatedInput, key) => {
+            let id = key;
+            if (id in modules) {
+              const virtualId = PREFIX + id;
+              virtualInputIds.push(virtualId);
+              id = virtualId;
+            }
+            // eslint-disable-next-line no-param-reassign
+            nextUpdatedInput[id] = updatedInput[key];
+            return nextUpdatedInput;
+          }, {});
+        }
+      }
+
+      return {
+        ...options,
+        input: updatedInput
+      };
+    },
+
     resolveId(id, importer) {
+      if (virtualInputIds.includes(id)) return id;
+
       if (id in modules) return PREFIX + id;
 
       if (importer) {

packages/virtual/test/test.js

@@ -25,3 +25,35 @@ test('loads an absolute path from memory', (t) => {
   t.is(resolved, `\0virtual:${path.resolve('src/foo.js')}`);
   t.is(plugin.load(resolved), 'export default 42');
 });
+
+test('from memory input entry options are prefixed immediately', (t) => {
+  const plugin = virtual({
+    'foo.js': 'export default 42',
+    'src/foo.js': 'export default 42'
+  });
+
+  const singleInputOption = {
+    input: 'foo.js'
+  };
+
+  const multipleInputOption = {
+    input: ['foo.js', 'src/foo.js']
+  };
+
+  const mappedInputOption = {
+    input: {
+      'foo.js': 'lib/foo.js',
+      'src/foo.js': 'lib/index.js'
+    }
+  };
+
+  t.is(plugin.options(singleInputOption).input, '\0virtual:foo.js');
+  t.deepEqual(plugin.options(multipleInputOption).input, [
+    '\0virtual:foo.js',
+    '\0virtual:src/foo.js'
+  ]);
+  t.deepEqual(plugin.options(mappedInputOption).input, {
+    '\0virtual:foo.js': 'lib/foo.js',
+    '\0virtual:src/foo.js': 'lib/index.js'
+  });
+});