@wular/pnext 0.0.4 → 0.0.7

package/src/compat/actions/serve.ts

@@ -1,6 +1,6 @@
-import { runAction, type RunActionOptions } from './endpoint';
-import { ACTION_FLIGHT_CONTENT_TYPE, createActionFlightResponse } from './flight';
-import { INVALID_ORIGIN_MESSAGE, isActionOriginAllowed } from './origin';
+import { runAction, type RunActionOptions } from './endpoint'
+import { ACTION_FLIGHT_CONTENT_TYPE, createActionFlightResponse } from './flight'
+import { INVALID_ORIGIN_MESSAGE, isActionOriginAllowed } from './origin'
 import {
   ACTION_ID_FIELD,
   SUBMIT_ACTION_ID_FIELD,
@@ -14,9 +14,9 @@ import {
   MASKED_ACTION_ERROR,
   REDIRECT_TYPE_HEADER,
   type ActionSuccessBody,
-} from './protocol';
+} from './protocol'
 
-export { ACTION_REFRESH_HEADER, ACTION_ID_FIELD };
+export { ACTION_REFRESH_HEADER, ACTION_ID_FIELD }
 
 /**
  * Server-action dispatch for the pnext servers. Actions POST to the page's own
@@ -34,7 +34,7 @@ export { ACTION_REFRESH_HEADER, ACTION_ID_FIELD };
 
 /** True when a request is a JS-client action RPC (id in header). */
 export function isActionRequest(request: Request): boolean {
-  return request.method.toUpperCase() === 'POST' && request.headers.has(ACTION_ID_HEADER);
+  return request.method.toUpperCase() === 'POST' && request.headers.has(ACTION_ID_HEADER)
 }
 
 /**
@@ -43,28 +43,27 @@ export function isActionRequest(request: Request): boolean {
  * stays consumable. Non-form POSTs and forms without the field return false.
  */
 export async function isProgressiveActionRequest(request: Request): Promise<boolean> {
-  if (request.method.toUpperCase() !== 'POST') return false;
-  if (request.headers.has(ACTION_ID_HEADER)) return false;
-  const contentType = request.headers.get('content-type') ?? '';
+  if (request.method.toUpperCase() !== 'POST') return false
+  if (request.headers.has(ACTION_ID_HEADER)) return false
+  const contentType = request.headers.get('content-type') ?? ''
   const isForm =
-    contentType.includes('multipart/form-data') || contentType.includes('form-urlencoded');
-  if (!isForm) return false;
+    contentType.includes('multipart/form-data') || contentType.includes('form-urlencoded')
+  if (!isForm) return false
   try {
-    const form = await request.clone().formData();
+    const form = await request.clone().formData()
     // A form-level action (ACTION_ID_FIELD) OR a bare submitter override
     // (SUBMIT_ACTION_ID_FIELD, e.g. <form><button formAction={fn}> with no form
     // action) both count as a progressive action submission.
-    const id =
-      lastFieldValue(form, SUBMIT_ACTION_ID_FIELD) ?? lastFieldValue(form, ACTION_ID_FIELD);
-    return typeof id === 'string' && id !== '';
+    const id = lastFieldValue(form, SUBMIT_ACTION_ID_FIELD) ?? lastFieldValue(form, ACTION_ID_FIELD)
+    return typeof id === 'string' && id !== ''
   } catch {
-    return false;
+    return false
   }
 }
 
 export interface ServeActionOptions extends RunActionOptions {
   /** Render the app's 404 page for a notFound() result (progressive + RPC). */
-  renderNotFound?: (request: Request) => Promise<Response>;
+  renderNotFound?: (request: Request) => Promise<Response>
   /**
    * Progressive useActionState submissions: re-render the posted page with the
    * action's result as the form's state (published via the consumed-once
@@ -74,22 +73,22 @@ export interface ServeActionOptions extends RunActionOptions {
     request: Request,
     state: unknown,
     actionId: string,
-  ) => Promise<Response | null>;
+  ) => Promise<Response | null>
   /**
    * Single-pass redirects: render the redirect target's page for an RPC redirect so the 303 response
    * carries the destination HTML and the client swaps it in without a follow-up GET. The request passed
    * already carries the action's cookie mutations. Null falls back to the JSON redirect envelope.
    */
-  renderRedirectTarget?: (request: Request, target: URL) => Promise<Response | null>;
+  renderRedirectTarget?: (request: Request, target: URL) => Promise<Response | null>
   /** Render a page payload for a JS action Flight response. */
-  renderActionFlight?: (request: Request, target: URL) => Promise<Response | null>;
+  renderActionFlight?: (request: Request, target: URL) => Promise<Response | null>
   /**
    * Next "forwarded action" discrimination: true when the POSTed route's module graph does NOT contain
    * the action (the client dispatched it after navigating away from the page that owns it). Next
    * forwards such requests to the owning worker and relays the inner response's HEADERS but not its
    * status, so the browser observes 200 + `x-action-redirect` instead of the direct-dispatch 303.
    */
-  isForwardedAction?: (id: string) => boolean;
+  isForwardedAction?: (id: string) => boolean
 }
 
 /** Serve a server-action request (either kind). */
@@ -97,7 +96,7 @@ export async function serveAction(
   request: Request,
   options: ServeActionOptions,
 ): Promise<Response> {
-  const progressive = !request.headers.has(ACTION_ID_HEADER);
+  const progressive = !request.headers.has(ACTION_ID_HEADER)
 
   // CSRF origin check runs before the action executes: a mismatched origin must
   // never run the action. JS clients get the error as a text/plain body (thrown
@@ -107,16 +106,16 @@ export async function serveAction(
       return new Response('Internal Server Error', {
         status: 500,
         headers: { 'content-type': 'text/plain; charset=utf-8' },
-      });
+      })
     }
     return new Response(options.dev ? INVALID_ORIGIN_MESSAGE : MASKED_ACTION_ERROR, {
       status: 500,
       headers: { 'content-type': 'text/plain; charset=utf-8' },
-    });
+    })
   }
 
-  const promoted = progressive ? await promoteFormActionId(request) : undefined;
-  const prepared = promoted?.request ?? request;
+  const promoted = progressive ? await promoteFormActionId(request) : undefined
+  const prepared = promoted?.request ?? request
 
   // A form POST to a page carrying no recognizable action id is an
   // unrecognized MPA action: 404 + Next's marker header and log, rather than a
@@ -125,64 +124,64 @@ export async function serveAction(
     console.error(
       'Failed to find Server Action. This request might be from an older or newer deployment.\n' +
         'Read more: https://nextjs.org/docs/messages/failed-to-find-server-action',
-    );
+    )
     return new Response('Server action not found.', {
       status: 404,
       headers: {
         'content-type': 'text/plain; charset=utf-8',
         [NEXT_ACTION_NOT_FOUND_HEADER]: '1',
       },
-    });
+    })
   }
 
-  const response = await runAction(prepared, options);
+  const response = await runAction(prepared, options)
 
   if (response.headers.has(ACTION_NOT_FOUND_HEADER) && options.renderNotFound) {
     // Serve the real 404 page HTML with a 404 status and the marker header. A
     // progressive submit shows it directly; the JS client runtime detects the
-    // 404 + marker and swaps the document in place (action-client.ts). Returning
+    // 404 + marker and swaps the document in place (client.ts). Returning
     // an empty 200 JSON here would leave the JS client with nothing to render.
-    const notFound = await options.renderNotFound(request);
-    const headers = new Headers(notFound.headers);
-    headers.set(ACTION_NOT_FOUND_HEADER, '1');
-    copySetCookies(response.headers, headers);
-    return new Response(notFound.body, { status: 404, headers });
+    const notFound = await options.renderNotFound(request)
+    const headers = new Headers(notFound.headers)
+    headers.set(ACTION_NOT_FOUND_HEADER, '1')
+    copySetCookies(response.headers, headers)
+    return new Response(notFound.body, { status: 404, headers })
   }
 
   if (!progressive) {
-    const wantsFlight = acceptsActionFlight(request);
+    const wantsFlight = acceptsActionFlight(request)
     if (response.status === 303 && response.headers.has(ACTION_REDIRECT_HEADER)) {
-      const target = response.headers.get(ACTION_REDIRECT_HEADER)!;
-      const headers = new Headers();
-      if (response.headers.has(ACTION_REFRESH_HEADER)) headers.set(ACTION_REFRESH_HEADER, '1');
-      const revalidated = response.headers.get(NEXT_ACTION_REVALIDATED_HEADER);
-      if (revalidated) headers.set(NEXT_ACTION_REVALIDATED_HEADER, revalidated);
-      const redirectType = response.headers.get(REDIRECT_TYPE_HEADER);
-      if (redirectType) headers.set(REDIRECT_TYPE_HEADER, redirectType);
-      copySetCookies(response.headers, headers);
+      const target = response.headers.get(ACTION_REDIRECT_HEADER)!
+      const headers = new Headers()
+      if (response.headers.has(ACTION_REFRESH_HEADER)) headers.set(ACTION_REFRESH_HEADER, '1')
+      const revalidated = response.headers.get(NEXT_ACTION_REVALIDATED_HEADER)
+      if (revalidated) headers.set(NEXT_ACTION_REVALIDATED_HEADER, revalidated)
+      const redirectType = response.headers.get(REDIRECT_TYPE_HEADER)
+      if (redirectType) headers.set(REDIRECT_TYPE_HEADER, redirectType)
+      copySetCookies(response.headers, headers)
 
       // Forwarded action (dispatched from a page that does not own it): Next
       // relays the owning worker's headers on a 200 — no single-pass 303.
       // The JSON envelope makes the client soft-navigate to the target.
-      const actionId = prepared.headers.get(ACTION_ID_HEADER);
+      const actionId = prepared.headers.get(ACTION_ID_HEADER)
       if (actionId && options.isForwardedAction?.(actionId)) {
-        headers.set(ACTION_REDIRECT_HEADER, target);
-        headers.set('content-type', 'application/json; charset=utf-8');
-        return new Response(JSON.stringify({ redirect: target }), { status: 200, headers });
+        headers.set(ACTION_REDIRECT_HEADER, target)
+        headers.set('content-type', 'application/json; charset=utf-8')
+        return new Response(JSON.stringify({ redirect: target }), { status: 200, headers })
       }
 
       // Same-origin targets: single-pass redirect. The 303 has NO location
       // header (fetch would transparently follow one) and carries the
       // destination page HTML; the client pushes history and swaps the
       // document in one round trip, like Next's flight redirects.
-      const targetUrl = resolveRedirectTarget(request, target);
+      const targetUrl = resolveRedirectTarget(request, target)
       if (targetUrl && (options.renderActionFlight || options.renderRedirectTarget)) {
         const rendered = await options
           .renderActionFlight?.(
             requestWithAppliedCookies(request, targetUrl, response.headers),
             targetUrl,
           )
-          .catch(() => null);
+          .catch(() => null)
         if (wantsFlight && rendered?.status === 200) {
           return createActionFlightResponse({
             pageResponse: rendered,
@@ -190,7 +189,7 @@ export async function serveAction(
             actionHeaders: response.headers,
             redirect: targetUrl.pathname + targetUrl.search,
             ...(redirectType ? { redirectType } : {}),
-          });
+          })
         }
         const htmlRendered = rendered
           ? rendered
@@ -199,32 +198,32 @@ export async function serveAction(
                 requestWithAppliedCookies(request, targetUrl, response.headers),
                 targetUrl,
               )
-              .catch(() => null);
+              .catch(() => null)
         if (htmlRendered?.status === 200) {
-          headers.set(ACTION_REDIRECT_HEADER, targetUrl.pathname + targetUrl.search);
+          headers.set(ACTION_REDIRECT_HEADER, targetUrl.pathname + targetUrl.search)
           headers.set(
             'content-type',
             htmlRendered.headers.get('content-type') ?? 'text/html; charset=utf-8',
-          );
-          return new Response(htmlRendered.body, { status: 303, headers });
+          )
+          return new Response(htmlRendered.body, { status: 303, headers })
         }
         // Same host, but the app cannot render it in-process (a path outside basePath, a rewrite to
         // another origin). Next still answers the action with a redirect status, so send the bare 303
         // plus marker and let the client make the follow-up request.
-        headers.set(ACTION_REDIRECT_HEADER, targetUrl.pathname + targetUrl.search);
-        return new Response(null, { status: 303, headers });
+        headers.set(ACTION_REDIRECT_HEADER, targetUrl.pathname + targetUrl.search)
+        return new Response(null, { status: 303, headers })
       }
 
       // Fallback: JSON envelope; the client soft-navigates (or hard-navigates
       // for external origins).
-      headers.set('content-type', 'application/json; charset=utf-8');
-      return new Response(JSON.stringify({ redirect: target }), { status: 200, headers });
+      headers.set('content-type', 'application/json; charset=utf-8')
+      return new Response(JSON.stringify({ redirect: target }), { status: 200, headers })
     }
     // A non-redirect action returns its plain JSON envelope. When it also revalidated (or mutated
     // cookies), the refresh header rides along and the JS client soft-refreshes the current route in
     // place, preserving hydrated island state. Wrapping the return in a full-page flight envelope here
     // would force the client to rewrite the document, discarding that live state.
-    return response;
+    return response
   }
 
   // Progressive success: a useActionState form re-renders the page with the
@@ -234,15 +233,15 @@ export async function serveAction(
   if (response.status === 200) {
     if (promoted?.hasFormState && options.renderPageForFormState) {
       try {
-        const body = (await response.clone().json()) as ActionSuccessBody;
+        const body = (await response.clone().json()) as ActionSuccessBody
         const page = await options.renderPageForFormState(
           request,
           body.data,
           prepared.headers.get(ACTION_ID_HEADER)!,
-        );
+        )
         if (page) {
-          copySetCookies(response.headers, page.headers);
-          return page;
+          copySetCookies(response.headers, page.headers)
+          return page
         }
       } catch {
         // fall through to the 303
@@ -255,43 +254,41 @@ export async function serveAction(
     // that observes the just-applied invalidations and cookie mutations) and return it as the POST
     // response, matching the single-pass render the flight client path already performs.
     if (response.headers.has(ACTION_REFRESH_HEADER) && options.renderRedirectTarget) {
-      const pageUrl = new URL(request.url);
-      const refreshRequest = requestWithAppliedCookies(request, pageUrl, response.headers);
-      refreshRequest.headers.set('x-pnext-soft-nav', '1');
-      const rendered = await options
-        .renderRedirectTarget(refreshRequest, pageUrl)
-        .catch(() => null);
+      const pageUrl = new URL(request.url)
+      const refreshRequest = requestWithAppliedCookies(request, pageUrl, response.headers)
+      refreshRequest.headers.set('x-pnext-soft-nav', '1')
+      const rendered = await options.renderRedirectTarget(refreshRequest, pageUrl).catch(() => null)
       if (rendered?.status === 200) {
-        const headers = new Headers(rendered.headers);
-        copySetCookies(response.headers, headers);
-        return new Response(rendered.body, { status: 200, headers });
+        const headers = new Headers(rendered.headers)
+        copySetCookies(response.headers, headers)
+        return new Response(rendered.body, { status: 200, headers })
       }
     }
-    const headers = new Headers({ location: progressiveReturnTarget(request) });
-    copySetCookies(response.headers, headers);
-    return new Response(null, { status: 303, headers });
+    const headers = new Headers({ location: progressiveReturnTarget(request) })
+    copySetCookies(response.headers, headers)
+    return new Response(null, { status: 303, headers })
   }
   // Progressive unknown-id: mirror Next's MPA behavior (a plain 500).
   if (response.status === 404 && !response.headers.has(ACTION_NOT_FOUND_HEADER)) {
     console.error(
       'Error: Failed to find Server Action. This request might be from an older or newer deployment',
-    );
+    )
     return new Response('Internal Server Error', {
       status: 500,
       headers: { 'content-type': 'text/plain; charset=utf-8' },
-    });
+    })
   }
-  return response;
+  return response
 }
 
 function progressiveReturnTarget(request: Request): string {
-  const referer = request.headers.get('referer');
-  if (referer) return referer;
-  return new URL(request.url).pathname || '/';
+  const referer = request.headers.get('referer')
+  if (referer) return referer
+  return new URL(request.url).pathname || '/'
 }
 
 function acceptsActionFlight(request: Request): boolean {
-  return request.headers.get('accept')?.includes(ACTION_FLIGHT_CONTENT_TYPE) ?? false;
+  return request.headers.get('accept')?.includes(ACTION_FLIGHT_CONTENT_TYPE) ?? false
 }
 
 /**
@@ -303,73 +300,72 @@ function acceptsActionFlight(request: Request): boolean {
 async function promoteFormActionId(
   request: Request,
 ): Promise<{ request: Request; hasFormState: boolean }> {
-  const contentType = request.headers.get('content-type') ?? '';
+  const contentType = request.headers.get('content-type') ?? ''
   const isForm =
-    contentType.includes('multipart/form-data') || contentType.includes('form-urlencoded');
-  if (!isForm) return { request, hasFormState: false };
+    contentType.includes('multipart/form-data') || contentType.includes('form-urlencoded')
+  if (!isForm) return { request, hasFormState: false }
 
-  let form: FormData;
+  let form: FormData
   try {
-    form = await request.clone().formData();
+    form = await request.clone().formData()
   } catch {
     // Unparseable body (e.g. a mismatched multipart boundary): no id to promote;
     // the caller treats it as an unrecognized MPA action.
-    return { request, hasFormState: false };
+    return { request, hasFormState: false }
   }
   // A per-button formAction override (SUBMIT_ACTION_ID_FIELD) wins over the
   // form's default action (ACTION_ID_FIELD), unambiguously and independent of
   // field order — a no-JS submit has no event.submitter to tell them apart, and
   // the form-level hidden field can render either before or after the button.
-  const submitId = firstFieldValue(form, SUBMIT_ACTION_ID_FIELD);
-  const formActionId = firstFieldValue(form, ACTION_ID_FIELD);
-  const id = submitId ?? formActionId;
-  if (typeof id !== 'string' || id === '') return { request, hasFormState: false };
-  form.delete(SUBMIT_ACTION_ID_FIELD);
+  const submitId = firstFieldValue(form, SUBMIT_ACTION_ID_FIELD)
+  const formActionId = firstFieldValue(form, ACTION_ID_FIELD)
+  const id = submitId ?? formActionId
+  if (typeof id !== 'string' || id === '') return { request, hasFormState: false }
+  form.delete(SUBMIT_ACTION_ID_FIELD)
   // Form state only applies to the form's own useActionState action, never a
   // plain submitter override (which runs as action(formData), not (state, fd)).
-  const hasFormState =
-    submitId === undefined && typeof form.get(FORM_STATE_FIELD) === 'string';
-  if (!hasFormState) form.delete(FORM_STATE_FIELD);
+  const hasFormState = submitId === undefined && typeof form.get(FORM_STATE_FIELD) === 'string'
+  if (!hasFormState) form.delete(FORM_STATE_FIELD)
 
-  const headers = new Headers(request.headers);
-  headers.set(ACTION_ID_HEADER, id);
+  const headers = new Headers(request.headers)
+  headers.set(ACTION_ID_HEADER, id)
   // Drop the stale content-type/length; the runtime derives a fresh multipart
   // content-type (with a new boundary) from the FormData body below.
-  headers.delete('content-type');
-  headers.delete('content-length');
+  headers.delete('content-type')
+  headers.delete('content-length')
   return {
     request: new Request(request.url, { method: 'POST', headers, body: form }),
     hasFormState,
-  };
+  }
 }
 
 function lastFieldValue(form: FormData, name: string) {
-  const values = form.getAll(name);
-  return values.length > 0 ? values[values.length - 1] : undefined;
+  const values = form.getAll(name)
+  return values.length > 0 ? values[values.length - 1] : undefined
 }
 
 function firstFieldValue(form: FormData, name: string) {
-  const values = form.getAll(name);
-  return values.length > 0 ? values[0] : undefined;
+  const values = form.getAll(name)
+  return values.length > 0 ? values[0] : undefined
 }
 
 function copySetCookies(from: Headers, to: Headers) {
-  const setCookies = (from as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? [];
-  for (const cookie of setCookies) to.append('set-cookie', cookie);
+  const setCookies = (from as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? []
+  for (const cookie of setCookies) to.append('set-cookie', cookie)
 }
 
 /** Same-origin redirect target URL, or undefined for external redirects. */
 function resolveRedirectTarget(request: Request, target: string): URL | undefined {
   try {
-    const requestUrl = new URL(request.url);
-    const relativeBase = new URL(requestUrl);
+    const requestUrl = new URL(request.url)
+    const relativeBase = new URL(requestUrl)
     if (!target.startsWith('/') && !/^[a-z][a-z0-9+.-]*:/i.test(target)) {
-      relativeBase.pathname = `${relativeBase.pathname.replace(/\/+$/, '')}/`;
+      relativeBase.pathname = `${relativeBase.pathname.replace(/\/+$/, '')}/`
     }
-    const url = new URL(target, relativeBase);
-    return url.origin === requestUrl.origin ? url : undefined;
+    const url = new URL(target, relativeBase)
+    return url.origin === requestUrl.origin ? url : undefined
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -380,35 +376,35 @@ function resolveRedirectTarget(request: Request, target: string): URL | undefine
  * browser following the redirect would send.
  */
 function requestWithAppliedCookies(request: Request, target: URL, actionHeaders: Headers): Request {
-  const headers = new Headers(request.headers);
-  headers.delete('content-type');
-  headers.delete('content-length');
-  headers.delete(ACTION_ID_HEADER);
+  const headers = new Headers(request.headers)
+  headers.delete('content-type')
+  headers.delete('content-length')
+  headers.delete(ACTION_ID_HEADER)
 
   const setCookies =
-    (actionHeaders as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? [];
+    (actionHeaders as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? []
   if (setCookies.length > 0) {
-    const jar = new Map<string, string>();
-    const existing = headers.get('cookie') ?? '';
+    const jar = new Map<string, string>()
+    const existing = headers.get('cookie') ?? ''
     for (const part of existing.split(';')) {
-      const eq = part.indexOf('=');
-      if (eq === -1) continue;
-      jar.set(part.slice(0, eq).trim(), part.slice(eq + 1).trim());
+      const eq = part.indexOf('=')
+      if (eq === -1) continue
+      jar.set(part.slice(0, eq).trim(), part.slice(eq + 1).trim())
     }
     for (const setCookie of setCookies) {
-      const [pair, ...attributes] = setCookie.split(';');
-      const eq = (pair ?? '').indexOf('=');
-      if (eq === -1) continue;
-      const name = pair!.slice(0, eq).trim();
-      const value = pair!.slice(eq + 1).trim();
-      const expired = attributes.some(attr => /^\s*max-age\s*=\s*0*\s*$/i.test(attr));
-      if (expired) jar.delete(name);
-      else jar.set(name, value);
+      const [pair, ...attributes] = setCookie.split(';')
+      const eq = (pair ?? '').indexOf('=')
+      if (eq === -1) continue
+      const name = pair!.slice(0, eq).trim()
+      const value = pair!.slice(eq + 1).trim()
+      const expired = attributes.some(attr => /^\s*max-age\s*=\s*0*\s*$/i.test(attr))
+      if (expired) jar.delete(name)
+      else jar.set(name, value)
     }
-    const cookieHeader = [...jar.entries()].map(([name, value]) => `${name}=${value}`).join('; ');
-    if (cookieHeader) headers.set('cookie', cookieHeader);
-    else headers.delete('cookie');
+    const cookieHeader = [...jar.entries()].map(([name, value]) => `${name}=${value}`).join('; ')
+    if (cookieHeader) headers.set('cookie', cookieHeader)
+    else headers.delete('cookie')
   }
 
-  return new Request(target.href, { headers });
+  return new Request(target.href, { headers })
 }

package/src/compat/actions/server-tag.ts

@@ -9,13 +9,13 @@
  * don't retain modules. Best-effort: an untagged action function renders as a
  * normal form (the client stub still POSTs it when JS runs).
  */
-const actionIds = new WeakMap<object, string>();
+const actionIds = new WeakMap<object, string>()
 
 export function tagServerAction(fn: unknown, id: string): void {
-  if (typeof fn === 'function') actionIds.set(fn, id);
+  if (typeof fn === 'function') actionIds.set(fn, id)
 }
 
 export function serverActionId(fn: unknown): string | undefined {
-  if (typeof fn !== 'function') return undefined;
-  return actionIds.get(fn);
+  if (typeof fn !== 'function') return undefined
+  return actionIds.get(fn)
 }

package/src/compat/actions/{action-shared.ts → shared.ts}

@@ -1,58 +1,58 @@
 /**
- * The sliver of the client action runtime both tiers need: the install-time half (action-client.ts)
- * and the dispatch half (action-dispatch.ts, loaded on the first action call). Keep this module small
+ * The sliver of the client action runtime both tiers need: the install-time half (client.ts)
+ * and the dispatch half (dispatch.ts, loaded on the first action call). Keep this module small
  * - every byte here ships at first paint on any page that uses a server action.
  */
-import type { ComponentType } from 'preact';
+import type { ComponentType } from 'preact'
 
 // Progressive-enhancement form fields: written by the server renderer, read by
 // the submit listener (initial) and stripped off the wire by the encoder.
-export const ACTION_ID_FIELD = '$pnext_action_id';
-export const SUBMIT_ACTION_ID_FIELD = '$pnext_submit_action_id';
-export const FORM_STATE_FIELD = '$pnext_form_state';
+export const ACTION_ID_FIELD = '$pnext_action_id'
+export const SUBMIT_ACTION_ID_FIELD = '$pnext_submit_action_id'
+export const FORM_STATE_FIELD = '$pnext_form_state'
 
 // Binary wire markers: encoded by the dispatch half, revived by both (island
 // props can carry typed arrays before any action has run).
-export const TYPED_ARRAY_MARKER = '$$pnext_typed_array';
-export const ARRAY_BUFFER_MARKER = '$$pnext_array_buffer';
+export const TYPED_ARRAY_MARKER = '$$pnext_typed_array'
+export const ARRAY_BUFFER_MARKER = '$$pnext_array_buffer'
 
 export interface ActionFunction {
-  (...args: unknown[]): Promise<unknown>;
-  $$pnextActionId?: string;
+  (...args: unknown[]): Promise<unknown>
+  $$pnextActionId?: string
 }
 
 export interface ActionRuntime {
-  call(id: string, args: unknown[]): Promise<unknown>;
-  createAction(id: string): ActionFunction;
-  registerClientReference(id: string, component: ComponentType<Record<string, unknown>>): void;
-  reviveProps<T>(value: T): T;
+  call(id: string, args: unknown[]): Promise<unknown>
+  createAction(id: string): ActionFunction
+  registerClientReference(id: string, component: ComponentType<Record<string, unknown>>): void
+  reviveProps<T>(value: T): T
 }
 
 declare global {
   interface Window {
-    __PNEXT_ACTIONS__?: ActionRuntime;
+    __PNEXT_ACTIONS__?: ActionRuntime
   }
 }
 
 interface PNextActionError extends Error {
-  $$pnextActionError?: boolean;
+  $$pnextActionError?: boolean
 }
 
 export function tagActionError(error: unknown): unknown {
-  if (error instanceof Error) (error as PNextActionError).$$pnextActionError = true;
-  return error;
+  if (error instanceof Error) (error as PNextActionError).$$pnextActionError = true
+  return error
 }
 
 /** True for errors produced by an action dispatch (boundary channel filter). */
 export function isActionError(error: unknown): boolean {
-  return Boolean(error instanceof Error && (error as PNextActionError).$$pnextActionError);
+  return Boolean(error instanceof Error && (error as PNextActionError).$$pnextActionError)
 }
 
 /** Client components an action return may reference by id (element markers). */
 export const actionReturnClientReferences = new Map<
   string,
   ComponentType<Record<string, unknown>>
->();
+>()
 
 const TYPED_ARRAY_CTORS: Record<string, new (buffer: ArrayBuffer) => ArrayBufferView> = {
   Int8Array,
@@ -66,30 +66,30 @@ const TYPED_ARRAY_CTORS: Record<string, new (buffer: ArrayBuffer) => ArrayBuffer
   Float64Array,
   BigInt64Array,
   BigUint64Array,
-};
+}
 
 export function base64ToArrayBuffer(base64: string): ArrayBuffer {
   if (typeof atob === 'function') {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    return bytes.buffer;
+    const binary = atob(base64)
+    const bytes = new Uint8Array(binary.length)
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+    return bytes.buffer
   }
-  const buf = Buffer.from(base64, 'base64');
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  const buf = Buffer.from(base64, 'base64')
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
 }
 
 /** Revive a typed-array / ArrayBuffer wire marker, else undefined. */
 export function reviveBinaryMarker(record: Record<string, unknown>): unknown {
-  const typed = record[TYPED_ARRAY_MARKER];
+  const typed = record[TYPED_ARRAY_MARKER]
   if (typed && typeof typed === 'object') {
-    const { type, data } = typed as { type?: string; data?: string };
-    const Ctor = type ? TYPED_ARRAY_CTORS[type] : undefined;
+    const { type, data } = typed as { type?: string; data?: string }
+    const Ctor = type ? TYPED_ARRAY_CTORS[type] : undefined
     if (Ctor && typeof data === 'string') {
-      return new Ctor(base64ToArrayBuffer(data));
+      return new Ctor(base64ToArrayBuffer(data))
     }
   }
-  const buffer = record[ARRAY_BUFFER_MARKER];
-  if (typeof buffer === 'string') return base64ToArrayBuffer(buffer);
-  return undefined;
+  const buffer = record[ARRAY_BUFFER_MARKER]
+  if (typeof buffer === 'string') return base64ToArrayBuffer(buffer)
+  return undefined
 }