@wular/pnext 0.0.4 → 0.0.6

package/src/compat/bundler/polyfill.ts

@@ -6,10 +6,10 @@
 // same placement SWC's usage mode picks, so the polyfill runs ahead of that module and ships in its
 // chunk. Gated on swcEnvOptions being configured, so a pure app pays nothing.
 
-import { createHash } from 'node:crypto';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import type { ResolvedConfig } from '../../config';
+import { createHash } from 'node:crypto'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
 
 // No-module polyfills chunk (COMPAT - Next parity).
 //
@@ -19,41 +19,41 @@ import type { ResolvedConfig } from '../../config';
 // carries the same `noModule` script tag Next emits, which some suites assert on.
 
 /** Inert body for the no-module polyfills chunk (never runs in module browsers). */
-export const POLYFILLS_NOMODULE_SOURCE = '!function(){"use strict"}();\n';
+export const POLYFILLS_NOMODULE_SOURCE = '!function(){"use strict"}();\n'
 
-let cachedPolyfillsFileName: string | undefined;
+let cachedPolyfillsFileName: string | undefined
 
 /** Content-hashed filename for the emitted no-module polyfills chunk. */
 export function polyfillsChunkFileName(): string {
-  if (cachedPolyfillsFileName) return cachedPolyfillsFileName;
-  const hash = createHash('sha256').update(POLYFILLS_NOMODULE_SOURCE).digest('hex').slice(0, 16);
-  return (cachedPolyfillsFileName = `polyfills-${hash}.js`);
+  if (cachedPolyfillsFileName) return cachedPolyfillsFileName
+  const hash = createHash('sha256').update(POLYFILLS_NOMODULE_SOURCE).digest('hex').slice(0, 16)
+  return (cachedPolyfillsFileName = `polyfills-${hash}.js`)
 }
 
 /** App-absolute served path of the polyfills chunk (before assetPrefix). */
 export function polyfillsChunkPath(): string {
-  return `/_next/static/chunks/${polyfillsChunkFileName()}`;
+  return `/_next/static/chunks/${polyfillsChunkFileName()}`
 }
 
 // The core-js module SWC's usage mode emits per feature, keyed by the syntax
 // that pulls it in. Extend as more features are needed.
 const POLYFILL_FEATURES: { usage: RegExp; module: string }[] = [
   { usage: /\.replaceAll\s*\(/, module: 'core-js/modules/es.string.replace-all.js' },
-];
+]
 
 /** Sniff tokens for the client transform below (one per feature usage). */
-export const POLYFILL_USAGE_TOKENS = POLYFILL_FEATURES.map(feature => feature.usage);
+export const POLYFILL_USAGE_TOKENS = POLYFILL_FEATURES.map(feature => feature.usage)
 
 // core-js resolves from the app, not from pnext. One require per root, reused
 // across the transform's per-module calls.
-const polyfillRequires = new Map<string, NodeJS.Require>();
+const polyfillRequires = new Map<string, NodeJS.Require>()
 
 function polyfillRequire(config: ResolvedConfig) {
-  const existing = polyfillRequires.get(config.root);
-  if (existing) return existing;
-  const created = createRequire(path.join(config.root, 'pnext-polyfill-resolve.cjs'));
-  polyfillRequires.set(config.root, created);
-  return created;
+  const existing = polyfillRequires.get(config.root)
+  if (existing) return existing
+  const created = createRequire(path.join(config.root, 'pnext-polyfill-resolve.cjs'))
+  polyfillRequires.set(config.root, created)
+  return created
 }
 
 /**
@@ -70,19 +70,19 @@ export function rewriteUsagePolyfillImports(
   file: string,
   config: ResolvedConfig,
 ): string {
-  const inApp = file.startsWith(`${config.root}${path.sep}`);
-  if (!inApp || file.includes(`${path.sep}node_modules${path.sep}`)) return source;
-  const require = polyfillRequire(config);
+  const inApp = file.startsWith(`${config.root}${path.sep}`)
+  if (!inApp || file.includes(`${path.sep}node_modules${path.sep}`)) return source
+  const require = polyfillRequire(config)
   const imports = POLYFILL_FEATURES.flatMap(feature => {
-    if (!feature.usage.test(source)) return [];
+    if (!feature.usage.test(source)) return []
     try {
-      return [`import ${JSON.stringify(require.resolve(feature.module))};`];
+      return [`import ${JSON.stringify(require.resolve(feature.module))};`]
     } catch {
-      return [];
+      return []
     }
-  });
-  if (imports.length === 0) return source;
+  })
+  if (imports.length === 0) return source
   // After the directive prologue: a `'use client'` module must keep it first.
-  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(source)?.[0] ?? '';
-  return `${directive}${imports.join('\n')}\n${source.slice(directive.length)}`;
+  const directive = /^(?:\s*['"][^'"]+['"];?\s*)*/.exec(source)?.[0] ?? ''
+  return `${directive}${imports.join('\n')}\n${source.slice(directive.length)}`
 }

package/src/compat/bundler/react-compiler.ts

@@ -4,11 +4,11 @@
 // `reactCompiler` flag reaches it through the compat-mode options seam.
 // ---------------------------------------------------------------------------
 
-import path from 'node:path';
-import { rewriteFacts } from '../../resolve/scan-facts';
-import { spliceSource } from '../../dev/module-transform';
+import path from 'node:path'
+import { rewriteFacts } from '../../resolve/scan-facts'
+import { spliceSource } from '../../runtime/module-transform'
 
-const profilerRuntimePath = path.join(import.meta.dirname, 'react-profiler.tsx');
+const profilerRuntimePath = path.join(import.meta.dirname, 'react-profiler.tsx')
 
 /**
  * Split `Profiler` out of a `react` named import onto pnext's own Profiler
@@ -16,46 +16,52 @@ const profilerRuntimePath = path.join(import.meta.dirname, 'react-profiler.tsx')
  * matched by shape rather than by a line-anchored regex.
  */
 export function rewriteReactProfilerImport(source: string, file = 'module.tsx'): string {
-  if (!source.includes('Profiler')) return source;
-  const edits: { start: number; end: number; value: string }[] = [];
+  if (!source.includes('Profiler')) return source
+  const edits: { start: number; end: number; value: string }[] = []
   for (const statement of rewriteFacts(file, source).imports) {
-    if (statement.specifier !== 'react') continue;
-    const profilers = statement.bindings.filter(binding => binding.imported === 'Profiler');
-    if (profilers.length === 0) continue;
+    if (statement.specifier !== 'react') continue
+    const profilers = statement.bindings.filter(binding => binding.imported === 'Profiler')
+    if (profilers.length === 0) continue
 
-    const rest = statement.bindings.filter(binding => binding.imported !== 'Profiler');
-    const named = rest.filter(binding => binding.imported !== 'default' && binding.imported !== '*');
-    const other = rest.filter(binding => binding.imported === 'default' || binding.imported === '*');
-    const indent = importIndent(source, statement.start);
-    const clause = named.map(printBinding).join(', ');
-    const prefix = other.map(binding => (binding.imported === '*' ? `* as ${binding.local}` : binding.local)).join(', ');
-    const lines: string[] = [];
-    if (prefix && clause) lines.push(`${indent}import ${prefix}, { ${clause} } from 'react';`);
-    else if (prefix) lines.push(`${indent}import ${prefix} from 'react';`);
-    else if (clause) lines.push(`${indent}import { ${clause} } from 'react';`);
+    const rest = statement.bindings.filter(binding => binding.imported !== 'Profiler')
+    const named = rest.filter(binding => binding.imported !== 'default' && binding.imported !== '*')
+    const other = rest.filter(binding => binding.imported === 'default' || binding.imported === '*')
+    const indent = importIndent(source, statement.start)
+    const clause = named.map(printBinding).join(', ')
+    const prefix = other
+      .map(binding => (binding.imported === '*' ? `* as ${binding.local}` : binding.local))
+      .join(', ')
+    const lines: string[] = []
+    if (prefix && clause) lines.push(`${indent}import ${prefix}, { ${clause} } from 'react';`)
+    else if (prefix) lines.push(`${indent}import ${prefix} from 'react';`)
+    else if (clause) lines.push(`${indent}import { ${clause} } from 'react';`)
     for (const profiler of profilers) {
       lines.push(
         `${indent}import { Profiler as ${profiler.local} } from ${JSON.stringify(profilerRuntimePath)};`,
-      );
+      )
     }
-    edits.push({ start: statement.start, end: statement.end, value: lines.join('\n').slice(indent.length) });
+    edits.push({
+      start: statement.start,
+      end: statement.end,
+      value: lines.join('\n').slice(indent.length),
+    })
   }
-  return edits.length > 0 ? spliceSource(source, edits) : source;
+  return edits.length > 0 ? spliceSource(source, edits) : source
 }
 
 function printBinding(binding: { imported: string; local: string; type: boolean }) {
-  const name = binding.imported === binding.local ? binding.local : `${binding.imported} as ${binding.local}`;
-  return binding.type ? `type ${name}` : name;
+  const name =
+    binding.imported === binding.local ? binding.local : `${binding.imported} as ${binding.local}`
+  return binding.type ? `type ${name}` : name
 }
 
 /** Leading whitespace of the statement's own line (the splice keeps the first one). */
 function importIndent(source: string, start: number) {
-  const lineStart = source.lastIndexOf('\n', start - 1) + 1;
-  const indent = source.slice(lineStart, start);
-  return /^[ \t]*$/.test(indent) ? indent : '';
+  const lineStart = source.lastIndexOf('\n', start - 1) + 1
+  const indent = source.slice(lineStart, start)
+  return /^[ \t]*$/.test(indent) ? indent : ''
 }
 
 export function rewriteReactProfilerServerSource(source: string, file?: string): string {
-  return rewriteReactProfilerImport(source, file);
+  return rewriteReactProfilerImport(source, file)
 }
-

package/src/compat/bundler/react-profiler.tsx

@@ -1,9 +1,9 @@
-import { Fragment, type ComponentChildren } from 'preact';
-import { useLayoutEffect, useRef } from 'preact/hooks';
+import { Fragment, type ComponentChildren } from 'preact'
+import { useLayoutEffect, useRef } from 'preact/hooks'
 
 export interface ProfilerProps {
-  id: string;
-  children?: ComponentChildren;
+  id: string
+  children?: ComponentChildren
   onRender?: (
     id: string,
     phase: 'mount' | 'update',
@@ -11,15 +11,15 @@ export interface ProfilerProps {
     baseDuration: number,
     startTime: number,
     commitTime: number,
-  ) => void;
+  ) => void
 }
 
 export function Profiler({ id, children, onRender }: ProfilerProps) {
-  const phase = useRef<'mount' | 'update'>('mount');
+  const phase = useRef<'mount' | 'update'>('mount')
   useLayoutEffect(() => {
-    const now = typeof performance === 'undefined' ? 0 : performance.now();
-    onRender?.(id, phase.current, 0, 0, now, now);
-    phase.current = 'update';
-  });
-  return <Fragment>{children}</Fragment>;
+    const now = typeof performance === 'undefined' ? 0 : performance.now()
+    onRender?.(id, phase.current, 0, 0, now, now)
+    phase.current = 'update'
+  })
+  return <Fragment>{children}</Fragment>
 }

package/src/compat/bundler/relay-transform.ts

@@ -14,10 +14,10 @@
 // Everything is resolved relative to `process.cwd()`, matching the SWC transform's root. That is what
 // makes the multi-project fixture work: each sub-project is built with its own cwd.
 
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { withSniff, type ServerSourceTransform } from '../../extensions';
-import type { RelayCompilerConfig } from './config';
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { withSniff, type ServerSourceTransform } from '../../extensions'
+import type { RelayCompilerConfig } from './config'
 
 /** The artifact extension relay-compiler emits for each `language` setting. */
 function artifactExtensions(language: RelayCompilerConfig['language']): string[] {
@@ -25,92 +25,93 @@ function artifactExtensions(language: RelayCompilerConfig['language']): string[]
   // project can point `artifactDirectory` at output generated with a different
   // `language` than next.config declares (the multi-project fixture reads its
   // `language` from a sibling project's relay config).
-  return language === 'typescript' ? ['.ts', '.js'] : ['.js', '.ts'];
+  return language === 'typescript' ? ['.ts', '.js'] : ['.js', '.ts']
 }
 
 /** `graphql`-tagged templates. GraphQL has no backticks, so a lazy scan is exact. */
 function relayTagPattern(): RegExp {
-  return /(?<![\w$.])graphql\s*`([\s\S]*?)`/g;
+  return /(?<![\w$.])graphql\s*`([\s\S]*?)`/g
 }
 
-const OPERATION_NAME = /\b(?:query|mutation|subscription|fragment)\s+([A-Za-z_][\w]*)/;
+const OPERATION_NAME = /\b(?:query|mutation|subscription|fragment)\s+([A-Za-z_][\w]*)/
 
 function isUnder(dir: string, file: string): boolean {
-  const relative = path.relative(dir, file);
-  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+  const relative = path.relative(dir, file)
+  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)
 }
 
 // Insert hoisted imports after any leading directive prologue ('use client' /
 // 'use server' / 'use strict') and optional shebang, so a client module's
 // `'use client'` stays the first statement.
 function injectAfterDirectives(source: string, injection: string): string {
-  const prologue = /^(\uFEFF?(?:#![^\n]*\n)?(?:[ \t]*(['"])use [\w-]+\2[ \t]*;?[ \t]*(?:\r?\n|$))*)/.exec(
-    source,
-  );
-  const index = prologue ? prologue[0].length : 0;
-  return `${source.slice(0, index)}${injection}\n${source.slice(index)}`;
+  const prologue =
+    /^(\uFEFF?(?:#![^\n]*\n)?(?:[ \t]*(['"])use [\w-]+\2[ \t]*;?[ \t]*(?:\r?\n|$))*)/.exec(source)
+  const index = prologue ? prologue[0].length : 0
+  return `${source.slice(0, index)}${injection}\n${source.slice(index)}`
 }
 
 /**
  * Build a source transform applying `compiler.relay`. Returns a no-op transform
  * when nothing is configured so pure-core apps pay nothing.
  */
-export function createRelayTransform(relay: RelayCompilerConfig | undefined): ServerSourceTransform {
-  if (!relay) return withSniff([], source => source);
+export function createRelayTransform(
+  relay: RelayCompilerConfig | undefined,
+): ServerSourceTransform {
+  if (!relay) return withSniff([], source => source)
 
-  const cwd = path.resolve(process.cwd());
-  const srcDir = path.resolve(cwd, relay.src);
+  const cwd = path.resolve(process.cwd())
+  const srcDir = path.resolve(cwd, relay.src)
   const artifactDir = relay.artifactDirectory
     ? path.resolve(cwd, relay.artifactDirectory)
-    : undefined;
-  const extensions = artifactExtensions(relay.language);
-  const resolved = new Map<string, string | undefined>();
+    : undefined
+  const extensions = artifactExtensions(relay.language)
+  const resolved = new Map<string, string | undefined>()
 
   /** The on-disk artifact for one operation name, or undefined when absent. */
   function artifactFor(fileDir: string, name: string): string | undefined {
     // Without `artifactDirectory`, relay-compiler writes `__generated__` next
     // to the source file.
-    const directory = artifactDir ?? path.join(fileDir, '__generated__');
-    const key = `${directory}\0${name}`;
-    if (resolved.has(key)) return resolved.get(key);
-    let found: string | undefined;
+    const directory = artifactDir ?? path.join(fileDir, '__generated__')
+    const key = `${directory}\0${name}`
+    if (resolved.has(key)) return resolved.get(key)
+    let found: string | undefined
     for (const extension of extensions) {
-      const candidate = path.join(directory, `${name}.graphql${extension}`);
+      const candidate = path.join(directory, `${name}.graphql${extension}`)
       if (existsSync(candidate)) {
-        found = candidate;
-        break;
+        found = candidate
+        break
       }
     }
-    resolved.set(key, found);
-    return found;
+    resolved.set(key, found)
+    return found
   }
 
   return withSniff(['graphql'], (source, file) => {
-    if (!source.includes('graphql`') && !/graphql\s*`/.test(source)) return source;
-    const absolute = path.resolve(file);
+    if (!source.includes('graphql`') && !/graphql\s*`/.test(source)) return source
+    const absolute = path.resolve(file)
     // Next scopes the transform to `src`. Files outside the build cwd entirely
     // (materialized copies) are not covered by that check, so only skip a file
     // that lives under the cwd but outside the configured source root.
-    if (isUnder(cwd, absolute) && !isUnder(srcDir, absolute)) return source;
+    if (isUnder(cwd, absolute) && !isUnder(srcDir, absolute)) return source
 
-    const bindings = new Map<string, string>();
+    const bindings = new Map<string, string>()
     const replaced = source.replace(relayTagPattern(), (match, body: string) => {
-      const name = OPERATION_NAME.exec(body)?.[1];
-      if (!name) return match;
-      const artifact = artifactFor(path.dirname(absolute), name);
-      if (!artifact) return match;
-      let binding = bindings.get(artifact);
+      const name = OPERATION_NAME.exec(body)?.[1]
+      if (!name) return match
+      const artifact = artifactFor(path.dirname(absolute), name)
+      if (!artifact) return match
+      let binding = bindings.get(artifact)
       if (!binding) {
-        binding = `__pnext_relay_${bindings.size}`;
-        bindings.set(artifact, binding);
+        binding = `__pnext_relay_${bindings.size}`
+        bindings.set(artifact, binding)
       }
-      return binding;
-    });
-    if (bindings.size === 0) return source;
+      return binding
+    })
+    if (bindings.size === 0) return source
 
     const imports = [...bindings]
       .map(([artifact, binding]) => `import * as ${binding} from ${JSON.stringify(artifact)};`)
-      .join('\n');
-    return injectAfterDirectives(replaced, imports);
-  });
+      .join('\n')
+    return injectAfterDirectives(replaced, imports)
+  })
 }