@ecopages/react 0.2.0-alpha.4 → 0.2.0-alpha.7

package/src/utils/reachability-analyzer.js

@@ -7,7 +7,7 @@ function parserLanguageForFile(filename) {
   if (extension === ".jsx") return "jsx";
   return "js";
 }
-function analyzeReachability(source, filename, program) {
+function analyzeReachability(source, filename, program, explicitlyRequestedExports) {
   let resolvedProgram;
   if (program) {
     resolvedProgram = program;
@@ -114,12 +114,86 @@ function analyzeReachability(source, filename, program) {
       potentialClientRoots.push(node);
     }
   }
+  function getExportedName(specifier) {
+    if (specifier?.exported?.type === "Identifier") return specifier.exported.name;
+    if (typeof specifier?.exported?.value === "string") return specifier.exported.value;
+    if (specifier?.local?.type === "Identifier") return specifier.local.name;
+    if (typeof specifier?.local?.value === "string") return specifier.local.value;
+    return void 0;
+  }
+  function getReexportedImportName(specifier) {
+    if (specifier?.local?.type === "Identifier") return specifier.local.name;
+    if (typeof specifier?.local?.value === "string") return specifier.local.value;
+    if (specifier?.imported?.type === "Identifier") return specifier.imported.name;
+    if (typeof specifier?.imported?.value === "string") return specifier.imported.value;
+    return getExportedName(specifier);
+  }
+  function getLocalExportName(specifier) {
+    if (specifier?.local?.type === "Identifier") return specifier.local.name;
+    if (typeof specifier?.local?.value === "string") return specifier.local.value;
+    return void 0;
+  }
+  function isExplicitlyRequestedExport(name) {
+    if (explicitlyRequestedExports === "*") return true;
+    return explicitlyRequestedExports?.has(name) ?? false;
+  }
   let isFallbackRoots = false;
   if (potentialClientRoots.length === 0) {
-    isFallbackRoots = true;
-    for (const node of resolvedProgram.body) {
-      if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
-        potentialClientRoots.push(node);
+    if (explicitlyRequestedExports) {
+      for (const node of resolvedProgram.body) {
+        if (node.type === "ExportNamedDeclaration") {
+          const exportNode = node;
+          if (exportNode.source && exportNode.specifiers?.length) {
+            const hasRequestedReexport = exportNode.specifiers.some((specifier) => {
+              const exportedName = getExportedName(specifier);
+              return exportedName ? isExplicitlyRequestedExport(exportedName) : false;
+            });
+            if (hasRequestedReexport) {
+              potentialClientRoots.push(node);
+            }
+            continue;
+          }
+          if (exportNode.declaration?.type === "FunctionDeclaration" || exportNode.declaration?.type === "ClassDeclaration") {
+            const declarationName = exportNode.declaration.id?.name;
+            if (declarationName && isExplicitlyRequestedExport(declarationName)) {
+              potentialClientRoots.push(node);
+            }
+            continue;
+          }
+          if (exportNode.declaration?.type === "VariableDeclaration") {
+            const hasRequestedDeclaration = exportNode.declaration.declarations.some(
+              (declaration) => declaration.id?.type === "Identifier" && isExplicitlyRequestedExport(declaration.id.name)
+            );
+            if (hasRequestedDeclaration) {
+              potentialClientRoots.push(node);
+            }
+            continue;
+          }
+          if (exportNode.specifiers?.length) {
+            const hasRequestedSpecifier = exportNode.specifiers.some((specifier) => {
+              const exportedName = getExportedName(specifier);
+              return exportedName ? isExplicitlyRequestedExport(exportedName) : false;
+            });
+            if (hasRequestedSpecifier) {
+              potentialClientRoots.push(node);
+            }
+          }
+        } else if (node.type === "ExportDefaultDeclaration") {
+          if (isExplicitlyRequestedExport("default")) {
+            potentialClientRoots.push(node);
+          }
+        } else if (node.type === "ExportAllDeclaration") {
+          if (explicitlyRequestedExports === "*") {
+            potentialClientRoots.push(node);
+          }
+        }
+      }
+    } else {
+      isFallbackRoots = true;
+      for (const node of resolvedProgram.body) {
+        if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
+          potentialClientRoots.push(node);
+        }
       }
     }
   }
@@ -167,6 +241,28 @@ function analyzeReachability(source, filename, program) {
       markImportReachable(node.source.value, "*");
       return;
     }
+    if (node.type === "ExportNamedDeclaration" && typeof node.source?.value === "string") {
+      for (const specifier of node.specifiers ?? []) {
+        const importedName = getReexportedImportName(specifier);
+        if (importedName) {
+          markImportReachable(node.source.value, importedName);
+        }
+      }
+      return;
+    }
+    if (node.type === "ExportNamedDeclaration" && !node.source && explicitlyRequestedExports && node.specifiers?.length) {
+      for (const specifier of node.specifiers) {
+        const exportedName = getExportedName(specifier);
+        if (!exportedName || !isExplicitlyRequestedExport(exportedName)) {
+          continue;
+        }
+        const localName = getLocalExportName(specifier);
+        if (localName && !currentScope.has(localName)) {
+          checkIdentifier(localName);
+        }
+      }
+      return;
+    }
     if (node.type === "Identifier" || node.type === "JSXIdentifier" && /^[A-Z]/.test(node.name)) {
       if (!currentScope.has(node.name)) {
         checkIdentifier(node.name);

package/src/utils/reachability-analyzer.ts

@@ -58,6 +58,16 @@ export type ReachabilityResult = {
 	analyzed: boolean;
 };
 
+/**
+ * Optional export filter supplied by the client graph boundary when a local
+ * module is imported through a narrower named-export surface.
+ *
+ * `'*'` means the whole module namespace is considered reachable, while a
+ * `Set` restricts analysis to the named exports that are actually requested by
+ * downstream client-reachable modules.
+ */
+type ExplicitlyRequestedExports = Set<string> | '*';
+
 /**
  * Analyzes a module using Oxc AST and extracts a strict reachability graph
  * starting from client roots (`render`, `errorBoundary`, `loadingFallback` of `eco.page` or `eco.component`).
@@ -66,11 +76,14 @@ export type ReachabilityResult = {
  * @param filename - Absolute or relative path to the module file.
  * @param program - Optional pre-parsed Oxc program AST. When supplied, the
  *   internal `parseSync` call is skipped entirely (avoids double-parsing).
+ * @param explicitlyRequestedExports - Optional named export filter propagated
+ *   from a downstream importer when this module is only partially reachable.
  */
 export function analyzeReachability(
 	source: string,
 	filename: string,
 	program?: ReturnType<typeof parseSync>['program'],
+	explicitlyRequestedExports?: ExplicitlyRequestedExports,
 ): ReachabilityResult {
 	/**
 	 * AST Resolution
@@ -242,6 +255,57 @@ export function analyzeReachability(
 		}
 	}
 
+	/**
+	 * Resolves the externally visible export name from an export specifier.
+	 *
+	 * @param specifier - Oxc export specifier node.
+	 * @returns The exported binding name when available.
+	 */
+	function getExportedName(specifier: any): string | undefined {
+		if (specifier?.exported?.type === 'Identifier') return specifier.exported.name;
+		if (typeof specifier?.exported?.value === 'string') return specifier.exported.value;
+		if (specifier?.local?.type === 'Identifier') return specifier.local.name;
+		if (typeof specifier?.local?.value === 'string') return specifier.local.value;
+		return undefined;
+	}
+
+	/**
+	 * Resolves the imported binding name represented by a re-export specifier.
+	 *
+	 * @param specifier - Oxc export specifier node.
+	 * @returns The source-module binding name that should be marked reachable.
+	 */
+	function getReexportedImportName(specifier: any): string | undefined {
+		if (specifier?.local?.type === 'Identifier') return specifier.local.name;
+		if (typeof specifier?.local?.value === 'string') return specifier.local.value;
+		if (specifier?.imported?.type === 'Identifier') return specifier.imported.name;
+		if (typeof specifier?.imported?.value === 'string') return specifier.imported.value;
+		return getExportedName(specifier);
+	}
+
+	/**
+	 * Resolves the local identifier used by a local export list entry.
+	 *
+	 * @param specifier - Oxc export specifier node.
+	 * @returns The local symbol name referenced by the export list.
+	 */
+	function getLocalExportName(specifier: any): string | undefined {
+		if (specifier?.local?.type === 'Identifier') return specifier.local.name;
+		if (typeof specifier?.local?.value === 'string') return specifier.local.value;
+		return undefined;
+	}
+
+	/**
+	 * Checks whether a named export is part of the explicitly requested subset.
+	 *
+	 * @param name - Export name to test.
+	 * @returns True when the export should seed or continue traversal.
+	 */
+	function isExplicitlyRequestedExport(name: string): boolean {
+		if (explicitlyRequestedExports === '*') return true;
+		return explicitlyRequestedExports?.has(name) ?? false;
+	}
+
 	/**
 	 * Client root resolution (fallback mode)
 	 *
@@ -255,14 +319,73 @@ export function analyzeReachability(
 	 */
 	let isFallbackRoots = false;
 	if (potentialClientRoots.length === 0) {
-		isFallbackRoots = true;
-		for (const node of resolvedProgram.body) {
-			if (
-				(node as { type: string }).type === 'ExportNamedDeclaration' ||
-				(node as { type: string }).type === 'ExportDefaultDeclaration' ||
-				(node as { type: string }).type === 'ExportAllDeclaration'
-			) {
-				potentialClientRoots.push(node);
+		if (explicitlyRequestedExports) {
+			for (const node of resolvedProgram.body) {
+				if ((node as { type: string }).type === 'ExportNamedDeclaration') {
+					const exportNode = node as any;
+					if (exportNode.source && exportNode.specifiers?.length) {
+						const hasRequestedReexport = exportNode.specifiers.some((specifier: any) => {
+							const exportedName = getExportedName(specifier);
+							return exportedName ? isExplicitlyRequestedExport(exportedName) : false;
+						});
+						if (hasRequestedReexport) {
+							potentialClientRoots.push(node);
+						}
+						continue;
+					}
+
+					if (
+						exportNode.declaration?.type === 'FunctionDeclaration' ||
+						exportNode.declaration?.type === 'ClassDeclaration'
+					) {
+						const declarationName = exportNode.declaration.id?.name;
+						if (declarationName && isExplicitlyRequestedExport(declarationName)) {
+							potentialClientRoots.push(node);
+						}
+						continue;
+					}
+
+					if (exportNode.declaration?.type === 'VariableDeclaration') {
+						const hasRequestedDeclaration = exportNode.declaration.declarations.some(
+							(declaration: any) =>
+								declaration.id?.type === 'Identifier' &&
+								isExplicitlyRequestedExport(declaration.id.name),
+						);
+						if (hasRequestedDeclaration) {
+							potentialClientRoots.push(node);
+						}
+						continue;
+					}
+
+					if (exportNode.specifiers?.length) {
+						const hasRequestedSpecifier = exportNode.specifiers.some((specifier: any) => {
+							const exportedName = getExportedName(specifier);
+							return exportedName ? isExplicitlyRequestedExport(exportedName) : false;
+						});
+						if (hasRequestedSpecifier) {
+							potentialClientRoots.push(node);
+						}
+					}
+				} else if ((node as { type: string }).type === 'ExportDefaultDeclaration') {
+					if (isExplicitlyRequestedExport('default')) {
+						potentialClientRoots.push(node);
+					}
+				} else if ((node as { type: string }).type === 'ExportAllDeclaration') {
+					if (explicitlyRequestedExports === '*') {
+						potentialClientRoots.push(node);
+					}
+				}
+			}
+		} else {
+			isFallbackRoots = true;
+			for (const node of resolvedProgram.body) {
+				if (
+					(node as { type: string }).type === 'ExportNamedDeclaration' ||
+					(node as { type: string }).type === 'ExportDefaultDeclaration' ||
+					(node as { type: string }).type === 'ExportAllDeclaration'
+				) {
+					potentialClientRoots.push(node);
+				}
 			}
 		}
 	}
@@ -353,6 +476,36 @@ export function analyzeReachability(
 			return;
 		}
 
+		if (node.type === 'ExportNamedDeclaration' && typeof node.source?.value === 'string') {
+			for (const specifier of node.specifiers ?? []) {
+				const importedName = getReexportedImportName(specifier);
+				if (importedName) {
+					markImportReachable(node.source.value as string, importedName);
+				}
+			}
+			return;
+		}
+
+		if (
+			node.type === 'ExportNamedDeclaration' &&
+			!node.source &&
+			explicitlyRequestedExports &&
+			node.specifiers?.length
+		) {
+			for (const specifier of node.specifiers) {
+				const exportedName = getExportedName(specifier);
+				if (!exportedName || !isExplicitlyRequestedExport(exportedName)) {
+					continue;
+				}
+
+				const localName = getLocalExportName(specifier);
+				if (localName && !currentScope.has(localName)) {
+					checkIdentifier(localName);
+				}
+			}
+			return;
+		}
+
 		if (node.type === 'Identifier' || (node.type === 'JSXIdentifier' && /^[A-Z]/.test(node.name))) {
 			if (!currentScope.has(node.name)) {
 				checkIdentifier(node.name);

package/src/utils/react-dom-runtime-interop-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
+export declare function createReactDomRuntimeInteropPlugin(options?: {
+    name?: string;
+    reactSpecifier?: string;
+}): EcoBuildPlugin;

package/src/utils/react-dom-runtime-interop-plugin.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+function createReactDomRuntimeInteropPlugin(options) {
+  const reactDomFileFilter = /[\\/]react-dom[\\/].*\.js$/;
+  const reactRequirePattern = /\brequire\((['"])react\1\)/g;
+  const reactSpecifier = options?.reactSpecifier ?? "react";
+  return {
+    name: options?.name ?? "react-dom-runtime-interop",
+    setup(build) {
+      build.onLoad({ filter: reactDomFileFilter }, (args) => {
+        const content = fs.readFileSync(args.path, "utf-8");
+        if (!reactRequirePattern.test(content)) {
+          return void 0;
+        }
+        reactRequirePattern.lastIndex = 0;
+        const rewritten = content.replace(reactRequirePattern, "__ecopages_react_runtime");
+        return {
+          contents: `import * as __ecopages_react_runtime from '${reactSpecifier}';
+${rewritten}`,
+          loader: "js",
+          resolveDir: path.dirname(args.path)
+        };
+      });
+    }
+  };
+}
+export {
+  createReactDomRuntimeInteropPlugin
+};

package/src/utils/react-dom-runtime-interop-plugin.ts

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
+
+export function createReactDomRuntimeInteropPlugin(options?: {
+	name?: string;
+	reactSpecifier?: string;
+}): EcoBuildPlugin {
+	const reactDomFileFilter = /[\\/]react-dom[\\/].*\.js$/;
+	const reactRequirePattern = /\brequire\((['"])react\1\)/g;
+	const reactSpecifier = options?.reactSpecifier ?? 'react';
+
+	return {
+		name: options?.name ?? 'react-dom-runtime-interop',
+		setup(build) {
+			build.onLoad({ filter: reactDomFileFilter }, (args) => {
+				const content = fs.readFileSync(args.path, 'utf-8');
+				if (!reactRequirePattern.test(content)) {
+					return undefined;
+				}
+
+				reactRequirePattern.lastIndex = 0;
+				const rewritten = content.replace(reactRequirePattern, '__ecopages_react_runtime');
+
+				return {
+					contents: `import * as __ecopages_react_runtime from '${reactSpecifier}';\n${rewritten}`,
+					loader: 'js',
+					resolveDir: path.dirname(args.path),
+				};
+			});
+		},
+	};
+}

package/src/utils/react-mdx-loader-plugin.js

@@ -1,11 +1,18 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import { compile } from "@mdx-js/mdx";
-import { SourceMapGenerator } from "source-map";
+import sourceMap from "source-map";
 import { VFile } from "vfile";
+function resolveCompileFormat(filePath, compilerOptions) {
+  const configuredFormat = compilerOptions?.format;
+  if (configuredFormat && configuredFormat !== "detect") {
+    return configuredFormat;
+  }
+  return path.extname(filePath).toLowerCase() === ".md" ? "mdx" : configuredFormat;
+}
 function createReactMdxLoaderPlugin(compilerOptions) {
   const mdxExtensions = compilerOptions?.mdxExtensions ?? [".mdx"];
-  const mdExtensions = compilerOptions?.mdExtensions ?? [".md"];
+  const mdExtensions = compilerOptions?.mdExtensions ?? [];
   const allExtensions = [...mdxExtensions, ...mdExtensions];
   const escapedExts = allExtensions.map((ext) => ext.replace(".", "\\."));
   const filter = new RegExp(`(${escapedExts.join("|")})(\\?.*)?$`);
@@ -18,13 +25,14 @@ function createReactMdxLoaderPlugin(compilerOptions) {
         const file = new VFile({ path: filePath, value: source });
         const compiled = await compile(file, {
           ...compilerOptions,
-          SourceMapGenerator
+          format: resolveCompileFormat(filePath, compilerOptions),
+          SourceMapGenerator: sourceMap.SourceMapGenerator
         });
-        const sourceMap = compiled.map ? `
+        const inlineSourceMap = compiled.map ? `
 //# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(compiled.map)).toString("base64")}
 ` : "";
         return {
-          contents: `${String(compiled.value)}${sourceMap}`,
+          contents: `${String(compiled.value)}${inlineSourceMap}`,
           loader: compilerOptions?.jsx ? "jsx" : "js",
           resolveDir: path.dirname(args.path)
         };

package/src/utils/react-mdx-loader-plugin.ts

@@ -2,12 +2,34 @@ import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
 import { type CompileOptions, compile } from '@mdx-js/mdx';
-import { SourceMapGenerator } from 'source-map';
+import sourceMap from 'source-map';
 import { VFile } from 'vfile';
 
+/**
+ * Resolves the MDX parser mode for a React-backed MDX source file.
+ *
+ * When `.md` files are explicitly opted into the React MDX loader they still
+ * need to compile as MDX, not plain markdown. Otherwise top-level ESM exports
+ * like `config` are treated as literal text and the route cannot execute as a
+ * page module.
+ *
+ * @param filePath Absolute or relative source file path.
+ * @param compilerOptions User-provided MDX compiler options.
+ * @returns The compile format that should be passed to `@mdx-js/mdx`.
+ */
+function resolveCompileFormat(filePath: string, compilerOptions?: CompileOptions): CompileOptions['format'] {
+	const configuredFormat = compilerOptions?.format;
+
+	if (configuredFormat && configuredFormat !== 'detect') {
+		return configuredFormat;
+	}
+
+	return path.extname(filePath).toLowerCase() === '.md' ? 'mdx' : configuredFormat;
+}
+
 export function createReactMdxLoaderPlugin(compilerOptions?: CompileOptions): EcoBuildPlugin {
 	const mdxExtensions = compilerOptions?.mdxExtensions ?? ['.mdx'];
-	const mdExtensions = compilerOptions?.mdExtensions ?? ['.md'];
+	const mdExtensions = compilerOptions?.mdExtensions ?? [];
 	const allExtensions = [...mdxExtensions, ...mdExtensions];
 	const escapedExts = allExtensions.map((ext) => ext.replace('.', '\\.'));
 	const filter = new RegExp(`(${escapedExts.join('|')})(\\?.*)?$`);
@@ -22,15 +44,16 @@ export function createReactMdxLoaderPlugin(compilerOptions?: CompileOptions): Ec
 
 				const compiled = await compile(file, {
 					...compilerOptions,
-					SourceMapGenerator,
+					format: resolveCompileFormat(filePath, compilerOptions),
+					SourceMapGenerator: sourceMap.SourceMapGenerator,
 				});
 
-				const sourceMap = compiled.map
+				const inlineSourceMap = compiled.map
 					? `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(compiled.map)).toString('base64')}\n`
 					: '';
 
 				return {
-					contents: `${String(compiled.value)}${sourceMap}`,
+					contents: `${String(compiled.value)}${inlineSourceMap}`,
 					loader: compilerOptions?.jsx ? 'jsx' : 'js',
 					resolveDir: path.dirname(args.path),
 				};

package/src/utils/react-runtime-specifier-map.d.ts

@@ -0,0 +1,6 @@
+import type { ReactRouterAdapter } from '../router-adapter.js';
+import type { ReactRuntimeImports } from '../services/react-runtime-bundle.service.js';
+export declare const REACT_RUNTIME_SPECIFIERS: readonly ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime", "react-dom/client"];
+export declare function buildReactRuntimeSpecifierMap(runtimeImports: ReactRuntimeImports, routerAdapter?: ReactRouterAdapter): Record<string, string>;
+export declare function getReactRuntimeExternalSpecifiers(): string[];
+export declare function getReactClientGraphAllowSpecifiers(runtimeSpecifiers: Iterable<string>, routerAdapter?: ReactRouterAdapter): string[];

package/src/utils/react-runtime-specifier-map.js

@@ -0,0 +1,37 @@
+const REACT_RUNTIME_SPECIFIERS = [
+  "react",
+  "react-dom",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react-dom/client"
+];
+function buildReactRuntimeSpecifierMap(runtimeImports, routerAdapter) {
+  const map = {
+    react: runtimeImports.react,
+    "react/jsx-runtime": runtimeImports.reactJsxRuntime,
+    "react/jsx-dev-runtime": runtimeImports.reactJsxDevRuntime,
+    "react-dom": runtimeImports.reactDom,
+    "react-dom/client": runtimeImports.reactDomClient
+  };
+  if (routerAdapter && runtimeImports.router) {
+    map[routerAdapter.importMapKey] = runtimeImports.router;
+  }
+  return map;
+}
+function getReactRuntimeExternalSpecifiers() {
+  return [...REACT_RUNTIME_SPECIFIERS];
+}
+function getReactClientGraphAllowSpecifiers(runtimeSpecifiers, routerAdapter) {
+  return [
+    "@ecopages/core",
+    ...REACT_RUNTIME_SPECIFIERS,
+    ...routerAdapter ? [routerAdapter.importMapKey] : [],
+    ...Array.from(runtimeSpecifiers)
+  ];
+}
+export {
+  REACT_RUNTIME_SPECIFIERS,
+  buildReactRuntimeSpecifierMap,
+  getReactClientGraphAllowSpecifiers,
+  getReactRuntimeExternalSpecifiers
+};

package/src/utils/react-runtime-specifier-map.ts

@@ -0,0 +1,45 @@
+import type { ReactRouterAdapter } from '../router-adapter.ts';
+import type { ReactRuntimeImports } from '../services/react-runtime-bundle.service.ts';
+
+export const REACT_RUNTIME_SPECIFIERS = [
+	'react',
+	'react-dom',
+	'react/jsx-runtime',
+	'react/jsx-dev-runtime',
+	'react-dom/client',
+] as const;
+
+export function buildReactRuntimeSpecifierMap(
+	runtimeImports: ReactRuntimeImports,
+	routerAdapter?: ReactRouterAdapter,
+): Record<string, string> {
+	const map: Record<string, string> = {
+		react: runtimeImports.react,
+		'react/jsx-runtime': runtimeImports.reactJsxRuntime,
+		'react/jsx-dev-runtime': runtimeImports.reactJsxDevRuntime,
+		'react-dom': runtimeImports.reactDom,
+		'react-dom/client': runtimeImports.reactDomClient,
+	};
+
+	if (routerAdapter && runtimeImports.router) {
+		map[routerAdapter.importMapKey] = runtimeImports.router;
+	}
+
+	return map;
+}
+
+export function getReactRuntimeExternalSpecifiers(): string[] {
+	return [...REACT_RUNTIME_SPECIFIERS];
+}
+
+export function getReactClientGraphAllowSpecifiers(
+	runtimeSpecifiers: Iterable<string>,
+	routerAdapter?: ReactRouterAdapter,
+): string[] {
+	return [
+		'@ecopages/core',
+		...REACT_RUNTIME_SPECIFIERS,
+		...(routerAdapter ? [routerAdapter.importMapKey] : []),
+		...Array.from(runtimeSpecifiers),
+	];
+}

package/src/utils/use-sync-external-store-shim-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
+export declare function createUseSyncExternalStoreShimPlugin(options?: {
+    name?: string;
+    namespace?: string;
+}): EcoBuildPlugin;

package/src/utils/use-sync-external-store-shim-plugin.js

@@ -0,0 +1,41 @@
+function createUseSyncExternalStoreShimPlugin(options) {
+  const namespace = options?.namespace ?? "ecopages-react-use-sync-external-store-shim";
+  return {
+    name: options?.name ?? "react-use-sync-external-store-shim",
+    setup(build) {
+      build.onResolve({ filter: /^use-sync-external-store\/shim(?:\/index\.js)?$/ }, () => ({
+        path: "use-sync-external-store/shim",
+        namespace
+      }));
+      build.onLoad({ filter: /^use-sync-external-store\/shim$/, namespace }, () => ({
+        contents: "export { useSyncExternalStore } from 'react';",
+        loader: "js"
+      }));
+      build.onLoad({ filter: /[\\/]use-sync-external-store[\\/]shim[\\/]index\.js$/ }, () => ({
+        contents: "export { useSyncExternalStore } from 'react';",
+        loader: "js"
+      }));
+      build.onLoad(
+        {
+          filter: /[\\/]use-sync-external-store[\\/]cjs[\\/]use-sync-external-store-shim\.development\.js$/
+        },
+        () => ({
+          contents: "export { useSyncExternalStore } from 'react';",
+          loader: "js"
+        })
+      );
+      build.onLoad(
+        {
+          filter: /[\\/]use-sync-external-store[\\/]cjs[\\/]use-sync-external-store-shim\.production\.js$/
+        },
+        () => ({
+          contents: "export { useSyncExternalStore } from 'react';",
+          loader: "js"
+        })
+      );
+    }
+  };
+}
+export {
+  createUseSyncExternalStoreShimPlugin
+};