@storybook/tanstack-react 0.0.0 → 10.4.0-alpha.17

package/dist/export-mocks/start-storage-context.d.ts

@@ -0,0 +1,16 @@
+import { Awaitable, RegisteredRouter } from '@tanstack/router-core';
+
+interface StartStorageContext {
+    getRouter: () => Awaitable<RegisteredRouter>;
+    request: Request;
+    startOptions: any;
+    contextAfterGlobalMiddlewares: any;
+    executedRequestMiddlewares: Set<any>;
+}
+
+declare function runWithStartContext<T>(context: StartStorageContext, fn: () => T | Promise<T>): Promise<T>;
+declare function getStartContext<TThrow extends boolean = true>(opts?: {
+    throwIfNotFound?: TThrow;
+}): TThrow extends false ? StartStorageContext | undefined : StartStorageContext;
+
+export { type StartStorageContext, getStartContext, runWithStartContext };

package/dist/export-mocks/start-storage-context.js

@@ -0,0 +1,33 @@
+import "../_browser-chunks/chunk-4BE7D4DS.js";
+
+// src/export-mocks/start-storage-context.ts
+var START_CONTEXT_SYMBOL = Symbol.for("storybook.tanstack-react.start-storage-context"), browserGlobals = globalThis;
+function createFallbackStartContext() {
+  if (!(browserGlobals.__TSR_ROUTER__ === void 0 && browserGlobals.__TSS_START_OPTIONS__ === void 0))
+    return {
+      getRouter: () => browserGlobals.__TSR_ROUTER__,
+      request: new Request("http://localhost/"),
+      startOptions: browserGlobals.__TSS_START_OPTIONS__,
+      contextAfterGlobalMiddlewares: void 0,
+      executedRequestMiddlewares: /* @__PURE__ */ new Set()
+    };
+}
+async function runWithStartContext(context, fn) {
+  let previousContext = browserGlobals[START_CONTEXT_SYMBOL];
+  browserGlobals[START_CONTEXT_SYMBOL] = context;
+  try {
+    return await fn();
+  } finally {
+    previousContext ? browserGlobals[START_CONTEXT_SYMBOL] = previousContext : delete browserGlobals[START_CONTEXT_SYMBOL];
+  }
+}
+function getStartContext(opts) {
+  let context = browserGlobals[START_CONTEXT_SYMBOL] ?? createFallbackStartContext();
+  if (!context && opts?.throwIfNotFound !== !1)
+    throw new Error("No Start context found in Storybook mock.");
+  return context;
+}
+export {
+  getStartContext,
+  runWithStartContext
+};

package/dist/export-mocks/start.d.ts

@@ -0,0 +1,120 @@
+import React from 'react';
+import { createServerFn as createServerFn$1 } from '@tanstack/start-client-core';
+export * from '@tanstack/start-client-core';
+export * from '@tanstack/react-start';
+
+type RequestOptions<TRegister = unknown> = {
+    context?: TRegister extends {
+        server: {
+            requestContext: infer TRequestContext;
+        };
+    } ? TRequestContext : unknown;
+};
+type MockRequestExecutor<TRegister = unknown> = (request: Request, opts?: RequestOptions<TRegister>) => Promise<unknown> | unknown;
+type HandlerContext = {
+    request: Request;
+    responseHeaders: Headers;
+    router?: unknown;
+    context?: unknown;
+    requestContext?: unknown;
+};
+type HandlerCallback<TRouter = unknown> = (context: HandlerContext & {
+    router?: TRouter;
+}) => Promise<unknown> | unknown;
+type SessionConfig = Record<string, unknown>;
+type MockSession<TSessionData extends Record<string, unknown> = Record<string, unknown>> = {
+    data: Partial<TSessionData>;
+    update: (update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
+    save: () => Promise<void>;
+    clear: () => Promise<void>;
+};
+declare const HEADERS: {
+    readonly TSS_SHELL: "X-TSS_SHELL";
+};
+declare const VIRTUAL_MODULES: {
+    readonly startManifest: "tanstack-start-manifest:v";
+    readonly injectedHeadScripts: "tanstack-start-injected-head-scripts:v";
+    readonly serverFnResolver: "#tanstack-start-server-fn-resolver";
+};
+declare function StartServer(): null;
+declare const defineHandlerCallback: <TRouter = unknown>(handler: HandlerCallback<TRouter>) => HandlerCallback<TRouter>;
+declare const defaultStreamHandler: () => Promise<Response>;
+declare const defaultRenderHandler: () => Promise<Response>;
+declare const requestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister>) => Promise<Response>;
+declare const createRequestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
+declare const createStartHandler: <TRegister = unknown>(cbOrOptions: HandlerCallback | {
+    handler?: HandlerCallback;
+}) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
+declare const attachRouterServerSsrUtils: <TRouter>(router: TRouter) => TRouter;
+declare const transformReadableStreamWithRouter: <TReadableStream>(stream: TReadableStream) => TReadableStream;
+declare const transformPipeableStreamWithRouter: <TPipeableStream>(stream: TPipeableStream) => TPipeableStream;
+declare const getRequest: () => Request;
+declare const getRequestHeaders: () => Headers;
+declare const getRequestHeader: (name: string) => string | undefined;
+declare const getRequestIP: (opts?: {
+    xForwardedFor?: boolean;
+}) => string | undefined;
+declare const getRequestHost: (opts?: {
+    xForwardedHost?: boolean;
+}) => string;
+declare const getRequestUrl: (opts?: {
+    xForwardedHost?: boolean;
+    xForwardedProto?: boolean;
+}) => URL;
+declare const getRequestProtocol: (opts?: {
+    xForwardedProto?: boolean;
+}) => string;
+declare const setResponseHeaders: (headers: HeadersInit) => void;
+declare const getResponseHeaders: () => Headers;
+declare const getResponseHeader: (name: string) => string | undefined;
+declare const setResponseHeader: (name: string, value: string | Array<string>) => void;
+declare const removeResponseHeader: (name: string) => void;
+declare const clearResponseHeaders: (headerNames?: Array<string>) => void;
+declare const getResponseStatus: () => number;
+declare const setResponseStatus: (code?: number, text?: string) => void;
+declare const getCookies: () => {
+    [k: string]: string;
+};
+declare const getCookie: (name: string) => string | undefined;
+declare const setCookie: (name: string, value: string, options?: Record<string, unknown>) => void;
+declare const deleteCookie: (name: string, options?: Record<string, unknown>) => void;
+declare const useSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
+declare const getSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
+declare const updateSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig, update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
+declare const sealSession: (_config: SessionConfig) => Promise<string>;
+declare const unsealSession: (_config: SessionConfig, sealed: string) => Promise<any>;
+declare const clearSession: (_config: Partial<SessionConfig>) => Promise<void>;
+declare const getResponse: () => {
+    status: number | undefined;
+    statusText: string | undefined;
+    readonly headers: Headers;
+};
+declare const getValidatedQuery: (schema: {
+    parse?: (value: Record<string, string>) => unknown;
+    safeParse?: (value: Record<string, string>) => unknown;
+    ["~standard"]?: {
+        validate?: (value: Record<string, string>) => Promise<unknown> | unknown;
+    };
+}) => Promise<unknown>;
+declare function useServerFn<T extends (...args: Array<any>) => Promise<any>>(serverFn: T): (...args: Parameters<T>) => ReturnType<T>;
+declare const createServerFn: typeof createServerFn$1;
+declare const Link: ({ to, children, ...props }: {
+    to: string;
+    children?: React.ReactNode;
+    [key: string]: unknown;
+}) => React.ReactElement<{
+    href: string;
+}, string | React.JSXElementConstructor<any>>;
+declare const Navigate: ({ to }: {
+    to: string;
+}) => null;
+declare const notFound: () => never;
+declare const createStart: () => {};
+declare const clearCookieStore: () => void;
+declare const fetchHandler: () => Promise<Response>;
+
+declare const _default: {
+    fetch: () => Promise<Response>;
+};
+
+export { HEADERS, Link, Navigate, StartServer, VIRTUAL_MODULES, attachRouterServerSsrUtils, clearCookieStore, clearResponseHeaders, clearSession, createRequestHandler, createServerFn, createStart, createStartHandler, _default as default, defaultRenderHandler, defaultStreamHandler, defineHandlerCallback, deleteCookie, fetchHandler as fetch, getCookie, getCookies, getRequest, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestProtocol, getRequestUrl, getResponse, getResponseHeader, getResponseHeaders, getResponseStatus, getSession, getValidatedQuery, notFound, removeResponseHeader, requestHandler, sealSession, setCookie, setResponseHeader, setResponseHeaders, setResponseStatus, transformPipeableStreamWithRouter, transformReadableStreamWithRouter, unsealSession, updateSession, useServerFn, useSession };

package/dist/export-mocks/start.js

@@ -0,0 +1,334 @@
+import {
+  onNavigate
+} from "../_browser-chunks/chunk-4CKCBIXI.js";
+import "../_browser-chunks/chunk-4BE7D4DS.js";
+
+// src/export-mocks/start.ts
+import React from "react";
+import { fn } from "storybook/test";
+export * from "@tanstack/start-client-core";
+export * from "@tanstack/react-start";
+var START_SERVER_STATE_SYMBOL = Symbol.for("storybook.tanstack-react.start-server.state"), browserGlobals = globalThis, HEADERS = {
+  TSS_SHELL: "X-TSS_SHELL"
+}, VIRTUAL_MODULES = {
+  startManifest: "tanstack-start-manifest:v",
+  injectedHeadScripts: "tanstack-start-injected-head-scripts:v",
+  serverFnResolver: "#tanstack-start-server-fn-resolver"
+};
+function createNamedMock(name, implementation) {
+  return fn(implementation).mockName(`@tanstack/react-start/server::${name}`);
+}
+function createDefaultRequest() {
+  return new Request("http://localhost/");
+}
+function parseCookieHeader(cookieHeader) {
+  let cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader)
+    return cookies;
+  for (let segment of cookieHeader.split(";")) {
+    let [rawName, ...rawValue] = segment.trim().split("=");
+    rawName && cookies.set(rawName, decodeURIComponent(rawValue.join("=")));
+  }
+  return cookies;
+}
+function serializeCookie(name, value, options) {
+  let parts = [`${name}=${encodeURIComponent(value)}`];
+  return typeof options?.path == "string" && parts.push(`Path=${options.path}`), typeof options?.domain == "string" && parts.push(`Domain=${options.domain}`), typeof options?.maxAge == "number" && parts.push(`Max-Age=${options.maxAge}`), options?.expires instanceof Date && parts.push(`Expires=${options.expires.toUTCString()}`), options?.httpOnly && parts.push("HttpOnly"), options?.secure && parts.push("Secure"), typeof options?.sameSite == "string" && parts.push(`SameSite=${options.sameSite}`), parts.join("; ");
+}
+function createMockState(request = createDefaultRequest()) {
+  return {
+    request,
+    responseHeaders: new Headers(),
+    responseStatus: void 0,
+    cookies: parseCookieHeader(request.headers.get("cookie")),
+    sessionData: {}
+  };
+}
+function getState() {
+  let existingState = browserGlobals[START_SERVER_STATE_SYMBOL];
+  if (existingState)
+    return existingState;
+  let nextState = createMockState();
+  return browserGlobals[START_SERVER_STATE_SYMBOL] = nextState, nextState;
+}
+async function withRequestState(request, run) {
+  let previousState = browserGlobals[START_SERVER_STATE_SYMBOL];
+  browserGlobals[START_SERVER_STATE_SYMBOL] = createMockState(request);
+  try {
+    return await run();
+  } finally {
+    previousState ? browserGlobals[START_SERVER_STATE_SYMBOL] = previousState : delete browserGlobals[START_SERVER_STATE_SYMBOL];
+  }
+}
+function mergeResponseState(response) {
+  let state = getState(), headers = new Headers(response.headers);
+  return state.responseHeaders.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+      return;
+    }
+    headers.set(key, value);
+  }), new Response(response.body, {
+    status: state.responseStatus?.code ?? response.status,
+    statusText: state.responseStatus?.text ?? response.statusText,
+    headers
+  });
+}
+function toResponse(result) {
+  return result instanceof Response ? mergeResponseState(result) : result == null ? mergeResponseState(new Response(null)) : mergeResponseState(typeof result == "string" ? new Response(result) : new Response(JSON.stringify(result), {
+    headers: { "content-type": "application/json" }
+  }));
+}
+function getSessionRecord() {
+  let state = getState();
+  return {
+    data: state.sessionData,
+    update: async (update) => {
+      let nextValue = typeof update == "function" ? update(state.sessionData) : update;
+      return state.sessionData = {
+        ...state.sessionData,
+        ...nextValue
+      }, getSessionRecord();
+    },
+    save: async () => {
+    },
+    clear: async () => {
+      state.sessionData = {};
+    }
+  };
+}
+function StartServer() {
+  return null;
+}
+var defineHandlerCallback = createNamedMock(
+  "defineHandlerCallback",
+  (handler) => handler
+), defaultStreamHandler = createNamedMock(
+  "defaultStreamHandler",
+  async () => new Response("Storybook Mock", { status: 200 })
+), defaultRenderHandler = createNamedMock(
+  "defaultRenderHandler",
+  async () => new Response("Storybook Mock", { status: 200 })
+), requestHandler = createNamedMock(
+  "requestHandler",
+  (handler) => async (request, requestOpts) => withRequestState(request, async () => toResponse(await handler(request, requestOpts)))
+), createRequestHandler = createNamedMock(
+  "createRequestHandler",
+  (handler) => requestHandler(handler)
+), createStartHandler = createNamedMock(
+  "createStartHandler",
+  (cbOrOptions) => {
+    let handler = typeof cbOrOptions == "function" ? cbOrOptions : cbOrOptions?.handler;
+    return requestHandler(async (request, requestOpts) => handler ? handler({
+      request,
+      responseHeaders: getState().responseHeaders,
+      router: browserGlobals.__TSR_ROUTER__,
+      context: requestOpts?.context,
+      requestContext: requestOpts?.context
+    }) : new Response("Storybook Mock", { status: 200 }));
+  }
+), attachRouterServerSsrUtils = createNamedMock(
+  "attachRouterServerSsrUtils",
+  (router) => router
+), transformReadableStreamWithRouter = createNamedMock(
+  "transformReadableStreamWithRouter",
+  (stream) => stream
+), transformPipeableStreamWithRouter = createNamedMock(
+  "transformPipeableStreamWithRouter",
+  (stream) => stream
+), getRequest = createNamedMock("getRequest", () => getState().request), getRequestHeaders = createNamedMock(
+  "getRequestHeaders",
+  () => getState().request.headers
+), getRequestHeader = createNamedMock("getRequestHeader", (name) => getState().request.headers.get(name) ?? void 0), getRequestIP = createNamedMock(
+  "getRequestIP",
+  (opts) => {
+    if (opts?.xForwardedFor)
+      return getRequestHeader("x-forwarded-for")?.split(",")[0]?.trim();
+  }
+), getRequestHost = createNamedMock(
+  "getRequestHost",
+  (opts) => (opts?.xForwardedHost ? getRequestHeader("x-forwarded-host") : getRequestHeader("host")) ?? new URL(getState().request.url).host ?? "localhost"
+), getRequestUrl = createNamedMock(
+  "getRequestUrl",
+  (opts) => {
+    let url = new URL(getState().request.url), forwardedHost = opts?.xForwardedHost ? getRequestHeader("x-forwarded-host") : void 0, forwardedProto = opts?.xForwardedProto === !1 ? void 0 : getRequestHeader("x-forwarded-proto");
+    return forwardedHost && (url.host = forwardedHost), forwardedProto && (url.protocol = `${forwardedProto}:`), url;
+  }
+), getRequestProtocol = createNamedMock(
+  "getRequestProtocol",
+  (opts) => {
+    let forwardedProto = opts?.xForwardedProto === !1 ? void 0 : getRequestHeader("x-forwarded-proto");
+    return forwardedProto || getRequestUrl().protocol.replace(/:$/, "") || "http";
+  }
+), setResponseHeaders = createNamedMock("setResponseHeaders", (headers) => {
+  getState().responseHeaders = new Headers(headers);
+}), getResponseHeaders = createNamedMock(
+  "getResponseHeaders",
+  () => getState().responseHeaders
+), getResponseHeader = createNamedMock("getResponseHeader", (name) => getState().responseHeaders.get(name) ?? void 0), setResponseHeader = createNamedMock(
+  "setResponseHeader",
+  (name, value) => {
+    let headers = getState().responseHeaders;
+    if (headers.delete(name), Array.isArray(value)) {
+      value.forEach((entry) => headers.append(name, entry));
+      return;
+    }
+    headers.set(name, value);
+  }
+), removeResponseHeader = createNamedMock("removeResponseHeader", (name) => {
+  getState().responseHeaders.delete(name);
+}), clearResponseHeaders = createNamedMock(
+  "clearResponseHeaders",
+  (headerNames) => {
+    if (!headerNames?.length) {
+      getState().responseHeaders = new Headers();
+      return;
+    }
+    headerNames.forEach((name) => getState().responseHeaders.delete(name));
+  }
+), getResponseStatus = createNamedMock("getResponseStatus", () => getState().responseStatus?.code ?? 200), setResponseStatus = createNamedMock(
+  "setResponseStatus",
+  (code, text) => {
+    getState().responseStatus = {
+      code,
+      text
+    };
+  }
+), getCookies = createNamedMock("getCookies", () => Object.fromEntries(getState().cookies)), getCookie = createNamedMock("getCookie", (name) => getState().cookies.get(name)), setCookie = createNamedMock(
+  "setCookie",
+  (name, value, options) => {
+    let state = getState();
+    state.cookies.set(name, value), state.responseHeaders.append("set-cookie", serializeCookie(name, value, options));
+  }
+), deleteCookie = createNamedMock(
+  "deleteCookie",
+  (name, options) => {
+    let state = getState();
+    state.cookies.delete(name), state.responseHeaders.append(
+      "set-cookie",
+      serializeCookie(name, "", {
+        ...options,
+        maxAge: 0
+      })
+    );
+  }
+), useSession = createNamedMock(
+  "useSession",
+  async (_config) => getSessionRecord()
+), getSession = createNamedMock(
+  "getSession",
+  async (_config) => getSessionRecord()
+), updateSession = createNamedMock(
+  "updateSession",
+  async (_config, update) => getSessionRecord().update(update)
+), sealSession = createNamedMock("sealSession", async (_config) => JSON.stringify(getState().sessionData)), unsealSession = createNamedMock(
+  "unsealSession",
+  async (_config, sealed) => {
+    try {
+      return JSON.parse(sealed);
+    } catch {
+      return {};
+    }
+  }
+), clearSession = createNamedMock(
+  "clearSession",
+  async (_config) => {
+    getState().sessionData = {};
+  }
+), getResponse = createNamedMock("getResponse", () => ({
+  status: getState().responseStatus?.code,
+  statusText: getState().responseStatus?.text,
+  get headers() {
+    return getState().responseHeaders;
+  }
+})), getValidatedQuery = createNamedMock(
+  "getValidatedQuery",
+  async (schema) => {
+    let query = Object.fromEntries(getRequestUrl().searchParams.entries());
+    if (typeof schema?.parse == "function")
+      return schema.parse(query);
+    if (typeof schema?.safeParse == "function") {
+      let result = await schema.safeParse(query);
+      return result && typeof result == "object" && "data" in result ? result.data : result;
+    }
+    return typeof schema?.["~standard"]?.validate == "function" ? schema["~standard"].validate(query) : query;
+  }
+);
+function useServerFn(serverFn) {
+  return React.useCallback(
+    (...args) => serverFn(...args),
+    [serverFn]
+  );
+}
+function createMockServerFnBuilder() {
+  let builder = () => createMockServerFnBuilder(), _storedOptions;
+  return builder.options = (opts) => (_storedOptions = opts, builder), builder.middleware = () => createMockServerFnBuilder(), builder.inputValidator = () => createMockServerFnBuilder(), builder.handler = (handlerFn) => {
+    let mock = fn().mockName("@tanstack/start-client-core::createServerFn.handler()");
+    return handlerFn && mock.mockImplementation(async (opts) => handlerFn(opts)), mock;
+  }, builder._getOptions = () => _storedOptions, builder;
+}
+var createServerFn = (options) => {
+  let builder = createMockServerFnBuilder();
+  return options !== void 0 && builder.options(options), builder;
+}, Link = ({
+  to,
+  children,
+  ...props
+}) => React.createElement("a", { href: to, ...props }, children), Navigate = ({ to }) => (React.useEffect(() => {
+  onNavigate({ to });
+}, [to]), null), notFound = () => {
+  throw new Error("Not found");
+}, createStart = () => ({}), clientCookieStore = /* @__PURE__ */ new Map(), clearCookieStore = () => {
+  clientCookieStore.clear();
+}, fetchHandler = async () => new Response("Storybook Mock", { status: 200 });
+var start_default = { fetch: fetchHandler };
+export {
+  HEADERS,
+  Link,
+  Navigate,
+  StartServer,
+  VIRTUAL_MODULES,
+  attachRouterServerSsrUtils,
+  clearCookieStore,
+  clearResponseHeaders,
+  clearSession,
+  createRequestHandler,
+  createServerFn,
+  createStart,
+  createStartHandler,
+  start_default as default,
+  defaultRenderHandler,
+  defaultStreamHandler,
+  defineHandlerCallback,
+  deleteCookie,
+  fetchHandler as fetch,
+  getCookie,
+  getCookies,
+  getRequest,
+  getRequestHeader,
+  getRequestHeaders,
+  getRequestHost,
+  getRequestIP,
+  getRequestProtocol,
+  getRequestUrl,
+  getResponse,
+  getResponseHeader,
+  getResponseHeaders,
+  getResponseStatus,
+  getSession,
+  getValidatedQuery,
+  notFound,
+  removeResponseHeader,
+  requestHandler,
+  sealSession,
+  setCookie,
+  setResponseHeader,
+  setResponseHeaders,
+  setResponseStatus,
+  transformPipeableStreamWithRouter,
+  transformReadableStreamWithRouter,
+  unsealSession,
+  updateSession,
+  useServerFn,
+  useSession
+};