@wular/pnext 0.0.3 → 0.0.6

package/src/{islands → render}/static-children.ts

@@ -1,21 +1,18 @@
-import { h, type ComponentChildren } from 'preact';
+import { h, type ComponentChildren } from 'preact'
 
-export const ISLAND_STATIC_CHILDREN_ATTRIBUTE = 'data-pnext-static-children';
+export const ISLAND_STATIC_CHILDREN_ATTRIBUTE = 'data-pnext-static-children'
 
-export function islandStaticChildren(
-  id: string,
-  children: ComponentChildren,
-) {
-  if (!hasIslandStaticChildren(children)) return undefined;
+export function islandStaticChildren(id: string, children: ComponentChildren) {
+  if (!hasIslandStaticChildren(children)) return undefined
   return h(
     'pnext-static-children',
     { [ISLAND_STATIC_CHILDREN_ATTRIBUTE]: id, style: { display: 'contents' } },
     children,
-  );
+  )
 }
 
 function hasIslandStaticChildren(children: ComponentChildren) {
-  return Array.isArray(children) ? children.length > 0 : children != null && children !== false;
+  return Array.isArray(children) ? children.length > 0 : children != null && children !== false
 }
 
 /**
@@ -25,13 +22,13 @@ function hasIslandStaticChildren(children: ComponentChildren) {
 export function plainIslandChildren(
   children: ComponentChildren,
 ): string | number | (string | number)[] | undefined {
-  if (typeof children === 'string' || typeof children === 'number') return children;
+  if (typeof children === 'string' || typeof children === 'number') return children
   if (
     Array.isArray(children) &&
     children.length > 0 &&
     children.every(child => typeof child === 'string' || typeof child === 'number')
   ) {
-    return children as (string | number)[];
+    return children as (string | number)[]
   }
-  return undefined;
+  return undefined
 }

package/src/{islands → render}/static-slots.ts

@@ -1,10 +1,10 @@
-import { h, type VNode } from 'preact';
-import { isElementLike } from '../utils/serialize';
+import { h, type VNode } from 'preact'
+import { isElementLike } from '../utils/serialize'
 
-export const ISLAND_STATIC_SLOT_ATTRIBUTE = 'data-pnext-static-slot';
-export const ISLAND_STATIC_SLOT_MARKER = '$$pnext_slot';
+export const ISLAND_STATIC_SLOT_ATTRIBUTE = 'data-pnext-static-slot'
+export const ISLAND_STATIC_SLOT_MARKER = '$$pnext_slot'
 
-type Props = Record<string, unknown>;
+type Props = Record<string, unknown>
 
 /**
  * Element-valued island props travel exactly like element children: the SSR pass wraps each one in a
@@ -13,7 +13,7 @@ type Props = Record<string, unknown>;
  * plain objects are covered; anything else (Map/Set values, class instances) is left alone.
  */
 export function islandStaticSlotProps(id: string, props: Props, mode: 'ssr' | 'wire'): Props {
-  return mapSlots(props, id, mode, [], new Set()) as Props;
+  return mapSlots(props, id, mode, [], new Set()) as Props
 }
 
 function mapSlots(
@@ -24,38 +24,38 @@ function mapSlots(
   seen: Set<object>,
 ): unknown {
   if (isElementLike(value)) {
-    const slot = `${id}:${path.join('.')}`;
-    if (mode === 'wire') return { [ISLAND_STATIC_SLOT_MARKER]: slot };
+    const slot = `${id}:${path.join('.')}`
+    if (mode === 'wire') return { [ISLAND_STATIC_SLOT_MARKER]: slot }
     return h(
       'pnext-static-slot',
       { [ISLAND_STATIC_SLOT_ATTRIBUTE]: slot, style: { display: 'contents' } },
       value as VNode,
-    );
+    )
   }
-  if (value === null || typeof value !== 'object') return value;
+  if (value === null || typeof value !== 'object') return value
   // Cyclic props are supported by the serializer; never walk a container twice.
-  if (seen.has(value)) return value;
-  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) return value;
-  seen.add(value);
-  let changed = false;
+  if (seen.has(value)) return value
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) return value
+  seen.add(value)
+  let changed = false
   const entries = Array.isArray(value)
     ? value.map((item, index) => [String(index), item] as const)
-    : Object.entries(value);
+    : Object.entries(value)
   const mapped = entries.map(([key, item]) => {
-    const next = mapSlots(item, id, mode, [...path, key], seen);
-    if (next !== item) changed = true;
-    return [key, next] as const;
-  });
-  seen.delete(value);
+    const next = mapSlots(item, id, mode, [...path, key], seen)
+    if (next !== item) changed = true
+    return [key, next] as const
+  })
+  seen.delete(value)
   // Untouched branches keep their identity (the taint check compares by identity).
-  if (!changed) return value;
-  if (Array.isArray(value)) return mapped.map(([, item]) => item);
-  return Object.fromEntries(mapped);
+  if (!changed) return value
+  if (Array.isArray(value)) return mapped.map(([, item]) => item)
+  return Object.fromEntries(mapped)
 }
 
 /** Cheap gate on the raw props attribute so islands with no element props skip the revive walk. */
 export function hasIslandStaticSlots(raw: string) {
-  return raw.includes(ISLAND_STATIC_SLOT_MARKER);
+  return raw.includes(ISLAND_STATIC_SLOT_MARKER)
 }
 
 /**
@@ -69,7 +69,7 @@ export async function reviveIslandStaticSlots(
   root: ParentNode,
   toChildren: (node: ParentNode) => unknown,
 ): Promise<Props> {
-  return (await reviveSlots(props, root, toChildren, new Set())) as Props;
+  return (await reviveSlots(props, root, toChildren, new Set())) as Props
 }
 
 async function reviveSlots(
@@ -78,29 +78,29 @@ async function reviveSlots(
   toChildren: (node: ParentNode) => unknown,
   seen: Set<object>,
 ): Promise<unknown> {
-  if (value === null || typeof value !== 'object' || seen.has(value)) return value;
-  const marker = (value as Props)[ISLAND_STATIC_SLOT_MARKER];
+  if (value === null || typeof value !== 'object' || seen.has(value)) return value
+  const marker = (value as Props)[ISLAND_STATIC_SLOT_MARKER]
   if (typeof marker === 'string') {
-    const node = root.querySelector(`[${ISLAND_STATIC_SLOT_ATTRIBUTE}="${cssEscape(marker)}"]`);
+    const node = root.querySelector(`[${ISLAND_STATIC_SLOT_ATTRIBUTE}="${cssEscape(marker)}"]`)
     // No server markup for this slot (the island never rendered the prop, or it was skipped for
     // SSR): nothing to adopt, so the prop arrives null rather than as an empty host.
-    if (!node) return null;
+    if (!node) return null
     return h(
       'pnext-static-slot',
       { [ISLAND_STATIC_SLOT_ATTRIBUTE]: marker, style: { display: 'contents' } },
       (await toChildren(node)) as VNode,
-    );
+    )
   }
-  const proto = Object.getPrototypeOf(value) as object | null;
-  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) return value;
-  seen.add(value);
-  const target = value as Props;
+  const proto = Object.getPrototypeOf(value) as object | null
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) return value
+  seen.add(value)
+  const target = value as Props
   for (const key of Object.keys(target)) {
-    target[key] = await reviveSlots(target[key], root, toChildren, seen);
+    target[key] = await reviveSlots(target[key], root, toChildren, seen)
   }
-  return value;
+  return value
 }
 
 function cssEscape(value: string) {
-  return value.replace(/["\\]/g, '\\$&');
+  return value.replace(/["\\]/g, '\\$&')
 }

package/src/{cache/context.ts → request/cache.ts}

@@ -1,34 +1,34 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks'
 
 export interface CacheNode {
-  children: Map<unknown, CacheNode>;
-  record?: CacheRecord;
+  children: Map<unknown, CacheNode>
+  record?: CacheRecord
 }
 
 export type CacheRecord =
   | { status: 'pending'; value: Promise<unknown> }
   | { status: 'resolved'; value: unknown; async: boolean }
-  | { status: 'rejected'; error: unknown; async: boolean };
+  | { status: 'rejected'; error: unknown; async: boolean }
 
 export interface CacheScope {
-  functions: WeakMap<object, CacheNode>;
-  fetches?: Map<string, Promise<unknown>>;
+  functions: WeakMap<object, CacheNode>
+  fetches?: Map<string, Promise<unknown>>
   /**
    * Lazily-created controller backing React.cacheSignal() in a request render. The signal stays live
    * for the whole render - including deferred/streamed Suspense boundaries that resolve after the
    * shell has flushed - so a slow cache component's bounded polling is never cut short. A build
    * prerender uses the prerender scope's signal instead, which aborts at completePrerender().
    */
-  controller?: AbortController;
+  controller?: AbortController
 }
 
 // globalThis-anchored: the prebundled server entry inlines its own copy of this module.
-const CACHE_SCOPE_STORAGE = Symbol.for('pnext.cacheScopeStorage');
+const CACHE_SCOPE_STORAGE = Symbol.for('pnext.cacheScopeStorage')
 const storage = ((globalThis as Record<PropertyKey, unknown>)[CACHE_SCOPE_STORAGE] ??=
-  new AsyncLocalStorage<CacheScope>()) as AsyncLocalStorage<CacheScope>;
+  new AsyncLocalStorage<CacheScope>()) as AsyncLocalStorage<CacheScope>
 
 export function currentCacheScope() {
-  return storage.getStore();
+  return storage.getStore()
 }
 
 /**
@@ -38,16 +38,16 @@ export function currentCacheScope() {
  * boundary's polling. Build prerenders get a deterministically-aborting signal from the prerender scope.
  */
 export function currentCacheSignal(): AbortSignal | null {
-  const scope = storage.getStore();
-  if (!scope) return null;
-  if (!scope.controller) scope.controller = new AbortController();
-  return scope.controller.signal;
+  const scope = storage.getStore()
+  if (!scope) return null
+  if (!scope.controller) scope.controller = new AbortController()
+  return scope.controller.signal
 }
 
 export function runWithCacheScope<T>(callback: () => T): T {
-  const existing = storage.getStore();
-  if (existing) return callback();
-  return storage.run({ functions: new WeakMap() }, callback);
+  const existing = storage.getStore()
+  if (existing) return callback()
+  return storage.run({ functions: new WeakMap() }, callback)
 }
 
 /**
@@ -58,7 +58,7 @@ export function runWithCacheScope<T>(callback: () => T): T {
  * Returns an identity wrapper when no scope is active.
  */
 export function captureCacheScope(): <T>(fn: () => T) => T {
-  const scope = storage.getStore();
-  if (!scope) return fn => fn();
-  return fn => storage.run(scope, fn);
+  const scope = storage.getStore()
+  if (!scope) return fn => fn()
+  return fn => storage.run(scope, fn)
 }