feat(virtual): accept a function resolver for the id option

packages/virtual/src/index.ts

@@ -2,39 +2,57 @@ import * as path from 'path';
 
 import type { Plugin } from 'rollup';
 
-import type { RollupVirtualOptions } from '../types';
+import type { RollupVirtualOptions, VirtualIdResolver } from '../types';
 
 const PREFIX = `\0virtual:`;
+const IMPORTER_SEP = `::`;
 
 export default function virtual(modules: RollupVirtualOptions): Plugin {
-  const resolvedIds = new Map<string, string>();
+  const resolvedIds = new Map<string, VirtualIdResolver>();
 
   Object.keys(modules).forEach((id) => {
     resolvedIds.set(path.resolve(id), modules[id]);
   });
 
+  function getImporterSuffix(id: string, importer: string | undefined) {
+    const module = modules[id] ?? resolvedIds.get(id);
+    if (typeof module === 'function') {
+      const importerSuffix = importer ? `${IMPORTER_SEP}${importer}` : '';
+      return importerSuffix;
+    }
+
+    return '';
+  }
+
   return {
     name: 'virtual',
 
     resolveId(id, importer) {
-      if (id in modules) return PREFIX + id;
+      if (id in modules) return PREFIX + id + getImporterSuffix(id, importer);
 
       if (importer) {
         const importerNoPrefix = importer.startsWith(PREFIX)
           ? importer.slice(PREFIX.length)
           : importer;
         const resolved = path.resolve(path.dirname(importerNoPrefix), id);
-        if (resolvedIds.has(resolved)) return PREFIX + resolved;
+        if (resolvedIds.has(resolved))
+          return PREFIX + resolved + getImporterSuffix(resolved, importer);
       }
 
       return null;
     },
 
     load(id) {
       if (id.startsWith(PREFIX)) {
-        const idNoPrefix = id.slice(PREFIX.length);
+        const [idNoPrefix, importer] = id.slice(PREFIX.length).split(IMPORTER_SEP);
+
+        const module = idNoPrefix in modules ? modules[idNoPrefix] : resolvedIds.get(idNoPrefix);
+
+        if (typeof module === 'function') {
+          return module(importer);
+        }
 
-        return idNoPrefix in modules ? modules[idNoPrefix] : resolvedIds.get(idNoPrefix);
+        return module;
       }
 
       return null;

packages/virtual/test/test.js

@@ -25,3 +25,19 @@ 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('use function that takes a module ID', (t) => {
+  const plugin = virtual({
+    routeName: (importer) => {
+      const routeRoot = 'src/views/';
+      const routeName = importer.replace(routeRoot, '').replace(/\.\w+$/, '');
+
+      return `export const routeName = '${routeName}'`;
+    }
+  });
+
+  const resolved = plugin.resolveId('routeName', 'src/views/user/index.vue');
+
+  t.is(resolved, `\0virtual:routeName::src/views/user/index.vue`);
+  t.is(plugin.load(resolved), "export const routeName = 'user/index'");
+});

packages/virtual/types/index.d.ts

@@ -1,7 +1,8 @@
 import type { Plugin } from 'rollup';
 
+export type VirtualIdResolver = string | ((importer: string | undefined) => string);
 export interface RollupVirtualOptions {
-  [id: string]: string;
+  [id: string]: VirtualIdResolver;
 }
 
 /**