@quark-fw/plugin-react 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quark-fw/plugin-react",
-	"version": "0.1.23",
+	"version": "0.1.25",
 	"main": "src/index.ts",
 	"types": "src/index.ts",
 	"type": "module",
@@ -22,9 +22,9 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@quark-fw/atom": "0.1.23",
-		"@quark-fw/plugin": "0.1.23",
-		"@trpc/client": "^11.0.0",
+		"@quark-fw/atom": "0.1.25",
+		"@quark-fw/plugin": "0.1.25",
+		"@trpc/client": "~11.18.0",
 		"@types/react-dom": "^19.2.3",
 		"express": "^5.2.1",
 		"vite-css-modules": "^1.13.0",
@@ -36,8 +36,8 @@
 		"@mantine/dates": "^9.0.0",
 		"@mantine/modals": "^9.0.0",
 		"@mantine/notifications": "^9.0.0",
-		"@quark-fw/core": "0.1.23",
-		"@quark-fw/store": "0.1.23",
+		"@quark-fw/core": "0.1.25",
+		"@quark-fw/store": "0.1.25",
 		"@vitejs/plugin-react": "^5.1.0",
 		"react": "^19.2.4",
 		"react-dom": "^19.2.4",
@@ -45,6 +45,7 @@
 		"vite": "^7.1.0"
 	},
 	"devDependencies": {
+		"@trpc/server": "~11.18.0",
 		"@types/express": "^5.0.6",
 		"@types/react": "^19.2.14",
 		"vitest": "^5.0.0"

package/src/frontend/HTML/index.tsx

@@ -15,7 +15,7 @@ export type HTMLProps = {
 	colorScheme: "dark" | "light" | undefined;
 	manifest: Manifest;
 	pathname?: string;
-	/** путь БЕЗ префикса локали — по нему клиентский SeoProvider ищет мету */
+	/** путь БЕЗ префикса локали + search — ключ, по которому SeoProvider ищет мету */
 	seoPathname?: string;
 	seo?: ResolvedSeo;
 	/** иконка вкладки; приложение задаёт её атомом quark.react.favicon */
@@ -40,8 +40,16 @@ function HTML({
 	linkBase,
 }: HTMLProps) {
 	const path = removeSearchParamsFromUrl(pathname!);
-	// без origin остаётся относительный URL — как было до появления поля
-	const canonical = origin ? origin + path : path;
+	// canonical из меты: относительный (от basename) дополняется linkBase,
+	// абсолютный берётся как есть; без меты — путь без query. Без origin
+	// остаётся относительный URL — как было до появления поля
+	const canonical = seo?.canonical
+		? seo.canonical.startsWith("/")
+			? (linkBase ?? "") + seo.canonical
+			: seo.canonical
+		: origin
+			? origin + path
+			: path;
 	// относительная картинка og:image без origin бесполезна для соцсетей
 	const abs = (url?: string) =>
 		url && url.startsWith("/") && origin ? origin + url : url;

package/src/frontend/entry-server.tsx

@@ -65,6 +65,8 @@ export class Renderer {
 	locale?: string;
 	basename?: string;
 	strippedPathname?: string;
+	/** нормализованный search запроса ("" или "?a=1") — часть ключа SEO-карты */
+	search: string;
 
 	constructor({
 		url,
@@ -72,18 +74,21 @@ export class Renderer {
 		locale,
 		basename,
 		strippedPathname,
+		search = "",
 	}: {
 		url: string;
 		manifest: Manifest;
 		locale?: string;
 		basename?: string;
 		strippedPathname?: string;
+		search?: string;
 	}) {
 		this.url = url;
 		this.manifest = manifest;
 		this.locale = locale;
 		this.basename = basename;
 		this.strippedPathname = strippedPathname;
+		this.search = search;
 	}
 
 	head({
@@ -97,7 +102,11 @@ export class Renderer {
 		return ReactDOMServer.renderToString(
 			<HTML
 				pathname={req.originalUrl}
-				seoPathname={this.strippedPathname}
+				seoPathname={
+					this.strippedPathname === undefined
+						? undefined
+						: this.strippedPathname + this.search
+				}
 				colorScheme={colorScheme}
 				manifest={this.manifest}
 				seo={seo}

package/src/seo/SeoProvider.tsx

@@ -5,6 +5,7 @@ import { matchPath } from "react-router-dom";
 import { getMatchedRoute } from "../Router/getMatchedRoute.js";
 import type { PageMeta } from "./createPageMeta.js";
 import SeoContext, { type SeoContextValue, type SeoMap } from "./SeoContext.js";
+import { parseSearch, seoKey } from "../utils/parseSearch.js";
 
 export function SeoProvider({
 	children,
@@ -17,11 +18,13 @@ export function SeoProvider({
 	locale?: string;
 }) {
 	const [seoObject, setSeoObject] = useState<SeoMap>(initial ?? {});
-	const { pathname } = useLocation();
+	const { pathname, search } = useLocation();
 	const navigate = useNavigate();
 	const store = useStore();
 
-	const current = seoObject[pathname];
+	// ключ с search: ?page=2 — другая мета (title, canonical), чем страница 1
+	const key = seoKey(pathname, search);
+	const current = seoObject[key];
 
 	// редирект из меты при клиентской навигации (на SSR его сделала мидлвара)
 	useEffect(() => {
@@ -56,9 +59,10 @@ export function SeoProvider({
 					typeof window === "undefined"
 						? undefined
 						: window.location.origin,
+				query: parseSearch(search).query,
 			});
 			if (!cancelled) {
-				setSeoObject((prev) => ({ ...prev, [pathname]: resolved }));
+				setSeoObject((prev) => ({ ...prev, [key]: resolved }));
 			}
 		})();
 		return () => {
@@ -68,7 +72,7 @@ export function SeoProvider({
 		// добавление в зависимости ничего бы не изменило; locale меняется
 		// только полной перезагрузкой (setLocale)
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [pathname, current]);
+	}, [key, current]);
 
 	// заголовок вкладки при клиентской навигации
 	useEffect(() => {

package/src/seo/createPageMeta.test.ts

@@ -23,6 +23,24 @@ test("resolveMeta передаёт locale и origin в функции меты
 	expect(seo.og?.locale).toBe("ru_RU");
 });
 
+test("resolveMeta передаёт query и резолвит canonical", async () => {
+	const seo = await resolveMeta(
+		{
+			canonical: ({ query }) =>
+				Number(query?.["page"]) > 1
+					? `/tbilisi?page=${query!["page"]}`
+					: undefined,
+		},
+		{ store: {} as never, params: {}, query: { page: "2" } },
+	);
+	expect(seo.canonical).toBe("/tbilisi?page=2");
+	const first = await resolveMeta(
+		{ canonical: ({ query }) => (query?.["page"] ? "/x" : undefined) },
+		{ store: {} as never, params: {} },
+	);
+	expect(first.canonical).toBeUndefined();
+});
+
 test("breadcrumbsJsonLd строит BreadcrumbList с абсолютными @id", () => {
 	const node = breadcrumbsJsonLd(
 		[

package/src/seo/createPageMeta.ts

@@ -14,6 +14,11 @@ export type PageMetaContext = {
 	 * на клиенте — из window.location.
 	 */
 	origin?: string;
+	/**
+	 * Query-параметры URL (первое значение каждого). Для страниц, чья мета
+	 * зависит от запроса — например пагинация каталога (?page=N).
+	 */
+	query?: Record<string, string>;
 };
 
 export type MetaValue<T> = T | ((ctx: PageMetaContext) => T | Promise<T>);
@@ -58,6 +63,12 @@ export type PageMeta = {
 	 * смена slug), чтобы не отдавать 404 по проиндексированным адресам.
 	 */
 	redirect?: MetaValue<PageMetaRedirect | undefined>;
+	/**
+	 * Canonical страницы: путь относительно basename (может содержать query,
+	 * например `/tbilisi?page=2`) или абсолютный URL. По умолчанию — путь
+	 * страницы без query. hreflang-кластер и og:url следуют за canonical.
+	 */
+	canonical?: MetaValue<string | undefined>;
 };
 
 export type ResolvedSeo = {
@@ -69,6 +80,7 @@ export type ResolvedSeo = {
 	breadcrumbs?: PageMetaBreadcrumb[];
 	status?: number;
 	redirect?: PageMetaRedirect;
+	canonical?: string;
 };
 
 export function createPageMeta(meta: PageMeta): PageMeta {
@@ -101,6 +113,7 @@ export async function resolveMeta(
 		breadcrumbs,
 		status,
 		redirect,
+		canonical,
 	] = await Promise.all([
 		resolveValue(meta.title, ctx),
 		resolveValue(meta.description, ctx),
@@ -110,6 +123,7 @@ export async function resolveMeta(
 		resolveValue(meta.breadcrumbs, ctx),
 		resolveValue(meta.status, ctx),
 		resolveValue(meta.redirect, ctx),
+		resolveValue(meta.canonical, ctx),
 	]);
 	return {
 		title,
@@ -120,6 +134,7 @@ export async function resolveMeta(
 		breadcrumbs,
 		status,
 		redirect,
+		canonical,
 	};
 }
 

package/src/ssr/createRequestTrpcClient.test.ts

@@ -0,0 +1,167 @@
+import { afterAll, beforeAll, expect, test } from "vitest";
+import express from "express";
+import http, { type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import type { Request, Response } from "express";
+import { initTRPC, TRPCError } from "@trpc/server";
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+import { isTRPCClientError } from "@trpc/client";
+import { createRequestTrpcClient } from "./createRequestTrpcClient.js";
+
+type Ctx = { req: Request; res: Response; user?: { id: string } };
+const t = initTRPC.context<Ctx>().create();
+
+// счётчик HTTP-вызовов: в local-режиме сервер не должен получать запросов
+let httpHits = 0;
+
+const appRouter = t.router({
+	entity: t.router({
+		task: t.router({
+			list: t.procedure
+				.input((v: unknown) => v as { limit: number })
+				.mutation(({ input, ctx }) => ({
+					limit: input.limit,
+					cookie: ctx.req.headers.cookie ?? null,
+					user: ctx.user?.id ?? null,
+				})),
+		}),
+	}),
+	secret: t.procedure.query(() => {
+		throw new TRPCError({ code: "UNAUTHORIZED", message: "login first" });
+	}),
+	now: t.procedure.query(() => new Date("2026-10-07T00:00:00.000Z")),
+});
+
+const createContext = ({ req, res }: { req: Request; res: Response }): Ctx => ({
+	req,
+	res,
+	user: (req as { user?: { id: string } }).user,
+});
+
+let server: Server;
+let port: number;
+
+beforeAll(async () => {
+	const app = express();
+	app.use((_req, _res, next) => {
+		httpHits++;
+		next();
+	});
+	app.use(
+		"/api/trpc",
+		createExpressMiddleware({ router: appRouter, createContext }),
+	);
+	server = http.createServer(app);
+	await new Promise<void>((resolve) => server.listen(0, resolve));
+	port = (server.address() as AddressInfo).port;
+});
+
+afterAll(async () => {
+	await new Promise<void>((resolve) => server.close(() => resolve()));
+});
+
+// SSR-запрос: cookie браузера и user, положенный passport'ом
+const fakeReq = () =>
+	({
+		headers: { cookie: "quark.sid=abc" },
+		user: { id: "u1" },
+	}) as unknown as Request;
+const fakeRes = () => ({}) as unknown as Response;
+
+test("local: вложенная mutation вызывается без HTTP, с контекстом запроса", async () => {
+	const before = httpHits;
+	const client = createRequestTrpcClient({
+		req: fakeReq(),
+		res: fakeRes(),
+		port,
+		router: appRouter,
+		createContext,
+	});
+	const result = await (
+		client as unknown as {
+			entity: {
+				task: {
+					list: {
+						mutate: (i: { limit: number }) => Promise<unknown>;
+					};
+				};
+			};
+		}
+	).entity.task.list.mutate({ limit: 5 });
+	expect(result).toEqual({ limit: 5, cookie: "quark.sid=abc", user: "u1" });
+	expect(httpHits).toBe(before);
+});
+
+test("local: TRPCError доходит как TRPCClientError с кодом, как по HTTP", async () => {
+	const client = createRequestTrpcClient({
+		req: fakeReq(),
+		res: fakeRes(),
+		port,
+		router: appRouter,
+		createContext,
+	});
+	const call = (
+		client as unknown as { secret: { query: () => Promise<unknown> } }
+	).secret.query();
+	await expect(call).rejects.toSatisfy((e: unknown) => {
+		return (
+			isTRPCClientError(e) &&
+			e.data?.code === "UNAUTHORIZED" &&
+			e.message === "login first"
+		);
+	});
+});
+
+test("local: Date приходит строкой — та же форма, что после JSON по HTTP", async () => {
+	const client = createRequestTrpcClient({
+		req: fakeReq(),
+		res: fakeRes(),
+		port,
+		router: appRouter,
+		createContext,
+	});
+	const now = await (
+		client as unknown as { now: { query: () => Promise<unknown> } }
+	).now.query();
+	expect(now).toBe("2026-10-07T00:00:00.000Z");
+});
+
+test("http: без роутера идём на loopback и пробрасываем cookie", async () => {
+	const before = httpHits;
+	const client = createRequestTrpcClient({
+		req: fakeReq(),
+		res: fakeRes(),
+		port,
+	});
+	const result = await (
+		client as unknown as {
+			entity: {
+				task: {
+					list: {
+						mutate: (i: { limit: number }) => Promise<unknown>;
+					};
+				};
+			};
+		}
+	).entity.task.list.mutate({ limit: 1 });
+	// user по HTTP не передаётся: его на той стороне восстановит сессия
+	expect(result).toEqual({ limit: 1, cookie: "quark.sid=abc", user: null });
+	expect(httpHits).toBe(before + 1);
+});
+
+test("http: явный url главнее локального роутера (API в другом процессе)", async () => {
+	const before = httpHits;
+	const client = createRequestTrpcClient({
+		req: fakeReq(),
+		res: fakeRes(),
+		port: 1, // заведомо мёртвый loopback-порт: должен использоваться url
+		router: appRouter,
+		createContext,
+		url: `http://127.0.0.1:${port}/api/trpc`,
+	});
+	const now = await (
+		client as unknown as { now: { query: () => Promise<unknown> } }
+	).now.query();
+	expect(now).toBe("2026-10-07T00:00:00.000Z");
+	expect(httpHits).toBe(before + 1);
+});

package/src/ssr/createRequestTrpcClient.ts

@@ -1,20 +1,75 @@
-import { createTRPCClient, httpLink } from "@trpc/client";
+import { createTRPCClient, httpLink, unstable_localLink } from "@trpc/client";
+import type { Request, Response } from "express";
 import { jsonSafeFetch, type TRPCClient } from "@quark-fw/store";
 
+// Тип роутера берём из сигнатуры link'а: plugin-react не зависит от
+// @trpc/server и не должен тянуть его ради одного типа
+type LocalLinkOptions = Parameters<typeof unstable_localLink>[0];
+export type SsrRouter = LocalLinkOptions["router"];
+
+export type CreateRequestTrpcClientArgs = {
+	req: Request;
+	res: Response;
+	/** порт собственного HTTP-сервера — для loopback, когда роутера нет */
+	port: number;
+	/** роутер приложения, если он живёт в этом же процессе (quark.trpc.router) */
+	router?: SsrRouter;
+	/** контекст процедуры из запроса — тот же, что у /api/trpc */
+	createContext?: (args: { req: Request; res: Response }) => unknown;
+	/**
+	 * Явный адрес API (SSR_TRPC_URL): tRPC-сервер в другом процессе или на
+	 * другой машине. Главнее локального роутера.
+	 */
+	url?: string;
+};
+
 /**
- * tRPC-клиент КОНКРЕТНОГО запроса: SSR ходит к собственному серверу по
- * HTTP и пробрасывает cookie, чтобы страница рендерилась от имени
- * залогиненного пользователя. Клиент собирается здесь, а роутер объявляет
+ * tRPC-клиент КОНКРЕТНОГО SSR-запроса. Три транспорта, по убыванию приоритета:
+ *
+ * 1. `url` — HTTP к внешнему API (другой процесс/машина), cookie пробрасывается.
+ * 2. `router` — вызов процедур in-process: без HTTP, сессии и passport на
+ *    каждое чтение store; контекст собирается из этого же req/res, так что
+ *    процедуры видят того же пользователя, что и по HTTP. Результат проходит
+ *    JSON-раундтрип внутри link'а — Date приходит строкой, как по сети.
+ * 3. loopback — HTTP к собственному серверу (поведение до появления router).
+ *
+ * Ограничение in-process пути: ctx.res — это стримящийся SSR-ответ, и
+ * процедура, которая ставит заголовки, после записи shell получит
+ * ERR_HTTP_HEADERS_SENT. Клиент собирается здесь, а роутер объявляет
  * приложение — тот же шов аугментации, что и в сторе.
  */
-export function createRequestTrpcClient(
-	port: number,
-	cookie: string | undefined,
-): TRPCClient {
+export function createRequestTrpcClient({
+	req,
+	res,
+	port,
+	router,
+	createContext,
+	url,
+}: CreateRequestTrpcClientArgs): TRPCClient {
+	const cookie = req.headers.cookie;
+
+	if (!url && router && createContext) {
+		return createTRPCClient({
+			links: [
+				unstable_localLink({
+					router,
+					createContext: async () => createContext({ req, res }),
+					// как express-адаптер: наружу уходит форма ошибки, в лог —
+					// только то, что по HTTP было бы 500
+					onError: ({ error, path }) => {
+						if (error.code === "INTERNAL_SERVER_ERROR") {
+							console.error(`[react] ssr tRPC ${path}:`, error);
+						}
+					},
+				}),
+			],
+		}) as TRPCClient;
+	}
+
 	return createTRPCClient({
 		links: [
 			httpLink({
-				url: `http://127.0.0.1:${port}/api/trpc`,
+				url: url ?? `http://127.0.0.1:${port}/api/trpc`,
 				headers: cookie ? { cookie } : {},
 				fetch: jsonSafeFetch,
 			}),

package/src/ssr/getRenderMiddleware.ts

@@ -3,6 +3,7 @@ import { Request, Response } from "express";
 import { matchPath } from "react-router-dom";
 import { UglyModule } from "../Router/UglyModule.js";
 import removeSearchParamsFromUrl from "../utils/removeSearchParamsFromUrl.js";
+import { parseSearch } from "../utils/parseSearch.js";
 import { resolveMeta, type PageMeta } from "../seo/createPageMeta.js";
 import {
 	buildLocalePath,
@@ -14,6 +15,7 @@ import {
 import {
 	getReactAtoms,
 	getRequestOrigin,
+	getTrpcPlugin,
 	parseCookies,
 	serverErrorBody,
 } from "./helpers.js";
@@ -62,12 +64,16 @@ export default function getRenderMiddleware({ vite }: GetRenderMiddlewareArgs) {
 				return;
 			}
 
+			// query нужен мете (пагинация) и ключу SEO-карты: одна и та же
+			// страница с разными ?page — разные title/canonical
+			const { search, query } = parseSearch(req.originalUrl);
 			const renderer = new rendererModule.Renderer({
 				url: req.originalUrl,
 				manifest,
 				locale,
 				basename,
 				strippedPathname,
+				search,
 			});
 
 			const page = rendererModule.hasUglyPage(strippedPathname) as
@@ -76,10 +82,17 @@ export default function getRenderMiddleware({ vite }: GetRenderMiddlewareArgs) {
 			const registerModule = createPreloadTagWriter(manifest, res);
 
 			const reactAtoms = getReactAtoms();
-			const trpcClient = createRequestTrpcClient(
-				reactAtoms?.port?.value ?? 3000,
-				req.headers.cookie,
-			);
+			// роутер читается на каждый запрос: приложение отдаёт его в
+			// setRouter после quark.ready(), конкурентно со стартом сервера
+			const trpc = getTrpcPlugin();
+			const trpcClient = createRequestTrpcClient({
+				req,
+				res,
+				port: reactAtoms?.port?.value ?? 3000,
+				router: trpc?.router,
+				createContext: trpc?.createContext,
+				url: process.env.SSR_TRPC_URL,
+			});
 			const { store, releaseCacheWrites } = createStreamingStore(
 				trpcClient,
 				res,
@@ -108,6 +121,7 @@ export default function getRenderMiddleware({ vite }: GetRenderMiddlewareArgs) {
 				params: (routeProps?.params ?? {}) as Record<string, string>,
 				locale: locale || undefined,
 				origin,
+				query,
 			});
 
 			// редирект из меты: страница переехала или схлопнута — отвечаем
@@ -122,13 +136,21 @@ export default function getRenderMiddleware({ vite }: GetRenderMiddlewareArgs) {
 
 			res.status(seo.status ?? (page ? 200 : 404));
 
-			// hreflang-кластер: каждая локаль + x-default на дефолтную
+			// hreflang-кластер: каждая локаль + x-default на дефолтную.
+			// Относительный canonical (например /tbilisi?page=2) задаёт путь
+			// кластера — иначе страница 2 ссылалась бы на страницу 1 других
+			// локалей и кластер переставал быть взаимным
+			const alternatePath =
+				seo.canonical && seo.canonical.startsWith("/")
+					? seo.canonical
+					: pathname;
 			const alternates =
 				i18nConfig && usesLocalePrefix(i18nConfig)
 					? [
 							...i18nConfig.locales.map((l) => ({
 								hreflang: l,
-								href: origin + buildLocalePath(l, pathname),
+								href:
+									origin + buildLocalePath(l, alternatePath),
 							})),
 							{
 								hreflang: "x-default",
@@ -136,7 +158,7 @@ export default function getRenderMiddleware({ vite }: GetRenderMiddlewareArgs) {
 									origin +
 									buildLocalePath(
 										i18nConfig.defaultLocale,
-										pathname,
+										alternatePath,
 									),
 							},
 						]
@@ -148,7 +170,8 @@ export default function getRenderMiddleware({ vite }: GetRenderMiddlewareArgs) {
 				store,
 				trpcClient,
 				seo,
-				seoObject: { [pathname]: seo },
+				// ключ — путь + search, как его увидит SeoProvider через useLocation()
+				seoObject: { [pathname + search]: seo },
 				favicon: reactAtoms?.favicon?.value,
 				origin,
 				alternates,

package/src/ssr/helpers.ts

@@ -1,5 +1,6 @@
 // Хелперы SSR-мидлвары.
-import type { Request } from "express";
+import type { Request, Response } from "express";
+import type { SsrRouter } from "./createRequestTrpcClient.js";
 
 export const isProd = process.env.NODE_ENV === "production";
 
@@ -49,6 +50,19 @@ export type ReactAtoms = {
 export const getReactAtoms = (): ReactAtoms | undefined =>
 	(globalThis as { quark?: { react?: ReactAtoms } }).quark?.react;
 
+/**
+ * Поверхность plugin-trpc для in-process вызовов из SSR. Читается
+ * структурно: plugin-react не зависит от plugin-trpc и работает без него
+ * (тогда SSR ходит по HTTP).
+ */
+export type TrpcPlugin = {
+	router?: SsrRouter;
+	createContext?: (args: { req: Request; res: Response }) => unknown;
+};
+
+export const getTrpcPlugin = (): TrpcPlugin | undefined =>
+	(globalThis as { quark?: { trpc?: TrpcPlugin } }).quark?.trpc;
+
 /**
  * Абсолютный origin запроса для canonical/hreflang/JSON-LD.
  *

package/src/utils/parseSearch.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "vitest";
+import { parseSearch, seoKey } from "./parseSearch.js";
+
+test("parseSearch: первое значение параметра, нормализованный search", () => {
+	expect(parseSearch("/ru/tbilisi?page=2&rooms=3&rooms=4#top")).toEqual({
+		search: "?page=2&rooms=3&rooms=4",
+		query: { page: "2", rooms: "3" },
+	});
+});
+
+test("parseSearch: пустой и одиночный ? дают пустой search", () => {
+	expect(parseSearch("/ru/tbilisi")).toEqual({ search: "", query: {} });
+	expect(parseSearch("?")).toEqual({ search: "", query: {} });
+});
+
+test("seoKey совпадает для SSR-URL и useLocation()", () => {
+	expect(seoKey("/tbilisi", "?page=2")).toBe("/tbilisi?page=2");
+	expect(seoKey("/tbilisi", "")).toBe("/tbilisi");
+	expect(seoKey("/tbilisi", "?")).toBe("/tbilisi");
+});

package/src/utils/parseSearch.ts

@@ -0,0 +1,27 @@
+// Разбор query-строки URL для меты и ключа SEO-карты. Без Node-зависимостей:
+// модуль нужен и SSR-мидлваре, и SeoProvider в браузере.
+
+export type ParsedSearch = {
+	/** нормализованный search: "?a=1" или "" (одиночный "?" — тоже "") */
+	search: string;
+	/** первое значение каждого параметра */
+	query: Record<string, string>;
+};
+
+export function parseSearch(urlOrSearch: string): ParsedSearch {
+	const index = urlOrSearch.indexOf("?");
+	const raw = index === -1 ? "" : urlOrSearch.slice(index + 1);
+	// hash в URL не относится к запросу
+	const withoutHash = raw.split("#")[0] ?? "";
+	const params = new URLSearchParams(withoutHash);
+	const query: Record<string, string> = {};
+	for (const [key, value] of params) {
+		if (!(key in query)) query[key] = value;
+	}
+	const search = params.toString();
+	return { search: search ? `?${search}` : "", query };
+}
+
+/** Ключ SEO-карты: путь без basename + нормализованный search. */
+export const seoKey = (pathname: string, search: string) =>
+	pathname + parseSearch(search).search;