@luckystack/core 0.10.2 → 0.11.0

package/dist/client.d.ts

@@ -1,335 +1,46 @@
-import { StreamPayload, ApiTypeMap } from './apiTypeStubs.js';
-export { SyncTypeMap } from './apiTypeStubs.js';
-import { H as HttpMethodLiteral } from './pageRouteValidation-B4Cmtfjv.js';
-export { A as ApiMethodMap, D as DEFAULT_PAGE_ROUTE_RULES, L as Logger, a as LoggerContext, N as Notifier, b as NotifyInput, c as NotifyParam, P as PagePathValidationResult, d as PageRouteRules, R as ROUTED_DATA_QUERY_KEY, S as SOCKETSTATUS, e as buildApiResponseEventName, f as buildApiStreamEventName, g as buildGetJoinedRoomsResponseEventName, h as buildJoinRoomResponseEventName, i as buildLeaveRoomResponseEventName, j as buildRoutedGetUrl, k as buildSyncProgressEventName, l as buildSyncResponseEventName, m as clearCsrfToken, n as enqueueApiRequest, o as enqueueSyncRequest, p as flushApiQueue, q as flushSyncQueue, r as getApiQueueSize, s as getCsrfToken, t as getLogger, u as getNotifier, v as getRegisteredApiMethod, w as getSyncQueueSize, x as httpFetch, y as incrementResponseIndex, z as isApiMethodMapRegistered, B as isOnline, C as normalizeErrorResponseCore, E as notify, F as parseServiceRouteName, G as registerApiMethodMap, I as registerLogger, J as registerNotifier, K as removeApiQueueItem, M as removeApiQueueItemsByKey, O as removeSyncQueueItem, Q as setSocket, T as sleep, U as socket, V as socketEventNames, W as statusContent, X as tryCatchSync, Y as validatePagePath, Z as waitForSocket } from './pageRouteValidation-B4Cmtfjv.js';
-import { B as BaseSessionLayout } from './sessionTypes-DanjuPaE.js';
-export { A as AppConfig, a as AuthProps, L as LoggingConfig, P as ProjectConfig, R as RateLimitingConfig, S as SessionConfig, b as SessionLocation, T as TransportConfig, g as getProjectConfig, i as isProjectConfigRegistered, r as registerProjectConfig } from './sessionTypes-DanjuPaE.js';
-import * as react from 'react';
-import { ReactNode, Dispatch, SetStateAction } from 'react';
-import 'socket.io-client';
-
-type ApiStreamEvent<T extends StreamPayload = StreamPayload> = T;
-type DataRequired<T> = Record<string, never> extends T ? false : true;
-type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends ((arg: infer I) => void) ? I : never;
-type ApiRouteRecord = UnionToIntersection<{
-    [P in keyof ApiTypeMap]: {
-        [N in keyof ApiTypeMap[P] as P extends 'root' ? `system/${Extract<N, string>}` : `${Extract<P, string>}/${Extract<N, string>}`]: ApiTypeMap[P][N];
-    };
-}[keyof ApiTypeMap]>;
-type ApiFullName = Extract<keyof ApiRouteRecord, string>;
-type VersionsForFullName<F extends ApiFullName> = keyof ApiRouteRecord[F] & string;
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type InputForFullName<F extends ApiFullName, V extends VersionsForFullName<F>> = ApiRouteRecord[F][V] extends {
-    input: infer I;
-} ? I : never;
-type OutputForFullName<F extends ApiFullName, V extends VersionsForFullName<F>> = ApiRouteRecord[F][V] extends {
-    output: infer O;
-} ? O : never;
-type StreamForFullName<F extends ApiFullName, V extends VersionsForFullName<F>> = ApiRouteRecord[F][V] extends {
-    stream: infer S;
-} ? S : never;
-type ApiStreamCallbackForFullName<F extends ApiFullName, V extends VersionsForFullName<F>> = [
-    StreamForFullName<F, V>
-] extends [never] ? never : (event: ApiStreamEvent<Prettify<StreamForFullName<F, V> extends StreamPayload ? StreamForFullName<F, V> : StreamPayload>>) => void;
-type ApiParamsForFullName<F extends ApiFullName, V extends VersionsForFullName<F>> = DataRequired<InputForFullName<F, V>> extends true ? {
-    name: F;
-    version: V;
-    data: Prettify<InputForFullName<F, V>>;
-    abortable?: boolean;
-    disableErrorMessage?: boolean;
-    onStream?: ApiStreamCallbackForFullName<F, V>;
-    signal?: AbortSignal;
-    timeoutMs?: number | false;
-} : {
-    name: F;
-    version: V;
-    data?: Prettify<InputForFullName<F, V>>;
-    abortable?: boolean;
-    disableErrorMessage?: boolean;
-    onStream?: ApiStreamCallbackForFullName<F, V>;
-    signal?: AbortSignal;
-    timeoutMs?: number | false;
-};
-interface ApiErrorResponse extends Record<string, unknown> {
-    status: 'error';
-    httpStatus: number;
-    message: string;
-    errorCode: string;
-    errorParams?: {
-        key: string;
-        value: string | number | boolean;
-    }[];
-}
-/**
- * Type-safe API request function.
- *
- * @example
- * ```typescript
- * // Full name usage - includes page in the name
- * const result = await apiRequest({ name: 'examples/publicApi', version: 'v1', data: { message: 'hello' } });
- * // result is typed correctly for publicApi
- *
- * // Global APIs use service-first naming
- * await apiRequest({ name: 'system/session', version: 'v1' });
- * ```
- */
-declare function apiRequest<F extends ApiFullName, V extends VersionsForFullName<F>>(params: ApiParamsForFullName<F, V>): Promise<Prettify<OutputForFullName<F, V>> | ApiErrorResponse>;
-
-declare function tryCatch<T, P = void>(func: (values: P) => Promise<T> | T, params?: P, context?: Record<string, unknown>): Promise<[Error | null, T | null]>;
-
-type RoutedInvocationMethod = HttpMethodLiteral;
-interface RoutedInvocationResponse<TResponse> {
-    kind: 'response';
-    response: TResponse;
-    httpStatus: number;
-}
-interface RoutedInvocationFailure {
-    kind: 'aborted' | 'timeout' | 'network-error' | 'invalid-response';
-}
-type RoutedInvocationResult<TResponse> = RoutedInvocationResponse<TResponse> | RoutedInvocationFailure;
-interface RoutedHttpInvocationInput<TStream> {
-    path: string;
-    method: RoutedInvocationMethod;
-    data: Record<string, unknown>;
-    stream?: (payload: TStream) => void;
-    signals?: readonly (AbortSignal | null | undefined)[];
-    timeoutMs?: number | false;
-}
-declare const invokeRoutedHttp: <TResponse, TStream = Record<string, unknown>>({ path, method, data, stream, signals, timeoutMs, }: RoutedHttpInvocationInput<TStream>) => Promise<RoutedInvocationResult<TResponse>>;
-
-type LocalesMap = Record<string, unknown>;
-type LanguageSource = () => string | null | undefined;
-declare const registerLocales: (locales: LocalesMap) => void;
-declare const getRegisteredLocales: () => LocalesMap;
-declare const getDefaultLocale: () => string;
-declare const registerLanguageSource: (fn: LanguageSource) => void;
-declare const getActiveLanguage: () => string;
-declare const getLocaleByCode: (code: string) => unknown;
-
-interface MiddlewareInput {
-    location: string;
-    searchParams: Record<string, string>;
-    session: BaseSessionLayout | null;
-}
-type MiddlewareResult = {
-    success: true;
-    redirect?: undefined;
-    status?: undefined;
-} | {
-    success: false;
-    redirect: string;
-    status?: undefined;
-} | {
-    success: false;
-    redirect?: undefined;
-    status: number;
-} | undefined;
-/** Normalized decision derived from a {@link MiddlewareResult}. */
-type MiddlewareOutcome = {
-    kind: 'allow';
-} | {
-    kind: 'redirect';
-    to: string;
-} | {
-    kind: 'deny';
-    status: number;
-} | {
-    kind: 'fallback';
-};
-type MiddlewareHandler = (input: MiddlewareInput) => MiddlewareResult | Promise<MiddlewareResult>;
-declare const registerMiddlewareHandler: (handler: MiddlewareHandler) => void;
-declare const getMiddlewareHandler: () => MiddlewareHandler;
-type PageMiddleware<TSession extends BaseSessionLayout = BaseSessionLayout> = (input: {
-    location: string;
-    searchParams: Record<string, string>;
-    session: TSession | null;
-}) => MiddlewareResult | Promise<MiddlewareResult>;
-declare const registerPageMiddleware: (path: string, middleware: PageMiddleware) => void;
-declare const getPageMiddleware: (path: string) => PageMiddleware | undefined;
-declare const hasPageMiddleware: (path: string) => boolean;
-
-interface ClientHookPayloadMap {
-    preLogin: {
-        candidateSession: BaseSessionLayout;
-    };
-    postLogin: {
-        session: BaseSessionLayout;
-    };
-    postLogout: {
-        previousSession: BaseSessionLayout;
-    };
-    queueItemDropped: {
-        queue: 'api' | 'sync';
-        key: string;
-        reason: 'queue-full' | 'expired';
-        dropPolicy: 'drop-oldest' | 'drop-newest' | 'reject';
-    };
-}
-type ClientHookName = keyof ClientHookPayloadMap;
-interface ClientHookStopSignal {
-    stop: true;
-    errorCode: string;
-}
-type ClientHookResult = void | undefined | ClientHookStopSignal;
-type ClientDispatchResult = {
-    stopped: false;
-} | {
-    stopped: true;
-    signal: ClientHookStopSignal;
-};
-type ClientHookHandler<N extends ClientHookName> = (payload: ClientHookPayloadMap[N]) => ClientHookResult | Promise<ClientHookResult>;
-/**
- * Subscribe to a client-side lifecycle hook. Returns an unsubscribe function
- * — call it to remove the handler (e.g. inside a React effect cleanup).
- *
- * Multiple handlers can be registered for the same hook; they all fire on
- * each dispatch. A handler that throws (sync) or rejects (async) is logged
- * to `console.error` and does not affect other handlers.
- */
-declare function registerClientHook<N extends ClientHookName>(name: N, handler: ClientHookHandler<N>): () => void;
-/**
- * Fire a client-side hook (fire-and-forget). Framework-internal — consumers
- * should not call this directly. Used for `post*` hooks where any stop-signal
- * returned by a handler is intentionally ignored: a `postLogin` listener that
- * tried to "stop" the framework would be too late — the transition already
- * happened. Use `dispatchVetoableClientHook` for `pre*` hooks where the
- * caller actually awaits the veto decision.
- */
-declare function dispatchClientHook<N extends ClientHookName>(name: N, payload: ClientHookPayloadMap[N]): void;
-/**
- * Awaits every registered handler for a `pre*` client hook. If any handler
- * returns a `ClientHookStopSignal`, dispatch short-circuits and returns
- * `{ stopped: true, signal }`; callers must respect the veto (skip the
- * pending action). Handlers that throw or reject are logged but treated as
- * `undefined` — a buggy handler must not silently block the user flow.
- *
- * Mirrors `dispatchHook` from `@luckystack/core` so consumer/framework code
- * can use the same stop-signal pattern on both sides of the wire.
- */
-declare function dispatchVetoableClientHook<N extends ClientHookName>(name: N, payload: ClientHookPayloadMap[N]): Promise<ClientDispatchResult>;
-
-interface ApiRequestInterceptorContext {
-    /** Resolved route name (`<page>/<api>` or `system/<api>`). */
-    name: string;
-    /** Route version literal (e.g. `'v1'`). */
-    version: string;
-    /**
-     * Outgoing request payload. Mutate this object in place to augment the
-     * request (correlation id, feature-flag context, ...). Replacing the
-     * reference has no effect — mutate keys on the existing object.
-     */
-    data: Record<string, unknown>;
-}
-interface ApiResponseInterceptorContext {
-    name: string;
-    version: string;
-    /** The response envelope the caller is about to receive (read-only intent). */
-    response: {
-        status: 'success' | 'error';
-        [key: string]: unknown;
-    };
-}
-type ApiRequestInterceptor = (ctx: ApiRequestInterceptorContext) => void | Promise<void>;
-type ApiResponseInterceptor = (ctx: ApiResponseInterceptorContext) => void | Promise<void>;
-/**
- * Register an outgoing-request interceptor. Returns an unsubscribe function.
- * Multiple interceptors run in registration order; each may mutate `ctx.data`.
- */
-declare function registerApiRequestInterceptor(interceptor: ApiRequestInterceptor): () => void;
-/**
- * Register an incoming-response interceptor. Returns an unsubscribe function.
- */
-declare function registerApiResponseInterceptor(interceptor: ApiResponseInterceptor): () => void;
-
-interface SessionContextValue<TSession extends BaseSessionLayout = BaseSessionLayout> {
-    session: TSession | null;
-    sessionLoaded: boolean;
-}
-declare const SessionContext: react.Context<SessionContextValue<BaseSessionLayout>>;
-declare function useSession<TSession extends BaseSessionLayout = BaseSessionLayout>(): SessionContextValue<TSession>;
-declare const setLatestSession: (session: BaseSessionLayout | null) => void;
-declare const getCurrentSession: <TSession extends BaseSessionLayout = BaseSessionLayout>() => TSession | null;
-/**
- * Vetoable entry point for committing a null → session transition (i.e. a
- * fresh login or a page-load session restore). Dispatches the `preLogin`
- * client hook to every registered handler in parallel; if any returns a
- * stop signal, the transition is aborted and `{ committed: false, signal }`
- * is returned. Otherwise, `setLatestSession(session)` runs synchronously
- * (which fires `postLogin`) and `{ committed: true }` comes back.
- *
- * Consumer's `SessionProvider` should `await` this for non-null session
- * commits and roll local React state back to `null` when a veto comes
- * through, so the UI doesn't render a half-logged-in state.
- */
-type ProposeLoginResult = {
-    stopped: false;
-    committed: true;
-} | {
-    stopped: true;
-    signal: ClientHookStopSignal;
-    committed: false;
-};
-declare const proposeLogin: (session: BaseSessionLayout) => Promise<ProposeLoginResult>;
-
-type AvatarStatus = 'avatar' | 'fallback';
-interface AvatarContextType {
-    avatarStatuses: Record<string, AvatarStatus>;
-    setAvatarStatus: (key: string, status: AvatarStatus) => void;
-}
-declare const AvatarProvider: ({ children }: {
-    children: ReactNode;
-}) => react.JSX.Element;
-declare function useAvatarContext(): AvatarContextType;
-
-type Theme = 'light' | 'dark';
-declare const useTheme: () => {
-    theme: Theme;
-    setTheme: (next: Theme) => void;
-};
-
-type TranslationRecord = Record<string, unknown>;
-declare function TranslationProvider({ children }: {
-    children: ReactNode;
-}): react.JSX.Element;
-declare function useTranslation(): TranslationRecord;
-declare function useUpdateLanguage(): Dispatch<SetStateAction<string>>;
-interface TranslateParam {
-    key: string;
-    value: string | number | boolean;
-}
-declare function translate({ translationList, key, params }: {
-    translationList: TranslationRecord;
-    key: unknown;
-    params?: TranslateParam[];
-}): string;
-declare const useTranslator: () => ({ key, params }: {
-    key: string;
-    params?: TranslateParam[];
-}) => string;
-
-interface NotifyInput {
-    key: string;
-    params?: TranslateParam[];
-}
-declare const notify: {
-    success: (input: NotifyInput) => void;
-    error: (input: NotifyInput) => void;
-    info: (input: NotifyInput) => void;
-    warning: (input: NotifyInput) => void;
-};
-
-declare function Middleware({ children, denied, }: {
-    children: ReactNode;
-    /**
-     * Rendered instead of the page when middleware denies IN PLACE
-     * (`{ success: false, status }`) — the URL is kept. Pass a node, or a
-     * function to vary by status. Defaults to a minimal built-in view.
-     */
-    denied?: ReactNode | ((status: number) => ReactNode);
-}): react.JSX.Element | null;
-
-declare function useRouter(): (path: string) => Promise<void>;
-
-export { type ApiErrorResponse, type ApiRequestInterceptor, type ApiRequestInterceptorContext, type ApiResponseInterceptor, type ApiResponseInterceptorContext, type ApiStreamEvent, ApiTypeMap, AvatarProvider, type AvatarStatus, BaseSessionLayout, type ClientDispatchResult, type ClientHookHandler, type ClientHookName, type ClientHookPayloadMap, type ClientHookResult, type ClientHookStopSignal, HttpMethodLiteral, type LanguageSource, type LocalesMap, Middleware, type MiddlewareHandler, type MiddlewareInput, type MiddlewareOutcome, type MiddlewareResult, type PageMiddleware, type RoutedHttpInvocationInput, type RoutedInvocationFailure, type RoutedInvocationMethod, type RoutedInvocationResponse, type RoutedInvocationResult, SessionContext, type SessionContextValue, StreamPayload, type Theme, type TranslateParam, TranslationProvider, type TranslationRecord, apiRequest, dispatchClientHook, dispatchVetoableClientHook, getActiveLanguage, getCurrentSession, getDefaultLocale, getLocaleByCode, getMiddlewareHandler, getPageMiddleware, getRegisteredLocales, hasPageMiddleware, notify as i18nNotify, invokeRoutedHttp, proposeLogin, registerApiRequestInterceptor, registerApiResponseInterceptor, registerClientHook, registerLanguageSource, registerLocales, registerMiddlewareHandler, registerPageMiddleware, setLatestSession, translate, tryCatch, useAvatarContext, useRouter, useSession, useTheme, useTranslation, useTranslator, useUpdateLanguage };
+export { apiRequest } from './apiRequest.js';
+export type { ApiStreamEvent, ApiErrorResponse } from './apiRequest.js';
+export { default as sleep } from './sleep.js';
+export { default as tryCatch } from './tryCatchClient.js';
+export { default as tryCatchSync } from './tryCatchSync.js';
+export { getProjectConfig, registerProjectConfig, isProjectConfigRegistered, } from './projectConfig.js';
+export type { ProjectConfig, AppConfig, LoggingConfig, RateLimitingConfig, SessionConfig, TransportConfig, } from './projectConfig.js';
+export { notify, registerNotifier, getNotifier } from './notifier.js';
+export type { Notifier, NotifyInput, NotifyParam } from './notifier.js';
+export { socket, setSocket, incrementResponseIndex, waitForSocket, } from './socketState.js';
+export { isOnline, enqueueApiRequest, enqueueSyncRequest, removeApiQueueItem, removeSyncQueueItem, removeApiQueueItemsByKey, flushApiQueue, flushSyncQueue, getApiQueueSize, getSyncQueueSize, } from './offlineQueue.js';
+export { normalizeErrorResponseCore } from './responseNormalizer.js';
+export { getCsrfToken, clearCsrfToken, httpFetch } from './csrf.js';
+export { invokeRoutedHttp } from './routedHttpInvocation.js';
+export { ROUTED_DATA_QUERY_KEY, buildRoutedGetUrl } from './routedDataQuery.js';
+export type { RoutedHttpInvocationInput, RoutedInvocationFailure, RoutedInvocationMethod, RoutedInvocationResponse, RoutedInvocationResult, } from './routedHttpInvocation.js';
+export { parseServiceRouteName } from './serviceRoute.js';
+export { buildApiResponseEventName, buildApiStreamEventName, buildSyncProgressEventName, buildSyncResponseEventName, buildJoinRoomResponseEventName, buildLeaveRoomResponseEventName, buildGetJoinedRoomsResponseEventName, socketEventNames, } from './socketEvents.js';
+export type { statusContent, SOCKETSTATUS } from './socketStatusTypes.js';
+export type { ApiTypeMap, SyncTypeMap, StreamPayload } from './apiTypeStubs.js';
+export type { BaseSessionLayout, SessionLocation, AuthProps } from './sessionTypes.js';
+export { getLogger, registerLogger } from './loggerRegistry.js';
+export type { Logger, LoggerContext } from './loggerRegistry.js';
+export { registerApiMethodMap, getRegisteredApiMethod, isApiMethodMapRegistered, } from './apiMethodMapRegistry.js';
+export type { HttpMethodLiteral, ApiMethodMap } from './apiMethodMapRegistry.js';
+export { registerLocales, getRegisteredLocales, getDefaultLocale, registerLanguageSource, getActiveLanguage, getLocaleByCode, } from './localesRegistry.js';
+export type { LocalesMap, LanguageSource } from './localesRegistry.js';
+export { registerMiddlewareHandler, getMiddlewareHandler, registerPageMiddleware, getPageMiddleware, hasPageMiddleware, } from './middlewareRegistry.js';
+export type { MiddlewareInput, MiddlewareResult, MiddlewareOutcome, MiddlewareHandler, PageMiddleware, } from './middlewareRegistry.js';
+export { registerClientHook, dispatchClientHook, dispatchVetoableClientHook, } from './clientHookBus.js';
+export type { ClientHookName, ClientHookHandler, ClientHookPayloadMap, ClientHookStopSignal, ClientHookResult, ClientDispatchResult, } from './clientHookBus.js';
+export { registerApiRequestInterceptor, registerApiResponseInterceptor, } from './apiInterceptors.js';
+export type { ApiRequestInterceptor, ApiResponseInterceptor, ApiRequestInterceptorContext, ApiResponseInterceptorContext, } from './apiInterceptors.js';
+export { validatePagePath, DEFAULT_PAGE_ROUTE_RULES, } from './pageRouteValidation.js';
+export type { PageRouteRules, PagePathValidationResult, } from './pageRouteValidation.js';
+export { SessionContext, useSession, setLatestSession, getCurrentSession, proposeLogin, } from './react/sessionContext.js';
+export type { SessionContextValue } from './react/sessionContext.js';
+export { AvatarProvider, useAvatarContext } from './react/AvatarProvider.js';
+export type { AvatarStatus } from './react/AvatarProvider.js';
+export { useTheme } from './react/useTheme.js';
+export type { Theme } from './react/useTheme.js';
+export { TranslationProvider, useTranslation, useUpdateLanguage, translate, useTranslator, } from './react/TranslationProvider.js';
+export type { TranslationRecord, TranslateParam } from './react/TranslationProvider.js';
+export { default as i18nNotify } from './react/notify.js';
+export { default as Middleware } from './react/Middleware.js';
+export { default as useRouter } from './react/Router.js';

package/dist/client.js

@@ -818,12 +818,12 @@ var applyDomClass = (theme) => {
 };
 var useTheme = () => {
   const initialTheme = getProjectConfig().defaultTheme ?? "light";
-  const [theme, setThemeState] = useState2(initialTheme);
+  const [themeState, setThemeState] = useState2(initialTheme);
   const setTheme = useCallback2((next) => {
     setThemeState(next);
     applyDomClass(next);
   }, []);
-  return { theme, setTheme };
+  return { theme: themeState, setTheme };
 };
 
 // src/react/TranslationProvider.tsx