@wular/pnext 0.0.4 → 0.0.6

package/src/compat/bundler/config.ts

@@ -7,8 +7,8 @@
 // safe defaults.
 // ---------------------------------------------------------------------------
 
-import { getNextConfig } from '../next/config-loader';
-import type { ModularizeRule } from './modularize-imports';
+import { getNextConfig } from '../next/config-loader'
+import type { ModularizeRule } from './modularize-imports'
 
 /** A predefined built-in set kept external server-side (Next ships this list). */
 const PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
@@ -18,10 +18,12 @@ const PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
   'canvas',
   '@node-rs/argon2',
   '@node-rs/bcrypt',
-];
+]
 
 function stringArray(value: unknown): string[] {
-  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : []
 }
 
 /**
@@ -29,11 +31,11 @@ function stringArray(value: unknown): string[] {
  * (resolved from node_modules, never bundled) in the server graph.
  */
 export function serverExternalPackages(): Set<string> {
-  const config = getNextConfig();
+  const config = getNextConfig()
   return new Set([
     ...PREDEFINED_SERVER_EXTERNAL_PACKAGES,
     ...stringArray(config.serverExternalPackages),
-  ]);
+  ])
 }
 
 /**
@@ -42,22 +44,22 @@ export function serverExternalPackages(): Set<string> {
  * and written to `required-server-files.json` so tooling can read it back.
  */
 export function deploymentId(): string | undefined {
-  const configured = getNextConfig().deploymentId;
-  if (typeof configured === 'string' && configured.length > 0) return configured;
+  const configured = getNextConfig().deploymentId
+  if (typeof configured === 'string' && configured.length > 0) return configured
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const fromEnv = process.env.NEXT_DEPLOYMENT_ID;
-  return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+  const fromEnv = process.env.NEXT_DEPLOYMENT_ID
+  return fromEnv && fromEnv.length > 0 ? fromEnv : undefined
 }
 
 /** `publicRuntimeConfig`: the subset of runtime config safe to inline into client bundles. */
 export function publicRuntimeConfig(): Record<string, unknown> {
-  const config = getNextConfig().publicRuntimeConfig;
-  return config && typeof config === 'object' ? (config as Record<string, unknown>) : {};
+  const config = getNextConfig().publicRuntimeConfig
+  return config && typeof config === 'object' ? (config as Record<string, unknown>) : {}
 }
 
 /** `transpilePackages`: node_modules packages force-bundled + transpiled. */
 export function transpilePackages(): string[] {
-  return stringArray(getNextConfig().transpilePackages);
+  return stringArray(getNextConfig().transpilePackages)
 }
 
 /**
@@ -67,19 +69,23 @@ export function transpilePackages(): string[] {
  * malformed/object-template entries are dropped so a build still proceeds.
  */
 export function modularizeImports(): Record<string, ModularizeRule> {
-  const raw = getNextConfig().modularizeImports;
-  if (!raw || typeof raw !== 'object') return {};
-  const out: Record<string, ModularizeRule> = {};
+  const raw = getNextConfig().modularizeImports
+  if (!raw || typeof raw !== 'object') return {}
+  const out: Record<string, ModularizeRule> = {}
   for (const [specifier, value] of Object.entries(raw as Record<string, unknown>)) {
-    if (value && typeof value === 'object' && typeof (value as ModularizeRule).transform === 'string') {
-      const rule = value as ModularizeRule;
+    if (
+      value &&
+      typeof value === 'object' &&
+      typeof (value as ModularizeRule).transform === 'string'
+    ) {
+      const rule = value as ModularizeRule
       out[specifier] = {
         transform: rule.transform,
         skipDefaultConversion: Boolean(rule.skipDefaultConversion),
-      };
+      }
     }
   }
-  return out;
+  return out
 }
 
 /**
@@ -89,19 +95,18 @@ export function modularizeImports(): Record<string, ModularizeRule> {
  */
 export function optimizePackageImports(): string[] {
   const experimental = getNextConfig().experimental as
-    | { optimizePackageImports?: unknown }
-    | undefined;
-  return stringArray(experimental?.optimizePackageImports);
+    { optimizePackageImports?: unknown } | undefined
+  return stringArray(experimental?.optimizePackageImports)
 }
 
 /** A normalized `compiler.relay` entry (see relay-transform.ts). */
 export interface RelayCompilerConfig {
   /** Source root the transform applies to, relative to `process.cwd()`. */
-  src: string;
+  src: string
   /** Where relay-compiler wrote its artifacts, relative to `process.cwd()`. */
-  artifactDirectory?: string;
+  artifactDirectory?: string
   /** The artifact language: decides the generated file's extension. */
-  language: 'javascript' | 'typescript' | 'flow';
+  language: 'javascript' | 'typescript' | 'flow'
 }
 
 /**
@@ -111,11 +116,10 @@ export interface RelayCompilerConfig {
  */
 export function relayCompilerConfig(): RelayCompilerConfig | undefined {
   const compiler = getNextConfig().compiler as
-    | { relay?: { src?: unknown; artifactDirectory?: unknown; language?: unknown } }
-    | undefined;
-  const relay = compiler?.relay;
-  if (!relay || typeof relay !== 'object' || typeof relay.src !== 'string') return undefined;
-  const language = relay.language;
+    { relay?: { src?: unknown; artifactDirectory?: unknown; language?: unknown } } | undefined
+  const relay = compiler?.relay
+  if (!relay || typeof relay !== 'object' || typeof relay.src !== 'string') return undefined
+  const language = relay.language
   return {
     src: relay.src,
     artifactDirectory:
@@ -124,7 +128,7 @@ export function relayCompilerConfig(): RelayCompilerConfig | undefined {
       language === 'typescript' || language === 'flow' || language === 'javascript'
         ? language
         : 'javascript',
-  };
+  }
 }
 
 /**
@@ -133,9 +137,8 @@ export function relayCompilerConfig(): RelayCompilerConfig | undefined {
  */
 export function esmExternals(): boolean | 'loose' {
   const experimental = getNextConfig().experimental as
-    | { esmExternals?: boolean | 'loose' }
-    | undefined;
-  return experimental?.esmExternals ?? true;
+    { esmExternals?: boolean | 'loose' } | undefined
+  return experimental?.esmExternals ?? true
 }
 
 /**
@@ -143,56 +146,54 @@ export function esmExternals(): boolean | 'loose' {
  * `turbopack.resolveExtensions`, and the legacy `experimental.turbo.resolveExtensions` spelling.
  */
 export function resolveExtensions(): string[] | undefined {
-  const config = getNextConfig();
-  const turbopack = config.turbopack as { resolveExtensions?: unknown } | undefined;
+  const config = getNextConfig()
+  const turbopack = config.turbopack as { resolveExtensions?: unknown } | undefined
   const experimental = config.experimental as
-    | { turbo?: { resolveExtensions?: unknown } }
-    | undefined;
+    { turbo?: { resolveExtensions?: unknown } } | undefined
   for (const value of [
     config.resolveExtensions,
     turbopack?.resolveExtensions,
     experimental?.turbo?.resolveExtensions,
   ]) {
-    const list = stringArray(value);
-    if (list.length > 0) return list;
+    const list = stringArray(value)
+    if (list.length > 0) return list
   }
-  return undefined;
+  return undefined
 }
 
 /** `typescript.tsconfigPath`: a non-default tsconfig location. */
 export function tsconfigPath(): string | undefined {
-  const ts = getNextConfig().typescript as { tsconfigPath?: string } | undefined;
-  return typeof ts?.tsconfigPath === 'string' ? ts.tsconfigPath : undefined;
+  const ts = getNextConfig().typescript as { tsconfigPath?: string } | undefined
+  return typeof ts?.tsconfigPath === 'string' ? ts.tsconfigPath : undefined
 }
 
 export interface CompilerDefines {
   /** Inlined into BOTH server and client bundles. */
-  define: Record<string, string>;
+  define: Record<string, string>
   /** Inlined into the SERVER bundle only (client sees the fallback). */
-  defineServer: Record<string, string>;
+  defineServer: Record<string, string>
 }
 
 function normalizeDefineMap(value: unknown): Record<string, string> {
-  if (!value || typeof value !== 'object') return {};
-  const out: Record<string, string> = {};
+  if (!value || typeof value !== 'object') return {}
+  const out: Record<string, string> = {}
   for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
     // esbuild `define` values must be JS source text: strings need to be
     // JSON-encoded, primitives stringified.
-    if (typeof raw === 'string') out[key] = JSON.stringify(raw);
-    else if (typeof raw === 'number' || typeof raw === 'boolean') out[key] = String(raw);
+    if (typeof raw === 'string') out[key] = JSON.stringify(raw)
+    else if (typeof raw === 'number' || typeof raw === 'boolean') out[key] = String(raw)
   }
-  return out;
+  return out
 }
 
 /** `compiler.define` / `compiler.defineServer` inlined-constant maps. */
 export function compilerDefines(): CompilerDefines {
   const compiler = getNextConfig().compiler as
-    | { define?: Record<string, unknown>; defineServer?: Record<string, unknown> }
-    | undefined;
+    { define?: Record<string, unknown>; defineServer?: Record<string, unknown> } | undefined
   return {
     define: normalizeDefineMap(compiler?.define),
     defineServer: normalizeDefineMap(compiler?.defineServer),
-  };
+  }
 }
 
 /** The console methods Next's SWC `removeConsole` transform can target. */
@@ -216,7 +217,7 @@ const CONSOLE_METHODS = [
   'timeLog',
   'trace',
   'warn',
-];
+]
 
 /**
  * `compiler.removeConsole`: `true` strips every `console.*` call; `{ exclude }`
@@ -225,21 +226,20 @@ const CONSOLE_METHODS = [
  */
 export function removeConsoleTargets(): string[] | undefined {
   const compiler = getNextConfig().compiler as
-    | { removeConsole?: boolean | { exclude?: unknown } }
-    | undefined;
-  const removeConsole = compiler?.removeConsole;
-  if (!removeConsole) return undefined;
+    { removeConsole?: boolean | { exclude?: unknown } } | undefined
+  const removeConsole = compiler?.removeConsole
+  if (!removeConsole) return undefined
   const exclude = new Set(
     typeof removeConsole === 'object' ? stringArray(removeConsole.exclude) : [],
-  );
-  return CONSOLE_METHODS.filter(method => !exclude.has(method)).map(method => `console.${method}`);
+  )
+  return CONSOLE_METHODS.filter(method => !exclude.has(method)).map(method => `console.${method}`)
 }
 
 /** `cacheComponents` (PPR): gates the `next-js` export condition. */
 export function cacheComponentsEnabled(): boolean {
-  const config = getNextConfig();
-  const experimental = config.experimental as { cacheComponents?: boolean } | undefined;
-  return Boolean(config.cacheComponents ?? experimental?.cacheComponents);
+  const config = getNextConfig()
+  const experimental = config.experimental as { cacheComponents?: boolean } | undefined
+  return Boolean(config.cacheComponents ?? experimental?.cacheComponents)
 }
 
 /**
@@ -251,39 +251,38 @@ export function cacheComponentsEnabled(): boolean {
  */
 export function swcEnvUsageMode(): 'usage' | 'entry' | undefined {
   const experimental = getNextConfig().experimental as
-    | { swcEnvOptions?: { mode?: unknown } }
-    | undefined;
-  const mode = experimental?.swcEnvOptions?.mode;
-  return mode === 'usage' || mode === 'entry' ? mode : undefined;
+    { swcEnvOptions?: { mode?: unknown } } | undefined
+  const mode = experimental?.swcEnvOptions?.mode
+  return mode === 'usage' || mode === 'entry' ? mode : undefined
 }
 
 /** Next's `reactCompiler` / legacy experimental flag. */
 export function reactCompilerEnabled(): boolean {
-  const config = getNextConfig();
-  const experimental = config.experimental as { reactCompiler?: boolean } | undefined;
-  return Boolean(config.reactCompiler ?? experimental?.reactCompiler);
+  const config = getNextConfig()
+  const experimental = config.experimental as { reactCompiler?: boolean } | undefined
+  return Boolean(config.reactCompiler ?? experimental?.reactCompiler)
 }
 
 /** A single `turbopack.rules` entry, normalized to the shapes pnext supports. */
 export interface WebpackLoaderRule {
   /** The rule's glob key, e.g. `'*.txt'` or `'*.test-file.ts'`. Only a leading `*` wildcard is honored. */
-  glob: string;
+  glob: string
   /** Loader module specifiers (relative path or bare package name), applied in array order. */
-  loaders: string[];
+  loaders: string[]
   /** The virtual extension of the loader chain's final output, e.g. `'*.js'`. */
-  as?: string;
+  as?: string
   /**
    * A conditional rule guard: the rule only applies when the import's
    * `resourceQuery` matches (string equality or a regex `.test`). Comes from the
    * conditional-array rule form `'*.ext': [{ condition: { query }, loaders }]`.
    */
-  condition?: { query: string | RegExp };
+  condition?: { query: string | RegExp }
   /**
    * A no-loader `type` asset rule: how the raw file is represented as a module.
    * `'resource'` emits the file under `/_next/static/media` and exports its URL
    * string; `'bytes'` exports a `Uint8Array`; `'source'` exports the file text.
    */
-  assetType?: 'resource' | 'bytes' | 'source';
+  assetType?: 'resource' | 'bytes' | 'source'
 }
 
 /**
@@ -294,13 +293,13 @@ export interface WebpackLoaderRule {
  * loader `type` asset rules (`{ type: 'asset' | 'bytes' | 'asset/source' }`).
  */
 export function turbopackLoaderRules(): WebpackLoaderRule[] {
-  const config = getNextConfig();
-  const turbopack = config.turbopack as { rules?: Record<string, unknown> } | undefined;
-  const rules = turbopack?.rules;
-  if (!rules || typeof rules !== 'object') return [];
-  const out: WebpackLoaderRule[] = [];
-  for (const [glob, raw] of Object.entries(rules)) collectLoaderRuleEntries(glob, raw, out);
-  return out;
+  const config = getNextConfig()
+  const turbopack = config.turbopack as { rules?: Record<string, unknown> } | undefined
+  const rules = turbopack?.rules
+  if (!rules || typeof rules !== 'object') return []
+  const out: WebpackLoaderRule[] = []
+  for (const [glob, raw] of Object.entries(rules)) collectLoaderRuleEntries(glob, raw, out)
+  return out
 }
 
 function collectLoaderRuleEntries(glob: string, raw: unknown, out: WebpackLoaderRule[]): void {
@@ -308,42 +307,48 @@ function collectLoaderRuleEntries(glob: string, raw: unknown, out: WebpackLoader
     // A plain array of loader specifiers, or the conditional-array form whose
     // entries are `{ condition, loaders, as }` objects.
     if (raw.every(item => typeof item === 'string')) {
-      const loaders = stringArray(raw);
-      if (loaders.length > 0) out.push({ glob, loaders });
-      return;
+      const loaders = stringArray(raw)
+      if (loaders.length > 0) out.push({ glob, loaders })
+      return
     }
     for (const item of raw) {
-      if (item && typeof item === 'object') pushLoaderRuleObject(glob, item as Record<string, unknown>, out);
+      if (item && typeof item === 'object')
+        pushLoaderRuleObject(glob, item as Record<string, unknown>, out)
     }
-    return;
+    return
   }
-  if (raw && typeof raw === 'object') pushLoaderRuleObject(glob, raw as Record<string, unknown>, out);
+  if (raw && typeof raw === 'object')
+    pushLoaderRuleObject(glob, raw as Record<string, unknown>, out)
 }
 
-function pushLoaderRuleObject(glob: string, entry: Record<string, unknown>, out: WebpackLoaderRule[]): void {
-  const loaders = stringArray(entry.loaders);
-  const as = typeof entry.as === 'string' ? entry.as : undefined;
-  const condition = parseRuleCondition(entry.condition);
+function pushLoaderRuleObject(
+  glob: string,
+  entry: Record<string, unknown>,
+  out: WebpackLoaderRule[],
+): void {
+  const loaders = stringArray(entry.loaders)
+  const as = typeof entry.as === 'string' ? entry.as : undefined
+  const condition = parseRuleCondition(entry.condition)
   if (loaders.length > 0) {
-    out.push({ glob, loaders, as, ...(condition ? { condition } : {}) });
-    return;
+    out.push({ glob, loaders, as, ...(condition ? { condition } : {}) })
+    return
   }
-  const assetType = parseAssetRuleType(entry.type);
-  if (assetType) out.push({ glob, loaders: [], as, assetType });
+  const assetType = parseAssetRuleType(entry.type)
+  if (assetType) out.push({ glob, loaders: [], as, assetType })
 }
 
 function parseRuleCondition(value: unknown): { query: string | RegExp } | undefined {
-  if (!value || typeof value !== 'object') return undefined;
-  const query = (value as { query?: unknown }).query;
-  if (typeof query === 'string' || query instanceof RegExp) return { query };
-  return undefined;
+  if (!value || typeof value !== 'object') return undefined
+  const query = (value as { query?: unknown }).query
+  if (typeof query === 'string' || query instanceof RegExp) return { query }
+  return undefined
 }
 
 function parseAssetRuleType(value: unknown): 'resource' | 'bytes' | 'source' | undefined {
-  if (value === 'asset' || value === 'asset/resource') return 'resource';
-  if (value === 'bytes') return 'bytes';
-  if (value === 'asset/source') return 'source';
-  return undefined;
+  if (value === 'asset' || value === 'asset/resource') return 'resource'
+  if (value === 'bytes') return 'bytes'
+  if (value === 'asset/source') return 'source'
+  return undefined
 }
 
 /**
@@ -352,12 +357,12 @@ function parseAssetRuleType(value: unknown): 'resource' | 'bytes' | 'source' | u
  * by the consumer.
  */
 export function turbopackResolveAlias(): Record<string, string> {
-  const turbopack = getNextConfig().turbopack as { resolveAlias?: unknown } | undefined;
-  const alias = turbopack?.resolveAlias;
-  if (!alias || typeof alias !== 'object') return {};
-  const out: Record<string, string> = {};
+  const turbopack = getNextConfig().turbopack as { resolveAlias?: unknown } | undefined
+  const alias = turbopack?.resolveAlias
+  if (!alias || typeof alias !== 'object') return {}
+  const out: Record<string, string> = {}
   for (const [key, value] of Object.entries(alias as Record<string, unknown>)) {
-    if (typeof value === 'string') out[key] = value;
+    if (typeof value === 'string') out[key] = value
   }
-  return out;
+  return out
 }

package/src/compat/bundler/externals.ts

@@ -1,7 +1,7 @@
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
-import { packageNameOfSpecifier, resolvePackageSpecifier } from '../../resolve/imports';
-import { escapeRegex } from '../../utils/source';
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
+import { packageNameOfSpecifier, resolvePackageSpecifier } from '../../resolve/imports'
+import { escapeRegex } from '../../utils/code'
 
 /**
  * Bundle configured server externals into client output with browser exports.
@@ -13,22 +13,22 @@ export function clientExternalPackageResolvePlugin(
   config: ResolvedConfig,
   externals: ReadonlySet<string>,
 ): Plugin | undefined {
-  if (externals.size === 0) return undefined;
-  const filter = new RegExp(`^(?:${[...externals].map(escapeRegex).join('|')})(?:/|$)`);
+  if (externals.size === 0) return undefined
+  const filter = new RegExp(`^(?:${[...externals].map(escapeRegex).join('|')})(?:/|$)`)
   return {
     name: 'pnext-client-external-package-resolve',
     setup(build) {
       build.onResolve({ filter }, args => {
-        const packageName = packageNameOfSpecifier(args.path);
-        if (!packageName || !externals.has(packageName)) return undefined;
+        const packageName = packageNameOfSpecifier(args.path)
+        if (!packageName || !externals.has(packageName)) return undefined
         const resolved = resolvePackageSpecifier(
           config.root,
           `${args.importer || config.root}/pnext-resolve.ts`,
           args.path,
           ['import', 'browser', 'require', 'default'],
-        );
-        return resolved ? { path: resolved } : undefined;
-      });
+        )
+        return resolved ? { path: resolved } : undefined
+      })
     },
-  };
+  }
 }

package/src/compat/bundler/import-meta-url.ts

@@ -1,11 +1,11 @@
-import { realpathSync } from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { rewriteFacts } from '../../resolve/scan-facts';
-import { spliceSource } from '../../dev/module-transform';
+import { realpathSync } from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { rewriteFacts } from '../../resolve/scan-facts'
+import { spliceSource } from '../../runtime/module-transform'
 
 export function sourceHasImportMetaUrl(source: string) {
-  return source.includes('import.meta.url');
+  return source.includes('import.meta.url')
 }
 
 /**
@@ -14,17 +14,17 @@ export function sourceHasImportMetaUrl(source: string) {
  * the regex also fired inside strings and comments.
  */
 export function rewriteImportMetaUrlSource(source: string, file: string) {
-  if (!sourceHasImportMetaUrl(source)) return source;
-  const facts = rewriteFacts(file, source);
-  if (facts.unreliable) return legacyRewriteImportMetaUrl(source, file);
+  if (!sourceHasImportMetaUrl(source)) return source
+  const facts = rewriteFacts(file, source)
+  if (facts.unreliable) return legacyRewriteImportMetaUrl(source, file)
   const edits = facts.importMetas
     .filter(meta => /^\.url\b/.test(source.slice(meta.end, meta.end + 5)))
     .map(meta => ({
       start: meta.start,
       end: meta.end + 4,
       value: JSON.stringify(pathToFileURL(virtualFixturePath(realSourcePath(file))).href),
-    }));
-  return edits.length > 0 ? spliceSource(source, edits) : source;
+    }))
+  return edits.length > 0 ? spliceSource(source, edits) : source
 }
 
 // A source oxc could only partially recover keeps the textual pass: an
@@ -33,7 +33,7 @@ function legacyRewriteImportMetaUrl(source: string, file: string) {
   return source.replace(
     /\bimport\.meta\.url\b/g,
     JSON.stringify(pathToFileURL(virtualFixturePath(realSourcePath(file))).href),
-  );
+  )
 }
 
 // Modules can reach the bundler through the pages-compat mirror's source-app/
@@ -41,20 +41,20 @@ function legacyRewriteImportMetaUrl(source: string, file: string) {
 // the filesystem relative to import.meta.url (Next inlines the real path).
 function realSourcePath(file: string) {
   try {
-    return realpathSync(file);
+    return realpathSync(file)
   } catch {
-    return file;
+    return file
   }
 }
 
 function virtualFixturePath(file: string) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const root = process.env.PNEXT_IMPORT_META_URL_FIXTURE_ROOT;
+  const root = process.env.PNEXT_IMPORT_META_URL_FIXTURE_ROOT
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const virtualRoot = process.env.PNEXT_IMPORT_META_URL_VIRTUAL_ROOT;
-  if (!root || !virtualRoot) return file;
-  const relative = path.relative(root, file);
+  const virtualRoot = process.env.PNEXT_IMPORT_META_URL_VIRTUAL_ROOT
+  if (!root || !virtualRoot) return file
+  const relative = path.relative(root, file)
   return relative && !relative.startsWith(`..${path.sep}`) && relative !== '..'
     ? path.join(virtualRoot, relative)
-    : file;
+    : file
 }