@wular/pnext 0.0.4 → 0.0.6

package/src/compat/next/navigation.ts

@@ -6,7 +6,7 @@ export {
   PNextRedirectError,
   PNextUnauthorizedError,
   unauthorized,
-} from '../../api/navigation';
+} from '../../api/navigation'
 import {
   permanentRedirect as pnextPermanentRedirect,
   PNextForbiddenError,
@@ -15,33 +15,33 @@ import {
   PNextUnauthorizedError,
   ReadonlyURLSearchParams,
   redirect as pnextRedirect,
-} from '../../api/navigation';
-import { isPostpone } from '../../ppr-postpone';
-import { currentParams, currentRequest } from '../../request/context';
-import { useContext } from 'preact/hooks';
+} from '../../api/navigation'
+import { isPostpone } from '../../render/postpone'
+import { currentParams, currentRequest } from '../../request/context'
+import { useContext } from 'preact/hooks'
 import {
   currentLayoutSegments,
   currentParamsSnapshot,
   hasLayoutSegmentScope,
-} from '../../render/slots';
-import { LayoutSegmentContext, RouteParamsContext } from '../../render/island-context';
-import { canonicalUrlHref } from './canonical-url';
-import { isUnrecognizedActionError } from '../actions/unrecognized-error';
-import { stripBasePath } from '../client/base-path';
-import { addBasePath } from '../client/base-path';
-import type { CurrentRoute, PNextRouter } from '../../api/client-navigation';
-import type { RouteParams, RoutePath } from '../../types';
-
-export type { RedirectStatus } from '../../api/navigation';
-export type { CurrentRoute, PNextRouter } from '../../api/client-navigation';
-export { ReadonlyURLSearchParams };
+} from '../../render/slots'
+import { LayoutSegmentContext, RouteParamsContext } from '../../render/island-context'
+import { canonicalUrlHref } from './canonical-url'
+import { isUnrecognizedActionError } from '../actions/unrecognized-error'
+import { stripBasePath } from '../client/base-path'
+import { addBasePath } from '../client/base-path'
+import type { CurrentRoute, PNextRouter } from '../../api/client-navigation'
+import type { RouteParams, RoutePath } from '../../types'
+
+export type { RedirectStatus } from '../../api/navigation'
+export type { CurrentRoute, PNextRouter } from '../../api/client-navigation'
+export { ReadonlyURLSearchParams }
 
 export const RedirectType = {
   push: 'push',
   replace: 'replace',
-} as const;
+} as const
 
-export type RedirectType = (typeof RedirectType)[keyof typeof RedirectType];
+export type RedirectType = (typeof RedirectType)[keyof typeof RedirectType]
 
 export function redirect(location: string, type?: RedirectType): never {
   try {
@@ -49,19 +49,19 @@ export function redirect(location: string, type?: RedirectType): never {
     // targets outside the basePath) are left as-is. Normalizing here means every downstream consumer -
     // the page-GET redirect response and the server-action redirect envelope - sees a basePath-space
     // location uniformly.
-    pnextRedirect(addBasePath(location));
+    pnextRedirect(addBasePath(location))
   } catch (error) {
     // Server actions honor push/replace history semantics on the client;
     // carry the requested type on the control-flow error.
     if (type && error instanceof PNextRedirectError) {
-      (error as PNextRedirectError & { redirectType?: RedirectType }).redirectType = type;
+      ;(error as PNextRedirectError & { redirectType?: RedirectType }).redirectType = type
     }
-    throw error;
+    throw error
   }
 }
 
 export function permanentRedirect(location: string, _type?: RedirectType): never {
-  pnextPermanentRedirect(addBasePath(location));
+  pnextPermanentRedirect(addBasePath(location))
 }
 
 /** Rethrow framework control-flow errors so user catch blocks don't swallow them. */
@@ -73,7 +73,7 @@ export function unstable_rethrow(error: unknown): void {
     error instanceof PNextUnauthorizedError ||
     isPostpone(error)
   ) {
-    throw error;
+    throw error
   }
 }
 
@@ -85,22 +85,22 @@ const serverRouter: PNextRouter = {
   back: () => undefined,
   forward: () => undefined,
   bfcacheId: '',
-};
+}
 
 export function useRouter(): PNextRouter {
-  return serverRouter;
+  return serverRouter
 }
 
 export function usePathname() {
-  return stripBasePath(currentUrl().pathname);
+  return stripBasePath(currentUrl().pathname)
 }
 
 export function useSearchParams(): ReadonlyURLSearchParams {
-  return new ReadonlyURLSearchParams(currentUrl().search);
+  return new ReadonlyURLSearchParams(currentUrl().search)
 }
 
 export function useParams<Route extends RoutePath = RoutePath>() {
-  return resolveParams() as RouteParams<Route>;
+  return resolveParams() as RouteParams<Route>
 }
 
 /**
@@ -112,41 +112,39 @@ export function useParams<Route extends RoutePath = RoutePath>() {
  * runs during a preact render.
  */
 function resolveParams(): Record<string, string | string[]> {
-  const scope = currentParamsSnapshot();
-  if (scope) return scope;
+  const scope = currentParamsSnapshot()
+  if (scope) return scope
   // Island SSR (a `'use client'` component in a slot) reads the snapshot from
   // the RouteParamsContext the renderer wraps around it. useContext is only
   // valid inside a preact render; a plain server component resolved by direct
   // call has no hook context, so guard it and fall back to the global params.
   try {
-    const snapshot = useContext(RouteParamsContext);
-    if (snapshot) return snapshot;
+    const snapshot = useContext(RouteParamsContext)
+    if (snapshot) return snapshot
   } catch {
     // not in a preact render — fall through to global route params
   }
-  return currentParams();
+  return currentParams()
 }
 
 export function useRoute<Route extends RoutePath = RoutePath>(): CurrentRoute<Route> {
-  const url = currentUrl();
+  const url = currentUrl()
   return {
     route: null,
     pathname: url.pathname,
     params: resolveParams() as RouteParams<Route>,
     searchParams: new ReadonlyURLSearchParams(url.search),
-  };
+  }
 }
 
-export function useSelectedLayoutSegment(
-  parallelRoutesKey?: string,
-): string | null {
-  const segments = selectedLayoutSegments(parallelRoutesKey);
-  return segments[parallelRoutesKey ? segments.length - 1 : 0] ?? null;
+export function useSelectedLayoutSegment(parallelRoutesKey?: string): string | null {
+  const segments = selectedLayoutSegments(parallelRoutesKey)
+  return segments[parallelRoutesKey ? segments.length - 1 : 0] ?? null
 }
 
 export function useSelectedLayoutSegments(parallelRoutesKey?: string): string[] {
   // A defensive copy so callers can't mutate the render-scoped array.
-  return [...selectedLayoutSegments(parallelRoutesKey)];
+  return [...selectedLayoutSegments(parallelRoutesKey)]
 }
 
 /**
@@ -156,14 +154,14 @@ export function useSelectedLayoutSegments(parallelRoutesKey?: string): string[]
  * re-provides at mount. useContext is safe: the no-scope branch only runs during a preact render.
  */
 function selectedLayoutSegments(parallelRoutesKey?: string): string[] {
-  if (hasLayoutSegmentScope()) return currentLayoutSegments(parallelRoutesKey);
-  const snapshot = useContext(LayoutSegmentContext);
-  if (!snapshot) return [];
-  return parallelRoutesKey ? (snapshot.slots[parallelRoutesKey] ?? []) : snapshot.segments;
+  if (hasLayoutSegmentScope()) return currentLayoutSegments(parallelRoutesKey)
+  const snapshot = useContext(LayoutSegmentContext)
+  if (!snapshot) return []
+  return parallelRoutesKey ? (snapshot.slots[parallelRoutesKey] ?? []) : snapshot.segments
 }
 
 export function useLinkStatus() {
-  return { pending: false };
+  return { pending: false }
 }
 
 /**
@@ -172,7 +170,7 @@ export function useLinkStatus() {
  * asked for read the recorded canonical URL first (see canonical-url.ts).
  */
 function currentUrl() {
-  return new URL(canonicalUrlHref() ?? currentRequest()?.url ?? 'http://pnext.local/');
+  return new URL(canonicalUrlHref() ?? currentRequest()?.url ?? 'http://pnext.local/')
 }
 
 /**
@@ -181,8 +179,8 @@ function currentUrl() {
  * action endpoint sends for an unknown id.
  */
 export function unstable_isUnrecognizedActionError(error: unknown): boolean {
-  return isUnrecognizedActionError(error);
+  return isUnrecognizedActionError(error)
 }
 
 // CSS-in-JS SSR insertion hook (Next exports it from next/navigation).
-export { useServerInsertedHTML } from '../react/server-inserted-html';
+export { useServerInsertedHTML } from '../react/server-inserted-html'

package/src/compat/next/offline.ts

@@ -1,33 +1,33 @@
 // `next/offline` - the useOffline() hook. Reports whether the app is currently offline: false on the
 // server and during hydration; in the browser it tracks the native online/offline events. The router's
-// own offline handling (soft-nav retry on reconnect) lives in api/router.ts; this hook is only the
+// own offline handling (soft-nav retry on reconnect) lives in client/router/index.ts; this hook is only the
 // UI-facing subscription.
 
-import { useEffect, useState } from 'preact/hooks';
+import { useEffect, useState } from 'preact/hooks'
 
-type Listener = () => void;
+type Listener = () => void
 
-const listeners = new Set<Listener>();
-let installed = false;
-let offline = false;
+const listeners = new Set<Listener>()
+let installed = false
+let offline = false
 
 function currentOffline(): boolean {
-  if (typeof navigator === 'undefined') return false;
-  return navigator.onLine === false;
+  if (typeof navigator === 'undefined') return false
+  return navigator.onLine === false
 }
 
 function install() {
-  if (installed || (!process.browser && typeof window === 'undefined')) return;
-  installed = true;
-  offline = currentOffline();
+  if (installed || (!process.browser && typeof window === 'undefined')) return
+  installed = true
+  offline = currentOffline()
   const update = () => {
-    const next = currentOffline();
-    if (next === offline) return;
-    offline = next;
-    for (const listener of [...listeners]) listener();
-  };
-  window.addEventListener('offline', update);
-  window.addEventListener('online', update);
+    const next = currentOffline()
+    if (next === offline) return
+    offline = next
+    for (const listener of [...listeners]) listener()
+  }
+  window.addEventListener('offline', update)
+  window.addEventListener('online', update)
 }
 
 /**
@@ -36,16 +36,16 @@ function install() {
  * client-side signal only).
  */
 export function useOffline(): boolean {
-  const [value, setValue] = useState(false);
+  const [value, setValue] = useState(false)
   useEffect(() => {
-    install();
-    const listener = () => setValue(offline);
-    listeners.add(listener);
+    install()
+    const listener = () => setValue(offline)
+    listeners.add(listener)
     // The state may have flipped between render and subscription.
-    listener();
+    listener()
     return () => {
-      listeners.delete(listener);
-    };
-  }, []);
-  return value;
+      listeners.delete(listener)
+    }
+  }, [])
+  return value
 }