gemi 0.52.0 → 0.53.0

package/dist/testing/Page.d.ts

@@ -0,0 +1,166 @@
+import { type ComponentType, type PropsWithChildren, type ReactNode } from "react";
+import { type FallbackProps } from "react-error-boundary";
+import type { User } from "../auth/types";
+import { type QueryConfig } from "../client/QueryManagerContext";
+import type { Breadcrumb } from "../client/useBreadcrumbs";
+/**
+ * A dictionary as `Dictionary.create` produces it: a name and a
+ * `{ key: { locale: string } }` map.
+ *
+ * Typed structurally rather than as `Dictionary<T>` for two reasons. It keeps
+ * `gemi/testing` from importing `gemi/i18n` — a server entry, which reaches the
+ * `Lang` facade and through it the container. And it means an object literal of
+ * the same shape is accepted, so a test never *has* to import the app's
+ * dictionaries at all.
+ *
+ * Only `name` and `dictionary` are read — both plain data. `Dictionary`'s
+ * server-only methods (`render`, `reference`, which throw once `window` is
+ * defined) are never called from here.
+ */
+export interface PageDictionary {
+    name: string;
+    dictionary: Record<string, Record<string, string>>;
+}
+export interface PageProps {
+    /**
+     * The URL the view is mounted at. A template (`/app/:orgId/chat`) is resolved
+     * against `params`, so the same string can be pasted from the router.
+     */
+    pathname?: string;
+    /** Route params, as the router would have parsed them out of `pathname`. */
+    params?: Record<string, string>;
+    /** `"?tab=recent"`, `"tab=recent"`, or `{ tab: "recent" }`. */
+    searchParams?: string | Record<string, string | number | boolean>;
+    hash?: string;
+    /** The locale `useTranslator` and `useLocale` report. */
+    locale?: string;
+    /**
+     * The app's default locale. Links and `useNavigate` omit the locale segment
+     * for it, so leaving this equal to `locale` (the default) keeps hrefs
+     * unprefixed — set it to seed a page being viewed in a non-default locale.
+     */
+    defaultLocale?: string;
+    supportedLocales?: string[];
+    /**
+     * Dictionaries the components under test translate against — the app's own,
+     * or literals of the same shape.
+     *
+     * Note what importing the app's costs: `app/i18n/index.ts` imports
+     * `gemi/i18n`, a server entry, so the test file pulls the container and
+     * `node:async_hooks` into its module graph. Nothing there runs (and nothing
+     * here calls it), so it is fine under any runner that has Node builtins —
+     * vitest, `bun test` — and not under one that renders in a real browser. Use
+     * `translations` there, which is the shape the client actually receives.
+     */
+    dictionaries?: PageDictionary[];
+    /**
+     * Translations for the current locale, already resolved: dictionary name →
+     * key → string. This is the shape the server serializes onto the page, so it
+     * is what the client reads at runtime — and it imports nothing.
+     *
+     * ```tsx
+     * <Page translations={{ Chat: { greeting: "Hello {{name}}" } }}>
+     * ```
+     *
+     * Merged over `dictionaries`, so the two compose: seed from the app's real
+     * dictionary and override the one key a test is about.
+     */
+    translations?: Record<string, Record<string, string>>;
+    /**
+     * Data `useQuery` finds already cached, keyed by API path — the path passed
+     * to `useQuery`, without the `/api` prefix the client adds when it fetches.
+     * A key may carry a query string (`"/lists?page=2"`) to seed one search
+     * variant.
+     *
+     * The cache is keyed by the *resolved* path, so a key's `:params` are
+     * resolved against the page's `params` — and a key naming one the page does
+     * not carry is an error, naming the key. That case is common enough to be
+     * worth the loud failure: a query often takes its params from the call site
+     * rather than the route (`useQuery("/orgs/:orgId/lists", { params: { orgId } })`
+     * with `orgId` in component state), and the right seed for it is the resolved
+     * path, `"/orgs/abc/lists"`.
+     *
+     * Seeded at mount only: a component that mutates or refetches its data owns
+     * the cache from then on.
+     */
+    queryData?: Record<string, unknown>;
+    /** App-wide `useQuery` defaults, as `createRoot` threads them. */
+    queryConfig?: QueryConfig;
+    /**
+     * What `useUser()` reports. Defaults to `null` — an anonymous visitor — and
+     * either way the hook resolves from here without issuing a request.
+     */
+    user?: Partial<User> | null;
+    /** What `useBreadcrumbs()` returns, in order. */
+    breadcrumbs?: Breadcrumb[];
+    /**
+     * The theme `useTheme()` starts on. The app reads a visitor's stored choice
+     * out of `localStorage`; a test has no session to have made one in, so this
+     * seeds it without writing to storage. `setTheme` works from either.
+     */
+    theme?: "light" | "dark" | "system";
+    /**
+     * Fallback for the `Suspense` boundary wrapped around the children — the
+     * stand-in for the view's own `Loading` export, which the real router
+     * supplies. Defaults to `null`.
+     */
+    fallback?: ReactNode;
+    /**
+     * Renders in place of the children when one throws, mirroring a view's
+     * `Error` export. Without it a thrown render (an errored suspense query,
+     * say) propagates out of `render()` and fails the test, which is usually
+     * what you want.
+     */
+    errorFallback?: ComponentType<FallbackProps>;
+    /**
+     * Called when something navigates — a `Link` click, `useNavigate().push`.
+     * The navigation is reported, not performed: `<Page>` renders one route and
+     * does not re-resolve the tree, so `useLocation()` keeps reporting the
+     * pathname it was given.
+     */
+    onNavigate?: (href: string, action: "push" | "replace") => void;
+}
+/**
+ * Mounts a component with the inputs a view normally arrives with — route
+ * params, the current locale and its dictionaries, prefetched query data, the
+ * signed-in user — so a unit test can assert what it renders rather than only
+ * its empty state.
+ *
+ * ```tsx
+ * import { render, screen } from "@testing-library/react";
+ * import { Page } from "gemi/testing";
+ *
+ * render(
+ *   <Page
+ *     pathname="/app/:orgId/chat"
+ *     params={{ orgId: "abc" }}
+ *     queryData={{ "/organizations/:orgId/messages": [{ id: 1, body: "hi" }] }}
+ *     dictionaries={[ChatDictionary]}
+ *   >
+ *     <OrgChat />
+ *   </Page>,
+ * );
+ *
+ * expect(screen.getByText("hi")).toBeDefined();
+ * ```
+ *
+ * It is a plain component, so it composes with any renderer — Testing
+ * Library's `render`, `react-test-renderer`, or `renderToString`.
+ *
+ * Two things it does not do.
+ *
+ * It does not route: there is no view tree and no route manifest behind it, so
+ * a navigation is reported through `onNavigate` rather than resolved. To
+ * assert the page *after* one, render a second `<Page>`.
+ *
+ * And under `renderToString` it renders the server's own no-data branch for an
+ * *unseeded* query rather than suspending — deliberately, because suspending
+ * there is the streaming server's job: `createRoot` threads the request's
+ * `ServerQueryStore` through `ServerQueryContext`, and that store is what runs
+ * the route handler. A harness has no request and no handler to run, so there
+ * is nothing to suspend on. Seeded queries render their data on the server
+ * exactly as they do in the browser; unseeded ones behave as a route with no
+ * `Query.prefetch` does, framework warning included.
+ */
+export declare const Page: (props: PropsWithChildren<PageProps>) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Page.d.ts.map

package/dist/testing/Page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Page.d.ts","sourceRoot":"","sources":["../../testing/Page.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAI1C,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAYvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAM3D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAChC;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,kEAAkE;IAClE,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC5B,iDAAiD;IACjD,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;CACjE;AA6ID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,iBAAiB,CAAC,SAAS,CAAC,4CA4PvD,CAAC"}

package/dist/testing/index.d.ts

@@ -0,0 +1,3 @@
+export { Page } from "./Page";
+export type { PageProps, PageDictionary } from "./Page";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,352 @@
+import { A as toVariantKey, E as createMemoryHistory, L as Subject, N as QueryManagerContext, P as QueryManagerProvider, T as Action, a as m, b as I18nProvider, c as ClientRouterContext, j as applyParams, k as RouteStateProvider, o as RouteTransitionProvider, r as WebSocketContext, t as ThemeProvider, w as ProgressManager, x as ServerDataContext } from "../chunks/ThemeProvider-CTX9LOFC.js";
+import { Suspense, useContext, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region testing/Page.tsx
+/** `"?a=b"` (or `""`) from any of the shapes `searchParams` accepts. */
+function toSearchString(search) {
+	if (!search) return "";
+	const query = typeof search === "string" ? search.replace(/^\?/, "") : new URLSearchParams(Object.entries(search).map(([key, value]) => [key, String(value)])).toString();
+	return query ? `?${query}` : "";
+}
+/**
+* The `:params` a seed key needs supplied. Wildcards (`:rest*`) are excluded —
+* `applyParams` drops those when missing, which is a resolution rather than a
+* failure.
+*
+* Optional params (`:id?`) cannot reach here at all: a key is split at its
+* first `?` to separate the search string, so `"/lists/:folderId?"` arrives as
+* the path `/lists/:folderId`. Seed the resolved path for those.
+*/
+function requiredParamsOf(path) {
+	return Array.from(path.matchAll(/:([^/]+)/g), ([, name]) => name).filter((name) => !name.endsWith("*"));
+}
+/**
+* Fails a `queryData` key whose `:params` the page does not carry, saying so
+* in terms of the key.
+*
+* Without this the two documented runners disagree, and neither is legible.
+* `applyParams` throws `Missing parameter: orgId` under `import.meta.env.DEV`
+* (vitest) — a router-utility stack trace out of `<Page>`'s render, before
+* anything mounts, naming nothing that appears in the test. Under `bun test`
+* that flag is falsy, so it logs and seeds the literal `/orgs/undefined/lists`
+* instead: the seed misses, the query goes to the network, and the assertion
+* runs against a loading state.
+*
+* The case is common because a query's params often come from the call site
+* rather than the route — `useQuery("/orgs/:orgId/lists", { params: { orgId } })`
+* with `orgId` in component state. The cache is keyed by the *resolved* path,
+* so the way out is to seed that path directly.
+*/
+function resolveSeedPath(key, rawPath, params) {
+	const missing = requiredParamsOf(rawPath).filter((name) => params[name] === void 0);
+	if (missing.length > 0) throw new Error(`[gemi] <Page> cannot resolve the queryData key "${key}": no value for ${missing.map((name) => `:${name}`).join(", ")}. The query cache is keyed by the resolved path, so either add ${missing.map((name) => `\`${name}\``).join(", ")} to the page's \`params\`, or seed the resolved path (e.g. "${applyParams(rawPath, Object.fromEntries(missing.map((name) => [name, "123"])))}") — which is what a query taking its params from component state reads under.`);
+	return applyParams(rawPath, params);
+}
+/**
+* `queryData` in the shape the query cache seeds from: `{ [path]: { [variant]:
+* data } }`, the same payload `Query.prefetch` puts on a server-rendered page.
+*/
+function toPrefetchedData(queryData, params, warned) {
+	const prefetchedData = {};
+	for (const [key, data] of Object.entries(queryData)) {
+		const [rawPath, rawSearch = ""] = key.split("?");
+		if (rawPath.startsWith("/api/") && !warned.has(key)) {
+			warned.add(key);
+			console.warn(`[gemi] queryData key "${key}" starts with /api. useQuery is keyed by the path you pass it — the /api prefix is added when it fetches — so this entry seeds a path no query reads.`);
+		}
+		const path = resolveSeedPath(key, rawPath, params);
+		prefetchedData[path] = {
+			...prefetchedData[path],
+			[toVariantKey(rawSearch)]: data
+		};
+	}
+	return prefetchedData;
+}
+/**
+* `{ [locale]: { [dictionary]: { [key]: string } } }` — the payload
+* `Translator` serializes onto the page, which is the only form the client
+* ever sees. `dictionaries` are transposed into it (they are keyed the other
+* way round, by key then locale); `translations` is already in it and lands
+* under `locale`, last, so it wins.
+*/
+function toClientDictionary(dictionaries, locales, locale, translations) {
+	const clientDictionary = {};
+	for (const supported of locales) clientDictionary[supported] ??= {};
+	for (const { name, dictionary } of dictionaries) for (const [key, byLocale] of Object.entries(dictionary ?? {})) for (const [dictLocale, translation] of Object.entries(byLocale ?? {})) {
+		clientDictionary[dictLocale] ??= {};
+		clientDictionary[dictLocale][name] ??= {};
+		clientDictionary[dictLocale][name][key] = translation;
+	}
+	for (const [name, keys] of Object.entries(translations)) {
+		clientDictionary[locale] ??= {};
+		clientDictionary[locale][name] = {
+			...clientDictionary[locale][name],
+			...keys
+		};
+	}
+	return clientDictionary;
+}
+/**
+* Mounts a component with the inputs a view normally arrives with — route
+* params, the current locale and its dictionaries, prefetched query data, the
+* signed-in user — so a unit test can assert what it renders rather than only
+* its empty state.
+*
+* ```tsx
+* import { render, screen } from "@testing-library/react";
+* import { Page } from "gemi/testing";
+*
+* render(
+*   <Page
+*     pathname="/app/:orgId/chat"
+*     params={{ orgId: "abc" }}
+*     queryData={{ "/organizations/:orgId/messages": [{ id: 1, body: "hi" }] }}
+*     dictionaries={[ChatDictionary]}
+*   >
+*     <OrgChat />
+*   </Page>,
+* );
+*
+* expect(screen.getByText("hi")).toBeDefined();
+* ```
+*
+* It is a plain component, so it composes with any renderer — Testing
+* Library's `render`, `react-test-renderer`, or `renderToString`.
+*
+* Two things it does not do.
+*
+* It does not route: there is no view tree and no route manifest behind it, so
+* a navigation is reported through `onNavigate` rather than resolved. To
+* assert the page *after* one, render a second `<Page>`.
+*
+* And under `renderToString` it renders the server's own no-data branch for an
+* *unseeded* query rather than suspending — deliberately, because suspending
+* there is the streaming server's job: `createRoot` threads the request's
+* `ServerQueryStore` through `ServerQueryContext`, and that store is what runs
+* the route handler. A harness has no request and no handler to run, so there
+* is nothing to suspend on. Seeded queries render their data on the server
+* exactly as they do in the browser; unseeded ones behave as a route with no
+* `Query.prefetch` does, framework warning included.
+*/
+var Page = (props) => {
+	const { children, pathname: routePath = "/", params = {}, searchParams, hash = "", locale = "en-US", defaultLocale = locale, dictionaries = [], translations = {}, queryData = {}, queryConfig, user = null, breadcrumbs = [], theme, fallback = null, errorFallback, onNavigate } = props;
+	const supportedLocales = useMemo(() => Array.from(/* @__PURE__ */ new Set([
+		...props.supportedLocales ?? [],
+		defaultLocale,
+		locale
+	])), [
+		props.supportedLocales,
+		defaultLocale,
+		locale
+	]);
+	const pathname = applyParams(routePath, params) || "/";
+	const search = toSearchString(searchParams);
+	const urlLocaleSegment = locale === defaultLocale ? null : locale;
+	const dictionary = useMemo(() => toClientDictionary(dictionaries, supportedLocales, locale, translations), [
+		dictionaries,
+		supportedLocales,
+		locale,
+		translations
+	]);
+	const warnedRef = useRef(/* @__PURE__ */ new Set());
+	const prefetchedData = useMemo(() => {
+		const seeded = toPrefetchedData(queryData, params, warnedRef.current);
+		seeded["/auth/me"] ??= { "": user ?? null };
+		return seeded;
+	}, [
+		queryData,
+		params,
+		user
+	]);
+	const { breadcrumbViews, breadcrumbsCache, breadcrumbsRecord } = useMemo(() => {
+		const views = breadcrumbs.map((_, index) => `breadcrumb-${index}`);
+		const cache = new Map(breadcrumbs.map((breadcrumb, index) => [`${views[index]}:${pathname}`, breadcrumb]));
+		return {
+			breadcrumbViews: views,
+			breadcrumbsCache: cache,
+			breadcrumbsRecord: Object.fromEntries(cache)
+		};
+	}, [breadcrumbs, pathname]);
+	const [isNavigatingSubject] = useState(() => new Subject(false));
+	const [progressManager] = useState(() => new ProgressManager(isNavigatingSubject));
+	const [history] = useState(() => createMemoryHistory({ initialEntries: [`${pathname}${search}${hash}`] }));
+	const routeState = useMemo(() => ({
+		views: [],
+		params,
+		search,
+		state: {},
+		pathname,
+		hash,
+		action: null,
+		routePath,
+		locale: urlLocaleSegment,
+		data: {},
+		i18n: {
+			currentLocale: locale,
+			dictionary,
+			supportedLocales
+		},
+		prefetchedData,
+		breadcrumbs: breadcrumbsRecord,
+		appId: "test"
+	}), [
+		params,
+		search,
+		pathname,
+		hash,
+		routePath,
+		urlLocaleSegment,
+		locale,
+		dictionary,
+		supportedLocales,
+		prefetchedData,
+		breadcrumbsRecord
+	]);
+	const [routerSubject] = useState(() => new Subject(routeState));
+	const onNavigateRef = useRef(onNavigate);
+	onNavigateRef.current = onNavigate;
+	const listeningRef = useRef(false);
+	if (!listeningRef.current) {
+		listeningRef.current = true;
+		history.listen(({ location, action }) => {
+			const href = `${location.pathname}${location.search}${location.hash}`;
+			onNavigateRef.current?.(href, action === Action.Replace ? "replace" : "push");
+		});
+	}
+	const serverData = useMemo(() => ({
+		routeManifest: {},
+		pageData: {},
+		breadcrumbs: breadcrumbsRecord,
+		prefetchedData,
+		router: {
+			pathname,
+			params,
+			currentPath: routePath,
+			is404: false,
+			searchParams: search,
+			urlLocaleSegment
+		},
+		i18n: {
+			dictionary,
+			currentLocale: locale,
+			supportedLocales,
+			defaultLocale
+		},
+		componentTree: [],
+		auth: { user },
+		__csrf: "test-csrf-token",
+		cssManifest: {},
+		modulePreloadManifest: {},
+		meta: {},
+		appId: "test"
+	}), [
+		breadcrumbsRecord,
+		prefetchedData,
+		pathname,
+		params,
+		routePath,
+		search,
+		urlLocaleSegment,
+		dictionary,
+		locale,
+		supportedLocales,
+		defaultLocale,
+		user
+	]);
+	const [viewEntriesSubject] = useState(() => new Subject([]));
+	const routerContext = useMemo(() => ({
+		viewEntriesSubject,
+		history,
+		updatePageData: () => {},
+		getPageData: () => ({}),
+		getScrollPosition: () => 0,
+		getViewPathsFromPathname: () => breadcrumbViews,
+		getRoutePathnameFromHref: (href) => href,
+		isNavigatingSubject,
+		setNavigationAbortController: () => {},
+		progressManager,
+		fetchRouteCSS: async () => {},
+		preloadRouteModules: () => {},
+		prefetchRoute: async () => {},
+		takePrefetched: () => null,
+		clearPrefetchCache: () => {},
+		breadcrumbsCache,
+		routerSubject,
+		urlLocaleSegment
+	}), [
+		viewEntriesSubject,
+		history,
+		breadcrumbViews,
+		isNavigatingSubject,
+		progressManager,
+		breadcrumbsCache,
+		routerSubject,
+		urlLocaleSegment
+	]);
+	const [websocket] = useState(() => ({
+		subscribe: async () => {},
+		unsubscribe: async () => {},
+		broadcast: () => {}
+	}));
+	return /* @__PURE__ */ jsx(ThemeProvider, {
+		theme,
+		children: /* @__PURE__ */ jsx(ServerDataContext.Provider, {
+			value: serverData,
+			children: /* @__PURE__ */ jsx(I18nProvider, { children: /* @__PURE__ */ jsx(WebSocketContext.Provider, {
+				value: websocket,
+				children: /* @__PURE__ */ jsx(QueryManagerProvider, {
+					queryConfig,
+					children: /* @__PURE__ */ jsx(ClientRouterContext.Provider, {
+						value: routerContext,
+						children: /* @__PURE__ */ jsx(RouteTransitionProvider, {
+							isPending: false,
+							isFetching: false,
+							transitionPath: ["", pathname],
+							children: /* @__PURE__ */ jsx(RouteStateProvider, {
+								state: routeState,
+								children: /* @__PURE__ */ jsx(Boundary, {
+									errorFallback,
+									fallback,
+									resetKey: pathname,
+									children
+								})
+							})
+						})
+					})
+				})
+			}) })
+		})
+	});
+};
+/**
+* The `Suspense` boundary every view renders inside, and — when the test
+* supplies a fallback for it — the error boundary too.
+*
+* `onReset={clearErrors}` is the part that has to be here rather than inline
+* above: it needs `QueryManagerContext`, and it is what makes a view's real
+* `Error` export testable. A fallback whose "Try again" calls
+* `resetErrorBoundary()` re-renders the child, and `useQuery` reads the
+* failure still stored on the `QueryResource` and throws it straight back —
+* so without this the fallback never goes away and the retry path that works
+* in the app cannot be exercised. `ClientRouter`'s own boundary wires exactly
+* this pair.
+*/
+var Boundary = (props) => {
+	const { errorFallback: ErrorFallback, fallback, resetKey, children } = props;
+	const { clearErrors } = useContext(QueryManagerContext);
+	const content = /* @__PURE__ */ jsx(Suspense, {
+		fallback,
+		children
+	});
+	if (!ErrorFallback) return content;
+	return /* @__PURE__ */ jsx(m, {
+		FallbackComponent: ErrorFallback,
+		resetKeys: [resetKey],
+		onReset: clearErrors,
+		children: content
+	});
+};
+//#endregion
+export { Page };
+
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../testing/Page.tsx"],"sourcesContent":["import {\n  Suspense,\n  useContext,\n  useMemo,\n  useRef,\n  useState,\n  type ComponentType,\n  type PropsWithChildren,\n  type ReactNode,\n} from \"react\";\nimport { ErrorBoundary, type FallbackProps } from \"react-error-boundary\";\nimport { Action, createMemoryHistory } from \"history\";\n\nimport type { User } from \"../auth/types\";\nimport { ClientRouterContext } from \"../client/ClientRouterContext\";\nimport { I18nProvider } from \"../client/I18nContext\";\nimport { ProgressManager } from \"../client/ProgressManager\";\nimport {\n  QueryManagerContext,\n  QueryManagerProvider,\n  type QueryConfig,\n} from \"../client/QueryManagerContext\";\nimport {\n  RouteStateProvider,\n  type PageData,\n  type RouteState,\n} from \"../client/RouteStateContext\";\nimport { RouteTransitionProvider } from \"../client/RouteTransitionProvider\";\nimport {\n  ServerDataContext,\n  type ServerDataContextValue,\n} from \"../client/ServerDataProvider\";\nimport { ThemeProvider } from \"../client/ThemeProvider\";\nimport type { Breadcrumb } from \"../client/useBreadcrumbs\";\nimport { WebSocketContext } from \"../client/WebsocketContext\";\nimport { applyParams } from \"../utils/applyParams\";\nimport { Subject } from \"../utils/Subject\";\nimport { toVariantKey } from \"../utils/variantKey\";\n\n/**\n * A dictionary as `Dictionary.create` produces it: a name and a\n * `{ key: { locale: string } }` map.\n *\n * Typed structurally rather than as `Dictionary<T>` for two reasons. It keeps\n * `gemi/testing` from importing `gemi/i18n` — a server entry, which reaches the\n * `Lang` facade and through it the container. And it means an object literal of\n * the same shape is accepted, so a test never *has* to import the app's\n * dictionaries at all.\n *\n * Only `name` and `dictionary` are read — both plain data. `Dictionary`'s\n * server-only methods (`render`, `reference`, which throw once `window` is\n * defined) are never called from here.\n */\nexport interface PageDictionary {\n  name: string;\n  dictionary: Record<string, Record<string, string>>;\n}\n\nexport interface PageProps {\n  /**\n   * The URL the view is mounted at. A template (`/app/:orgId/chat`) is resolved\n   * against `params`, so the same string can be pasted from the router.\n   */\n  pathname?: string;\n  /** Route params, as the router would have parsed them out of `pathname`. */\n  params?: Record<string, string>;\n  /** `\"?tab=recent\"`, `\"tab=recent\"`, or `{ tab: \"recent\" }`. */\n  searchParams?: string | Record<string, string | number | boolean>;\n  hash?: string;\n  /** The locale `useTranslator` and `useLocale` report. */\n  locale?: string;\n  /**\n   * The app's default locale. Links and `useNavigate` omit the locale segment\n   * for it, so leaving this equal to `locale` (the default) keeps hrefs\n   * unprefixed — set it to seed a page being viewed in a non-default locale.\n   */\n  defaultLocale?: string;\n  supportedLocales?: string[];\n  /**\n   * Dictionaries the components under test translate against — the app's own,\n   * or literals of the same shape.\n   *\n   * Note what importing the app's costs: `app/i18n/index.ts` imports\n   * `gemi/i18n`, a server entry, so the test file pulls the container and\n   * `node:async_hooks` into its module graph. Nothing there runs (and nothing\n   * here calls it), so it is fine under any runner that has Node builtins —\n   * vitest, `bun test` — and not under one that renders in a real browser. Use\n   * `translations` there, which is the shape the client actually receives.\n   */\n  dictionaries?: PageDictionary[];\n  /**\n   * Translations for the current locale, already resolved: dictionary name →\n   * key → string. This is the shape the server serializes onto the page, so it\n   * is what the client reads at runtime — and it imports nothing.\n   *\n   * ```tsx\n   * <Page translations={{ Chat: { greeting: \"Hello {{name}}\" } }}>\n   * ```\n   *\n   * Merged over `dictionaries`, so the two compose: seed from the app's real\n   * dictionary and override the one key a test is about.\n   */\n  translations?: Record<string, Record<string, string>>;\n  /**\n   * Data `useQuery` finds already cached, keyed by API path — the path passed\n   * to `useQuery`, without the `/api` prefix the client adds when it fetches.\n   * A key may carry a query string (`\"/lists?page=2\"`) to seed one search\n   * variant.\n   *\n   * The cache is keyed by the *resolved* path, so a key's `:params` are\n   * resolved against the page's `params` — and a key naming one the page does\n   * not carry is an error, naming the key. That case is common enough to be\n   * worth the loud failure: a query often takes its params from the call site\n   * rather than the route (`useQuery(\"/orgs/:orgId/lists\", { params: { orgId } })`\n   * with `orgId` in component state), and the right seed for it is the resolved\n   * path, `\"/orgs/abc/lists\"`.\n   *\n   * Seeded at mount only: a component that mutates or refetches its data owns\n   * the cache from then on.\n   */\n  queryData?: Record<string, unknown>;\n  /** App-wide `useQuery` defaults, as `createRoot` threads them. */\n  queryConfig?: QueryConfig;\n  /**\n   * What `useUser()` reports. Defaults to `null` — an anonymous visitor — and\n   * either way the hook resolves from here without issuing a request.\n   */\n  user?: Partial<User> | null;\n  /** What `useBreadcrumbs()` returns, in order. */\n  breadcrumbs?: Breadcrumb[];\n  /**\n   * The theme `useTheme()` starts on. The app reads a visitor's stored choice\n   * out of `localStorage`; a test has no session to have made one in, so this\n   * seeds it without writing to storage. `setTheme` works from either.\n   */\n  theme?: \"light\" | \"dark\" | \"system\";\n  /**\n   * Fallback for the `Suspense` boundary wrapped around the children — the\n   * stand-in for the view's own `Loading` export, which the real router\n   * supplies. Defaults to `null`.\n   */\n  fallback?: ReactNode;\n  /**\n   * Renders in place of the children when one throws, mirroring a view's\n   * `Error` export. Without it a thrown render (an errored suspense query,\n   * say) propagates out of `render()` and fails the test, which is usually\n   * what you want.\n   */\n  errorFallback?: ComponentType<FallbackProps>;\n  /**\n   * Called when something navigates — a `Link` click, `useNavigate().push`.\n   * The navigation is reported, not performed: `<Page>` renders one route and\n   * does not re-resolve the tree, so `useLocation()` keeps reporting the\n   * pathname it was given.\n   */\n  onNavigate?: (href: string, action: \"push\" | \"replace\") => void;\n}\n\n/** `\"?a=b\"` (or `\"\"`) from any of the shapes `searchParams` accepts. */\nfunction toSearchString(search: PageProps[\"searchParams\"]): string {\n  if (!search) return \"\";\n  const query =\n    typeof search === \"string\"\n      ? search.replace(/^\\?/, \"\")\n      : new URLSearchParams(\n          Object.entries(search).map(([key, value]) => [key, String(value)]),\n        ).toString();\n  return query ? `?${query}` : \"\";\n}\n\n/**\n * The `:params` a seed key needs supplied. Wildcards (`:rest*`) are excluded —\n * `applyParams` drops those when missing, which is a resolution rather than a\n * failure.\n *\n * Optional params (`:id?`) cannot reach here at all: a key is split at its\n * first `?` to separate the search string, so `\"/lists/:folderId?\"` arrives as\n * the path `/lists/:folderId`. Seed the resolved path for those.\n */\nfunction requiredParamsOf(path: string): string[] {\n  return Array.from(path.matchAll(/:([^/]+)/g), ([, name]) => name).filter(\n    (name) => !name.endsWith(\"*\"),\n  );\n}\n\n/**\n * Fails a `queryData` key whose `:params` the page does not carry, saying so\n * in terms of the key.\n *\n * Without this the two documented runners disagree, and neither is legible.\n * `applyParams` throws `Missing parameter: orgId` under `import.meta.env.DEV`\n * (vitest) — a router-utility stack trace out of `<Page>`'s render, before\n * anything mounts, naming nothing that appears in the test. Under `bun test`\n * that flag is falsy, so it logs and seeds the literal `/orgs/undefined/lists`\n * instead: the seed misses, the query goes to the network, and the assertion\n * runs against a loading state.\n *\n * The case is common because a query's params often come from the call site\n * rather than the route — `useQuery(\"/orgs/:orgId/lists\", { params: { orgId } })`\n * with `orgId` in component state. The cache is keyed by the *resolved* path,\n * so the way out is to seed that path directly.\n */\nfunction resolveSeedPath(\n  key: string,\n  rawPath: string,\n  params: Record<string, string>,\n): string {\n  const missing = requiredParamsOf(rawPath).filter(\n    (name) => params[name] === undefined,\n  );\n  if (missing.length > 0) {\n    throw new Error(\n      `[gemi] <Page> cannot resolve the queryData key \"${key}\": no value for ` +\n        `${missing.map((name) => `:${name}`).join(\", \")}. The query cache is ` +\n        `keyed by the resolved path, so either add ${missing\n          .map((name) => `\\`${name}\\``)\n          .join(\", \")} to the page's \\`params\\`, or seed the resolved path ` +\n        `(e.g. \"${applyParams(\n          rawPath,\n          Object.fromEntries(missing.map((name) => [name, \"123\"])),\n        )}\") — which is what a query taking its params from component state ` +\n        `reads under.`,\n    );\n  }\n  return applyParams(rawPath, params);\n}\n\n/**\n * `queryData` in the shape the query cache seeds from: `{ [path]: { [variant]:\n * data } }`, the same payload `Query.prefetch` puts on a server-rendered page.\n */\nfunction toPrefetchedData(\n  queryData: Record<string, unknown>,\n  params: Record<string, string>,\n  warned: Set<string>,\n) {\n  const prefetchedData: Record<string, Record<string, unknown>> = {};\n  for (const [key, data] of Object.entries(queryData)) {\n    const [rawPath, rawSearch = \"\"] = key.split(\"?\");\n    // Once per key per page, not once per render: this runs again on every\n    // re-render, and a duplicated warning reads as a second mistake.\n    if (rawPath.startsWith(\"/api/\") && !warned.has(key)) {\n      warned.add(key);\n      console.warn(\n        `[gemi] queryData key \"${key}\" starts with /api. useQuery is keyed by ` +\n          `the path you pass it — the /api prefix is added when it fetches — ` +\n          `so this entry seeds a path no query reads.`,\n      );\n    }\n    const path = resolveSeedPath(key, rawPath, params);\n    prefetchedData[path] = {\n      ...prefetchedData[path],\n      [toVariantKey(rawSearch)]: data,\n    };\n  }\n  return prefetchedData;\n}\n\n/**\n * `{ [locale]: { [dictionary]: { [key]: string } } }` — the payload\n * `Translator` serializes onto the page, which is the only form the client\n * ever sees. `dictionaries` are transposed into it (they are keyed the other\n * way round, by key then locale); `translations` is already in it and lands\n * under `locale`, last, so it wins.\n */\nfunction toClientDictionary(\n  dictionaries: PageDictionary[],\n  locales: string[],\n  locale: string,\n  translations: Record<string, Record<string, string>>,\n): Record<string, Record<string, Record<string, string>>> {\n  const clientDictionary: Record<\n    string,\n    Record<string, Record<string, string>>\n  > = {};\n  for (const supported of locales) {\n    clientDictionary[supported] ??= {};\n  }\n  for (const { name, dictionary } of dictionaries) {\n    for (const [key, byLocale] of Object.entries(dictionary ?? {})) {\n      for (const [dictLocale, translation] of Object.entries(byLocale ?? {})) {\n        clientDictionary[dictLocale] ??= {};\n        clientDictionary[dictLocale][name] ??= {};\n        clientDictionary[dictLocale][name][key] = translation;\n      }\n    }\n  }\n  for (const [name, keys] of Object.entries(translations)) {\n    clientDictionary[locale] ??= {};\n    clientDictionary[locale][name] = {\n      ...clientDictionary[locale][name],\n      ...keys,\n    };\n  }\n  return clientDictionary;\n}\n\n/**\n * Mounts a component with the inputs a view normally arrives with — route\n * params, the current locale and its dictionaries, prefetched query data, the\n * signed-in user — so a unit test can assert what it renders rather than only\n * its empty state.\n *\n * ```tsx\n * import { render, screen } from \"@testing-library/react\";\n * import { Page } from \"gemi/testing\";\n *\n * render(\n *   <Page\n *     pathname=\"/app/:orgId/chat\"\n *     params={{ orgId: \"abc\" }}\n *     queryData={{ \"/organizations/:orgId/messages\": [{ id: 1, body: \"hi\" }] }}\n *     dictionaries={[ChatDictionary]}\n *   >\n *     <OrgChat />\n *   </Page>,\n * );\n *\n * expect(screen.getByText(\"hi\")).toBeDefined();\n * ```\n *\n * It is a plain component, so it composes with any renderer — Testing\n * Library's `render`, `react-test-renderer`, or `renderToString`.\n *\n * Two things it does not do.\n *\n * It does not route: there is no view tree and no route manifest behind it, so\n * a navigation is reported through `onNavigate` rather than resolved. To\n * assert the page *after* one, render a second `<Page>`.\n *\n * And under `renderToString` it renders the server's own no-data branch for an\n * *unseeded* query rather than suspending — deliberately, because suspending\n * there is the streaming server's job: `createRoot` threads the request's\n * `ServerQueryStore` through `ServerQueryContext`, and that store is what runs\n * the route handler. A harness has no request and no handler to run, so there\n * is nothing to suspend on. Seeded queries render their data on the server\n * exactly as they do in the browser; unseeded ones behave as a route with no\n * `Query.prefetch` does, framework warning included.\n */\nexport const Page = (props: PropsWithChildren<PageProps>) => {\n  const {\n    children,\n    pathname: routePath = \"/\",\n    params = {},\n    searchParams,\n    hash = \"\",\n    locale = \"en-US\",\n    defaultLocale = locale,\n    dictionaries = [],\n    translations = {},\n    queryData = {},\n    queryConfig,\n    user = null,\n    breadcrumbs = [],\n    theme,\n    fallback = null,\n    errorFallback,\n    onNavigate,\n  } = props;\n\n  // The caller's list, in the caller's order — a language switcher maps over\n  // it, so hoisting the page's own locale to the front would reorder the\n  // rendered options. The defaults are appended, only to guarantee presence.\n  const supportedLocales = useMemo(\n    () =>\n      Array.from(\n        new Set([...(props.supportedLocales ?? []), defaultLocale, locale]),\n      ),\n    [props.supportedLocales, defaultLocale, locale],\n  );\n  const pathname = applyParams(routePath, params) || \"/\";\n  const search = toSearchString(searchParams);\n  // The URL's locale segment, which the default locale does not get.\n  const urlLocaleSegment = locale === defaultLocale ? null : locale;\n\n  const dictionary = useMemo(\n    () =>\n      toClientDictionary(dictionaries, supportedLocales, locale, translations),\n    [dictionaries, supportedLocales, locale, translations],\n  );\n\n  // Keys that have already drawn a warning, so a re-render does not repeat it.\n  const warnedRef = useRef<Set<string>>(new Set());\n  const prefetchedData = useMemo(() => {\n    const seeded = toPrefetchedData(queryData, params, warnedRef.current);\n    // `useUser` reads `/auth/me` like any other query. Seeding it — with `null`\n    // for the anonymous default — is what keeps a component test off the\n    // network for a hook nothing in the test asked for.\n    seeded[\"/auth/me\"] ??= { \"\": user ?? null };\n    return seeded;\n  }, [queryData, params, user]);\n\n  // Keyed by `${view}:${pathname}` in the router's cache; the view names are\n  // ours to choose here, and only their order reaches `useBreadcrumbs`.\n  const { breadcrumbViews, breadcrumbsCache, breadcrumbsRecord } =\n    useMemo(() => {\n      const views = breadcrumbs.map((_, index) => `breadcrumb-${index}`);\n      const cache = new Map<string, Breadcrumb>(\n        breadcrumbs.map((breadcrumb, index) => [\n          `${views[index]}:${pathname}`,\n          breadcrumb,\n        ]),\n      );\n      return {\n        breadcrumbViews: views,\n        breadcrumbsCache: cache,\n        breadcrumbsRecord: Object.fromEntries(cache),\n      };\n    }, [breadcrumbs, pathname]);\n\n  const [isNavigatingSubject] = useState(() => new Subject<boolean>(false));\n  const [progressManager] = useState(\n    () => new ProgressManager(isNavigatingSubject),\n  );\n  const [history] = useState(() =>\n    createMemoryHistory({ initialEntries: [`${pathname}${search}${hash}`] }),\n  );\n\n  const routeState: RouteState & PageData = useMemo(\n    () => ({\n      views: [],\n      params,\n      search,\n      state: {},\n      pathname,\n      hash,\n      action: null,\n      routePath,\n      locale: urlLocaleSegment,\n      data: {},\n      i18n: { currentLocale: locale, dictionary, supportedLocales },\n      prefetchedData,\n      breadcrumbs: breadcrumbsRecord,\n      appId: \"test\",\n    }),\n    [\n      params,\n      search,\n      pathname,\n      hash,\n      routePath,\n      urlLocaleSegment,\n      locale,\n      dictionary,\n      supportedLocales,\n      prefetchedData,\n      breadcrumbsRecord,\n    ],\n  );\n\n  const [routerSubject] = useState(() => new Subject<RouteState>(routeState));\n\n  const onNavigateRef = useRef(onNavigate);\n  onNavigateRef.current = onNavigate;\n  // Subscribed during render, not in an effect, because React flushes child\n  // effects before parent ones — and mount-time navigation is a real pattern:\n  // `<Redirect>` pushes from its own mount effect, as does any auth guard. A\n  // listener registered in `<Page>`'s effect is not there yet when those fire,\n  // so `onNavigate` would silently miss exactly the redirects a test most\n  // wants to assert. Ref-guarded, so React's double-invoke registers one.\n  //\n  // Nothing unsubscribes: this history is created per `<Page>` and reachable\n  // from nowhere else, so it is collected with the page it belongs to.\n  const listeningRef = useRef(false);\n  if (!listeningRef.current) {\n    listeningRef.current = true;\n    history.listen(({ location, action }) => {\n      const href = `${location.pathname}${location.search}${location.hash}`;\n      onNavigateRef.current?.(\n        href,\n        action === Action.Replace ? \"replace\" : \"push\",\n      );\n    });\n  }\n\n  const serverData: ServerDataContextValue = useMemo(\n    () => ({\n      routeManifest: {},\n      pageData: {},\n      breadcrumbs: breadcrumbsRecord,\n      prefetchedData,\n      router: {\n        pathname,\n        params,\n        currentPath: routePath,\n        is404: false,\n        searchParams: search,\n        urlLocaleSegment,\n      },\n      i18n: {\n        dictionary,\n        currentLocale: locale,\n        supportedLocales,\n        defaultLocale,\n      },\n      componentTree: [],\n      auth: { user: user as User },\n      __csrf: \"test-csrf-token\",\n      cssManifest: {},\n      modulePreloadManifest: {},\n      meta: {},\n      appId: \"test\",\n    }),\n    [\n      breadcrumbsRecord,\n      prefetchedData,\n      pathname,\n      params,\n      routePath,\n      search,\n      urlLocaleSegment,\n      dictionary,\n      locale,\n      supportedLocales,\n      defaultLocale,\n      user,\n    ],\n  );\n\n  // Everything the router hooks read, inert: nothing here fetches, preloads or\n  // resolves a route, but every hook finds the shape it expects rather than an\n  // empty context to crash on.\n  const [viewEntriesSubject] = useState(() => new Subject<string[]>([]));\n  const routerContext = useMemo(\n    () => ({\n      viewEntriesSubject,\n      history,\n      updatePageData: () => {},\n      getPageData: () => ({}),\n      getScrollPosition: () => 0,\n      getViewPathsFromPathname: () => breadcrumbViews,\n      getRoutePathnameFromHref: (href: string) => href,\n      isNavigatingSubject,\n      setNavigationAbortController: () => {},\n      progressManager,\n      fetchRouteCSS: async () => {},\n      preloadRouteModules: () => {},\n      prefetchRoute: async () => {},\n      takePrefetched: () => null,\n      clearPrefetchCache: () => {},\n      breadcrumbsCache,\n      routerSubject,\n      urlLocaleSegment,\n    }),\n    [\n      viewEntriesSubject,\n      history,\n      breadcrumbViews,\n      isNavigatingSubject,\n      progressManager,\n      breadcrumbsCache,\n      routerSubject,\n      urlLocaleSegment,\n    ],\n  );\n\n  const [websocket] = useState(() => ({\n    subscribe: async () => {},\n    unsubscribe: async () => {},\n    broadcast: () => {},\n  }));\n\n  return (\n    <ThemeProvider theme={theme}>\n      <ServerDataContext.Provider value={serverData}>\n        <I18nProvider>\n          <WebSocketContext.Provider value={websocket}>\n            <QueryManagerProvider queryConfig={queryConfig}>\n              <ClientRouterContext.Provider value={routerContext}>\n                <RouteTransitionProvider\n                  isPending={false}\n                  isFetching={false}\n                  transitionPath={[\"\", pathname]}\n                >\n                  <RouteStateProvider state={routeState}>\n                    <Boundary\n                      errorFallback={errorFallback}\n                      fallback={fallback}\n                      resetKey={pathname}\n                    >\n                      {children}\n                    </Boundary>\n                  </RouteStateProvider>\n                </RouteTransitionProvider>\n              </ClientRouterContext.Provider>\n            </QueryManagerProvider>\n          </WebSocketContext.Provider>\n        </I18nProvider>\n      </ServerDataContext.Provider>\n    </ThemeProvider>\n  );\n};\n\n/**\n * The `Suspense` boundary every view renders inside, and — when the test\n * supplies a fallback for it — the error boundary too.\n *\n * `onReset={clearErrors}` is the part that has to be here rather than inline\n * above: it needs `QueryManagerContext`, and it is what makes a view's real\n * `Error` export testable. A fallback whose \"Try again\" calls\n * `resetErrorBoundary()` re-renders the child, and `useQuery` reads the\n * failure still stored on the `QueryResource` and throws it straight back —\n * so without this the fallback never goes away and the retry path that works\n * in the app cannot be exercised. `ClientRouter`'s own boundary wires exactly\n * this pair.\n */\nconst Boundary = (\n  props: PropsWithChildren<{\n    errorFallback?: ComponentType<FallbackProps>;\n    fallback: ReactNode;\n    resetKey: string;\n  }>,\n) => {\n  const { errorFallback: ErrorFallback, fallback, resetKey, children } = props;\n  const { clearErrors } = useContext(QueryManagerContext);\n  const content = <Suspense fallback={fallback}>{children}</Suspense>;\n\n  if (!ErrorFallback) {\n    return content;\n  }\n\n  return (\n    <ErrorBoundary\n      FallbackComponent={ErrorFallback}\n      resetKeys={[resetKey]}\n      onReset={clearErrors}\n    >\n      {content}\n    </ErrorBoundary>\n  );\n};\n"],"mappings":"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"}

package/dist/utils/Subject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Subject.d.ts","sourceRoot":"","sources":["../../utils/Subject.ts"],"names":[],"mappings":"AAAA,qBAAa,OAAO,CAAC,CAAC;IACpB,WAAW,cAAmB,CAAC,KAAK,IAAI,EAAI;IAC5C,KAAK,EAAE,CAAC,CAAC;gBAEG,YAAY,EAAE,CAAC;IAIpB,SAAS,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI;IAOxC,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,QAAQ;CAGhB"}
+{"version":3,"file":"Subject.d.ts","sourceRoot":"","sources":["../../utils/Subject.ts"],"names":[],"mappings":"AAAA,qBAAa,OAAO,CAAC,CAAC;IACpB,WAAW,cAAmB,CAAC,KAAK,IAAI,EAAI;IAC5C,KAAK,EAAE,CAAC,CAAC;gBAEG,YAAY,EAAE,CAAC;IAoBpB,SAAS,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI;IAOxC,IAAI,CAAC,KAAK,EAAE,CAAC;IAKb,QAAQ;CAGhB"}

package/dist/utils/variantKey.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The key one search-param combination is cached under, inside a query's
+ * resource: the params sorted and serialized, empty when there are none.
+ *
+ * Sorted because `?b=2&a=1` and `?a=1&b=2` are the same request, and a cache
+ * that keyed them separately would fetch twice and hydrate one of them from a
+ * payload the server produced for the other. Nullish values are dropped for
+ * the same reason: an optional filter left `undefined` is absent, not the
+ * string `"undefined"`.
+ *
+ * Every site that reads or writes the cache derives its key from here —
+ * `useQuery` (the read), `useMutate` (the write), and `gemi/testing`'s `<Page>`
+ * (the seed). They used to hold a copy each, which is the kind of duplication
+ * that fails quietly: a seed built by an old copy simply misses, and the test
+ * that should have read it fetches over the network and asserts an empty state
+ * with nothing pointing at the mismatch.
+ */
+export declare function toVariantKey(search: string | Record<string, unknown> | null | undefined): string;
+//# sourceMappingURL=variantKey.d.ts.map

package/dist/utils/variantKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variantKey.d.ts","sourceRoot":"","sources":["../../utils/variantKey.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAC1D,MAAM,CAQR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemi",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "private": false,
   "license": "MIT",
   "author": "Enes Tufekci <enes@gemijs.dev>",
@@ -20,6 +20,7 @@
   "exports": {
     "./http": "./dist/http/index.js",
     "./client": "./dist/client/index.js",
+    "./testing": "./dist/testing/index.js",
     "./app": "./dist/app/index.js",
     "./facades": "./dist/facades/index.js",
     "./email": "./dist/email/index.js",

package/dist/chunk-0tbwn6er.js

@@ -1,5 +0,0 @@
-// @bun
-import{Ae as O}from"./chunk-4t6a82fh.js";import{Re as M}from"./chunk-0h3jr9d9.js";var x={};M(x,{registeredNames:()=>S,register:()=>R,has:()=>_,get:()=>C,clearRegistry:()=>b});var D=new Map;function R(j,B){D.set(j,B)}function _(j){return D.has(j)}function C(j){let B=D.get(j);if(B===void 0)throw new O(j,[...D.keys()]);return B}function S(){return[...D.keys()]}function b(){D.clear()}import{AsyncLocalStorage as H}from"async_hooks";class K{content={title:"Gemi App",description:null,openGraph:null};touched=!1;render(){return{title:this.content.title,description:this.content.description,openGraph:this.content.openGraph}}title(j){this.touched=!0,this.content.title=j}description(j){this.touched=!0,this.content.description=j}openGraph({title:j,description:B,type:z,url:J,image:F,imageAlt:Q,imageWidth:V,imageHeight:X,twitterImage:Y=F,twitterImageAlt:N=Q,twitterImageWidth:P=V,twitterImageHeight:U=X}){this.touched=!0;let Z=F,$=Y;if(F&&!F.startsWith("http"))Z=`${process.env.HOST_NAME}${F}`,$=`${process.env.HOST_NAME}${Y}`;this.content.openGraph=Object.fromEntries(Object.entries({title:j,description:B,type:z,url:J,image:Z,imageAlt:Q,imageWidth:V,imageHeight:X,twitterImage:$,twitterImageAlt:N,twitterImageWidth:P,twitterImageHeight:U}).filter(([A,T])=>T!==void 0))}}function E(j,B,z={}){return[`${j}=${B}`,z.maxAge?`Max-Age=${z.maxAge}`:"",z.httpOnly?"HttpOnly":"",z.secure?"Secure":"",z.sameSite?`SameSite=${z.sameSite}`:"SameSite=Strict",z.path?`Path=${z.path}`:"Path=/",z.domain?`Domain=${z.domain}`:"",z.expires?`Expires=${z.expires.toUTCString()}`:"",z.partitioned?"Partitioned":""].filter((J)=>J!=="").join("; ")}var G=new H;class L{req;cookies=new Set;headers=new Headers;serverQueries=null;user=null;csrfHmac=null;locale=null;metadata=new K;rangeRequest=null;constructor(j){this.req=j}setLocale(j){this.locale=j}renderMeta(){return this.metadata.render()}setCSRFHmac(j){this.csrfHmac=j}setCookie(j,B,z={}){this.cookies.add(E(j,B,z))}deleteCookie(j){this.cookies.add(E(j,"",{maxAge:-1}))}setHeaders(j,B){this.headers.set(j,B)}setUser(j){this.user=j}setRequest(j){this.req=j}destroy(){delete this.cookies,delete this.headers,this.serverQueries=null,delete this.user}}class W{static getStore(){return G.getStore()}static setRequest(j){G.getStore().req=j}static run(j,B){return G.run(new L(j),B)}static runWith(j,B){return G.run(j,B)}}
-export{W as ae,R as be,_ as ce,C as de,S as ee,x as fe};
-
-//# debugId=7F460FF2666379D464756E2164756E21