@wular/pnext 0.0.4 → 0.0.6

package/src/compat/next/script.tsx

@@ -1,20 +1,20 @@
-import type { JSX } from 'preact';
-import { escapeHtml } from '../../utils/html';
-import { getNextConfig } from './config-loader';
-import { registerResourceHint } from '../../render/resource-hints';
+import type { JSX } from 'preact'
+import { escapeHtml } from '../../utils/html'
+import { getNextConfig } from './config-loader'
+import { registerResourceHint } from '../../render/resource-hints'
 
-export type ScriptStrategy = 'beforeInteractive' | 'afterInteractive' | 'lazyOnload' | 'worker';
+export type ScriptStrategy = 'beforeInteractive' | 'afterInteractive' | 'lazyOnload' | 'worker'
 
 export type ScriptProps = Omit<JSX.ScriptHTMLAttributes<HTMLScriptElement>, 'src'> & {
-  src?: string;
-  strategy?: ScriptStrategy;
-  onLoad?: (event: Event) => void;
-  onReady?: () => void;
-  onError?: (event: Event) => void;
-  children?: string;
+  src?: string
+  strategy?: ScriptStrategy
+  onLoad?: (event: Event) => void
+  onReady?: () => void
+  onError?: (event: Event) => void
+  children?: string
   /** Stylesheets the script depends on; Next preloads these alongside the script itself. */
-  stylesheets?: string[];
-};
+  stylesheets?: string[]
+}
 
 /**
  * Server-renderable approximation of next/script. onLoad/onReady/onError are unserializable across a
@@ -29,22 +29,22 @@ export default function Script({
   stylesheets,
   ...scriptProps
 }: ScriptProps) {
-  const src = typeof scriptProps.src === 'string' ? scriptProps.src : undefined;
+  const src = typeof scriptProps.src === 'string' ? scriptProps.src : undefined
 
   // Dedup on Next's cache key (`id ?? src`): two `<Script id="x">` must be serialized to the document
   // exactly once. The executed-set is scoped to the current render (tied to the per-request
   // resource-hints buffer) so it never leaks across requests.
-  const dedupKey = (typeof scriptProps.id === 'string' && scriptProps.id) || src;
+  const dedupKey = (typeof scriptProps.id === 'string' && scriptProps.id) || src
   if (dedupKey) {
-    const keys = executedScriptKeys();
-    if (keys.has(dedupKey)) return null;
-    keys.add(dedupKey);
+    const keys = executedScriptKeys()
+    if (keys.has(dedupKey)) return null
+    keys.add(dedupKey)
   }
 
   // A manually-passed `nonce` prop always wins, matching Next. The CSP-detected case has no per-Script
   // signal to read here - it is stamped uniformly, after the whole document is assembled, by the
   // renderer's stampDocumentNonce - so only the explicit override needs threading through this module.
-  const manualNonce = typeof scriptProps.nonce === 'string' ? scriptProps.nonce : undefined;
+  const manualNonce = typeof scriptProps.nonce === 'string' ? scriptProps.nonce : undefined
 
   // lazyOnload scripts load well after hydration on a browser idle callback;
   // Next doesn't preload them (a preload hint for something fetched minutes
@@ -58,12 +58,12 @@ export default function Script({
       ...(typeof scriptProps.crossOrigin === 'string'
         ? { crossOrigin: scriptProps.crossOrigin }
         : {}),
-    });
+    })
   }
 
   if (stylesheets) {
     for (const url of stylesheets) {
-      registerResourceHint({ rel: 'stylesheet', url });
+      registerResourceHint({ rel: 'stylesheet', url })
     }
   }
 
@@ -76,8 +76,8 @@ export default function Script({
     headScripts().push({
       props: { 'data-nscript': 'beforeInteractive', ...scriptProps },
       content: inlineScriptContent(scriptProps, children),
-    });
-    return null;
+    })
+    return null
   }
 
   if (strategy === 'worker' && nextScriptWorkersEnabled()) {
@@ -88,10 +88,10 @@ export default function Script({
       ...scriptProps,
       type: 'text/partytown',
       'data-nscript': 'worker',
-    };
+    }
     const workerInline =
-      typeof children === 'string' ? { dangerouslySetInnerHTML: { __html: children } } : {};
-    return <script {...partytownProps} {...workerInline} />;
+      typeof children === 'string' ? { dangerouslySetInnerHTML: { __html: children } } : {}
+    return <script {...partytownProps} {...workerInline} />
   }
 
   // afterInteractive / lazyOnload: Next never SSRs the actual tag for these - only the preload hint
@@ -100,33 +100,33 @@ export default function Script({
   // racing them. A bare `<Script>` usage inside a Server Component tree hydrates nothing here, so SSRing
   // the tag inline would execute it immediately during HTML parse. Queue a descriptor instead; the
   // renderer flushes one shared bootstrap that creates and appends the real elements at the right time.
-  const deferredContent = inlineScriptContent(scriptProps, children);
+  const deferredContent = inlineScriptContent(scriptProps, children)
   deferredScripts().push({
     strategy: strategy === 'lazyOnload' ? 'lazyOnload' : 'afterInteractive',
     attrs: deferredAttrs({ ...scriptProps, ...(manualNonce ? { nonce: manualNonce } : {}) }),
     ...(typeof scriptProps.id === 'string' ? { id: scriptProps.id } : {}),
     ...(src ? { src } : {}),
     ...(deferredContent !== undefined ? { content: deferredContent } : {}),
-  });
-  return null;
+  })
+  return null
 }
 
-export { Script };
+export { Script }
 
 /**
  * `experimental.nextScriptWorkers` gate. When on, `strategy="worker"` scripts
  * are rewritten to Partytown (`type="text/partytown"`).
  */
 function nextScriptWorkersEnabled(): boolean {
-  const experimental = getNextConfig().experimental as { nextScriptWorkers?: boolean } | undefined;
-  return experimental?.nextScriptWorkers === true;
+  const experimental = getNextConfig().experimental as { nextScriptWorkers?: boolean } | undefined
+  return experimental?.nextScriptWorkers === true
 }
 
 /**
  * The Partytown loader path Next serves the library from. Copied verbatim by the
  * asset pipeline; the injected snippet points the worker sandbox here.
  */
-export const PARTYTOWN_LIB_PATH = '/_next/static/~partytown/';
+export const PARTYTOWN_LIB_PATH = '/_next/static/~partytown/'
 
 /**
  * Partytown config plus the inline snippet Next injects into <head> once when any `worker` script is
@@ -135,14 +135,14 @@ export const PARTYTOWN_LIB_PATH = '/_next/static/~partytown/';
  */
 export function partytownHeadScripts(): HeadScript[] {
   const config = getNextConfig() as {
-    experimental?: { nextScriptWorkers?: boolean };
-    partytown?: Record<string, unknown>;
-  };
-  if (config.experimental?.nextScriptWorkers !== true) return [];
+    experimental?: { nextScriptWorkers?: boolean }
+    partytown?: Record<string, unknown>
+  }
+  if (config.experimental?.nextScriptWorkers !== true) return []
   const partytownConfig = {
     lib: PARTYTOWN_LIB_PATH,
     ...(config.partytown ?? {}),
-  };
+  }
   return [
     {
       props: { 'data-partytown-config': '' },
@@ -152,7 +152,7 @@ export function partytownHeadScripts(): HeadScript[] {
       props: { 'data-partytown': '' },
       content: partytownSnippet(partytownConfig.lib),
     },
-  ];
+  ]
 }
 
 /**
@@ -160,7 +160,7 @@ export function partytownHeadScripts(): HeadScript[] {
  * the render seam. Returns '' when nextScriptWorkers is disabled - a no-op for every other app.
  */
 export function renderPartytownHeadScripts(): string {
-  return partytownHeadScripts().map(renderHeadScript).join('');
+  return partytownHeadScripts().map(renderHeadScript).join('')
 }
 
 /**
@@ -178,7 +178,7 @@ function partytownSnippet(lib: string): string {
     `f.async=!0;f.src=c.lib+'partytown.js';` +
     `document.head.appendChild(f);` +
     `})(window,'partytown');`
-  );
+  )
 }
 
 // afterInteractive/lazyOnload descriptors (§ deferred bootstrap). Consumed by
@@ -186,170 +186,170 @@ function partytownSnippet(lib: string): string {
 // copy of this shape (core may not import compat) keyed off the same global —
 // mirrors the ResourceHint/HeadScript protocol above.
 export interface DeferredScript {
-  strategy: 'afterInteractive' | 'lazyOnload';
-  attrs: Record<string, string>;
-  id?: string;
-  src?: string;
-  content?: string;
+  strategy: 'afterInteractive' | 'lazyOnload'
+  attrs: Record<string, string>
+  id?: string
+  src?: string
+  content?: string
 }
 
 function deferredScripts() {
-  const holder = globalThis as { __PNEXT_DEFERRED_SCRIPTS__?: DeferredScript[] };
-  holder.__PNEXT_DEFERRED_SCRIPTS__ ??= [];
-  return holder.__PNEXT_DEFERRED_SCRIPTS__;
+  const holder = globalThis as { __PNEXT_DEFERRED_SCRIPTS__?: DeferredScript[] }
+  holder.__PNEXT_DEFERRED_SCRIPTS__ ??= []
+  return holder.__PNEXT_DEFERRED_SCRIPTS__
 }
 
 export function clearDeferredScripts() {
-  (globalThis as { __PNEXT_DEFERRED_SCRIPTS__?: DeferredScript[] }).__PNEXT_DEFERRED_SCRIPTS__ = [];
+  ;(globalThis as { __PNEXT_DEFERRED_SCRIPTS__?: DeferredScript[] }).__PNEXT_DEFERRED_SCRIPTS__ = []
 }
 
 export function takeDeferredScripts() {
-  const holder = globalThis as { __PNEXT_DEFERRED_SCRIPTS__?: DeferredScript[] };
-  const scripts = holder.__PNEXT_DEFERRED_SCRIPTS__ ?? [];
-  holder.__PNEXT_DEFERRED_SCRIPTS__ = [];
-  return scripts;
+  const holder = globalThis as { __PNEXT_DEFERRED_SCRIPTS__?: DeferredScript[] }
+  const scripts = holder.__PNEXT_DEFERRED_SCRIPTS__ ?? []
+  holder.__PNEXT_DEFERRED_SCRIPTS__ = []
+  return scripts
 }
 
 // Like scriptAttrs, but building a raw name -> value map (for
 // `element.setAttribute(name, value)` client-side) instead of an
 // HTML-escaped string — the deferred bootstrap reconstructs real elements via
 // the DOM, never via innerHTML.
-const DEFERRED_SKIP_PROPS = new Set(['src', 'strategy', 'dangerouslysetinnerhtml', 'id']);
+const DEFERRED_SKIP_PROPS = new Set(['src', 'strategy', 'dangerouslysetinnerhtml', 'id'])
 
 function deferredAttrs(props: Record<string, unknown>): Record<string, string> {
-  const attrs: Record<string, string> = {};
+  const attrs: Record<string, string> = {}
   for (const [key, value] of Object.entries(props)) {
-    const name = attrName(key);
-    if (!isAttrName(name) || DEFERRED_SKIP_PROPS.has(name) || name.startsWith('on')) continue;
-    if (value == null || value === false || typeof value === 'function') continue;
+    const name = attrName(key)
+    if (!isAttrName(name) || DEFERRED_SKIP_PROPS.has(name) || name.startsWith('on')) continue
+    if (value == null || value === false || typeof value === 'function') continue
     if (value === true) {
-      attrs[name] = '';
-      continue;
+      attrs[name] = ''
+      continue
     }
     if (name === 'class' && Array.isArray(value)) {
       const className = value
         .filter(
           (item): item is string | number => typeof item === 'string' || typeof item === 'number',
         )
-        .join(' ');
-      if (className) attrs[name] = className;
-      continue;
+        .join(' ')
+      if (className) attrs[name] = className
+      continue
     }
     if (typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint') {
-      attrs[name] = String(value);
+      attrs[name] = String(value)
     }
   }
-  return attrs;
+  return attrs
 }
 
 export interface HeadScript {
-  props: Record<string, unknown>;
-  content?: string;
+  props: Record<string, unknown>
+  content?: string
 }
 
 // The renderer replaces the resource-hints array with a fresh `[]` at the start
 // of every render (clearResourceHints). Keying the executed-set off that array
 // via a WeakMap gives us a dedup scope that lives exactly one render and is
 // garbage-collected with it — no cross-request leakage.
-const scriptDedupRegistry = new WeakMap<object, Set<string>>();
+const scriptDedupRegistry = new WeakMap<object, Set<string>>()
 
 function executedScriptKeys(): Set<string> {
-  const holder = globalThis as { __PNEXT_RESOURCE_HINTS__?: object };
-  holder.__PNEXT_RESOURCE_HINTS__ ??= [];
-  const arr = holder.__PNEXT_RESOURCE_HINTS__;
-  let keys = scriptDedupRegistry.get(arr);
+  const holder = globalThis as { __PNEXT_RESOURCE_HINTS__?: object }
+  holder.__PNEXT_RESOURCE_HINTS__ ??= []
+  const arr = holder.__PNEXT_RESOURCE_HINTS__
+  let keys = scriptDedupRegistry.get(arr)
   if (!keys) {
-    keys = new Set<string>();
-    scriptDedupRegistry.set(arr, keys);
+    keys = new Set<string>()
+    scriptDedupRegistry.set(arr, keys)
   }
-  return keys;
+  return keys
 }
 
 function headScripts() {
-  const holder = globalThis as { __PNEXT_HEAD_SCRIPTS__?: HeadScript[] };
-  holder.__PNEXT_HEAD_SCRIPTS__ ??= [];
-  return holder.__PNEXT_HEAD_SCRIPTS__;
+  const holder = globalThis as { __PNEXT_HEAD_SCRIPTS__?: HeadScript[] }
+  holder.__PNEXT_HEAD_SCRIPTS__ ??= []
+  return holder.__PNEXT_HEAD_SCRIPTS__
 }
 
 export function clearHeadScripts() {
-  (globalThis as { __PNEXT_HEAD_SCRIPTS__?: HeadScript[] }).__PNEXT_HEAD_SCRIPTS__ = [];
+  ;(globalThis as { __PNEXT_HEAD_SCRIPTS__?: HeadScript[] }).__PNEXT_HEAD_SCRIPTS__ = []
 }
 
 export function takeHeadScripts() {
-  const holder = globalThis as { __PNEXT_HEAD_SCRIPTS__?: HeadScript[] };
-  const scripts = holder.__PNEXT_HEAD_SCRIPTS__ ?? [];
-  holder.__PNEXT_HEAD_SCRIPTS__ = [];
-  return scripts;
+  const holder = globalThis as { __PNEXT_HEAD_SCRIPTS__?: HeadScript[] }
+  const scripts = holder.__PNEXT_HEAD_SCRIPTS__ ?? []
+  holder.__PNEXT_HEAD_SCRIPTS__ = []
+  return scripts
 }
 
 export function renderHeadScripts() {
-  return takeHeadScripts().map(renderHeadScript).join('\n    ');
+  return takeHeadScripts().map(renderHeadScript).join('\n    ')
 }
 
 function renderHeadScript(script: HeadScript) {
-  const attrs = scriptAttrs(script.props);
-  const open = attrs ? `<script ${attrs}>` : '<script>';
+  const attrs = scriptAttrs(script.props)
+  const open = attrs ? `<script ${attrs}>` : '<script>'
   return script.content === undefined
     ? `${open}</script>`
-    : `${open}${escapeScriptText(script.content)}</script>`;
+    : `${open}${escapeScriptText(script.content)}</script>`
 }
 
 function inlineScriptContent(
   props: Record<string, unknown>,
   children: string | undefined,
 ): string | undefined {
-  if (typeof children === 'string') return children;
-  const dangerous = props.dangerouslySetInnerHTML;
+  if (typeof children === 'string') return children
+  const dangerous = props.dangerouslySetInnerHTML
   if (
     dangerous &&
     typeof dangerous === 'object' &&
     typeof (dangerous as { __html?: unknown }).__html === 'string'
   ) {
-    return (dangerous as { __html: string }).__html;
+    return (dangerous as { __html: string }).__html
   }
-  return undefined;
+  return undefined
 }
 
 function scriptAttrs(props: Record<string, unknown>) {
-  const attrs = Object.entries(props).flatMap(([key, value]) => scriptAttr(attrName(key), value));
-  return attrs.join(' ');
+  const attrs = Object.entries(props).flatMap(([key, value]) => scriptAttr(attrName(key), value))
+  return attrs.join(' ')
 }
 
 function scriptAttr(name: string, value: unknown): string[] {
-  if (!isAttrName(name)) return [];
-  if (value == null || value === false || typeof value === 'function') return [];
-  if (name === 'strategy' || name === 'dangerouslysetinnerhtml' || name.startsWith('on')) return [];
-  if (value === true) return [name];
+  if (!isAttrName(name)) return []
+  if (value == null || value === false || typeof value === 'function') return []
+  if (name === 'strategy' || name === 'dangerouslysetinnerhtml' || name.startsWith('on')) return []
+  if (value === true) return [name]
   if (name === 'class' && Array.isArray(value)) {
     const className = value
       .filter(
         (item): item is string | number => typeof item === 'string' || typeof item === 'number',
       )
-      .join(' ');
-    return className ? [`class="${escapeHtml(className)}"`] : [];
+      .join(' ')
+    return className ? [`class="${escapeHtml(className)}"`] : []
   }
   if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'bigint') {
-    return [];
+    return []
   }
-  return [`${name}="${escapeHtml(value)}"`];
+  return [`${name}="${escapeHtml(value)}"`]
 }
 
 function attrName(key: string) {
-  if (key === 'className') return 'class';
-  if (key === 'htmlFor') return 'for';
-  return key.toLowerCase();
+  if (key === 'className') return 'class'
+  if (key === 'htmlFor') return 'for'
+  return key.toLowerCase()
 }
 
 function isAttrName(name: string) {
-  return /^[a-zA-Z_:][a-zA-Z0-9:._-]*$/.test(name);
+  return /^[a-zA-Z_:][a-zA-Z0-9:._-]*$/.test(name)
 }
 
-const scriptTerminator = /(<\/|<)(s)(cript)/gi;
+const scriptTerminator = /(<\/|<)(s)(cript)/gi
 
 function escapeScriptText(text: string) {
   return text.replace(
     scriptTerminator,
     (_, prefix: string, s: string, suffix: string) =>
       `${prefix}${s === 's' ? '\\u0073' : '\\u0053'}${suffix}`,
-  );
+  )
 }

package/src/compat/next/server-only.ts

@@ -1,3 +1,3 @@
 // server-only import marker: valid in server modules (react-server condition
 // equivalent); the client bundler keeps the real package error path.
-export {};
+export {}

package/src/compat/next/server.ts

@@ -1,28 +1,28 @@
-import { requireRequest, requestApiPromise } from '../../request/context';
-import { assertRequestApiAllowedInAfter } from '../lifecycle/after-scope';
-import { assertNoDynamicApiInsideCache } from '../cache/revalidate';
-import { assertDynamicErrorRequestApi } from './headers';
+import { requireRequest, requestApiPromise } from '../../request/context'
+import { assertRequestApiAllowedInAfter } from '../lifecycle/after-scope'
+import { assertNoDynamicApiInsideCache } from '../cache/revalidate'
+import { assertDynamicErrorRequestApi } from './headers'
 
-export { after } from '../lifecycle/after';
-export { io } from '../ppr/io';
-export { NextRequest, NextResponse } from '../../api/server';
-export type { NextRequestGeo } from '../../api/server';
-export type { NextFetchEvent } from '../../types';
-export type { ProxyConfig } from '../../proxy';
-export { ImageResponse } from './og';
+export { after } from '../lifecycle/after'
+export { io } from '../ppr/io'
+export { NextRequest, NextResponse } from '../../api/server'
+export type { NextRequestGeo } from '../../api/server'
+export type { NextFetchEvent } from '../../types'
+export type { ProxyConfig } from '../../routing/proxy'
+export { ImageResponse } from './og'
 // Pure UA/URLPattern helpers live in a client-safe module so the client
 // `next/server` variant (client-server.ts) can share them without pulling this
 // file's node:async_hooks imports into the browser bundle.
-export { URLPattern, userAgent, userAgentFromString } from './user-agent';
-export type { UserAgent } from './user-agent';
+export { URLPattern, userAgent, userAgentFromString } from './user-agent'
+export type { UserAgent } from './user-agent'
 
 /** Marks the surrounding scope as dynamic, like headers()/cookies(). */
 export function connection(): Promise<Record<never, never>> {
-  assertRequestApiAllowedInAfter('connection()');
-  assertDynamicErrorRequestApi('connection()');
-  assertNoDynamicApiInsideCache('connection()');
+  assertRequestApiAllowedInAfter('connection()')
+  assertDynamicErrorRequestApi('connection()')
+  assertNoDynamicApiInsideCache('connection()')
   return requestApiPromise('connection()', () => {
-    requireRequest('connection()');
-    return {};
-  });
+    requireRequest('connection()')
+    return {}
+  })
 }

package/src/compat/next/svgr.ts

@@ -6,34 +6,35 @@
 // reference and reproduce the import-as-component semantics directly against core's `staticAssetModule`
 // seam (see image/static-metadata.ts) instead of executing the loader.
 
-let svgAsComponent = false;
+let svgAsComponent = false
 
 /** Derived per config load (see config-loader's setNextConfig) — never a process one-shot. */
 export function setSvgAsComponentEnabled(enabled: boolean): void {
-  svgAsComponent = enabled;
+  svgAsComponent = enabled
 }
 
 export function isSvgAsComponentEnabled(): boolean {
-  return svgAsComponent;
+  return svgAsComponent
 }
 
 /** True when next.config's `webpack()` references `@svgr/webpack` (the common custom-loader use). */
 export function webpackReferencesSvgr(config: { webpack?: unknown }): boolean {
-  return typeof config.webpack === 'function' && String(config.webpack).includes('@svgr/webpack');
+  return typeof config.webpack === 'function' && String(config.webpack).includes('@svgr/webpack')
 }
 
-const XML_PROLOGUE = /^\uFEFF?\s*(?:<\?xml[^>]*\?>\s*)?(?:<!DOCTYPE[^>]*>\s*)?/i;
-const SVG_TAG = /^<svg([^>]*)>([\s\S]*)<\/svg>\s*$/i;
-const ATTR = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*"([^"]*)"|([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*'([^']*)'/g;
+const XML_PROLOGUE = /^\uFEFF?\s*(?:<\?xml[^>]*\?>\s*)?(?:<!DOCTYPE[^>]*>\s*)?/i
+const SVG_TAG = /^<svg([^>]*)>([\s\S]*)<\/svg>\s*$/i
+const ATTR =
+  /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*"([^"]*)"|([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*'([^']*)'/g
 
 function parseRootAttrs(raw: string): Record<string, string> {
-  const attrs: Record<string, string> = {};
+  const attrs: Record<string, string> = {}
   for (const match of raw.matchAll(ATTR)) {
-    const name = match[1] ?? match[3];
-    const value = match[2] ?? match[4] ?? '';
-    if (name) attrs[name] = value;
+    const name = match[1] ?? match[3]
+    const value = match[2] ?? match[4] ?? ''
+    if (name) attrs[name] = value
   }
-  return attrs;
+  return attrs
 }
 
 /**
@@ -43,10 +44,10 @@ function parseRootAttrs(raw: string): Record<string, string> {
  * hydration sees the same markup the server rendered.
  */
 export function svgComponentModule(bytes: Uint8Array): string {
-  const text = new TextDecoder().decode(bytes).replace(XML_PROLOGUE, '').trim();
-  const match = SVG_TAG.exec(text);
-  const rootAttrs = match ? parseRootAttrs(match[1] ?? '') : {};
-  const inner = match ? match[2] : text;
+  const text = new TextDecoder().decode(bytes).replace(XML_PROLOGUE, '').trim()
+  const match = SVG_TAG.exec(text)
+  const rootAttrs = match ? parseRootAttrs(match[1] ?? '') : {}
+  const inner = match ? match[2] : text
   return `import { h } from 'preact';
 const __pnextSvgAttrs = ${JSON.stringify(rootAttrs)};
 const __pnextSvgInner = ${JSON.stringify(inner)};
@@ -54,5 +55,5 @@ function SvgComponent(props) {
   return h('svg', { ...__pnextSvgAttrs, ...props, dangerouslySetInnerHTML: { __html: __pnextSvgInner } });
 }
 export default SvgComponent;
-`;
+`
 }

package/src/compat/next/telemetry.ts

@@ -5,33 +5,33 @@
 // indentation (closing brace at column 0) is part of the contract. pnext sends nothing anywhere - this
 // is wire-format parity only, emitted once per CLI session after next.config loads.
 
-import type { NextConfigObject } from './config-loader';
+import type { NextConfigObject } from './config-loader'
 
-const EVENT_CLI_SESSION_STARTED = 'NEXT_CLI_SESSION_STARTED';
-const EVENT_BUILD_FEATURE_USAGE = 'NEXT_BUILD_FEATURE_USAGE';
+const EVENT_CLI_SESSION_STARTED = 'NEXT_CLI_SESSION_STARTED'
+const EVENT_BUILD_FEATURE_USAGE = 'NEXT_BUILD_FEATURE_USAGE'
 
-let emitted = false;
-let featureUsageEmitted = false;
+let emitted = false
+let featureUsageEmitted = false
 
 function configuredStaleTimes(config: NextConfigObject): { static?: number; dynamic?: number } {
-  const experimental = config.experimental;
-  if (!experimental || typeof experimental !== 'object') return {};
-  const staleTimes = (experimental as { staleTimes?: unknown }).staleTimes;
-  if (!staleTimes || typeof staleTimes !== 'object') return {};
-  const value = staleTimes as { static?: unknown; dynamic?: unknown };
+  const experimental = config.experimental
+  if (!experimental || typeof experimental !== 'object') return {}
+  const staleTimes = (experimental as { staleTimes?: unknown }).staleTimes
+  if (!staleTimes || typeof staleTimes !== 'object') return {}
+  const value = staleTimes as { static?: unknown; dynamic?: unknown }
   return {
     ...(typeof value.static === 'number' ? { static: value.static } : {}),
     ...(typeof value.dynamic === 'number' ? { dynamic: value.dynamic } : {}),
-  };
+  }
 }
 
 /** Print the session-started telemetry event when NEXT_TELEMETRY_DEBUG is on. */
 export function emitSessionStartedTelemetry(config: NextConfigObject): void {
-  if (emitted) return;
+  if (emitted) return
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (!process.env.NEXT_TELEMETRY_DEBUG) return;
-  emitted = true;
-  const staleTimes = configuredStaleTimes(config);
+  if (!process.env.NEXT_TELEMETRY_DEBUG) return
+  emitted = true
+  const staleTimes = configuredStaleTimes(config)
   const event = {
     eventName: EVENT_CLI_SESSION_STARTED,
     payload: {
@@ -40,8 +40,8 @@ export function emitSessionStartedTelemetry(config: NextConfigObject): void {
       staticStaleTime: staleTimes.static ?? null,
       dynamicStaleTime: staleTimes.dynamic ?? null,
     },
-  };
-  console.log(`[telemetry] ${JSON.stringify(event, null, 2)}`);
+  }
+  console.log(`[telemetry] ${JSON.stringify(event, null, 2)}`)
 }
 
 /**
@@ -51,16 +51,16 @@ export function emitSessionStartedTelemetry(config: NextConfigObject): void {
  * any extra key fails the deep match.
  */
 export function emitBuildFeatureUsageTelemetry(config: NextConfigObject): void {
-  if (featureUsageEmitted) return;
+  if (featureUsageEmitted) return
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (!process.env.NEXT_TELEMETRY_DEBUG) return;
-  if ((process.argv[2] ?? '') !== 'build') return;
-  featureUsageEmitted = true;
-  const experimental = config.experimental;
+  if (!process.env.NEXT_TELEMETRY_DEBUG) return
+  if ((process.argv[2] ?? '') !== 'build') return
+  featureUsageEmitted = true
+  const experimental = config.experimental
   const esmExternals =
     experimental && typeof experimental === 'object'
       ? (experimental as { esmExternals?: unknown }).esmExternals
-      : undefined;
+      : undefined
   // Next counts a feature as "used" only when it is set away from its default.
   if (esmExternals !== undefined && esmExternals !== true) {
     console.log(
@@ -72,6 +72,6 @@ export function emitBuildFeatureUsageTelemetry(config: NextConfigObject): void {
         null,
         2,
       )}`,
-    );
+    )
   }
 }