vite-import-maps 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# vite-plugin-native-import-maps
+
+## 0.1.2
+
+### Patch Changes
+
+- 2490e79: Improve importMapHtmlTransformer signature
+
+## 0.1.1
+
+### Patch Changes
+
+- 9bd2ce2: Fix missing types in published package
+
+## 0.1.0
+
+### Minor Changes
+
+- d8d4a14: Add support for vite7. SSR improvements
+- 9f40567: Add support for import maps `integrity` field
+
+## 0.0.4
+
+### Patch Changes
+
+- 4016f08: add support to output import maps as a file
+- 91389f1: Add `virtual-modules` strategy in build mode. Add support to local entries as import maps
+
+## 0.0.3
+
+### Patch Changes
+
+- add repository information to npm
+
+## 0.0.2
+
+### Patch Changes
+
+- publish dist folder
+
+## 0.0.1
+
+### Patch Changes
+
+- ac41be4: First release

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Riccardo Perra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,343 @@
+<h1 align="center">vite-import-maps</h1>
+<br/>
+<p align="center">
+  <a href="https://npmjs.com/package/vite-plugin-native-import-maps"><img src="https://img.shields.io/npm/v/vite-plugin-native-import-maps.svg" alt="npm package"></a>
+  <a href="https://github.com/riccardoperra/vite-plugin-import-maps/actions/workflows/ci.yml"><img src="https://github.com/riccardoperra/vite-plugin-import-maps/actions/workflows/release.yml/badge.svg?branch=main" alt="build status"></a>
+</p>
+
+A Vite plugin that generates and keeps **browser import maps** in sync with your Vite dev server and production build.
+
+It's aimed at **micro-frontends**, **plugin systems**, and any setup where you load ESM modules at runtime and want to:
+
+- Share dependencies (React, Solid, etc.) **without relying on CDNs**
+- Avoid bundling multiple copies of the same library
+- Expose npm packages or **your own local entry modules** through an import map
+- Keep **remote modules truly "native"**: remotes can be plain ESM files **without requiring you** to setup build step or use other plugins.
+
+---
+
+## Table of Contents
+
+- [Install](#install)
+- [Setup](#setup)
+- [Configuration](#configuration)
+- [Do You Need This Plugin?](#do-you-need-this-plugin)
+- [Recipes](#recipes)
+- [Troubleshooting](#troubleshooting)
+- [How It Works](#how-it-works)
+- [Examples](#examples)
+- [License](#license)
+
+---
+
+## Install
+
+```shell
+# pnpm
+pnpm i -D vite-import-maps
+
+# npm
+npm i -D vite-import-maps
+
+# yarn
+yarn add -D vite-import-maps
+```
+
+## Setup
+
+```ts
+import { defineConfig } from "vite";
+import { vitePluginNativeImportMaps } from "vite-plugin-native-import-maps";
+
+// Host app configuration
+export default defineConfig({
+  plugins: [
+    vitePluginNativeImportMaps({
+      // Add SRI hashes to verify module integrity in build
+      integrity: 'sha-384',
+      log: true,
+      imports: [
+        // Wanna expose react with import maps?
+        "react",
+        "react-dom",
+        // Expose a custom/local entry under a public specifier
+        { name: "react/jsx-runtime", entry: "./src/custom-jsx-runtime.ts" },
+        { name: "my-app-shared-lib", entry: "./src/my-app-shared-oib.ts" },
+      ],
+    }),
+  ],
+});
+```
+
+---
+
+## Configuration
+
+### Options
+
+- `imports` — List of modules to expose via the import map. Each entry can be a string (the specifier to expose, e.g.
+  `"react"`) or an object with `name` (the specifier), `entry` (the local path or package to resolve), and optionally
+  `integrity` (enable SRI hash).
+
+- `modulesOutDir` — Directory prefix for emitted shared chunks in production. Defaults to `""` (root of output
+  directory).
+
+- `integrity` —
+  Enable [Subresource Integrity](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script/type/importmap#integrity_metadata_map)
+  for all shared dependencies. Set to `true`, `"sha256"`, `"sha384"`, or `"sha512"`. This adds an `integrity` map to the
+  import map so browsers can verify module contents. Can also be configured per-dependency via the object form in
+  `imports`.
+
+- `log` — Enable debug logging. Defaults to `false`.
+
+- `injectImportMapsToHtml` — Automatically inject a `<script type="importmap">` into the HTML `<head>`. Defaults to
+  `true`. Set to `false` for SSR apps and use the `virtual:importmap` module instead.
+
+- `importMapHtmlTransformer` — A function to transform the resolved `imports` object before injecting into HTML. Useful
+  for adding a base path prefix, rewriting URLs to a CDN, or filtering entries.
+
+- `outputAsFile` — Emit the import map as a standalone JSON file. Set to `true` for `/import-map.json`, or provide a
+  custom name (e.g. `"my-map"` → `/my-map.json`). The file is served by Vite in dev and emitted as an asset in build.
+
+---
+
+## Do You Need This Plugin?
+
+If you're considering [import maps](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap),
+you're likely building one of the following:
+
+- **Micro-frontend architecture** — A host app loads remote modules at runtime, and all parts need to share the same dependency instances (React, Solid, etc.)
+- **Plugin system** — Your app dynamically loads user-provided or third-party modules that rely on shared libraries
+- **Self-hosted dependency sharing** — You want to share dependencies across apps without relying on external CDN services like esm.sh or jspm.io
+
+### Why Not Third-Party Services?
+
+Services like [esm.sh](https://esm.sh) or [jspm.io](https://jspm.io) are convenient, but they come with trade-offs:
+
+- **External dependency** — Your app relies on a third-party service you don't control. If it goes down or changes, your app breaks.
+- **Network restrictions** — Many corporate environments, VPNs, and air-gapped networks block connections to public services. Your app simply won't work.
+- **Version alignment** — Ensuring host and remotes use the exact same dependency version from an external source can be error-prone.
+- **Limited flexibility** — You can't easily expose modified builds, subsets of exports, or local wrapper modules.
+
+With this plugin, **your host app becomes the source of truth**. Shared dependencies are built and served from your own infrastructure.
+
+### Why This Plugin?
+
+**Works in both development and production**
+
+Most import map solutions only work at build time. This plugin keeps the import map in sync with Vite's dev server _and_ production builds. During development, it resolves to Vite's optimized deps; in production, it points to the correct hashed chunk filenames. No manual updates, no mismatches.
+
+**No build step required for remotes**
+
+Remote modules can be plain ESM files—no bundler, no plugins, no special conventions. They just `import "your-lib"` and the browser resolves it via the import map provided by the host.
+
+**Single dependency instance**
+
+Host and all remotes share the exact same module instances.
+
+**Full control over what you share**
+
+Expose npm packages as-is, or provide custom wrapper modules, modified builds, or local files. You decide exactly what each specifier resolves to.
+
+> **Note:** If a remote _does_ use a bundler, shared dependencies must be marked as **external**.
+> Otherwise the remote bundles its own copy and you lose the single-instance benefit.
+
+Import maps are simple in concept, but keeping them in sync with your build is tedious:
+
+- In dev, Vite serves optimized deps from `node_modules/.vite/deps` with cache-busting hashes
+- In production, chunks have content hashes in their filenames
+- Manually updating the import map every time something changes is error-prone
+
+This plugin handles all of that. You declare what to share, and it generates the correct import map for both dev and build—automatically.
+
+**Example output:**
+
+```html
+<script type="importmap">
+  {
+    "imports": {
+      "react": "/shared/react-DyndEn3u.js",
+      "react/jsx-runtime": "/shared/react_jsx-runtime-CAvv468t.js"
+    }
+  }
+</script>
+```
+
+---
+
+## Recipes
+
+### Expose Local Entry Points (Custom ESM Wrappers)
+
+Expose a local file that re-exports a dependency, giving you full control over what gets shared:
+
+```ts
+vitePluginNativeImportMaps({
+  imports: [
+    { name: "react", entry: "./src/react-esm.ts" },
+    { name: "react/jsx-runtime", entry: "./src/react-jsx-runtime.ts" },
+    "react-dom",
+  ],
+  modulesOutDir: "shared",
+});
+```
+
+---
+
+### Enable Integrity Checks
+
+Add SRI hashes to verify module integrity:
+
+```ts
+vitePluginNativeImportMaps({
+  imports: ["react", "react-dom"],
+  integrity: "sha384", // applies to all
+});
+
+// Or per-dependency:
+vitePluginNativeImportMaps({
+  imports: [
+    { name: "react", entry: "react", integrity: "sha384" },
+    { name: "react-dom", entry: "react-dom", integrity: false },
+  ],
+});
+```
+
+---
+
+### Mark Shared Deps as `external` in Remote Builds
+
+If a remote module uses a bundler, configure shared dependencies as `external` to prevent bundling them:
+
+**tsdown example:**
+
+```ts
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  external: ["react", "react-dom", "react/jsx-runtime"],
+});
+```
+
+**Vite (library mode) example:**
+
+```ts
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: "./src/index.ts",
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: ["react", "react-dom", "react/jsx-runtime"],
+    },
+  },
+});
+```
+
+---
+
+### Serve Import Map as JSON File
+
+```ts
+vitePluginNativeImportMaps({
+  imports: ["react"],
+  outputAsFile: true, // /import-map.json
+});
+```
+
+---
+
+## Troubleshooting
+
+### SSR App Doesn't Show the Import Map
+
+Set `injectImportMapsToHtml: false` and inject the import map yourself using `virtual:importmap`:
+
+```ts
+import importMap from "virtual:importmap";
+// Inject into your SSR HTML template
+```
+
+---
+
+### Specifier Resolves to the Wrong Module
+
+Ensure the specifier matches exactly what your code imports:
+
+- `react/jsx-runtime` ≠ `react`
+- `solid-js/web` ≠ `solid-js`
+
+---
+
+### Import Maps Not Supported in Target Browser
+
+Import maps require modern browsers. For broader support, use a polyfill
+like [es-module-shims](https://github.com/guybedford/es-module-shims).
+
+See the example: [`./examples/react-host-es-module-shims`](./examples/react-host-es-module-shims)
+
+### Integrate with es-module-shims (dynamic import maps)
+
+You can integrate this plugin with **es-module-shims** in two common ways depending on how you want import maps applied at runtime:
+
+- **Apply import maps dynamically at runtime** — If you prefer the plugin to emit a JSON file (use `outputAsFile: true`) or to use the `virtual:importmap` module, you can fetch or import the map and pass it to the es-module-shims runtime via the global `importShim` API (it exposes helpers like `addImportMap` and `import`).
+
+  ```ts
+  import "es-module-shims";
+
+  // When using outputAsFile: true (e.g. /import-map.json)
+  fetch("/import-map.json")
+    .then((r) => r.json())
+    .then((map) => importShim.addImportMap(map))
+    .then(() => importShim.import("/your/entry.js"));
+  ```
+
+  Example (virtual module):
+
+  ```js
+  import "es-module-shims";
+  import importMap from "virtual:importmap";
+
+  importShim.addImportMap(importMap).then(() => {
+    // now safe to dynamically import shimmed modules
+  });
+  ```
+
+---
+
+## How It Works
+
+1. **Collects** the `shared` entries from your config
+2. **In dev:** Resolves corresponding Vite dev-server URLs
+3. **In build:** Adds extra Rollup inputs so shared deps get dedicated output chunks, then records the final chunk URLs
+4. **Exposes** the mapping via:
+   - HTML injection (optional)
+   - `virtual:importmap` module (always)
+   - JSON file (optional)
+
+**Build snapshot:**
+
+- [`./test/fixture/basic`](./test/fixture/basic)
+- [`./test/__snapshot__/build-project-with-right-import-maps`](./test/__snapshot__/build-project-with-right-import-maps)
+
+---
+
+## Examples
+
+| Example                                                               | Description                              |
+| --------------------------------------------------------------------- | ---------------------------------------- |
+| [`solidjs-host`](./examples/solidjs-host)                             | Solid.js host app                        |
+| [`solidjs-remote-counter`](./examples/solidjs-remote-counter)         | Solid.js remote module                   |
+| [`react-host-custom`](./examples/react-host-custom)                   | React host with custom ESM wrappers      |
+| [`react-host-es-module-shims`](./examples/react-host-es-module-shims) | React host with es-module-shims polyfill |
+| [`react-remote-counter`](./examples/react-remote-counter)             | React remote module                      |
+| [`react-tanstack-start-ssr`](./examples/react-tanstack-start-ssr)     | SSR example with TanStack Start          |
+
+---
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/dist/index.d.mts

@@ -0,0 +1,125 @@
+import { Plugin } from "vite";
+
+//#region src/store.d.ts
+interface RegisteredDependency {
+  packageName: string;
+  url: string;
+  integrity?: string;
+}
+interface NormalizedDependencyInput {
+  name: string;
+  entry: string;
+  localFile: boolean;
+  integrity: DependencyIntegrityCheck | boolean;
+}
+declare class VitePluginImportMapsStore {
+  readonly defaultIntegrity: boolean | DependencyIntegrityCheck;
+  readonly sharedDependencies: ReadonlyArray<NormalizedDependencyInput>;
+  readonly modulesOutDir: string;
+  readonly log: boolean;
+  readonly importMapHtmlTransformer: ImportMapTransformerFn;
+  readonly importMapDependencies: Map<string, RegisteredDependency>;
+  readonly inputs: Array<ImportMapBuildChunkEntrypoint>;
+  constructor(options: VitePluginImportMapsConfig);
+  private normalizeDependencyInput;
+  clearDependencies(): void;
+  addDependency(dependency: RegisteredDependency): void;
+  getNormalizedDependencyName(dependency: string): string;
+  getEntrypointPath(entrypoint: string): string;
+  addInput(input: NormalizedDependencyInput): ImportMapBuildChunkEntrypoint;
+  getImportMapAsJson(): Record<string, any>;
+}
+interface ImportMapBuildChunkEntrypoint {
+  originalDependencyName: string;
+  normalizedDependencyName: string;
+  entrypoint: string;
+  idToResolve: string;
+  localFile: boolean;
+  integrity: DependencyIntegrityCheck | boolean;
+}
+//#endregion
+//#region src/config.d.ts
+interface ImportMapSignature {
+  /**
+  * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script/type/importmap#imports
+  */
+  imports?: Record<string, any>;
+  /**
+  * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script/type/importmap#integrity
+  */
+  integrity?: Record<string, string>;
+  /**
+  * @see @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script/type/importmap#scopes
+  */
+  scopes?: Record<string, any>;
+}
+type ImportMapTransformerFn = (importMap: ImportMapSignature, meta: {
+  entries: Map<string, RegisteredDependency>;
+  store: VitePluginImportMapsStore;
+}) => ImportMapSignature;
+type DependencyIntegrityCheck = "sha256" | "sha384" | "sha512";
+interface SharedDependencyObjectConfig {
+  /**
+  * The name of the dependency that will be resolved
+  */
+  name: string;
+  /**
+  * Local path to the entry file, or the dependency name (e.g., react)
+  */
+  entry: string;
+  /**
+  * Enable integrity check for the dependency (only in build)
+  *
+  * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script/type/importmap#integrity_metadata_map
+  */
+  integrity?: boolean | DependencyIntegrityCheck;
+}
+type SharedDependencyConfig = Array<string | SharedDependencyObjectConfig>;
+interface VitePluginImportMapsConfig {
+  /**
+  * Dependencies shared by modules
+  */
+  imports: SharedDependencyConfig;
+  /**
+  * Directory where the shared chunks are stored
+  *
+  * @default ""
+  */
+  modulesOutDir?: string;
+  /**
+  * Default `integrity` value for entries.
+  * Can be customized per dependency through {@link SharedDependencyObjectConfig#integrity}
+  *
+  * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script/type/importmap#integrity_metadata_map
+  */
+  integrity?: boolean | DependencyIntegrityCheck;
+  /**
+  * Enable logging
+  */
+  log?: boolean;
+  /**
+  * Whether to inject the import map in to the main HTML file. Defaults to true.
+  *
+  * NOTE: You probably have to set `false` in apps with SSR enabled,
+  * and use the `virtual:importmap` dynamic import instead.
+  */
+  injectImportMapsToHtml?: boolean;
+  /**
+  * Transform the resolved import map `imports` before writing it to the HTML file
+  */
+  importMapHtmlTransformer?: ImportMapTransformerFn;
+  /**
+  * Whether to generate an import file.
+  *
+  * If a string is provided, it will be used as the output file name. Default as 'import-map.json'.
+  *
+  * Output file will be generated in the root directory of your generated bundle and will be
+  * available also in development mode via the Vite Dev Server.
+  */
+  outputAsFile?: boolean | string;
+}
+//#endregion
+//#region src/index.d.ts
+declare function vitePluginNativeImportMaps(options: VitePluginImportMapsConfig): Array<Plugin>;
+//#endregion
+export { vitePluginNativeImportMaps };

package/dist/index.mjs

@@ -0,0 +1,364 @@
+import path from "node:path";
+import { normalizePath } from "vite";
+import { createHash } from "node:crypto";
+
+//#region src/utils.ts
+/**
+* Normalize a dependency name to be used as an entrypoint input
+*
+* @example
+* ```
+* @scope/package-name -> @scope_package-name
+* package-name/sub-entrypoint -> package-name_sub-entrypoint
+* ```
+*/
+function normalizeDependencyName(dep) {
+	return dep.replace(/\//g, "_");
+}
+/**
+* Prefix for resolved fs paths, since windows paths may not be valid as URLs.
+*
+* @see https://github.com/vitejs/vite/blob/fd38d076fe2455aac1e00a7b15cd51159bf12bb5/packages/vite/src/node/constants.ts#L108
+*/
+const FS_PREFIX = `/@fs/`;
+function fileToUrl(file, root) {
+	const url = path.relative(root, file);
+	if (url[0] === ".") return path.posix.join(FS_PREFIX, normalizePath(file));
+	return "/" + normalizePath(url);
+}
+
+//#endregion
+//#region src/store.ts
+var VitePluginImportMapsStore = class {
+	defaultIntegrity;
+	sharedDependencies = [];
+	modulesOutDir = "";
+	log;
+	importMapHtmlTransformer = (importMap) => importMap;
+	importMapDependencies = /* @__PURE__ */ new Map();
+	inputs = [];
+	constructor(options) {
+		this.defaultIntegrity = options.integrity || false;
+		this.sharedDependencies = [...options.imports.map(this.normalizeDependencyInput)];
+		this.log = options.log || false;
+		if (options.modulesOutDir) this.modulesOutDir = options.modulesOutDir;
+		if (options.importMapHtmlTransformer) this.importMapHtmlTransformer = options.importMapHtmlTransformer;
+	}
+	normalizeDependencyInput = (entry) => {
+		if (typeof entry === "string") return {
+			name: entry,
+			entry,
+			localFile: false,
+			integrity: this.defaultIntegrity
+		};
+		return {
+			name: entry.name,
+			entry: entry.entry,
+			localFile: entry.entry.startsWith("./") || entry.entry.startsWith("../"),
+			integrity: entry.integrity ?? this.defaultIntegrity
+		};
+	};
+	clearDependencies() {
+		this.importMapDependencies.clear();
+	}
+	addDependency(dependency) {
+		this.importMapDependencies.set(dependency.packageName, dependency);
+	}
+	getNormalizedDependencyName(dependency) {
+		return normalizeDependencyName(dependency);
+	}
+	getEntrypointPath(entrypoint) {
+		return path.join(this.modulesOutDir, entrypoint);
+	}
+	addInput(input) {
+		const dependency = input.name;
+		const normalizedDepName = this.getNormalizedDependencyName(dependency);
+		const meta = {
+			originalDependencyName: dependency,
+			entrypoint: this.getEntrypointPath(normalizedDepName),
+			normalizedDependencyName: normalizedDepName,
+			idToResolve: input.entry,
+			localFile: input.localFile,
+			integrity: input.integrity
+		};
+		this.inputs.push(meta);
+		return meta;
+	}
+	getImportMapAsJson() {
+		const imports = {};
+		const integrity = {};
+		this.importMapDependencies.forEach((dep) => {
+			imports[dep.packageName] = dep.url;
+			if (dep.integrity) integrity[dep.url] = dep.integrity;
+		});
+		const importMap = { imports };
+		if (Object.keys(integrity).length > 0) importMap.integrity = integrity;
+		return this.importMapHtmlTransformer(importMap, {
+			store: this,
+			entries: this.importMapDependencies
+		});
+	}
+};
+
+//#endregion
+//#region src/config.ts
+const PLUGIN_NAME = "vite-plugin-import-maps";
+function pluginName(name) {
+	return `${PLUGIN_NAME}:${name}`;
+}
+
+//#endregion
+//#region src/build-only/virtual-chunk-resolver.ts
+const VIRTUAL_ID_PREFIX = `\0virtual:import-map-chunk`;
+function getVirtualFileName(name) {
+	return `${VIRTUAL_ID_PREFIX}/${name}`;
+}
+function virtualChunksResolverPlugin(store) {
+	return {
+		name: pluginName("build:virtual-chunks-loader"),
+		apply: "build",
+		resolveId(id) {
+			if (this.environment.name === "ssr") return;
+			if (id.startsWith(VIRTUAL_ID_PREFIX)) {
+				const normalizedId = id.slice(VIRTUAL_ID_PREFIX.length + 1);
+				return {
+					id,
+					meta: { info: store.inputs.find((input) => input.normalizedDependencyName === normalizedId) }
+				};
+			}
+		},
+		async load(id) {
+			if (this.environment.name === "ssr") return;
+			if (!id.startsWith(VIRTUAL_ID_PREFIX)) return;
+			const virtualModuleInfo = this.getModuleInfo(id);
+			if (!virtualModuleInfo) return;
+			const chunk = virtualModuleInfo.meta["info"];
+			const resolvedId = await this.resolve(chunk.idToResolve);
+			if (!resolvedId) return;
+			let hasDefaultExport = false;
+			const [fileName] = resolvedId.id.split("?");
+			const moduleInfo = this.getModuleInfo(fileName);
+			if (moduleInfo) {
+				hasDefaultExport = moduleInfo.hasDefaultExport ?? false;
+				if (!hasDefaultExport) {
+					if ("commonjs" in moduleInfo.meta && moduleInfo.meta.commonjs.isCommonJS) {
+						const requires = moduleInfo.meta.commonjs.requires;
+						if (Array.isArray(requires)) {
+							for (const require of requires) if (require.resolved) {
+								const innerResolvedId = this.getModuleInfo(require.resolved.id);
+								if (!innerResolvedId) break;
+								hasDefaultExport = innerResolvedId.hasDefaultExport || false;
+								if (hasDefaultExport) break;
+								if (innerResolvedId.exports?.includes("__require")) {
+									hasDefaultExport = true;
+									break;
+								}
+							}
+						}
+					}
+				}
+			}
+			let code = `export * from "${chunk.originalDependencyName}"`;
+			if (hasDefaultExport) code += `\nexport { default } from '${chunk.originalDependencyName}'`;
+			return {
+				moduleSideEffects: "no-treeshake",
+				code
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/build-only/virtual-chunk-generator.ts
+function virtualChunksGeneratorPlugin(store) {
+	const name = pluginName("build:virtual");
+	const virtualModules = /* @__PURE__ */ new Map();
+	const localModules = /* @__PURE__ */ new Map();
+	let config;
+	return {
+		name,
+		apply: "build",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		buildStart() {
+			for (const input of store.inputs) if (input.localFile) {
+				const id = path.resolve(input.idToResolve);
+				if (!localModules.has(id)) this.emitFile({
+					type: "chunk",
+					name: input.entrypoint,
+					id,
+					preserveSignature: "strict"
+				});
+				localModules.set(id, input);
+			} else {
+				const id = getVirtualFileName(input.normalizedDependencyName);
+				if (!virtualModules.has(id)) this.emitFile({
+					type: "chunk",
+					name: input.entrypoint,
+					id,
+					preserveSignature: "strict"
+				});
+				virtualModules.set(id, input);
+			}
+		},
+		generateBundle(_, bundle) {
+			store.clearDependencies();
+			const keys = Object.keys(bundle);
+			for (const key of keys) {
+				const entry = bundle[key];
+				if (entry.type !== "chunk") continue;
+				const handledModules = new Map([...virtualModules.entries(), ...localModules.entries()]);
+				if (entry.facadeModuleId && (entry.facadeModuleId.startsWith(VIRTUAL_ID_PREFIX) || path.isAbsolute(entry.facadeModuleId))) {
+					const entryImportMap = handledModules.get(entry.facadeModuleId);
+					if (!entryImportMap) continue;
+					entry.isEntry = false;
+					let integrity;
+					if (entryImportMap.integrity !== false) {
+						const algorithm = typeof entryImportMap.integrity === "string" ? entryImportMap.integrity : "sha384";
+						integrity = `${algorithm}-${createHash(algorithm).update(entry.code).digest("base64")}`;
+					}
+					const url = `./${entry.fileName}`, packageName = entryImportMap.originalDependencyName;
+					store.addDependency({
+						url,
+						packageName,
+						integrity
+					});
+					store.log && config.logger.info(`[${name}] Added ${packageName}: ${url}`, { timestamp: true });
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build-only/build-plugin.ts
+function pluginImportMapsBuildEnv(store) {
+	const plugins = [];
+	for (const dep of store.sharedDependencies) store.addInput(dep);
+	plugins.push(virtualChunksGeneratorPlugin(store));
+	plugins.push(virtualChunksResolverPlugin(store));
+	return plugins;
+}
+
+//#endregion
+//#region src/import-map-html.ts
+function pluginImportMapsInject(store) {
+	return {
+		name: pluginName("inject-html-import-map"),
+		transformIndexHtml(source) {
+			const importMap = store.getImportMapAsJson();
+			return {
+				html: source,
+				tags: [{
+					tag: "script",
+					attrs: { type: "importmap" },
+					children: JSON.stringify(importMap),
+					injectTo: "head-prepend"
+				}]
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/dev/dev-plugin.ts
+function pluginImportMapsDevelopmentEnv(store) {
+	const name = pluginName("development");
+	let latestBrowserHash = void 0;
+	let cachedResolvedModules = [];
+	return {
+		name,
+		apply: "serve",
+		async transformIndexHtml(_, { server }) {
+			if (!server) return;
+			const { pluginContainer, config } = server, devOptimizer = server.environments["client"].depsOptimizer;
+			let resolvedModules;
+			if (devOptimizer.metadata.browserHash === latestBrowserHash) resolvedModules = cachedResolvedModules;
+			else resolvedModules = (await Promise.all(store.sharedDependencies.map(async (dependency) => {
+				const resolvedId = await pluginContainer.resolveId(dependency.entry);
+				if (!resolvedId) return null;
+				const path = fileToUrl(resolvedId.id, config.root);
+				store.log && server.config.logger.info(`[${name}] Added ${dependency.entry}: ${path}`, { timestamp: true });
+				return {
+					name: dependency.name,
+					path
+				};
+			}))).filter((value) => !!value);
+			cachedResolvedModules = resolvedModules;
+			latestBrowserHash = devOptimizer.metadata.browserHash;
+			for (const { path: url, name: packageName } of resolvedModules) store.addDependency({
+				packageName,
+				url
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/import-map-file.ts
+function pluginImportMapsAsFile(store, options) {
+	const { name = "import-map" } = options;
+	return {
+		name: pluginName("import-maps-as-file"),
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				if (req.url === `/${name}.json`) {
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify(store.getImportMapAsJson()));
+				} else next();
+			});
+		},
+		generateBundle() {
+			const json = store.getImportMapAsJson();
+			this.emitFile({
+				type: "asset",
+				fileName: `/${name}.json`,
+				source: JSON.stringify(json, null, 2)
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/import-map-module.ts
+const virtualImportMapId = "virtual:importmap";
+const resolvedVirtualImportMapId = "\0" + virtualImportMapId;
+function pluginImportMapsAsModule(store) {
+	return {
+		name: pluginName("virtual-module-import-map"),
+		resolveId(id) {
+			if (id === virtualImportMapId) return resolvedVirtualImportMapId;
+		},
+		load(id) {
+			if (id === resolvedVirtualImportMapId) {
+				const content = JSON.stringify(store.getImportMapAsJson());
+				return `
+          export const importMapRaw = '${content}';
+          export const importMap = ${content};
+          export default importMap;
+        `;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+function vitePluginNativeImportMaps(options) {
+	const { injectImportMapsToHtml = true, outputAsFile } = options;
+	const plugins = [];
+	const store = new VitePluginImportMapsStore(options);
+	plugins.push(...pluginImportMapsBuildEnv(store));
+	plugins.push(pluginImportMapsDevelopmentEnv(store));
+	if (injectImportMapsToHtml) plugins.push(pluginImportMapsInject(store));
+	plugins.push(pluginImportMapsAsModule(store));
+	if (outputAsFile) {
+		const name = typeof outputAsFile === "string" ? outputAsFile : void 0;
+		plugins.push(pluginImportMapsAsFile(store, { name }));
+	}
+	return plugins;
+}
+
+//#endregion
+export { vitePluginNativeImportMaps };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "vite-import-maps",
+  "version": "0.1.2",
+  "description": "A Vite plugin that manages import maps for shared dependencies in your Vite applications.",
+  "main": "./dist/index.mjs",
+  "module ": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "import-maps",
+    "mfe",
+    "import maps",
+    "microfrontend",
+    "plugin"
+  ],
+  "repository": "https://github.com/riccardoperra/vite-plugin-import-maps",
+  "homepage": "https://github.com/riccardoperra/vite-plugin-import-maps",
+  "author": {
+    "name": "Riccardo Perra",
+    "email": "riccardo.perra@icloud.com",
+    "url": "https://github.com/riccardoperra"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "vite": "^7.3.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@tanstack/eslint-config": "^0.3.4",
+    "@types/node": "^25.2.0",
+    "eslint": "^9.39.2",
+    "prettier": "^3.8.1",
+    "rollup": "^4.57.1",
+    "tsdown": "^0.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "vite": ">=7.0.0"
+  },
+  "scripts": {
+    "test": "vitest --config ./vitest.config.ts",
+    "build": "tsdown",
+    "format": "prettier --write .",
+    "ci:publish": "changeset publish",
+    "ci:version": "changeset version"
+  }
+}