@quark-fw/store 0.1.6 → 0.1.8

package/dist/Store.d.ts

@@ -0,0 +1,20 @@
+import type { CreateTRPCClient } from "@trpc/client";
+import { createTinyRPCClient, type StoreListenersDict, type StorePromisesDict, type StoreReactPromisesDict, type StoreSubscribersDict, type StoreValuesDict } from "./createTinyRPCClient.js";
+import type { AppRouter } from "./types.js";
+export declare class Store<TRouter extends AppRouter = AppRouter, TClient extends CreateTRPCClient<TRouter> = CreateTRPCClient<TRouter>> {
+    values: StoreValuesDict;
+    trpcClient: TClient;
+    tiny: ReturnType<typeof createTinyRPCClient<TRouter, TClient>>;
+    promises: StorePromisesDict;
+    reactPromises: StoreReactPromisesDict;
+    listeners: StoreListenersDict;
+    subscribers: StoreSubscribersDict;
+    callback?: (key: string, data: unknown) => void;
+    constructor({ trpcClient, values, promises, callback, }: {
+        trpcClient: TClient;
+        values?: StoreValuesDict;
+        promises?: StorePromisesDict;
+        callback?: (key: string, data: unknown) => void;
+    });
+    emit(key: string, data: unknown): void;
+}

package/dist/Store.js

@@ -0,0 +1,34 @@
+import { createTinyRPCClient, } from "./createTinyRPCClient.js";
+export class Store {
+    values;
+    trpcClient;
+    tiny;
+    promises;
+    reactPromises;
+    listeners = {};
+    subscribers = {};
+    callback;
+    constructor({ trpcClient, values, promises, callback, }) {
+        this.trpcClient = trpcClient;
+        this.values = values ?? {};
+        this.promises = promises ?? {};
+        this.reactPromises = {};
+        this.callback = callback;
+        this.tiny = createTinyRPCClient({
+            trpcClient,
+            values: this.values,
+            promises: this.promises,
+            reactPromises: this.reactPromises,
+            callback,
+            listeners: this.listeners,
+            subscribers: this.subscribers,
+        });
+    }
+    emit(key, data) {
+        const callbacks = this.listeners[key];
+        // слушатели одноразовые (резолверы подвисших Suspense-чтений):
+        // снимаем ДО вызова, чтобы не потерять переподписку из колбэка
+        delete this.listeners[key];
+        callbacks?.forEach((cb) => cb(data));
+    }
+}

package/dist/context.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "react";
+import { Store } from "./Store.js";
+import type { TRPCClient } from "./trpcClient.js";
+export declare const StoreContext: Context<Store<import("./types.js").AppRouter, import("@trpc/client").CreateTRPCClient<import("./types.js").AppRouter>>>;
+export declare const useStore: () => Store;
+export type TStore = ReturnType<typeof useStore>;
+export declare const TRPCContext: Context<TRPCClient>;
+export declare const useTrpc: () => TRPCClient;

package/dist/context.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from "react";
+export const StoreContext = createContext({});
+export const useStore = () => useContext(StoreContext);
+// аннотации явные: без них d.ts разворачивает тип клиента структурно и
+// спотыкается о непубличный символ tRPC (untypedClientSymbol)
+export const TRPCContext = createContext({});
+export const useTrpc = () => useContext(TRPCContext);

package/dist/createTinyRPCClient.d.ts

@@ -0,0 +1,47 @@
+import { createTRPCClient } from "@trpc/client";
+import type { AnyProcedure, inferProcedureInput, inferProcedureOutput, TRPCRouterRecord } from "@trpc/server";
+import { Dispatch, SetStateAction } from "react";
+import type { Serialize } from "./serialize.js";
+import type { AppRouter } from "./types.js";
+type ProcedureArgs<TProcedure extends AnyProcedure> = [
+    input?: inferProcedureInput<TProcedure>
+];
+type ProcedureOutput<TProcedure extends AnyProcedure> = Serialize<inferProcedureOutput<TProcedure>>;
+export type StoreValuesDict = Record<string, unknown>;
+export type StorePromisesDict = Record<string, Promise<unknown>>;
+export type StoreReactPromisesDict = Record<string, () => unknown>;
+/** подписчики useSyncExternalStore на изменения значения по ключу кэша */
+export type StoreSubscribersDict = Record<string, Set<() => void>>;
+/** подписчики на готовность значения по ключу кэша */
+export type StoreListenersDict = Record<string, ((data: unknown) => void)[]>;
+type DecorateProcedure<TProcedure extends AnyProcedure> = {
+    get(...args: ProcedureArgs<TProcedure>): ProcedureOutput<TProcedure>;
+    mutate(...args: ProcedureArgs<TProcedure>): ProcedureOutput<TProcedure>;
+    mutatePromise(...args: ProcedureArgs<TProcedure>): Promise<ProcedureOutput<TProcedure>>;
+    getPromise(...args: ProcedureArgs<TProcedure>): Promise<ProcedureOutput<TProcedure>>;
+    reFetch(...args: ProcedureArgs<TProcedure>): ProcedureOutput<TProcedure>;
+    clearCache(...args: ProcedureArgs<TProcedure>): void;
+    setCache(...args: ProcedureArgs<TProcedure>): (data: ProcedureOutput<TProcedure>) => void;
+    getState(...args: ProcedureArgs<TProcedure>): [
+        ProcedureOutput<TProcedure>,
+        Dispatch<SetStateAction<ProcedureOutput<TProcedure>>>
+    ];
+};
+type DecorateRouterRecord<TRecord extends TRPCRouterRecord> = {
+    [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends TRPCRouterRecord ? DecorateRouterRecord<$Value> : never : never;
+};
+type DecoratedProcedureSSGRecord<TRouter extends AppRouter> = TRouter extends {
+    _def: {
+        record: infer TRecord extends TRPCRouterRecord;
+    };
+} ? DecorateRouterRecord<TRecord> : {};
+export declare const createTinyRPCClient: <TRouter extends AppRouter, TClient extends ReturnType<typeof createTRPCClient<TRouter>>>({ callback, trpcClient, values, promises, reactPromises, listeners, subscribers, }: {
+    callback?: (key: string, value: unknown) => void;
+    trpcClient: TClient;
+    values: StoreValuesDict;
+    promises: StorePromisesDict;
+    reactPromises: StoreReactPromisesDict;
+    listeners: StoreListenersDict;
+    subscribers: StoreSubscribersDict;
+}) => DecoratedProcedureSSGRecord<TRouter>;
+export {};

package/dist/createTinyRPCClient.js

@@ -0,0 +1,161 @@
+// Порт @ugliest/store под quark: изоморфный tiny-кэш поверх tRPC
+// с потоковой SSR-гидратацией через window.cache.
+import { createFlatProxy } from "@trpc/server/shared";
+// createRecursiveProxy убран из shared в tRPC 11.18 — только unstable core
+import { createRecursiveProxy } from "@trpc/server/unstable-core-do-not-import";
+import { getUntypedClient } from "@trpc/client";
+import { useSyncExternalStore } from "react";
+import { ERROR_STATE, NOT_READY_STATE } from "./sentinels.js";
+import { stableStringify } from "./stableStringify.js";
+import { usePromise } from "./usePromise.js";
+export const createTinyRPCClient = ({ callback, trpcClient, values, promises, reactPromises, listeners, subscribers, }) => {
+    const untypedClient = getUntypedClient(trpcClient);
+    /** будит все компоненты, подписанные на ключ через getState */
+    const notify = (key) => subscribers[key]?.forEach((cb) => cb());
+    return createFlatProxy((key) => createRecursiveProxy(({ path, args, }) => {
+        const pathCopy = [key, ...path];
+        const utilName = pathCopy.pop();
+        const fullPath = pathCopy.join(".");
+        // хвостовые undefined отбрасываются: get() и get(undefined) —
+        // один и тот же вызов и обязаны делить ключ кэша
+        const keyArgs = [...args];
+        while (keyArgs.length &&
+            keyArgs[keyArgs.length - 1] === undefined) {
+            keyArgs.pop();
+        }
+        const fullKey = `${fullPath}:${stableStringify(keyArgs)}`;
+        const getPromise = (type = "query") => {
+            if (!promises[fullKey]) {
+                const promise = untypedClient[type](fullPath, ...args);
+                promises[fullKey] = promise;
+                callback?.(fullKey, NOT_READY_STATE);
+                promise
+                    .then((value) => {
+                    // values — источник снапшотов для подписок
+                    // getState; без этой записи резолв жил бы
+                    // только в замыкании reactPromises
+                    values[fullKey] = value;
+                    notify(fullKey);
+                    callback?.(fullKey, value);
+                })
+                    .catch((e) => {
+                    console.error(e);
+                    // иначе SSR-стрим не закрыл бы ключ и клиент
+                    // висел бы в NOT_READY_STATE навсегда
+                    callback?.(fullKey, ERROR_STATE);
+                });
+            }
+            return promises[fullKey];
+        };
+        /*
+         * usePromise — это хук, и вызывается он отсюда, из прокси, а не
+         * из компонента. Так и задумано: чтение значения происходит в
+         * теле рендера потребителя, поэтому порядок вызовов совпадает с
+         * порядком чтений. Отвечает за это вызывающий: читать значения
+         * нужно безусловно, как обычные хуки.
+         */
+        /* eslint-disable react-hooks/rules-of-hooks */
+        const get = (type = "query") => {
+            if (values[fullKey] === NOT_READY_STATE) {
+                if (!reactPromises[fullKey]) {
+                    reactPromises[fullKey] = usePromise(new Promise((resolve) => {
+                        if (!listeners[fullKey])
+                            listeners[fullKey] = [];
+                        listeners[fullKey].push((data) => {
+                            if (data === ERROR_STATE) {
+                                // серверный запрос упал: забываем
+                                // ключ, ниже клиент перезапросит
+                                delete values[fullKey];
+                                delete promises[fullKey];
+                                delete reactPromises[fullKey];
+                            }
+                            else {
+                                values[fullKey] = data;
+                            }
+                            notify(fullKey);
+                            resolve(data);
+                        });
+                    }));
+                }
+                return reactPromises[fullKey]();
+            }
+            if (values[fullKey] === ERROR_STATE) {
+                // ключ с упавшим серверным запросом (из window.cache):
+                // забываем и перезапрашиваем с клиента
+                delete values[fullKey];
+                delete promises[fullKey];
+                delete reactPromises[fullKey];
+            }
+            // `in`, а не truthiness: null/0/""/false — легитимные
+            // закэшированные ответы, их нельзя перезапрашивать
+            if (fullKey in values)
+                return values[fullKey];
+            if (!reactPromises[fullKey]) {
+                reactPromises[fullKey] = usePromise(getPromise(type));
+            }
+            return reactPromises[fullKey]?.();
+        };
+        /* eslint-enable react-hooks/rules-of-hooks */
+        switch (utilName) {
+            case "get": {
+                return get();
+            }
+            case "mutate": {
+                return get("mutation");
+            }
+            case "getPromise": {
+                return getPromise();
+            }
+            case "mutatePromise": {
+                return getPromise("mutation");
+            }
+            case "clearCache": {
+                // delete по отсутствующему ключу — no-op, проверка
+                // была лишней
+                delete values[fullKey];
+                delete promises[fullKey];
+                delete reactPromises[fullKey];
+                break;
+            }
+            case "reFetch": {
+                delete values[fullKey];
+                delete promises[fullKey];
+                delete reactPromises[fullKey];
+                return get();
+            }
+            case "setCache": {
+                return (value) => {
+                    values[fullKey] = value;
+                    // в каждом словаре лежит то, что он объявляет:
+                    // раньше сюда клали сырое значение, и повторный
+                    // getPromise вернул бы не промис
+                    promises[fullKey] = Promise.resolve(value);
+                    reactPromises[fullKey] = () => value;
+                    notify(fullKey);
+                };
+            }
+            case "getState": {
+                // хук зовётся безусловно на каждый рендер; прежний
+                // useState кэшировал кортеж первого рендера в словаре,
+                // из-за чего значение замораживалось, а сеттер был
+                // привязан к одному-единственному компоненту
+                const initial = get();
+                const getSnapshot = () => fullKey in values ? values[fullKey] : initial;
+                const value = useSyncExternalStore((onChange) => {
+                    (subscribers[fullKey] ??= new Set()).add(onChange);
+                    return () => subscribers[fullKey]?.delete(onChange);
+                }, getSnapshot, getSnapshot);
+                const setValue = (next) => {
+                    const resolved = typeof next === "function"
+                        ? next(values[fullKey])
+                        : next;
+                    values[fullKey] = resolved;
+                    promises[fullKey] = Promise.resolve(resolved);
+                    reactPromises[fullKey] = () => resolved;
+                    notify(fullKey);
+                };
+                return [value, setValue];
+            }
+        }
+    }));
+};

package/dist/index.d.ts

@@ -1,76 +1,7 @@
-import { CreateTRPCClient, createTRPCClient } from "@trpc/client";
-import type { AnyProcedure, inferProcedureInput, inferProcedureOutput, TRPCRouterRecord } from "@trpc/server";
-import { Dispatch, SetStateAction } from "react";
-import type { Serialize } from "./serialize.js";
-import type { AppRouter } from "./types.js";
-type ProcedureArgs<TProcedure extends AnyProcedure> = [
-    input?: inferProcedureInput<TProcedure>
-];
-type ProcedureOutput<TProcedure extends AnyProcedure> = Serialize<inferProcedureOutput<TProcedure>>;
-export type StoreValuesDict = Record<string, unknown>;
-export type StorePromisesDict = Record<string, Promise<unknown>>;
-type StoreReactPromisesDict = Record<string, () => unknown>;
-type StoreStatesDict = Record<string, [
-    unknown,
-    Dispatch<SetStateAction<unknown>>
-]>;
-/** подписчики на готовность значения по ключу кэша */
-type StoreListenersDict = Record<string, ((data: unknown) => void)[]>;
-type DecorateProcedure<TProcedure extends AnyProcedure> = {
-    get(...args: ProcedureArgs<TProcedure>): ProcedureOutput<TProcedure>;
-    mutate(...args: ProcedureArgs<TProcedure>): ProcedureOutput<TProcedure>;
-    mutatePromise(...args: ProcedureArgs<TProcedure>): Promise<ProcedureOutput<TProcedure>>;
-    getPromise(...args: ProcedureArgs<TProcedure>): Promise<ProcedureOutput<TProcedure>>;
-    reFetch(...args: ProcedureArgs<TProcedure>): Serialize<Promise<inferProcedureOutput<TProcedure>>>;
-    clearCache(...args: ProcedureArgs<TProcedure>): void;
-    setCache(...args: ProcedureArgs<TProcedure>): (data: ProcedureOutput<TProcedure>) => void;
-    getState(...args: ProcedureArgs<TProcedure>): [
-        ProcedureOutput<TProcedure>,
-        Dispatch<SetStateAction<ProcedureOutput<TProcedure>>>
-    ];
-};
-type DecorateRouterRecord<TRecord extends TRPCRouterRecord> = {
-    [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends TRPCRouterRecord ? DecorateRouterRecord<$Value> : never : never;
-};
-type DecoratedProcedureSSGRecord<TRouter extends AppRouter> = TRouter extends {
-    _def: {
-        record: infer TRecord extends TRPCRouterRecord;
-    };
-} ? DecorateRouterRecord<TRecord> : {};
-export declare const createTinyRPCClient: <TRouter extends AppRouter, TClient extends ReturnType<typeof createTRPCClient<TRouter>>>({ callback, trpcClient, values, promises, reactPromises, listeners, states, }: {
-    callback?: (key: string, value: unknown) => void;
-    trpcClient: TClient;
-    values: StoreValuesDict;
-    promises: StorePromisesDict;
-    reactPromises: StoreReactPromisesDict;
-    listeners: StoreListenersDict;
-    states: StoreStatesDict;
-}) => DecoratedProcedureSSGRecord<TRouter>;
-declare class Store<TRouter extends AppRouter = AppRouter, TClient extends CreateTRPCClient<TRouter> = CreateTRPCClient<TRouter>> {
-    values: StoreValuesDict;
-    trpcClient: TClient;
-    tiny: ReturnType<typeof createTinyRPCClient<TRouter, TClient>>;
-    promises: StorePromisesDict;
-    reactPromises: StoreReactPromisesDict;
-    listeners: StoreListenersDict;
-    states: StoreStatesDict;
-    callback?: (key: string, data: unknown) => void;
-    constructor({ trpcClient, values, promises, callback, }: {
-        trpcClient: TClient;
-        values?: StoreValuesDict;
-        promises?: StorePromisesDict;
-        callback?: (key: string, data: unknown) => void;
-    });
-    emit(key: string, data: unknown): void;
-}
-declare const StoreContext: import("react").Context<Store<AppRouter, CreateTRPCClient<AppRouter>>>;
-declare const useStore: () => Store;
-export type TStore = ReturnType<typeof useStore>;
-declare const useTrpc: () => AppTRPCClient;
-export declare const jsonSafeFetch: (url: RequestInfo | URL, options?: RequestInit) => Promise<Response>;
-type AppTRPCClient = CreateTRPCClient<AppRouter>;
-declare const trpcClient: AppTRPCClient;
-export type TRPCClient = AppTRPCClient;
-declare const TRPCContext: import("react").Context<AppTRPCClient>;
-export { useStore, StoreContext, useTrpc, TRPCContext, trpcClient };
+import { Store } from "./Store.js";
+export { createTinyRPCClient, type StorePromisesDict, type StoreValuesDict, } from "./createTinyRPCClient.js";
+export { jsonSafeFetch } from "./jsonSafeFetch.js";
+export { ERROR_STATE, NOT_READY_STATE } from "./sentinels.js";
+export { trpcClient, type TRPCClient } from "./trpcClient.js";
+export { StoreContext, TRPCContext, useStore, useTrpc, type TStore, } from "./context.js";
 export default Store;

package/dist/index.js

@@ -1,173 +1,9 @@
-// Порт @ugliest/store под quark: изоморфный tiny-кэш поверх tRPC
-// с потоковой SSR-гидратацией через window.cache.
-import { createFlatProxy } from "@trpc/server/shared";
-// createRecursiveProxy убран из shared в tRPC 11.18 — только unstable core
-import { createRecursiveProxy } from "@trpc/server/unstable-core-do-not-import";
-import { createTRPCClient, getUntypedClient, httpLink, } from "@trpc/client";
-import { createContext, useContext, useState, } from "react";
-import { usePromise } from "./usePromise.js";
-export const createTinyRPCClient = ({ callback, trpcClient, values, promises, reactPromises, listeners, states, }) => {
-    const untypedClient = getUntypedClient(trpcClient);
-    return createFlatProxy((key) => createRecursiveProxy(({ path, args, }) => {
-        const pathCopy = [key, ...path];
-        const utilName = pathCopy.pop();
-        const fullPath = pathCopy.join(".");
-        const fullKey = `${fullPath}:${JSON.stringify(args)}`;
-        const getPromise = (type = "query") => {
-            if (!promises[fullKey]) {
-                const promise = untypedClient[type](fullPath, ...args);
-                promises[fullKey] = promise;
-                callback?.(fullKey, "NOT_READY_STATE");
-                promise
-                    .then((value) => callback?.(fullKey, value))
-                    .catch((e) => {
-                    console.error(e);
-                });
-            }
-            return promises[fullKey];
-        };
-        /*
-         * usePromise — это хук, и вызывается он отсюда, из прокси, а не
-         * из компонента. Так и задумано: чтение значения происходит в
-         * теле рендера потребителя, поэтому порядок вызовов совпадает с
-         * порядком чтений. Отвечает за это вызывающий: читать значения
-         * нужно безусловно, как обычные хуки.
-         */
-        /* eslint-disable react-hooks/rules-of-hooks */
-        const get = (type = "query") => {
-            if (values[fullKey]) {
-                if (values[fullKey] === "NOT_READY_STATE") {
-                    if (!reactPromises[fullKey]) {
-                        reactPromises[fullKey] = usePromise(new Promise((resolve) => {
-                            if (!listeners[fullKey])
-                                listeners[fullKey] = [];
-                            listeners[fullKey].push((data) => {
-                                values[fullKey] = data;
-                                resolve(data);
-                            });
-                        }));
-                    }
-                    return reactPromises[fullKey]();
-                }
-                return values[fullKey];
-            }
-            if (!reactPromises[fullKey]) {
-                reactPromises[fullKey] = usePromise(getPromise(type));
-            }
-            return reactPromises[fullKey]?.();
-        };
-        /* eslint-enable react-hooks/rules-of-hooks */
-        switch (utilName) {
-            case "get": {
-                return get();
-            }
-            case "mutate": {
-                return get("mutation");
-            }
-            case "getPromise": {
-                return getPromise();
-            }
-            case "mutatePromise": {
-                return getPromise("mutation");
-            }
-            case "clearCache": {
-                // delete по отсутствующему ключу — no-op, проверка
-                // была лишней
-                delete values[fullKey];
-                delete promises[fullKey];
-                delete reactPromises[fullKey];
-                break;
-            }
-            case "reFetch": {
-                delete values[fullKey];
-                delete promises[fullKey];
-                delete reactPromises[fullKey];
-                return get();
-            }
-            case "setCache": {
-                return (value) => {
-                    values[fullKey] = value;
-                    // в каждом словаре лежит то, что он объявляет:
-                    // раньше сюда клали сырое значение, и повторный
-                    // getPromise вернул бы не промис
-                    promises[fullKey] = Promise.resolve(value);
-                    reactPromises[fullKey] = () => value;
-                    states[fullKey]?.[1](value);
-                };
-            }
-            case "getState": {
-                if (!states[fullKey]) {
-                    states[fullKey] = useState(get());
-                }
-                return states[fullKey];
-            }
-        }
-    }));
-};
-class Store {
-    values;
-    trpcClient;
-    tiny;
-    promises;
-    reactPromises;
-    listeners = {};
-    states = {};
-    callback;
-    constructor({ trpcClient, values, promises, callback, }) {
-        this.trpcClient = trpcClient;
-        this.values = values ?? {};
-        this.promises = promises ?? {};
-        this.reactPromises = {};
-        this.callback = callback;
-        this.tiny = createTinyRPCClient({
-            trpcClient,
-            values: this.values,
-            promises: this.promises,
-            reactPromises: this.reactPromises,
-            callback,
-            listeners: this.listeners,
-            states: this.states,
-        });
-    }
-    emit(key, data) {
-        this.listeners[key]?.forEach((cb) => cb(data));
-    }
-}
-const StoreContext = createContext({});
-const useStore = () => useContext(StoreContext);
-const useTrpc = () => useContext(TRPCContext);
-// tRPC ждёт JSON; прокси или express могут ответить HTML — превращаем такой
-// ответ в читаемую tRPC-ошибку вместо "Unexpected token '<'"
-export const jsonSafeFetch = async (url, options) => {
-    const res = await fetch(url, options);
-    const contentType = res.headers.get("content-type") || "";
-    if (contentType.includes("application/json"))
-        return res;
-    const text = (await res.text())
-        .replace(/<[^>]*>/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-    return new Response(JSON.stringify({
-        error: {
-            message: `API returned a non-JSON response (HTTP ${res.status}): ${text.slice(0, 300)}`,
-            code: -32603,
-            data: { code: "INTERNAL_SERVER_ERROR", httpStatus: res.status },
-        },
-    }), {
-        status: res.status,
-        headers: { "content-type": "application/json" },
-    });
-};
-// Клиент создаётся до того, как приложение объявит свой роутер, поэтому
-// собирается на нетипизированном и приводится к AppRouter здесь.
-const trpcClient = createTRPCClient({
-    links: [
-        httpLink({
-            url: "/api/trpc",
-            fetch: jsonSafeFetch,
-        }),
-    ],
-});
-const TRPCContext = createContext({});
-export { useStore, StoreContext, useTrpc, TRPCContext, trpcClient };
+// Публичная поверхность пакета: реализация разложена по файлам
+// (1 функция = 1 файл), здесь — только реэкспорт под прежними именами.
+import { Store } from "./Store.js";
+export { createTinyRPCClient, } from "./createTinyRPCClient.js";
+export { jsonSafeFetch } from "./jsonSafeFetch.js";
+export { ERROR_STATE, NOT_READY_STATE } from "./sentinels.js";
+export { trpcClient } from "./trpcClient.js";
+export { StoreContext, TRPCContext, useStore, useTrpc, } from "./context.js";
 export default Store;

package/dist/jsonSafeFetch.d.ts

@@ -0,0 +1 @@
+export declare const jsonSafeFetch: (url: RequestInfo | URL, options?: RequestInit) => Promise<Response>;

package/dist/jsonSafeFetch.js

@@ -0,0 +1,22 @@
+// tRPC ждёт JSON; прокси или express могут ответить HTML — превращаем такой
+// ответ в читаемую tRPC-ошибку вместо "Unexpected token '<'"
+export const jsonSafeFetch = async (url, options) => {
+    const res = await fetch(url, options);
+    const contentType = res.headers.get("content-type") || "";
+    if (contentType.includes("application/json"))
+        return res;
+    const text = (await res.text())
+        .replace(/<[^>]*>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return new Response(JSON.stringify({
+        error: {
+            message: `API returned a non-JSON response (HTTP ${res.status}): ${text.slice(0, 300)}`,
+            code: -32603,
+            data: { code: "INTERNAL_SERVER_ERROR", httpStatus: res.status },
+        },
+    }), {
+        status: res.status,
+        headers: { "content-type": "application/json" },
+    });
+};

package/dist/sentinels.d.ts

@@ -0,0 +1,4 @@
+/** значение ещё не готово — сервер стримит его позже */
+export declare const NOT_READY_STATE = "__quark:not-ready__";
+/** серверный запрос упал — клиент должен перезапросить сам */
+export declare const ERROR_STATE = "__quark:error__";

package/dist/sentinels.js

@@ -0,0 +1,7 @@
+// Сентинелы протокола SSR-гидратации (window.cache). Строки, а не символы:
+// значения переживают JSON-сериализацию в стрим-скриптах. Значения намеренно
+// «непроизносимые», чтобы не совпасть с легитимным ответом процедуры.
+/** значение ещё не готово — сервер стримит его позже */
+export const NOT_READY_STATE = "__quark:not-ready__";
+/** серверный запрос упал — клиент должен перезапросить сам */
+export const ERROR_STATE = "__quark:error__";

package/dist/stableStringify.d.ts

@@ -0,0 +1 @@
+export declare const stableStringify: (value: unknown) => string;

package/dist/stableStringify.js

@@ -0,0 +1,14 @@
+// Стабильная сериализация аргументов для ключа кэша: вызовы, одинаковые по
+// смыслу, обязаны давать один ключ независимо от порядка ключей объекта.
+const sortValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (value && typeof value === "object") {
+        const source = value;
+        return Object.fromEntries(Object.keys(source)
+            .sort()
+            .map((key) => [key, sortValue(source[key])]));
+    }
+    return value;
+};
+export const stableStringify = (value) => JSON.stringify(sortValue(value));

package/dist/trpcClient.d.ts

@@ -0,0 +1,6 @@
+import { CreateTRPCClient } from "@trpc/client";
+import type { AppRouter } from "./types.js";
+type AppTRPCClient = CreateTRPCClient<AppRouter>;
+export type TRPCClient = AppTRPCClient;
+export declare const trpcClient: AppTRPCClient;
+export {};

package/dist/trpcClient.js

@@ -0,0 +1,12 @@
+import { createTRPCClient, httpLink } from "@trpc/client";
+import { jsonSafeFetch } from "./jsonSafeFetch.js";
+// Клиент создаётся до того, как приложение объявит свой роутер, поэтому
+// собирается на нетипизированном и приводится к AppRouter здесь.
+export const trpcClient = createTRPCClient({
+    links: [
+        httpLink({
+            url: "/api/trpc",
+            fetch: jsonSafeFetch,
+        }),
+    ],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quark-fw/store",
-	"version": "0.1.6",
+	"version": "0.1.8",
 	"description": "Isomorphic store and tRPC client hooks for the Quark framework",
 	"type": "module",
 	"main": "dist/index.js",
@@ -18,7 +18,8 @@
 		"dist"
 	],
 	"scripts": {
-		"build": "tsc -p tsconfig.build.json && node ../../scripts/postbuild.mjs"
+		"build": "tsc -p tsconfig.build.json && node ../../scripts/postbuild.mjs",
+		"test": "vitest run"
 	},
 	"keywords": [
 		"quark"
@@ -36,6 +37,10 @@
 		"react": "^19.2.4"
 	},
 	"devDependencies": {
-		"@types/react": "^19.2.14"
+		"@types/react": "^19.2.14",
+		"happy-dom": "^20.14.0",
+		"react": "^19.2.8",
+		"react-dom": "^19.2.8",
+		"vitest": "^5.0.0"
 	}
 }