vite(plugin): transform aliases in runtime to avoid ESM import transforms

Author: harlan-zw

packages/vite/src/plugins.ts

@@ -1,50 +1,104 @@
 import { createUnplugin } from 'unplugin'
 import { resolvePath } from 'mlly'
-import { dirname } from 'pathe'
+import { dirname, join } from 'pathe'
+import MagicString from 'magic-string'
 
 export interface PluginOptions {
   /**
    * Should the runtime be swapped out with a mock one, used for SSR-only mode.
    */
   mock?: boolean
   /**
-   * Whether to use schema-dts types on define functions
+   * Whether to use schema-dts types on define functions.
    */
   full?: boolean
+  /**
+   * Path to a real custom runtime (not mocked).
+   */
+  runtimePath?: string
+  /**
+   * Path to a real custom provider (not mocked).
+   */
+  providerPath?: string
+  /**
+   * Scan files from this root directory (ignoring node_modules).
+   */
+  transformPaths?: string[]
+}
+
+const SchemaOrgPkg = '@vueuse/schema-org'
+
+interface AliasPaths {
+  pkgDir: string
+  provider: string
+  runtime: string
 }
 
 export const schemaOrgSwapAliases = () => createUnplugin<PluginOptions>((args) => {
+  let paths: AliasPaths
+  const fetchPaths = async () => {
+    if (paths)
+      return paths
+    const pkgDir = dirname(await resolvePath(SchemaOrgPkg))
+    let provider, runtime
+    if (args?.mock) {
+      provider = runtime = await resolvePath(`${SchemaOrgPkg}/runtime/mock`)
+    }
+    else {
+      provider = args?.providerPath || await resolvePath(`${SchemaOrgPkg}/${args?.full ? 'full' : 'simple'}`)
+      runtime = args?.runtimePath || await resolvePath(`${SchemaOrgPkg}/runtime`)
+    }
+    paths = {
+      pkgDir,
+      provider,
+      runtime,
+    }
+    return paths
+  }
+
   return {
     name: '@vueuse/schema-org:aliases',
     enforce: 'pre',
+    async buildStart() {
+      await fetchPaths()
+    },
+    transformInclude(id) {
+      if (id.startsWith(join(paths.pkgDir, 'runtime')))
+        return true
+      for (const p of args?.transformPaths || []) {
+        if (id.startsWith(p))
+          return true
+      }
+      return false
+    },
+    transform(code) {
+      // swap out aliases for real paths
+      const s = new MagicString(code)
+      s.replace('#vueuse/schema-org/provider', paths.provider)
+      s.replace('#vueuse/schema-org/runtime', paths.runtime)
+
+      return {
+        code: s.toString(),
+        map: s.generateMap(),
+      }
+    },
     vite: {
       async config(config, ctx) {
+        const { pkgDir, provider, runtime } = await fetchPaths()
+
         config.resolve = config.resolve || {}
         config.resolve.alias = config.resolve.alias || {}
-        args = args || {}
 
         if (typeof args.mock === 'undefined')
           args.mock = !ctx.ssrBuild
-
-        const SchemaOrgPkg = '@vueuse/schema-org'
         // avoid unwanted behavior with different package managers
-
         // @ts-expect-error untyped
-        config.resolve.alias[SchemaOrgPkg] = dirname(await resolvePath(SchemaOrgPkg))
-
-        if (args?.mock) {
-          const mockPath = await resolvePath(`${SchemaOrgPkg}/runtime/mock`)
-          // @ts-expect-error untyped
-          config.resolve.alias['#vueuse/schema-org/provider'] = mockPath
-          // @ts-expect-error untyped
-          config.resolve.alias['#vueuse/schema-org/runtime'] = mockPath
-        }
-        else {
-          // @ts-expect-error untyped
-          config.resolve.alias['#vueuse/schema-org/provider'] = await resolvePath(`${SchemaOrgPkg}/${args?.full ? 'full' : 'simple'}`)
-          // @ts-expect-error untyped
-          config.resolve.alias['#vueuse/schema-org/runtime'] = await resolvePath(`${SchemaOrgPkg}/runtime`)
-        }
+        config.resolve.alias[SchemaOrgPkg] = pkgDir
+        // @ts-expect-error untyped
+        config.resolve.alias['#vueuse/schema-org/provider'] = provider
+        // @ts-expect-error untyped
+        config.resolve.alias['#vueuse/schema-org/runtime'] = runtime
+        return config
       },
     },
   }