@quark-fw/store 0.0.1

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export type ErrorHandler = (error: unknown, context?: string) => void;
+export declare function setErrorHandler(next: ErrorHandler): void;
+export declare function reportError(error: unknown, context?: string): void;
+/** Достаёт человекочитаемое сообщение из ошибки tRPC/Error/строки. */
+export declare function errorMessage(error: unknown): string;

package/dist/errors.js

@@ -0,0 +1,18 @@
+let handler = (error, context) => {
+    console.error(context ? `[${context}]` : "[quark]", error);
+};
+export function setErrorHandler(next) {
+    handler = next;
+}
+export function reportError(error, context) {
+    handler(error, context);
+}
+/** Достаёт человекочитаемое сообщение из ошибки tRPC/Error/строки. */
+export function errorMessage(error) {
+    if (typeof error === "string")
+        return error;
+    if (error && typeof error === "object" && "message" in error) {
+        return String(error.message);
+    }
+    return "Неизвестная ошибка";
+}

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+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 };
+export default Store;

package/dist/index.js

@@ -0,0 +1,173 @@
+// Порт @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 };
+export default Store;

package/dist/serialize.d.ts

@@ -0,0 +1,27 @@
+export type FilterKeys<TObj extends object, TFilter> = {
+    [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
+}[keyof TObj];
+export type Simplify<TType> = TType extends unknown[] | Date ? TType : {
+    [K in keyof TType]: TType[K];
+};
+type JsonPrimitive = boolean | number | string | null;
+type FilterDefinedKeys<TObj extends object> = Exclude<{
+    [TKey in keyof TObj]: undefined extends TObj[TKey] ? never : TKey;
+}[keyof TObj], undefined>;
+type UndefinedToOptional<T extends object> = Pick<T, FilterDefinedKeys<T>> & {
+    [k in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[k], undefined>;
+};
+type AnyFunction = (...args: never[]) => unknown;
+type NonJsonPrimitive = AnyFunction | symbol | undefined;
+type IsAny<T> = 0 extends T & 1 ? true : false;
+type JsonReturnable = JsonPrimitive | undefined;
+type SerializeTuple<T extends [unknown, ...unknown[]]> = {
+    [k in keyof T]: T[k] extends NonJsonPrimitive ? null : Serialize<T[k]>;
+};
+export type SerializeObject<T extends object> = {
+    [k in keyof Omit<T, FilterKeys<T, NonJsonPrimitive>>]: Serialize<T[k]>;
+};
+export type Serialize<T> = IsAny<T> extends true ? any : T extends JsonReturnable ? T : T extends Map<unknown, unknown> | Set<unknown> ? object : T extends NonJsonPrimitive ? never : T extends {
+    toJSON(): infer U;
+} ? U : T extends [] ? [] : T extends [unknown, ...unknown[]] ? SerializeTuple<T> : T extends readonly (infer U)[] ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] : T extends object ? Simplify<SerializeObject<UndefinedToOptional<T>>> : never;
+export {};

package/dist/serialize.js

@@ -0,0 +1,3 @@
+// Порт Serialize<T> из @ugliest/core/type: форма значения после
+// JSON-сериализации (функции/symbol/undefined исчезают, учитывается toJSON).
+export {};

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export interface AppRouter {
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/usePromise.d.ts

@@ -0,0 +1 @@
+export declare function usePromise<T>(promise: Promise<T>): () => T;

package/dist/usePromise.js

@@ -0,0 +1,21 @@
+export function usePromise(promise) {
+    let status = "pending";
+    let response;
+    const suspender = promise.then((res) => {
+        status = "success";
+        response = res;
+    }, (err) => {
+        status = "error";
+        response = err;
+    });
+    return () => {
+        switch (status) {
+            case "pending":
+                throw suspender;
+            case "error":
+                throw response;
+            default:
+                return response;
+        }
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@quark-fw/store",
+	"version": "0.0.1",
+	"description": "Isomorphic store and tRPC client hooks for the Quark framework",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json",
+		"./src/*": "./dist/*",
+		"./*": "./dist/*"
+	},
+	"files": ["dist"],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json && node ../../scripts/postbuild.mjs"
+	},
+	"keywords": ["quark"],
+	"author": "",
+	"license": "ISC",
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@trpc/client": "^11.0.0",
+		"@trpc/server": "^11.0.0"
+	},
+	"peerDependencies": {
+		"react": "^19.2.4"
+	},
+	"devDependencies": {
+		"@types/react": "^19.2.14"
+	}
+}