@wular/pnext 0.0.4 → 0.0.6

package/src/compat/next/constants.cjs

@@ -1,6 +1,6 @@
-exports.PHASE_EXPORT = 'phase-export';
-exports.PHASE_PRODUCTION_BUILD = 'phase-production-build';
-exports.PHASE_PRODUCTION_SERVER = 'phase-production-server';
-exports.PHASE_DEVELOPMENT_SERVER = 'phase-development-server';
-exports.PHASE_TEST = 'phase-test';
-exports.PHASE_INFO = 'phase-info';
+exports.PHASE_EXPORT = 'phase-export'
+exports.PHASE_PRODUCTION_BUILD = 'phase-production-build'
+exports.PHASE_PRODUCTION_SERVER = 'phase-production-server'
+exports.PHASE_DEVELOPMENT_SERVER = 'phase-development-server'
+exports.PHASE_TEST = 'phase-test'
+exports.PHASE_INFO = 'phase-info'

package/src/compat/next/constants.ts

@@ -1,6 +1,6 @@
-export const PHASE_EXPORT = 'phase-export';
-export const PHASE_PRODUCTION_BUILD = 'phase-production-build';
-export const PHASE_PRODUCTION_SERVER = 'phase-production-server';
-export const PHASE_DEVELOPMENT_SERVER = 'phase-development-server';
-export const PHASE_TEST = 'phase-test';
-export const PHASE_INFO = 'phase-info';
+export const PHASE_EXPORT = 'phase-export'
+export const PHASE_PRODUCTION_BUILD = 'phase-production-build'
+export const PHASE_PRODUCTION_SERVER = 'phase-production-server'
+export const PHASE_DEVELOPMENT_SERVER = 'phase-development-server'
+export const PHASE_TEST = 'phase-test'
+export const PHASE_INFO = 'phase-info'

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

@@ -13,27 +13,27 @@
 // Only a missing, symlinked, or previously shimmed `node_modules/next` is replaced: the e2e harness
 // links the real Next checkout for tsc typechecks, and fixtures with a genuinely installed `next` are
 // left alone.
-import { existsSync, lstatSync, readFileSync } from 'node:fs';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { ResolvedConfig } from '../../config';
+import { existsSync, lstatSync, readFileSync } from 'node:fs'
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
 
-const SERVER_ENTRY_NAMES = ['server.js', 'server.mjs', 'server.cjs', 'server.ts'];
-const SHIM_VERSION = '0.0.0-pnext-custom-server';
+const SERVER_ENTRY_NAMES = ['server.js', 'server.mjs', 'server.cjs', 'server.ts']
+const SHIM_VERSION = '0.0.0-pnext-custom-server'
 
 /** Whether the app root ships a custom server entry that imports 'next'. */
 export function hasCustomServerEntry(root: string): boolean {
   for (const name of SERVER_ENTRY_NAMES) {
-    const file = path.join(root, name);
-    if (!existsSync(file)) continue;
+    const file = path.join(root, name)
+    if (!existsSync(file)) continue
     try {
-      const source = readFileSync(file, 'utf8');
-      if (/(?:require\(\s*['"]next['"]\s*\)|from\s+['"]next['"])/.test(source)) return true;
+      const source = readFileSync(file, 'utf8')
+      if (/(?:require\(\s*['"]next['"]\s*\)|from\s+['"]next['"])/.test(source)) return true
     } catch {
       // Unreadable entry — skip.
     }
   }
-  return false;
+  return false
 }
 
 /**
@@ -42,32 +42,34 @@ export function hasCustomServerEntry(root: string): boolean {
  * third-party install (absent, symlinked, or an earlier shim is replaced).
  */
 export async function emitCustomServerShim(config: ResolvedConfig): Promise<void> {
-  if (!hasCustomServerEntry(config.root)) return;
-  const target = path.join(config.root, 'node_modules', 'next');
+  if (!hasCustomServerEntry(config.root)) return
+  const target = path.join(config.root, 'node_modules', 'next')
   try {
-    const stat = lstatSync(target);
+    const stat = lstatSync(target)
     // A previously emitted shim is a real directory too — refresh it, so a
     // rebuild in an existing test dir never keeps a stale copy.
-    if (!stat.isSymbolicLink() && !isEmittedShim(target)) return; // real install — leave it alone
-    await rm(target, { recursive: true, force: true });
+    if (!stat.isSymbolicLink() && !isEmittedShim(target)) return // real install — leave it alone
+    await rm(target, { recursive: true, force: true })
   } catch {
     // Missing — create fresh below.
   }
-  await mkdir(target, { recursive: true });
+  await mkdir(target, { recursive: true })
   await writeFile(
     path.join(target, 'package.json'),
     `${JSON.stringify({ name: 'next', version: SHIM_VERSION, main: 'index.cjs' }, null, 2)}\n`,
-  );
-  await writeFile(path.join(target, 'index.cjs'), customServerShimSource());
+  )
+  await writeFile(path.join(target, 'index.cjs'), customServerShimSource())
 }
 
 /** Whether `node_modules/next` is a shim this build emitted earlier. */
 function isEmittedShim(target: string): boolean {
   try {
-    const pkg = JSON.parse(readFileSync(path.join(target, 'package.json'), 'utf8')) as { version?: string };
-    return pkg.version === SHIM_VERSION;
+    const pkg = JSON.parse(readFileSync(path.join(target, 'package.json'), 'utf8')) as {
+      version?: string
+    }
+    return pkg.version === SHIM_VERSION
   } catch {
-    return false;
+    return false
   }
 }
 
@@ -76,7 +78,7 @@ function isEmittedShim(target: string): boolean {
  * same runtime the harness/build used, from any app directory.
  */
 function customServerShimSource(): string {
-  const cliPath = path.resolve(import.meta.dirname, '..', '..', 'cli', 'index.ts');
+  const cliPath = path.resolve(import.meta.dirname, '..', '..', 'cli', 'index.ts')
   return `'use strict';
 // pnext custom-server shim for require('next') / import next from 'next'.
 // Generated by pnext build; see src/compat/next/custom-server.ts.
@@ -232,5 +234,5 @@ function createServer(options = {}) {
 
 module.exports = createServer;
 module.exports.default = createServer;
-`;
+`
 }

package/src/compat/next/dist/client/components/app-router-headers.ts

@@ -1,16 +1,16 @@
 // Header-name constants matching
 // next/src/client/components/app-router-headers.ts exactly.
-export const RSC_HEADER = 'rsc' as const;
-export const ACTION_HEADER = 'next-action' as const;
-export const NEXT_ROUTER_STATE_TREE_HEADER = 'next-router-state-tree' as const;
-export const NEXT_ROUTER_PREFETCH_HEADER = 'next-router-prefetch' as const;
-export const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'next-router-segment-prefetch' as const;
-export const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh' as const;
-export const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__' as const;
-export const NEXT_URL = 'next-url' as const;
-export const RSC_CONTENT_TYPE_HEADER = 'text/x-component' as const;
+export const RSC_HEADER = 'rsc' as const
+export const ACTION_HEADER = 'next-action' as const
+export const NEXT_ROUTER_STATE_TREE_HEADER = 'next-router-state-tree' as const
+export const NEXT_ROUTER_PREFETCH_HEADER = 'next-router-prefetch' as const
+export const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'next-router-segment-prefetch' as const
+export const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh' as const
+export const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__' as const
+export const NEXT_URL = 'next-url' as const
+export const RSC_CONTENT_TYPE_HEADER = 'text/x-component' as const
 
-export const NEXT_INSTANT_TEST_COOKIE = 'next-instant-navigation-testing' as const;
+export const NEXT_INSTANT_TEST_COOKIE = 'next-instant-navigation-testing' as const
 
 export const FLIGHT_HEADERS = [
   RSC_HEADER,
@@ -18,15 +18,15 @@ export const FLIGHT_HEADERS = [
   NEXT_ROUTER_PREFETCH_HEADER,
   NEXT_HMR_REFRESH_HEADER,
   NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
-] as const;
+] as const
 
-export const NEXT_RSC_UNION_QUERY = '_rsc' as const;
-export const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time' as const;
-export const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed' as const;
-export const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path' as const;
-export const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query' as const;
-export const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender' as const;
-export const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found' as const;
-export const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id' as const;
-export const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id' as const;
-export const NEXT_ACTION_REVALIDATED_HEADER = 'x-action-revalidated' as const;
+export const NEXT_RSC_UNION_QUERY = '_rsc' as const
+export const NEXT_ROUTER_STALE_TIME_HEADER = 'x-nextjs-stale-time' as const
+export const NEXT_DID_POSTPONE_HEADER = 'x-nextjs-postponed' as const
+export const NEXT_REWRITTEN_PATH_HEADER = 'x-nextjs-rewritten-path' as const
+export const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query' as const
+export const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender' as const
+export const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found' as const
+export const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id' as const
+export const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id' as const
+export const NEXT_ACTION_REVALIDATED_HEADER = 'x-action-revalidated' as const

package/src/compat/next/dist/server/app-render/work-unit-async-storage.external.cjs

@@ -6,7 +6,7 @@
 // framework populates during a render. Next backs that with an
 // AsyncLocalStorage whose store carries `type` ('request' | 'prerender' |
 // 'prerender-runtime') plus, for a request work unit, `cookies`/`headers`.
-// pnext keeps that state in core (src/request/context.ts, src/ppr.ts) and
+// pnext keeps that state in core (src/request/context.ts, src/render/ppr.ts) and
 // publishes a getter onto globalThis, which this module reflects — so a direct
 // import observes the live store rather than a separate, empty instance.
 //
@@ -16,7 +16,7 @@
 // requirable. The same module as a `.ts` external is forced through that
 // transform, becomes an async module, and `require()` throws
 // "require() async module ... is unsupported". Same rule as constants.cjs /
-// navigation.cjs — see the note in src/compat/index.ts.
+// navigation.cjs — see the note in src/compat/aliases.ts.
 const WORK_UNIT_EXTERNAL = Symbol.for('pnext.workUnitExternal')
 /** @type {Record<PropertyKey, unknown>} */
 const root = globalThis
@@ -24,8 +24,7 @@ const root = globalThis
 const workUnitAsyncStorage = {
   // Never undefined: fixtures do `getStore().type` during build prerenders as
   // well as live requests. Core's getter always answers with a store.
-  getStore: () =>
-    /** @type {(() => unknown) | undefined} */ (root[WORK_UNIT_EXTERNAL])?.(),
+  getStore: () => /** @type {(() => unknown) | undefined} */ (root[WORK_UNIT_EXTERNAL])?.(),
   /**
    * @param {unknown} _store
    * @param {(...args: unknown[]) => unknown} callback

package/src/compat/next/dist/server/web/spec-extension/revalidate.ts

@@ -1 +1 @@
-export { revalidatePath, revalidateTag } from '../../../../cache';
+export { revalidatePath, revalidateTag } from '../../../../cache'

package/src/compat/next/dist/server/web/spec-extension/unstable-cache.ts

@@ -1 +1 @@
-export { unstable_cache } from '../../../../cache';
+export { unstable_cache } from '../../../../cache'

package/src/compat/next/dist/server/web/spec-extension/unstable-no-store.ts

@@ -1 +1 @@
-export { unstable_noStore } from '../../../../cache';
+export { unstable_noStore } from '../../../../cache'

package/src/compat/next/dynamic.tsx

@@ -1,5 +1,5 @@
-import { h, type ComponentType } from 'preact';
-import { lazy, Suspense } from 'preact/compat';
+import { h, type ComponentType } from 'preact'
+import { lazy, Suspense } from 'preact/compat'
 import {
   dynamic as pnextDynamic,
   dynamicReferenceSymbol,
@@ -8,9 +8,9 @@ import {
   type DynamicOptions,
   type DynamicReference,
   type DynamicTarget,
-} from '../../api/dynamic';
+} from '../../api/dynamic'
 
-export type { DynamicLoader, DynamicModule, DynamicOptions };
+export type { DynamicLoader, DynamicModule, DynamicOptions }
 
 export default function dynamic<Props extends object = object>(
   loader: DynamicLoader<Props>,
@@ -18,33 +18,36 @@ export default function dynamic<Props extends object = object>(
   // Injected by the server compile; see rewriteDynamicCallTargets.
   target?: DynamicTarget,
 ) {
-  if (typeof loader === 'string') return pnextDynamic(loader, options, target);
+  if (typeof loader === 'string') return pnextDynamic(loader, options, target)
 
-  const coreDynamic = pnextDynamic(loader, options, target) as DynamicWithReference<Props>;
-  const Lazy = lazy(() => loader().then(module => ({ default: componentFromModule(module) })));
+  const coreDynamic = pnextDynamic(loader, options, target) as DynamicWithReference<Props>
+  const Lazy = lazy(() => loader().then(module => ({ default: componentFromModule(module) })))
   const DynamicComponent = ((props: Props) => {
-    const Loading = options.loading;
+    const Loading = options.loading
     // ssr:false renders nothing on the server, so the client mount is a *hydration* whose only child
     // suspends. preact/compat nulls a hydrating vnode's type when it unmounts, and Suspense reuses the
     // same props.children vnode on its resolve re-render - the poisoned element then renders as text.
     // The hooks-based core component loads without suspending, so that boundary is never entered.
     if (options.ssr === false) {
-      return h('pnext-dynamic', { style: { display: 'contents' } },
-        (!process.browser && typeof window === 'undefined') ? null : h(coreDynamic, props));
+      return h(
+        'pnext-dynamic',
+        { style: { display: 'contents' } },
+        !process.browser && typeof window === 'undefined' ? null : h(coreDynamic, props),
+      )
     }
-    return h(Suspense, { fallback: Loading ? h(Loading, props) : null }, h(Lazy, props));
-  }) as DynamicWithReference<Props>;
+    return h(Suspense, { fallback: Loading ? h(Loading, props) : null }, h(Lazy, props))
+  }) as DynamicWithReference<Props>
 
-  DynamicComponent[dynamicReferenceSymbol] = coreDynamic[dynamicReferenceSymbol];
-  return DynamicComponent;
+  DynamicComponent[dynamicReferenceSymbol] = coreDynamic[dynamicReferenceSymbol]
+  return DynamicComponent
 }
 
-export { dynamic };
+export { dynamic }
 
 type DynamicWithReference<Props extends object> = ComponentType<Props> & {
-  [dynamicReferenceSymbol]?: DynamicReference<Props>;
-};
+  [dynamicReferenceSymbol]?: DynamicReference<Props>
+}
 
 function componentFromModule<Props>(module: DynamicModule<Props>) {
-  return typeof module === 'function' ? module : module.default;
+  return typeof module === 'function' ? module : module.default
 }

package/src/compat/next/error.tsx

@@ -1,13 +1,13 @@
-'use client';
+'use client'
 
-import { Component, Fragment, h, type ComponentChildren, type ComponentType } from 'preact';
-import { isControlFlowError } from '../client/errors/control-flow';
-import { untagPrimitiveThrow } from '../client/errors/primitive-throw';
+import { Component, Fragment, h, type ComponentChildren, type ComponentType } from 'preact'
+import { isControlFlowError } from '../client/errors/control-flow'
+import { untagPrimitiveThrow } from '../client/errors/primitive-throw'
 
 export interface ErrorInfo {
-  error: unknown;
-  reset: () => void;
-  unstable_retry: () => void;
+  error: unknown
+  reset: () => void
+  unstable_retry: () => void
 }
 
 // Island error-boundary protocol (see render/renderer.ts): when a Server Component inside this
@@ -17,64 +17,64 @@ export interface ErrorInfo {
 // state and the server-rendered fallback hydrates interactive. Without this handoff the client would
 // remount with "no error" and blank out the fallback. The renderer only performs the handoff for
 // components carrying `Symbol.for('pnext.islandErrorBoundary')`, stamped below.
-const ISLAND_BOUNDARY_ERROR_PROP = '__pnextBoundaryError';
-const islandErrorBoundarySymbol = Symbol.for('pnext.islandErrorBoundary');
+const ISLAND_BOUNDARY_ERROR_PROP = '__pnextBoundaryError'
+const islandErrorBoundarySymbol = Symbol.for('pnext.islandErrorBoundary')
 
 interface IslandBoundaryErrorMarker {
-  name?: string;
-  message?: string;
-  digest?: string;
+  name?: string
+  message?: string
+  digest?: string
 }
 
 interface CatchErrorProps {
-  children?: ComponentChildren;
-  clearError?: () => void;
-  [ISLAND_BOUNDARY_ERROR_PROP]?: IslandBoundaryErrorMarker;
+  children?: ComponentChildren
+  clearError?: () => void
+  [ISLAND_BOUNDARY_ERROR_PROP]?: IslandBoundaryErrorMarker
 }
 
 interface CatchErrorState {
-  error: unknown;
-  hasError: boolean;
-  version: number;
+  error: unknown
+  hasError: boolean
+  version: number
 }
 
 function reviveBoundaryError(marker: IslandBoundaryErrorMarker): Error & { digest?: string } {
-  const error = new Error(String(marker.message ?? '')) as Error & { digest?: string };
-  if (marker.name) error.name = String(marker.name);
-  if (typeof marker.digest === 'string') error.digest = marker.digest;
-  return error;
+  const error = new Error(String(marker.message ?? '')) as Error & { digest?: string }
+  if (marker.name) error.name = String(marker.name)
+  if (typeof marker.digest === 'string') error.digest = marker.digest
+  return error
 }
 
 function initialCatchErrorState(props: CatchErrorProps): CatchErrorState {
-  const marker = props[ISLAND_BOUNDARY_ERROR_PROP];
+  const marker = props[ISLAND_BOUNDARY_ERROR_PROP]
   if (marker && typeof marker === 'object') {
-    return { error: reviveBoundaryError(marker), hasError: true, version: 0 };
+    return { error: reviveBoundaryError(marker), hasError: true, version: 0 }
   }
-  return { error: undefined, hasError: false, version: 0 };
+  return { error: undefined, hasError: false, version: 0 }
 }
 
 export function unstable_catchError<Props extends Record<string, unknown>>(
   Fallback: (props: Props, info: ErrorInfo) => ComponentChildren,
 ): ComponentType<Props & CatchErrorProps> {
   class CatchError extends Component<Props & CatchErrorProps, CatchErrorState> {
-    state: CatchErrorState = initialCatchErrorState(this.props);
+    state: CatchErrorState = initialCatchErrorState(this.props)
 
     static getDerivedStateFromError(error: unknown): Partial<CatchErrorState> {
       // Router signals belong to their owning route boundary. Capturing one
       // here turns a redirect/notFound into a stale local fallback instead of
       // letting the client control-flow handler complete the navigation.
-      if (isControlFlowError(error)) throw error;
-      return { error: normalizeBoundaryError(error), hasError: true };
+      if (isControlFlowError(error)) throw error
+      return { error: normalizeBoundaryError(error), hasError: true }
     }
 
     reset = () => {
-      this.props.clearError?.();
+      this.props.clearError?.()
       this.setState(state => ({
         error: undefined,
         hasError: false,
         version: state.version + 1,
-      }));
-    };
+      }))
+    }
 
     unstable_retry = () => {
       // App-Router only: `unstable_retry` re-runs the server render, which the Pages Router has no
@@ -84,52 +84,52 @@ export function unstable_catchError<Props extends Record<string, unknown>>(
       if (!isAppRouterDocument()) {
         throw new Error(
           '`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.',
-        );
+        )
       }
       if (!process.browser && typeof window === 'undefined') {
-        this.reset();
-        return;
+        this.reset()
+        return
       }
       // Refresh FIRST, reset when it settles. Resetting immediately re-renders the children while the
       // refresh response is still in flight; anything the user does in that window is wiped when the
       // body swap lands, so a rapid retry-then-interact cycle loses the new state. Deferring the reset
       // closes that window (if the swap remounted this boundary the setState is a no-op on an unmounted
       // instance, which preact ignores). A failed refresh still resets.
-      const refreshed = routerRefresh();
+      const refreshed = routerRefresh()
       void Promise.resolve(refreshed)
         .catch(() => undefined)
-        .then(() => this.reset());
-    };
+        .then(() => this.reset())
+    }
 
     render(props: Props & CatchErrorProps, state: CatchErrorState) {
       if (state.hasError) {
         // Strip the internal handoff marker; the user's fallback gets the
         // component's own props (title, clearError, ...), matching Next.
-        const { [ISLAND_BOUNDARY_ERROR_PROP]: _marker, ...rest } = props;
+        const { [ISLAND_BOUNDARY_ERROR_PROP]: _marker, ...rest } = props
         return Fallback(rest as unknown as Props, {
           error: state.error,
           reset: this.reset,
           unstable_retry: this.unstable_retry,
-        });
+        })
       }
-      return h(Fragment, { key: state.version }, props.children);
+      return h(Fragment, { key: state.version }, props.children)
     }
   }
   // Opt in to the renderer's island error-boundary handoff (see above).
-  (CatchError as unknown as Record<symbol, boolean>)[islandErrorBoundarySymbol] = true;
-  return CatchError;
+  ;(CatchError as unknown as Record<symbol, boolean>)[islandErrorBoundarySymbol] = true
+  return CatchError
 }
 
 function isAppRouterDocument(): boolean {
-  if (typeof document === 'undefined') return false;
-  return Boolean(document.querySelector('pnext-layout, [data-pnext-root]'));
+  if (typeof document === 'undefined') return false
+  return Boolean(document.querySelector('pnext-layout, [data-pnext-root]'))
 }
 
 function routerRefresh() {
   const global = window as unknown as {
-    __PNEXT_ROUTER__?: { refresh?: () => Promise<void> | void };
-  };
-  return global.__PNEXT_ROUTER__?.refresh?.();
+    __PNEXT_ROUTER__?: { refresh?: () => Promise<void> | void }
+  }
+  return global.__PNEXT_ROUTER__?.refresh?.()
 }
 
 function normalizeBoundaryError(error: unknown): unknown {
@@ -137,12 +137,12 @@ function normalizeBoundaryError(error: unknown): unknown {
   // `throw undefined`/`null` arrives here re-thrown as a tagged Error so it
   // survived preact's own `e.then` suspense check without crashing. Unwrap
   // back to the raw value Next passes to error UIs.
-  const untagged = untagPrimitiveThrow(error);
-  if (untagged !== error) return untagged;
+  const untagged = untagPrimitiveThrow(error)
+  if (untagged !== error) return untagged
   if (error instanceof Error) {
     // Fallback for any crash that slips through un-tagged (defense in depth).
-    if (error.message === "Cannot read properties of undefined (reading 'then')") return undefined;
-    if (error.message === "Cannot read properties of null (reading 'then')") return null;
+    if (error.message === "Cannot read properties of undefined (reading 'then')") return undefined
+    if (error.message === "Cannot read properties of null (reading 'then')") return null
   }
-  return error;
+  return error
 }