@solidjs/web 2.0.0-rc.2 → 2.0.0-rc.4

package/types/server-functions/flash.d.ts

@@ -5,34 +5,14 @@
  * returned one fills `result` — mirroring the split a scripted call sees.
  */
 export interface FlashSubmission {
-  /** The arguments the call was made with (files are dropped). */
-  input: any[];
-  /** The call's url: pathname + search of the server function request. */
-  url: string;
-  /** The returned value, when the call returned. */
-  result?: any;
-  /** The thrown value, when the call threw. */
-  error?: any;
+    /** The arguments the call was made with (files are dropped). */
+    input: any[];
+    /** The call's url: pathname + search of the server function request. */
+    url: string;
+    /** The returned value, when the call returned. */
+    result?: any;
+    /** The thrown value, when the call threw. */
+    error?: any;
 }
-
-/**
- * Encodes the outcome of a no-JS call as a `Set-Cookie` value, for the
- * handler to send with its redirect. `url` identifies which submission the
- * outcome belongs to; pass `thrown` when the call threw rather than
- * returned.
- *
- * The payload is JSON inside the cookie: `FormData` and `URLSearchParams`
- * arguments are captured as entry pairs and revived on decode, and `File`
- * entries are dropped (they cannot ride a cookie). Keep in mind the 4 KB
- * cookie budget — outcomes larger than that will not survive the round
- * trip.
- */
-export function encodeFlashCookie(url: string, result: any, input: any[], thrown?: boolean): string;
-
-/**
- * Decodes the flash cookie out of a request's `Cookie` header, for the
- * render that follows the redirect. Returns undefined when the cookie is
- * absent or unreadable — a malformed cookie never takes down the render,
- * and `clearFlashCookie` should be appended regardless.
- */
-export function decodeFlashCookie(cookieHeader: string | null): FlashSubmission | undefined;
+export declare function encodeFlashCookie(url: string, result: any, input: any[], thrown?: boolean): string;
+export declare function decodeFlashCookie(cookieHeader: string | null): FlashSubmission | undefined;

package/types/server-functions/registry.d.ts

@@ -0,0 +1,100 @@
+export type { InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, ServerFunctionRPC } from "./shared.js";
+import type { InvokeOptions } from "./shared.js";
+export declare const SERVER_FUNCTION_METADATA: unique symbol;
+/**
+ * Reads a server function reference's declaration metadata (e.g.
+ * `method: "GET"` for `GET(fn)` references). Returns undefined when `fn`
+ * is not a server function reference; plain references carry an empty
+ * metadata object.
+ */
+export declare function getServerFunctionMetadata(fn: any): any;
+/**
+ * Whether `fn` is a server function reference (a client proxy or a
+ * server-side registered callable). Detection is by the registered-symbol
+ * metadata brand, so it holds across duplicated module instances.
+ */
+export declare function isServerFunction(fn: any): boolean;
+/**
+ * Attaches user-declared transport metadata to a server function reference
+ * (client proxy or server-registered callable) and returns the reference.
+ * Writes ride the same channel `GET` uses: later writes shallow-merge over
+ * earlier ones, and `getServerFunctionMetadata(fn)` reads the merged bag —
+ * so `withMeta` composes with `GET` in either order.
+ *
+ * The pattern is declare-on-function, react-in-hook: metadata declared
+ * here is what `prepareRequest` receives as `context.meta`, letting
+ * session-dynamic transport policy key on declarations instead of
+ * comparing function ids:
+ *
+ * ```ts
+ * export const chargeCard = withMeta(async (amount: number) => {
+ *   "use server";
+ *   // ...
+ * }, { requiresAuth: true });
+ *
+ * configureServerFunctionsClient({
+ *   prepareRequest(init, { meta }) {
+ *     if (meta?.requiresAuth) {
+ *       return {
+ *         ...init,
+ *         headers: { ...init.headers, Authorization: `Bearer ${session.token()}` }
+ *       };
+ *     }
+ *     return init;
+ *   }
+ * });
+ * ```
+ */
+export declare function withMeta(fn: any, meta: any): any;
+export declare const SERVER_FUNCTION_INVOKE: unique symbol;
+/**
+ * Applies a server function once with per-call, invocation-scoped options —
+ * `Function.prototype.call` for server functions, the options bag in the
+ * `thisArg` slot (declaration wrappers like `GET` and `withMeta` are `bind`:
+ * they return a new reference with context baked in; `invoke` applies one
+ * call and leaves no residue on the reference).
+ *
+ * ```ts
+ * import { invoke } from "@solidjs/web/server-functions";
+ *
+ * const user = await invoke(getUser, { signal: controller.signal }, id);
+ * ```
+ *
+ * Options are strictly invocation-scoped — things that vary between calls
+ * of the SAME function and cannot be declared or configured: `signal`
+ * (the call's lifecycle; aborting rejects the call and cancels the
+ * request), `keepalive` (calls made while the page unloads), `priority`
+ * (fetch priority hint). Anything with a longer lifetime is refused with a
+ * pointer to its home: session-dynamic transport policy → `prepareRequest`;
+ * declaration-static shape → `GET`/`withMeta`; call policy (retries,
+ * dedupe, deadlines) → the data layer that owns the call, wired through
+ * `signal`.
+ *
+ * Dispatches through the reference's invocation channel
+ * (`SERVER_FUNCTION_INVOKE`). Core's declaration wrappers forward it —
+ * `GET` invokes over its query encoding, `live` ends its iteration on
+ * abort. Wrappers that share calls (caches, channels) may adapt or decline
+ * it; a data layer needs neither — it holds the reference below such
+ * wrappers and invokes it directly with its own signal. On the server the
+ * call runs in-process: `signal`
+ * rejects the caller (the work, like a server behind HTTP, runs on unless
+ * the function observes a signal itself) and the transport hints are
+ * no-ops, since they describe a wire that does not exist.
+ */
+export declare function invoke<A extends readonly any[], R>(fn: (...args: A) => R, options: InvokeOptions, ...args: A): R;
+export declare const LIVE_SOURCE: unique symbol;
+/**
+ * Fills the RPC seam. Called by the transport halves (client fetch RPC,
+ * server in-process dispatch) when the first server function reference is
+ * created; first write wins — both halves register equivalent surfaces, and
+ * a per-build half never coexists with the other build's.
+ * @internal
+ */
+export declare function provideServerFunctionRPC(rpc: any): void;
+/**
+ * The registered RPC surface, or undefined when no server function exists
+ * in this build's graph. Integration plumbing (routers): gate every use of
+ * the transport/codec behind this read instead of importing it.
+ * @internal
+ */
+export declare function getServerFunctionRPC(): any;

package/types/server-functions/rich-args.d.ts

@@ -1,10 +1 @@
-/**
- * Opt-in codec encoding for server-function ARGUMENTS. By default the client
- * sends argument lists as plain JSON (no serializer in the bundle) and
- * throws on values JSON can't carry faithfully. Call once at startup to
- * send Dates, Maps, Sets, typed arrays, cyclic structures, etc. through the
- * codec — at the cost of the serializer's write half (~5 KB gz on top of
- * the decode half responses already need). The handler accepts both
- * encodings unconditionally.
- */
-export function enableRichArguments(): void;
+export declare function enableRichArguments(): void;