@wular/pnext 0.0.4 → 0.0.7

package/src/resolve/engine.ts

@@ -1,19 +1,29 @@
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import type { ResolverFactory, NapiResolveOptions } from 'oxc-resolver';
-import { loadNative } from '../utils/native-require';
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import type { ResolverFactory, NapiResolveOptions } from 'oxc-resolver'
+import { loadNative } from '../utils/native-require'
 
 // Lazy: the native binding costs ~1.3 MB RSS and a prod server may never resolve.
 function createResolverFactory(options: NapiResolveOptions): ResolverFactory {
   const { ResolverFactory: Factory } = loadNative(
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     () => require('oxc-resolver') as typeof import('oxc-resolver'),
-  );
-  return new Factory(options);
-}
-import { clearNodeModulesFsCache } from '../utils/fs-cache';
-
-const sourceExtensions = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.mts', '.cts', '.module.css', '.css'];
+  )
+  return new Factory(options)
+}
+import { clearNodeModulesFsCache } from '../utils/fs-cache'
+
+const sourceExtensions = [
+  '.tsx',
+  '.ts',
+  '.jsx',
+  '.js',
+  '.mjs',
+  '.mts',
+  '.cts',
+  '.module.css',
+  '.css',
+]
 
 // An ESM `import './x.js'` is authored against the source file that compiles to
 // it — a source convention only (see isSourceRequest / probePackageTarget).
@@ -22,41 +32,41 @@ const extensionAlias = {
   '.jsx': ['.tsx', '.jsx'],
   '.mjs': ['.mts', '.mjs'],
   '.cjs': ['.cts', '.cjs'],
-};
+}
 
 export interface ResolvedModule {
-  path: string;
+  path: string
 }
 
 /** The package answered "no" for this subpath (Node's ERR_PACKAGE_PATH_NOT_EXPORTED). */
 export interface UnexportedModule {
-  notExported: true;
+  notExported: true
 }
 
-export type ResolveOutcome = ResolvedModule | UnexportedModule | undefined;
+export type ResolveOutcome = ResolvedModule | UnexportedModule | undefined
 
-let configuredExtensions: string[] | undefined;
-let configuredTsConfigPath: string | undefined;
+let configuredExtensions: string[] | undefined
+let configuredTsConfigPath: string | undefined
 
-let baseFactory: ResolverFactory | undefined;
-const factories = new Map<string, ResolverFactory>();
-const tsConfigFiles = new Map<string, string | undefined>();
+let baseFactory: ResolverFactory | undefined
+const factories = new Map<string, ResolverFactory>()
+const tsConfigFiles = new Map<string, string | undefined>()
 
 export function setEngineExtensions(extensions: readonly string[] | undefined): void {
-  configuredExtensions = extensions && extensions.length > 0 ? [...extensions] : undefined;
-  resetEngine();
+  configuredExtensions = extensions && extensions.length > 0 ? [...extensions] : undefined
+  resetEngine()
 }
 
 export function setEngineTsConfigPath(file: string | undefined): void {
-  configuredTsConfigPath = file;
-  resetEngine();
+  configuredTsConfigPath = file
+  resetEngine()
 }
 
 function resetEngine() {
-  baseFactory = undefined;
-  factories.clear();
-  tsConfigFiles.clear();
-  nodeModulesOutcomes.clear();
+  baseFactory = undefined
+  factories.clear()
+  tsConfigFiles.clear()
+  nodeModulesOutcomes.clear()
 }
 
 /**
@@ -65,24 +75,24 @@ function resetEngine() {
  * constructed, only their fs cache is emptied.
  */
 export function clearResolverFsCache(): void {
-  baseFactory?.clearCache();
-  for (const factory of factories.values()) factory.clearCache();
-  nodeModulesOutcomes.clear();
-  clearNodeModulesFsCache();
+  baseFactory?.clearCache()
+  for (const factory of factories.values()) factory.clearCache()
+  nodeModulesOutcomes.clear()
+  clearNodeModulesFsCache()
 }
 
 /** The tsconfig (or jsconfig) driving `paths`/`baseUrl` for a resolution root. */
 export function tsConfigFileFor(root: string): string | undefined {
-  const key = path.resolve(root);
-  if (tsConfigFiles.has(key)) return tsConfigFiles.get(key);
+  const key = path.resolve(root)
+  if (tsConfigFiles.has(key)) return tsConfigFiles.get(key)
   const candidates = [
     ...(configuredTsConfigPath ? [path.resolve(key, configuredTsConfigPath)] : []),
     path.join(key, 'tsconfig.json'),
     path.join(key, 'jsconfig.json'),
-  ];
-  const file = candidates.find(candidate => existsSync(candidate));
-  tsConfigFiles.set(key, file);
-  return file;
+  ]
+  const file = candidates.find(candidate => existsSync(candidate))
+  tsConfigFiles.set(key, file)
+  return file
 }
 
 /**
@@ -91,11 +101,11 @@ export function tsConfigFileFor(root: string): string | undefined {
  * package-imports specifier, not a fragment.
  */
 export function splitResourceQuery(specifier: string): { path: string; query: string } {
-  const offset = specifier.startsWith('#') ? 1 : 0;
-  const match = /[?#]/.exec(specifier.slice(offset));
-  if (!match) return { path: specifier, query: '' };
-  const index = offset + match.index;
-  return { path: specifier.slice(0, index), query: specifier.slice(index) };
+  const offset = specifier.startsWith('#') ? 1 : 0
+  const match = /[?#]/.exec(specifier.slice(offset))
+  if (!match) return { path: specifier, query: '' }
+  const index = offset + match.index
+  return { path: specifier.slice(0, index), query: specifier.slice(index) }
 }
 
 /**
@@ -108,14 +118,14 @@ export function resolveFrom(
   conditions: readonly string[],
   tsConfigRoot?: string,
 ): ResolveOutcome {
-  const { path: request } = splitResourceQuery(specifier);
-  const tsconfig = tsConfigRoot ? tsConfigFileFor(tsConfigRoot) : undefined;
-  return resolveRequest(dir, request, conditions, tsconfig, isSourceRequest(request));
+  const { path: request } = splitResourceQuery(specifier)
+  const tsconfig = tsConfigRoot ? tsConfigFileFor(tsConfigRoot) : undefined
+  return resolveRequest(dir, request, conditions, tsconfig, isSourceRequest(request))
 }
 
 /** Probe a literal on-disk path with the resolver's extension/index rules. */
 export function probeFile(target: string, conditions: readonly string[]): string | undefined {
-  return probe(target, conditions, true);
+  return probe(target, conditions, true)
 }
 
 /**
@@ -124,26 +134,29 @@ export function probeFile(target: string, conditions: readonly string[]): string
  * source alias: Node and webpack read a package's stated target literally, so a
  * stale `x.ts` next to the built `x.js` must never win.
  */
-export function probePackageTarget(target: string, conditions: readonly string[]): string | undefined {
-  return probe(target, conditions, false);
+export function probePackageTarget(
+  target: string,
+  conditions: readonly string[],
+): string | undefined {
+  return probe(target, conditions, false)
 }
 
 function probe(target: string, conditions: readonly string[], sourceAlias: boolean) {
-  const { path: file } = splitResourceQuery(target);
-  const request = `./${path.basename(file)}`;
-  const outcome = resolveRequest(path.dirname(file), request, conditions, undefined, sourceAlias);
-  return outcome && 'path' in outcome ? outcome.path : undefined;
+  const { path: file } = splitResourceQuery(target)
+  const request = `./${path.basename(file)}`
+  const outcome = resolveRequest(path.dirname(file), request, conditions, undefined, sourceAlias)
+  return outcome && 'path' in outcome ? outcome.path : undefined
 }
 
 /** Runtime-cache reset (bench/tests): drop memoized node_modules resolutions. */
 export function clearNodeModulesResolutionCache(): void {
-  nodeModulesOutcomes.clear();
+  nodeModulesOutcomes.clear()
 }
 
 // Lookups FROM node_modules only: installed layouts are process-immutable,
 // app-source resolution must stay live under watch (see clearResolverFsCache).
-const nodeModulesOutcomes = new Map<string, ResolveOutcome>();
-const NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`;
+const nodeModulesOutcomes = new Map<string, ResolveOutcome>()
+const NODE_MODULES_SEGMENT = `${path.sep}node_modules${path.sep}`
 
 function resolveRequest(
   dir: string,
@@ -154,9 +167,9 @@ function resolveRequest(
 ): ResolveOutcome {
   const key = dir.includes(NODE_MODULES_SEGMENT)
     ? `${dir}\0${request}\0${conditions.join(',')}\0${tsconfig ?? ''}\0${sourceAlias}`
-    : undefined;
-  if (key !== undefined && nodeModulesOutcomes.has(key)) return nodeModulesOutcomes.get(key);
-  const { path: file, error } = resolverFor(conditions, tsconfig, sourceAlias).sync(dir, request);
+    : undefined
+  if (key !== undefined && nodeModulesOutcomes.has(key)) return nodeModulesOutcomes.get(key)
+  const { path: file, error } = resolverFor(conditions, tsconfig, sourceAlias).sync(dir, request)
   // Declaration files carry no runtime and are never a valid resolution.
   const outcome: ResolveOutcome = file
     ? isDeclarationFile(file)
@@ -164,9 +177,9 @@ function resolveRequest(
       : { path: file }
     : error?.includes('is not exported')
       ? { notExported: true }
-      : undefined;
-  if (key !== undefined) nodeModulesOutcomes.set(key, outcome);
-  return outcome;
+      : undefined
+  if (key !== undefined) nodeModulesOutcomes.set(key, outcome)
+  return outcome
 }
 
 // oxc applies `extensionAlias` to the target it reads out of a package's
@@ -174,7 +187,7 @@ function resolveRequest(
 // (relative or absolute, authored against the file its own build emits) gets
 // the `.js` -> `.ts` rewrite. Bare specifiers are package lookups.
 function isSourceRequest(request: string) {
-  return request.startsWith('.') || path.isAbsolute(request);
+  return request.startsWith('.') || path.isAbsolute(request)
 }
 
 function resolverFor(
@@ -182,8 +195,8 @@ function resolverFor(
   tsconfig: string | undefined,
   sourceExtensionAlias: boolean,
 ) {
-  const key = `${conditions.join(',')}\0${tsconfig ?? ''}\0${sourceExtensionAlias}`;
-  let resolver = factories.get(key);
+  const key = `${conditions.join(',')}\0${tsconfig ?? ''}\0${sourceExtensionAlias}`
+  let resolver = factories.get(key)
   if (!resolver) {
     // cloneWithOptions replaces the option set rather than merging it, so the
     // base options are repeated here; the clone shares the base file-system cache.
@@ -192,12 +205,12 @@ function resolverFor(
       extensionAlias: sourceExtensionAlias ? extensionAlias : {},
       conditionNames: [...conditions],
       mainFields: mainFieldsFor(conditions),
-    };
-    if (tsconfig) options.tsconfig = { configFile: tsconfig };
-    resolver = baseResolver().cloneWithOptions(options);
-    factories.set(key, resolver);
+    }
+    if (tsconfig) options.tsconfig = { configFile: tsconfig }
+    resolver = baseResolver().cloneWithOptions(options)
+    factories.set(key, resolver)
   }
-  return resolver;
+  return resolver
 }
 
 function baseOptions(): NapiResolveOptions {
@@ -206,24 +219,24 @@ function baseOptions(): NapiResolveOptions {
     // Symlink policy is the caller's (see realLinkedPackageFile in imports.ts):
     // pnpm virtual-store paths carry version identity that must not collapse.
     symlinks: false,
-  };
+  }
 }
 
 function baseResolver() {
-  baseFactory ??= createResolverFactory(baseOptions());
-  return baseFactory;
+  baseFactory ??= createResolverFactory(baseOptions())
+  return baseFactory
 }
 
 // `edge-light`/`browser` are plain package.json main fields in Next/webpack, not
 // only `exports` conditions — a package shipping just `main`/`module`/`edge-light`
 // must still prefer `edge-light` on the edge layer.
 function mainFieldsFor(conditions: readonly string[]) {
-  const fields = ['module', 'main'];
-  if (conditions.includes('browser')) fields.unshift('browser');
-  if (conditions.includes('edge-light')) fields.unshift('edge-light');
-  return fields;
+  const fields = ['module', 'main']
+  if (conditions.includes('browser')) fields.unshift('browser')
+  if (conditions.includes('edge-light')) fields.unshift('edge-light')
+  return fields
 }
 
 function isDeclarationFile(file: string) {
-  return /\.d\.[cm]?ts$/.test(file);
+  return /\.d\.[cm]?ts$/.test(file)
 }