@wular/pnext 0.0.4 → 0.0.6

package/src/utils/serialize.ts

@@ -3,22 +3,22 @@
 // as the action wire's $$pnext_date) instead of throwing; the client/server
 // revive the marker back into the original view. assertSerializable accepts
 // them (they are "serializable" via the marker path) rather than rejecting.
-const TYPED_ARRAY_MARKER = '$$pnext_typed_array';
-const ARRAY_BUFFER_MARKER = '$$pnext_array_buffer';
+const TYPED_ARRAY_MARKER = '$$pnext_typed_array'
+const ARRAY_BUFFER_MARKER = '$$pnext_array_buffer'
 // Map/Set are part of React's flight wire vocabulary (client components can receive them as props); pnext
 // does not stream them as distinct RSC row types yet, so they ride as ordinary marker objects, entries
 // encoded recursively like the binary markers above, instead of throwing "must be a plain object". Client
 // code that only round-trips the value sees a marker object rather than a live Map/Set instance - a known
 // gap, not a full flight-protocol Map/Set.
-const MAP_MARKER = '$$pnext_map';
-const SET_MARKER = '$$pnext_set';
+const MAP_MARKER = '$$pnext_map'
+const SET_MARKER = '$$pnext_set'
 // Cyclic props (a client component receiving `obj.self === obj`) are part of React's flight vocabulary:
 // flight emits a BACK-REFERENCE to the row/path the value was first written at rather than expanding it
 // forever. Same idea here, scoped to the ancestor chain: an object that reappears INSIDE ITSELF is written as
 // `{$$pnext_ref: [...path from the props root]}` and the client patches the original object back in,
 // restoring identity. Only true cycles are encoded this way - a value that merely appears twice in different
 // branches is still expanded, so every acyclic payload is byte-identical to what it was before.
-const REF_MARKER = '$$pnext_ref';
+const REF_MARKER = '$$pnext_ref'
 
 type TypedArray =
   | Int8Array
@@ -31,26 +31,26 @@ type TypedArray =
   | Float32Array
   | Float64Array
   | BigInt64Array
-  | BigUint64Array;
+  | BigUint64Array
 
 function isTypedArray(value: unknown): value is TypedArray {
-  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+  return ArrayBuffer.isView(value) && !(value instanceof DataView)
 }
 
 function bytesToBase64(bytes: Uint8Array): string {
-  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64');
-  let binary = '';
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
+  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64')
+  let binary = ''
+  for (const byte of bytes) binary += String.fromCharCode(byte)
+  return btoa(binary)
 }
 
 function encodeTypedArray(value: TypedArray) {
-  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  return { [TYPED_ARRAY_MARKER]: { type: value.constructor.name, data: bytesToBase64(bytes) } };
+  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+  return { [TYPED_ARRAY_MARKER]: { type: value.constructor.name, data: bytesToBase64(bytes) } }
 }
 
 function encodeArrayBuffer(value: ArrayBuffer) {
-  return { [ARRAY_BUFFER_MARKER]: bytesToBase64(new Uint8Array(value)) };
+  return { [ARRAY_BUFFER_MARKER]: bytesToBase64(new Uint8Array(value)) }
 }
 
 /**
@@ -66,24 +66,20 @@ function encodeBinary(
   ancestors = new Map<object, string[]>(),
   path: string[] = [],
 ): unknown {
-  if (value === null || typeof value !== 'object') return value;
-  if (isTypedArray(value)) return encodeTypedArray(value);
-  if (value instanceof ArrayBuffer) return encodeArrayBuffer(value);
-  const ancestorPath = ancestors.get(value);
-  if (ancestorPath) return { [REF_MARKER]: ancestorPath };
-  ancestors.set(value, path);
-  const encoded = encodeContainer(value, ancestors, path);
-  ancestors.delete(value);
-  return encoded;
+  if (value === null || typeof value !== 'object') return value
+  if (isTypedArray(value)) return encodeTypedArray(value)
+  if (value instanceof ArrayBuffer) return encodeArrayBuffer(value)
+  const ancestorPath = ancestors.get(value)
+  if (ancestorPath) return { [REF_MARKER]: ancestorPath }
+  ancestors.set(value, path)
+  const encoded = encodeContainer(value, ancestors, path)
+  ancestors.delete(value)
+  return encoded
 }
 
-function encodeContainer(
-  value: object,
-  ancestors: Map<object, string[]>,
-  path: string[],
-): unknown {
+function encodeContainer(value: object, ancestors: Map<object, string[]>, path: string[]): unknown {
   if (Array.isArray(value)) {
-    return value.map((item, index) => encodeBinary(item, ancestors, [...path, String(index)]));
+    return value.map((item, index) => encodeBinary(item, ancestors, [...path, String(index)]))
   }
   if (value instanceof Map) {
     return {
@@ -91,22 +87,22 @@ function encodeContainer(
         encodeBinary(k, ancestors),
         encodeBinary(v, ancestors),
       ]),
-    };
+    }
   }
   if (value instanceof Set) {
-    return { [SET_MARKER]: [...value].map(item => encodeBinary(item, ancestors)) };
+    return { [SET_MARKER]: [...value].map(item => encodeBinary(item, ancestors)) }
   }
-  if (Object.getPrototypeOf(value) !== Object.prototype) return value;
-  const out: Record<string, unknown> = {};
+  if (Object.getPrototypeOf(value) !== Object.prototype) return value
+  const out: Record<string, unknown> = {}
   for (const [key, item] of Object.entries(value)) {
-    out[key] = encodeBinary(item, ancestors, [...path, key]);
+    out[key] = encodeBinary(item, ancestors, [...path, key])
   }
-  return out;
+  return out
 }
 
 // Errors reach `error.tsx` as props and ride the same marker convention (the
 // encoder for this one lives on the render side, with the boundary props).
-const ERROR_MARKER = '$$pnextError';
+const ERROR_MARKER = '$$pnextError'
 
 /**
  * Revive the wire markers `serializeProps` wrote, IN PLACE:
@@ -124,22 +120,22 @@ export function reviveSerializedRefs<T>(
   root: T,
   extra?: (node: Record<string, unknown>) => unknown,
 ): T {
-  if (root === null || typeof root !== 'object') return root;
+  if (root === null || typeof root !== 'object') return root
   const visit = (node: Record<string, unknown>): void => {
     for (const key of Object.keys(node)) {
-      const item = node[key];
-      if (item === null || typeof item !== 'object' || ArrayBuffer.isView(item)) continue;
-      const child = item as Record<string, unknown>;
-      const revived = refTarget(root, child) ?? extra?.(child) ?? binaryTarget(child);
+      const item = node[key]
+      if (item === null || typeof item !== 'object' || ArrayBuffer.isView(item)) continue
+      const child = item as Record<string, unknown>
+      const revived = refTarget(root, child) ?? extra?.(child) ?? binaryTarget(child)
       if (revived !== undefined) {
-        node[key] = revived;
-        continue;
+        node[key] = revived
+        continue
       }
-      visit(child);
+      visit(child)
     }
-  };
-  visit(root as Record<string, unknown>);
-  return root;
+  }
+  visit(root as Record<string, unknown>)
+  return root
 }
 
 /**
@@ -149,17 +145,17 @@ export function reviveSerializedRefs<T>(
  * untouched when compat is off), and only compat entries import this name.
  */
 export function reviveSerializedErrorRefs<T>(root: T): T {
-  return reviveSerializedRefs(root, errorTarget);
+  return reviveSerializedRefs(root, errorTarget)
 }
 
 function errorTarget(node: Record<string, unknown>): Error | undefined {
-  const marker = node[ERROR_MARKER];
-  if (marker === null || typeof marker !== 'object') return undefined;
-  const data = marker as { name?: unknown; message?: unknown; digest?: unknown };
-  const error = new Error(typeof data.message === 'string' ? data.message : '');
-  if (typeof data.name === 'string') error.name = data.name;
-  if (typeof data.digest === 'string') (error as Error & { digest?: string }).digest = data.digest;
-  return error;
+  const marker = node[ERROR_MARKER]
+  if (marker === null || typeof marker !== 'object') return undefined
+  const data = marker as { name?: unknown; message?: unknown; digest?: unknown }
+  const error = new Error(typeof data.message === 'string' ? data.message : '')
+  if (typeof data.name === 'string') error.name = data.name
+  if (typeof data.digest === 'string') (error as Error & { digest?: string }).digest = data.digest
+  return error
 }
 
 // The wire carries the view's constructor NAME. Resolved off the global rather than a name-to-constructor
@@ -167,48 +163,48 @@ function errorTarget(node: Record<string, unknown>): Error | undefined {
 // so any other name - including one that resolves to something else entirely - resolves to undefined and the
 // marker is left alone.
 function typedArrayConstructor(name: string) {
-  const constructor = (globalThis as unknown as Record<string, unknown>)[name];
+  const constructor = (globalThis as unknown as Record<string, unknown>)[name]
   return typeof constructor === 'function' && 'BYTES_PER_ELEMENT' in constructor
     ? (constructor as unknown as new (buffer: ArrayBuffer) => TypedArray)
-    : undefined;
+    : undefined
 }
 
 // Decode side is client-only (the encoder is what runs on the server), so no
 // Buffer fast path — `atob` is global in every runtime that reaches this.
 function base64ToBytes(data: string): Uint8Array {
-  return Uint8Array.from(atob(data), character => character.charCodeAt(0));
+  return Uint8Array.from(atob(data), character => character.charCodeAt(0))
 }
 
 function binaryTarget(node: Record<string, unknown>): TypedArray | ArrayBuffer | undefined {
-  const buffer = node[ARRAY_BUFFER_MARKER];
-  if (typeof buffer === 'string') return base64ToBytes(buffer).buffer as ArrayBuffer;
-  const typed = node[TYPED_ARRAY_MARKER];
-  if (typed === null || typeof typed !== 'object') return undefined;
-  const { type, data } = typed as { type?: unknown; data?: unknown };
-  if (typeof type !== 'string' || typeof data !== 'string') return undefined;
-  const Constructor = typedArrayConstructor(type);
-  return Constructor ? new Constructor(base64ToBytes(data).buffer as ArrayBuffer) : undefined;
+  const buffer = node[ARRAY_BUFFER_MARKER]
+  if (typeof buffer === 'string') return base64ToBytes(buffer).buffer as ArrayBuffer
+  const typed = node[TYPED_ARRAY_MARKER]
+  if (typed === null || typeof typed !== 'object') return undefined
+  const { type, data } = typed as { type?: unknown; data?: unknown }
+  if (typeof type !== 'string' || typeof data !== 'string') return undefined
+  const Constructor = typedArrayConstructor(type)
+  return Constructor ? new Constructor(base64ToBytes(data).buffer as ArrayBuffer) : undefined
 }
 
 function refTarget(root: unknown, node: Record<string, unknown>): unknown {
-  const path = node[REF_MARKER];
-  if (!Array.isArray(path)) return undefined;
-  let current: unknown = root;
+  const path = node[REF_MARKER]
+  if (!Array.isArray(path)) return undefined
+  let current: unknown = root
   for (const key of path) {
-    if (current === null || typeof current !== 'object') return undefined;
-    current = (current as Record<string, unknown>)[String(key)];
+    if (current === null || typeof current !== 'object') return undefined
+    current = (current as Record<string, unknown>)[String(key)]
   }
-  return current;
+  return current
 }
 
 /** A preact vnode: `h` sets `constructor` to undefined on every one it makes. */
 export function isElementLike(value: unknown): boolean {
-  if (value === null || typeof value !== 'object') return false;
+  if (value === null || typeof value !== 'object') return false
   return (
     (value as { constructor?: unknown }).constructor === undefined &&
     'type' in value &&
     'props' in value
-  );
+  )
 }
 
 export function assertSerializable(
@@ -219,59 +215,59 @@ export function assertSerializable(
   // static-slots), so they are serializable there. Server-action args/returns keep throwing.
   allowElements = false,
 ) {
-  if (value == null) return;
-  if (allowElements && isElementLike(value)) return;
-  const type = typeof value;
-  if (type === 'string' || type === 'number' || type === 'boolean') return;
+  if (value == null) return
+  if (allowElements && isElementLike(value)) return
+  const type = typeof value
+  if (type === 'string' || type === 'number' || type === 'boolean') return
   if (type === 'function' || type === 'symbol' || type === 'bigint' || type === 'undefined') {
-    throw new Error(`${path} is not serializable: ${type}`);
+    throw new Error(`${path} is not serializable: ${type}`)
   }
   // Typed arrays / ArrayBuffers are serializable via the binary marker path.
-  if (isTypedArray(value) || value instanceof ArrayBuffer) return;
+  if (isTypedArray(value) || value instanceof ArrayBuffer) return
   if (value instanceof Date || value instanceof URL) {
-    throw new Error(`${path} must be a plain JSON value`);
+    throw new Error(`${path} must be a plain JSON value`)
   }
-  if (typeof value !== 'object') return;
+  if (typeof value !== 'object') return
   // A value that contains ITSELF is serializable: encodeBinary writes it as a
   // `$$pnext_ref` back-reference (React flight does the same), so stop walking
   // rather than rejecting the props.
-  if (seen.has(value)) return;
-  seen.add(value);
+  if (seen.has(value)) return
+  seen.add(value)
 
   if (Array.isArray(value)) {
     value.forEach((item, index) =>
       assertSerializable(item, `${path}[${index}]`, seen, allowElements),
-    );
-    return;
+    )
+    return
   }
 
-  // The slot walk (islands/static-slots) never enters Map/Set, so elements inside them must
+  // The slot walk (render/static-slots) never enters Map/Set, so elements inside them must
   // still throw rather than ship mangled.
   if (value instanceof Map) {
-    let index = 0;
+    let index = 0
     for (const [key, item] of value.entries()) {
-      assertSerializable(key, `${path}<Map key ${index}>`, seen);
-      assertSerializable(item, `${path}<Map value ${index}>`, seen);
-      index++;
+      assertSerializable(key, `${path}<Map key ${index}>`, seen)
+      assertSerializable(item, `${path}<Map value ${index}>`, seen)
+      index++
     }
-    return;
+    return
   }
 
   if (value instanceof Set) {
-    let index = 0;
+    let index = 0
     for (const item of value) {
-      assertSerializable(item, `${path}<Set item ${index}>`, seen);
-      index++;
+      assertSerializable(item, `${path}<Set item ${index}>`, seen)
+      index++
     }
-    return;
+    return
   }
 
   if (Object.getPrototypeOf(value) !== Object.prototype) {
-    throw new Error(`${path} must be a plain object`);
+    throw new Error(`${path} must be a plain object`)
   }
 
   for (const [key, item] of Object.entries(value)) {
-    assertSerializable(item, `${path}.${key}`, seen, allowElements);
+    assertSerializable(item, `${path}.${key}`, seen, allowElements)
   }
 }
 
@@ -291,26 +287,26 @@ export function assertSerializable(
 // original) must not split the tainted set.
 // ---------------------------------------------------------------------------
 
-const TAINT_REGISTRY_KEY = '__pnext_tainted_values__';
+const TAINT_REGISTRY_KEY = '__pnext_tainted_values__'
 
 /** Dev message plus the redacted text prod shows in its place. */
 export interface TaintMessages {
-  dev: string;
-  prod: string;
+  dev: string
+  prod: string
 }
 
 function taintRegistry(): Map<object, TaintMessages> {
-  const host = globalThis as { [TAINT_REGISTRY_KEY]?: Map<object, TaintMessages> };
-  const existing = host[TAINT_REGISTRY_KEY];
-  if (existing) return existing;
-  const created = new Map<object, TaintMessages>();
-  host[TAINT_REGISTRY_KEY] = created;
-  return created;
+  const host = globalThis as { [TAINT_REGISTRY_KEY]?: Map<object, TaintMessages> }
+  const existing = host[TAINT_REGISTRY_KEY]
+  if (existing) return existing
+  const created = new Map<object, TaintMessages>()
+  host[TAINT_REGISTRY_KEY] = created
+  return created
 }
 
 /** Register `value` as unsafe to pass to a client component. */
 export function taintObjectReference(messages: TaintMessages, value: object): void {
-  taintRegistry().set(value, messages);
+  taintRegistry().set(value, messages)
 }
 
 /**
@@ -319,60 +315,57 @@ export function taintObjectReference(messages: TaintMessages, value: object): vo
  * identity the check relies on).
  */
 export function assertNotTainted(value: unknown, seen = new Set<unknown>()): void {
-  const registry = taintRegistry();
-  if (registry.size === 0) return;
-  if (value === null || typeof value !== 'object') return;
-  const messages = registry.get(value);
+  const registry = taintRegistry()
+  if (registry.size === 0) return
+  if (value === null || typeof value !== 'object') return
+  const messages = registry.get(value)
   if (messages !== undefined) {
     // Next surfaces the explanatory message in dev only; prod renders React's
     // redacted RSC error text in the nearest error boundary.
     throw new Error(
       // eslint-disable-next-line turbo/no-undeclared-env-vars
       process.env.NODE_ENV === 'development' ? messages.dev : messages.prod,
-    );
+    )
   }
-  if (seen.has(value)) return;
-  seen.add(value);
+  if (seen.has(value)) return
+  seen.add(value)
   if (Array.isArray(value)) {
-    for (const item of value) assertNotTainted(item, seen);
-    return;
+    for (const item of value) assertNotTainted(item, seen)
+    return
   }
   if (value instanceof Map) {
     for (const [key, item] of value.entries()) {
-      assertNotTainted(key, seen);
-      assertNotTainted(item, seen);
+      assertNotTainted(key, seen)
+      assertNotTainted(item, seen)
     }
-    return;
+    return
   }
   if (value instanceof Set) {
-    for (const item of value) assertNotTainted(item, seen);
-    return;
+    for (const item of value) assertNotTainted(item, seen)
+    return
   }
-  const proto = Object.getPrototypeOf(value) as object | null;
-  if (proto !== Object.prototype && proto !== null) return;
-  for (const item of Object.values(value)) assertNotTainted(item, seen);
+  const proto = Object.getPrototypeOf(value) as object | null
+  if (proto !== Object.prototype && proto !== null) return
+  for (const item of Object.values(value)) assertNotTainted(item, seen)
 }
 
 export function serializeProps(value: unknown, options?: { allowElements?: boolean }) {
-  assertNotTainted(value);
-  assertSerializable(value, 'props', new Set(), options?.allowElements);
-  return JSON.stringify(encodeBinary(value)).replace(
-    /[<>&\u2028\u2029]/g,
-    char => {
-      switch (char) {
-        case '<':
-          return '\\u003c';
-        case '>':
-          return '\\u003e';
-        case '&':
-          return '\\u0026';
-        case '\u2028':
-          return '\\u2028';
-        case '\u2029':
-          return '\\u2029';
-        default:
-          return char;
-      }
-    },
-  );
+  assertNotTainted(value)
+  assertSerializable(value, 'props', new Set(), options?.allowElements)
+  return JSON.stringify(encodeBinary(value)).replace(/[<>&\u2028\u2029]/g, char => {
+    switch (char) {
+      case '<':
+        return '\\u003c'
+      case '>':
+        return '\\u003e'
+      case '&':
+        return '\\u0026'
+      case '\u2028':
+        return '\\u2028'
+      case '\u2029':
+        return '\\u2029'
+      default:
+        return char
+    }
+  })
 }

package/src/utils/verbose.ts

@@ -1,39 +1,39 @@
-import { dim } from './ansi';
+import { dim } from './ansi'
 
 export interface VerboseLogger {
-  readonly enabled: boolean;
-  log(message: string): void;
-  step<T>(label: string, task: () => Promise<T>): Promise<T>;
+  readonly enabled: boolean
+  log(message: string): void
+  step<T>(label: string, task: () => Promise<T>): Promise<T>
 }
 
 export function createVerboseLogger(enabled: boolean, scope: string): VerboseLogger {
-  const prefix = dim(`pnext ${scope}`);
+  const prefix = dim(`pnext ${scope}`)
   // Stamp every line with time-since-process-start: once stages run in
   // parallel their lines interleave, and only the stamps say what overlapped.
   const write = (message: string) =>
-    console.log(`${prefix} ${dim(`@${(performance.now() / 1000).toFixed(2)}s`)} ${message}`);
+    console.log(`${prefix} ${dim(`@${(performance.now() / 1000).toFixed(2)}s`)} ${message}`)
 
   return {
     enabled,
     log(message) {
-      if (enabled) write(message);
+      if (enabled) write(message)
     },
     async step(label, task) {
-      if (!enabled) return task();
-      write(label);
-      const start = performance.now();
+      if (!enabled) return task()
+      write(label)
+      const start = performance.now()
       try {
-        return await task();
+        return await task()
       } finally {
-        write(`  ${dim(`↳ ${label} ${formatDuration(performance.now() - start)}`)}`);
+        write(`  ${dim(`↳ ${label} ${formatDuration(performance.now() - start)}`)}`)
       }
     },
-  };
+  }
 }
 
-function formatDuration(durationMs: number) {
-  const ms = Math.max(0, durationMs);
-  if (ms < 10) return `${ms.toFixed(1)}ms`;
-  if (ms < 1000) return `${Math.round(ms)}ms`;
-  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`;
+export function formatDuration(durationMs: number) {
+  const ms = Math.max(0, durationMs)
+  if (ms < 10) return `${ms.toFixed(1)}ms`
+  if (ms < 1000) return `${Math.round(ms)}ms`
+  return `${(ms / 1000).toFixed(ms < 10000 ? 2 : 1)}s`
 }