@vef-framework/core 2.0.10 → 2.1.0

package/dist/types/src/http/client.d.ts

@@ -0,0 +1,112 @@
+import { AxiosProgressEvent } from 'axios';
+import { ApiResult, HttpClientOptions, RequestOptions } from './types';
+/**
+ * The HTTP client.
+ */
+export declare class HttpClient {
+    #private;
+    constructor(options: HttpClientOptions);
+    private initInterceptors;
+    /**
+     * Check if the code matches the target code(s).
+     */
+    private matchesCode;
+    /**
+     * Handle the request interceptor.
+     */
+    private handleRequest;
+    /**
+     * Handle the request error interceptor.
+     */
+    private handleRequestError;
+    /**
+     * Handle the response interceptor.
+     */
+    private handleResponse;
+    /**
+     * Handle the response error interceptor.
+     */
+    private handleResponseError;
+    /**
+     * Handle 401 unauthorized response.
+     */
+    private handleUnauthorized;
+    /**
+     * Log info message using configured handler or console.
+     */
+    private logInfo;
+    /**
+     * Log warning message using configured handler or console.
+     */
+    private logWarning;
+    /**
+     * Log error message using configured handler or console.
+     */
+    private logError;
+    /**
+     * Inject access token into request Authorization header.
+     */
+    private injectAccessToken;
+    /**
+     * Replace path parameters in the URL (e.g., /users/:id -> /users/123).
+     */
+    private replacePathParams;
+    /**
+     * Ensure the token is refreshed. Can be called proactively by external code
+     * (e.g., fetch-based SSE) to refresh token before/after request.
+     *
+     * @param triggerCallback - Whether to trigger onUnauthenticated callback on failure.
+     * @returns True if token refresh succeeded, false otherwise.
+     */
+    ensureTokenRefreshed(triggerCallback?: boolean): Promise<boolean>;
+    /**
+     * Try to refresh the token using the provided refresh callback.
+     */
+    private tryRefreshToken;
+    /**
+     * Retry the request with refreshed token.
+     */
+    private retryRequest;
+    /**
+     * GET request.
+     */
+    get<R = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * POST request.
+     */
+    post<R = unknown, D = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        data?: D;
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * PUT request.
+     */
+    put<R = unknown, D = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        data?: D;
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * DELETE request.
+     */
+    delete<R = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * Upload file via multipart/form-data.
+     */
+    upload<R = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+        data: FormData;
+        onProgress?: (event: AxiosProgressEvent) => void;
+    }): Promise<ApiResult<R>>;
+    /**
+     * Download file as blob and trigger browser download.
+     */
+    download<P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+        onProgress?: (progress: AxiosProgressEvent) => void;
+        filename?: string | ((filename: string) => string);
+    }): Promise<void>;
+}

package/dist/types/src/http/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The key for the HTTP client in dependency injection.
+ */
+export declare const HTTP_CLIENT_KEY = "__vef_http_client_key";
+/**
+ * The regex for path parameters in URLs (e.g., /users/:id).
+ */
+export declare const PATH_PARAM_REGEX: RegExp;
+/**
+ * The regex for extracting filename from Content-Disposition header.
+ */
+export declare const CONTENT_DISPOSITION_FILENAME_REGEX: RegExp;
+/**
+ * The header name for skipping authentication.
+ */
+export declare const SKIP_AUTH_HEADER = "X-Skip-Authentication";
+/**
+ * The header value for skipping authentication.
+ */
+export declare const SKIP_AUTH_VALUE = "1";
+/**
+ * Default request timeout in milliseconds (30 seconds).
+ */
+export declare const DEFAULT_TIMEOUT = 30000;

package/dist/types/src/http/errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Business error returned by the API when the response code indicates a business logic failure.
+ */
+export declare class BusinessError extends Error {
+    /**
+     * The business error code from the API response.
+     */
+    readonly code: number;
+    /**
+     * The original API response data.
+     */
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}

package/dist/types/src/http/helpers.d.ts

@@ -0,0 +1,17 @@
+import { HttpClientOptions } from './types';
+import { HttpClient } from './client';
+import { BusinessError } from './errors';
+/**
+ * Create the http client.
+ *
+ * @param options - The options for the http client.
+ * @returns The http client.
+ */
+export declare function createHttpClient(options: HttpClientOptions): Readonly<HttpClient>;
+/**
+ * Type guard to check if an error is a BusinessError.
+ *
+ * @param error - The error to check.
+ * @returns True if the error is a BusinessError.
+ */
+export declare function isBusinessError(error: unknown): error is BusinessError;

package/dist/types/src/http/index.d.ts

@@ -0,0 +1,5 @@
+export { HttpClient } from './client';
+export { CONTENT_DISPOSITION_FILENAME_REGEX, DEFAULT_TIMEOUT, HTTP_CLIENT_KEY, PATH_PARAM_REGEX, SKIP_AUTH_HEADER, SKIP_AUTH_VALUE, SKIP_AUTH_HEADER as skipAuthenticationHeader, SKIP_AUTH_VALUE as skipAuthenticationValue } from './constants';
+export { BusinessError } from './errors';
+export { createHttpClient, isBusinessError } from './helpers';
+export type * from './types';

package/dist/types/src/http/types.d.ts

@@ -0,0 +1,101 @@
+import { Awaitable, MaybeArray, MaybeUndefined } from '@vef-framework/shared';
+import { AxiosProgressEvent, GenericAbortSignal, RawAxiosRequestHeaders } from 'axios';
+export type ProgressEvent = AxiosProgressEvent;
+/**
+ * The result of the API.
+ */
+export interface ApiResult<T = unknown> {
+    /**
+     * The code of the API.
+     */
+    readonly code: number;
+    /**
+     * The message of the API.
+     */
+    readonly message: string;
+    /**
+     * The data of the API.
+     */
+    readonly data: T;
+}
+/**
+ * The authenticated tokens.
+ */
+export interface AuthTokens {
+    /**
+     * The access token
+     */
+    accessToken: string;
+    /**
+     * The refresh token
+     */
+    refreshToken: string;
+}
+/**
+ * The options for the HTTP client.
+ */
+export interface HttpClientOptions {
+    /**
+     * The base URL of the API.
+     */
+    baseUrl: string;
+    /**
+     * The timeout of the request.
+     */
+    timeout?: number;
+    /**
+     * The function to get the authentication tokens.
+     */
+    getAuthTokens?: () => Awaitable<MaybeUndefined<Readonly<AuthTokens>>>;
+    /**
+     * The function to set the authentication tokens.
+     */
+    setAuthTokens?: (tokens: Readonly<AuthTokens>) => Awaitable<void>;
+    /**
+     * The function to refresh the authentication tokens.
+     * Receives the current tokens and should return new tokens.
+     * If refresh fails, the promise should reject.
+     */
+    refreshToken?: (tokens: Readonly<AuthTokens>) => Awaitable<Readonly<AuthTokens>>;
+    /**
+     * The codes that are considered as successful.
+     */
+    okCode?: MaybeArray<number>;
+    /**
+     * The codes that are considered as authentication token expired.
+     */
+    tokenExpiredCode?: MaybeArray<number>;
+    /**
+     * The function to handle the unauthenticated error.
+     */
+    onUnauthenticated?: () => Awaitable<void>;
+    /**
+     * The function to handle the access denied error.
+     */
+    onAccessDenied?: () => Awaitable<void>;
+    /**
+     * The function to show the info message.
+     */
+    showInfoMessage?: (message: string) => void;
+    /**
+     * The function to show the warning message.
+     */
+    showWarningMessage?: (message: string) => void;
+    /**
+     * The function to show the error message.
+     */
+    showErrorMessage?: (message: string) => void;
+}
+/**
+ * The options for the request.
+ */
+export interface RequestOptions {
+    /**
+     * The signal for the request.
+     */
+    signal?: GenericAbortSignal;
+    /**
+     * The headers for the request.
+     */
+    headers?: RawAxiosRequestHeaders;
+}

package/dist/types/src/immer/index.d.ts

@@ -0,0 +1,2 @@
+export { applyPatches, current as currentState, original as originalState, produce, produceWithPatches } from 'immer';
+export { useImmer, useImmerReducer } from 'use-immer';

package/dist/types/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from './ai';
+export { ApiClient, createApiClient, HTTP_CLIENT, QUERY_CLIENT, type ApiClientOptions, type MutationFunction, type QueryFunction, type QueryKey } from './api';
+export { checkPermission, type PermissionCheckMode } from './auth';
+export { type DataOption, type DataOptionWithPinyin, type PaginationParams, type PaginationResult } from './common';
+export { ApiClientProvider, AppContextProvider, createContextWithSelector, DisabledProvider, useApiClient, useAppContext, useDisabled, type AppContext, type SelectorContextProviderProps, type SelectorContextResult, type UseSelectorContext } from './context';
+export { AxisModifier, DragDropContext, DragDropProvider, Draggable, DragOverlay, Droppable, KeyboardSensor, moveArrayItem, moveDragItem, PointerSensor, restrictShapeToBoundingRectangle, RestrictToElement, RestrictToHorizontalAxis, RestrictToVerticalAxis, RestrictToWindow, SnapModifier, swapArrayItem, swapDragItem, useDragDropMonitor, useDraggable, useDroppable, useSortable, type DragDropContextProps, type DragDropEventHandlers, type DragDropEvents, type DraggableChildrenFn, type DraggableId, type DraggableLocation, type DraggableProps, type DraggableProvided, type DraggableProvidedDraggableProps, type DraggableProvidedDragHandleProps, type DraggableRubric, type DraggableStateSnapshot, type DroppableId, type DroppableProps, type DroppableProvided, type DroppableProvidedProps, type DroppableStateSnapshot, type DropResult, type OnBeforeCaptureResponder, type OnBeforeDragStartResponder, type OnDragEndResponder, type OnDragStartResponder, type OnDragUpdateResponder } from './dnd';
+export type { ApiResult, AuthTokens, BusinessError, HttpClient, HttpClientOptions, isBusinessError, ProgressEvent, RequestOptions } from './http';
+export { skipAuthenticationHeader, skipAuthenticationValue } from './http';
+export { applyPatches, currentState, originalState, produce, produceWithPatches, useImmer, useImmerReducer } from './immer';
+export { AnimatePresence, LayoutGroup, motion, MotionProvider, Reorder, useDragControls, useInView, type MotionProps, type ResolvedValues, type TargetAndTransition, type Transition, type Variant, type VariantLabels, type Variants } from './motion';
+export { keepPreviousData, matchMutation, matchQuery, skipQueryToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useMutationState, useQueries, useQuery, useQueryErrorResetBoundary, type DefinedInitialDataOptions, type DefinedUseQueryResult, type InitialDataFunction, type MutationFunctionContext, type MutationMeta, type MutationScope, type PlaceholderDataFunction, type QueryClientOptions, type QueryKeyHashFunction, type QueryMeta, type RefetchOptions, type RetryDelayFunction, type RetryDelayValue, type RetryValue, type ShouldRetryFunction, type SkipQueryToken, type StaleTime, type UndefinedInitialDataOptions, type UseInfiniteQueryOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult } from './query';
+export { createSseClient, SseClient, type SseClientOptions, type SseEventHandlers, type SseMessageEvent, type SseRequestConfig } from './sse';
+export { atom, AtomStoreProvider, createAtomStore, getDefaultAtomStore, useAtom, useAtomStore, useAtomValue, useSetAtom, type Atom, type AtomGetter, type AtomSetter, type ExtractAtomArgs, type ExtractAtomResult, type ExtractAtomValue, type PrimitiveAtom, type SetStateAction, type WritableAtom } from './state';
+export { Actor, createActor, createMachine, updateContext, useActor, useActorRef, type ActorLogic, type ActorOptions, type AnyActorLogic, type AnyMachineSnapshot, type AnyStateMachine, type MachineConfig, type MachineContext, type MachineSnapshot, type RequiredActorOptionsKeys, type SnapshotFrom, type StateMachine } from './state-machine';
+export { createComponentStore, createPersistedStore, createStore, useDeep, useShallow, type PersistenceOptions, type ReturnedComponentStoreResult, type SliceStateCreator, type StoreProviderProps, type UnboundStore, type UseBoundStore, type UseBoundStoreWithPersist, type UseStore } from './store';
+export { clsx, type ClassArray, type ClassDictionary, type ClassValue } from 'clsx';

package/dist/types/src/motion/features.d.ts

@@ -0,0 +1 @@
+export { domMax as default } from 'motion/react';

package/dist/types/src/motion/index.d.ts

@@ -0,0 +1,4 @@
+export { default as MotionProvider } from './motion-provider.js';
+export type { MotionProps, ResolvedValues, TargetAndTransition, Transition, Variant, VariantLabels, Variants } from 'motion/react';
+export { AnimatePresence, LayoutGroup, Reorder, useDragControls, useInView } from 'motion/react';
+export * as motion from 'motion/react-m';

package/dist/types/src/motion/motion-provider.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+interface MotionProviderProps {
+    children: ReactNode;
+}
+/**
+ * Motion provider component that wraps the application with LazyMotion and MotionConfig.
+ * Uses lazy loading for motion features to optimize bundle size.
+ */
+export default function MotionProvider({ children }: MotionProviderProps): ReactNode;
+export {};

package/dist/types/src/query/constants.d.ts

@@ -0,0 +1 @@
+export declare const QUERY_CLIENT_KEY = "__vef_query_client_key";

package/dist/types/src/query/helpers.d.ts

@@ -0,0 +1,7 @@
+import { QueryClientOptions } from './types';
+import { QueryClient } from '@tanstack/react-query';
+/**
+ * Creates a configured QueryClient instance with mutation cache and default options
+ */
+export declare function createQueryClient(options?: QueryClientOptions): QueryClient;
+export { keepPreviousData } from '@tanstack/react-query';

package/dist/types/src/query/hooks.d.ts

@@ -0,0 +1,27 @@
+import { DefinedInitialDataInfiniteOptions, DefinedInitialDataOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, InfiniteData, MutationFilters, MutationState, NoInfer, QueriesResults, QueryFilters, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult, useMutationState as useMutationStateInternal, useQueries as useQueriesInternal } from '@tanstack/react-query';
+import { QueryKey } from '../api';
+export declare function useQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(options: DefinedInitialDataOptions<TQueryFnData, Error, TData, QueryKey<TParams>>): DefinedUseQueryResult<NoInfer<TData>, Error>;
+export declare function useQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(options: UndefinedInitialDataOptions<TQueryFnData, Error, TData, QueryKey<TParams>> | UseQueryOptions<TQueryFnData, Error, TData, QueryKey<TParams>>): UseQueryResult<NoInfer<TData>, Error>;
+export declare function useInfiniteQuery<TQueryFnData, TData = InfiniteData<TQueryFnData>, TParams = never, TPageParam = never>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>): DefinedUseInfiniteQueryResult<TData, Error>;
+export declare function useInfiniteQuery<TQueryFnData, TData = InfiniteData<TQueryFnData>, TParams = never, TPageParam = never>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>): UseInfiniteQueryResult<TData, Error>;
+/**
+ * Hook for executing multiple queries in parallel
+ */
+export declare function useQueries<T extends unknown[], TCombinedResult = QueriesResults<T>>(options: Parameters<typeof useQueriesInternal<T, TCombinedResult>>[0]): TCombinedResult;
+/**
+ * Hook for executing mutations with automatic error typing
+ */
+export declare function useMutation<TData = unknown, TParams = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, Error, TParams, TOnMutateResult>): UseMutationResult<TData, Error, TParams, TOnMutateResult>;
+/**
+ * Hook for accessing mutation state across the application
+ */
+export declare function useMutationState<TResult = MutationState>(options?: Parameters<typeof useMutationStateInternal<TResult>>[0]): TResult[];
+/**
+ * Hook for getting the count of currently fetching queries
+ */
+export declare function useIsFetching(filters?: QueryFilters): number;
+/**
+ * Hook for getting the count of currently executing mutations
+ */
+export declare function useIsMutating(filters?: MutationFilters): number;
+export { matchMutation, matchQuery, skipToken as skipQueryToken, useQueryErrorResetBoundary } from '@tanstack/react-query';

package/dist/types/src/query/index.d.ts

@@ -0,0 +1,4 @@
+export { QUERY_CLIENT_KEY } from './constants';
+export { createQueryClient, keepPreviousData } from './helpers';
+export { matchMutation, matchQuery, skipQueryToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useMutationState, useQueries, useQuery, useQueryErrorResetBoundary } from './hooks';
+export type * from './types';

package/dist/types/src/query/types.d.ts

@@ -0,0 +1,51 @@
+import { DefinedInitialDataOptions as DefinedInitialDataOptionsInternal, DefinedUseQueryResult as DefinedUseQueryResultInternal, QueryKeyHashFunction as QueryKeyHashFunctionInternal, UndefinedInitialDataOptions as UndefinedInitialDataOptionsInternal, UseInfiniteQueryOptions as UseInfiniteQueryOptionsInternal, UseMutationResult as UseMutationResultInternal, UseQueryOptions as UseQueryOptionsInternal, UseQueryResult as UseQueryResultInternal } from '@tanstack/react-query';
+import { MaybeUndefined } from '@vef-framework/shared';
+import { QueryKey } from '../api';
+declare module "@tanstack/react-query" {
+    interface Register {
+        mutationMeta: {
+            /**
+             * Query keys to invalidate on successful mutation
+             */
+            invalidates?: Array<QueryKey<never> | QueryKey<unknown>>;
+            /**
+             * Whether to show success feedback (default: true)
+             */
+            shouldShowSuccessFeedback?: boolean;
+        };
+    }
+}
+/**
+ * Options for creating a QueryClient instance
+ */
+export interface QueryClientOptions {
+    /**
+     * Time in ms before data is considered stale (default: 5000)
+     */
+    staleTime?: number;
+    /**
+     * Time in ms before inactive queries are garbage collected (default: 300000)
+     */
+    gcTime?: number;
+    /**
+     * Callback to display success message from mutation response
+     */
+    showSuccessMessage?: (message: string) => void;
+}
+export type ShouldRetryFunction = (failureCount: number, error: Error) => boolean;
+export type RetryValue = boolean | number | ShouldRetryFunction;
+export type RetryDelayFunction = (failureCount: number, error: Error) => number;
+export type RetryDelayValue = number | RetryDelayFunction;
+export type PlaceholderDataFunction<TData = unknown> = (previousData: MaybeUndefined<TData>) => MaybeUndefined<TData>;
+export interface RefetchOptions {
+    cancelRefetch?: boolean;
+}
+export type QueryKeyHashFunction<TParams = never> = QueryKeyHashFunctionInternal<QueryKey<TParams>>;
+export type UseQueryResult<TData = unknown> = UseQueryResultInternal<TData, Error>;
+export type DefinedUseQueryResult<TData = unknown> = DefinedUseQueryResultInternal<TData, Error>;
+export type UseQueryOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = UseQueryOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>>;
+export type DefinedInitialDataOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = DefinedInitialDataOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>>;
+export type UndefinedInitialDataOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = UndefinedInitialDataOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>>;
+export type UseInfiniteQueryOptions<TQueryFnData, TData = TQueryFnData, TParams = never, TPageParam = never> = UseInfiniteQueryOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>;
+export type UseMutationResult<TData = unknown, TParams = unknown, TOnMutateResult = unknown> = UseMutationResultInternal<TData, Error, TParams, TOnMutateResult>;
+export type { InitialDataFunction, MutationFunctionContext, MutationMeta, MutationScope, QueryMeta, SkipToken as SkipQueryToken, StaleTime } from '@tanstack/react-query';

package/dist/types/src/sse/client.d.ts

@@ -0,0 +1,16 @@
+import { SseClientOptions, SseEventHandlers, SseRequestConfig } from './types';
+/**
+ * SSE client wrapper around @microsoft/fetch-event-source.
+ */
+export declare class SseClient {
+    #private;
+    constructor(options?: SseClientOptions);
+    /**
+     * Start an SSE stream request.
+     */
+    stream(config: SseRequestConfig, handlers: SseEventHandlers): Promise<void>;
+    /**
+     * Abort all active stream requests.
+     */
+    abort(): void;
+}

package/dist/types/src/sse/helpers.d.ts

@@ -0,0 +1,9 @@
+import { SseClientOptions } from './types';
+import { SseClient } from './client';
+/**
+ * Create an SSE client instance (factory).
+ *
+ * @param options - SSE client options.
+ * @returns SSE client instance.
+ */
+export declare function createSseClient(options: SseClientOptions): SseClient;

package/dist/types/src/sse/index.d.ts

@@ -0,0 +1,3 @@
+export { SseClient } from './client';
+export { createSseClient } from './helpers';
+export type * from './types';

package/dist/types/src/sse/types.d.ts

@@ -0,0 +1,98 @@
+import { Awaitable, MaybeUndefined } from '@vef-framework/shared';
+import { AuthTokens } from '../http';
+/**
+ * SSE client options.
+ */
+export interface SseClientOptions {
+    /**
+     * Retrieve auth tokens (optional, used to auto-inject Authorization header).
+     */
+    getAuthTokens?: () => Awaitable<MaybeUndefined<Readonly<Pick<AuthTokens, "accessToken">>>>;
+    /**
+     * Whether to enable automatic retries.
+     *
+     * @default true
+     */
+    enableRetry?: boolean;
+    /**
+     * Maximum retry attempts.
+     *
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Optional error message handler.
+     */
+    showErrorMessage?: (message: string) => void;
+    /**
+     * Callback when token expires (401 response).
+     * Return true if token was refreshed and request should be retried.
+     * Return false to abort the request.
+     */
+    onTokenExpired?: () => Awaitable<boolean>;
+}
+/**
+ * SSE request configuration.
+ */
+export interface SseRequestConfig {
+    /**
+     * Request URL.
+     */
+    url: string;
+    /**
+     * HTTP method.
+     *
+     * @default "POST"
+     */
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    /**
+     * Request headers.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request body (POST/PUT only).
+     */
+    body?: string | object;
+    /**
+     * AbortSignal for canceling the request.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * SSE message event.
+ */
+export interface SseMessageEvent {
+    /**
+     * Event ID.
+     */
+    id?: string;
+    /**
+     * Event type.
+     */
+    event?: string;
+    /**
+     * Message data.
+     */
+    data: string;
+}
+/**
+ * SSE event handlers.
+ */
+export interface SseEventHandlers {
+    /**
+     * Connection opened callback.
+     */
+    onOpen?: (response: Response) => Awaitable<void>;
+    /**
+     * Message received callback.
+     */
+    onMessage: (event: SseMessageEvent) => void;
+    /**
+     * Error callback.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Connection closed callback.
+     */
+    onClose?: () => void;
+}

package/dist/types/src/state/index.d.ts

@@ -0,0 +1 @@
+export { atom, Provider as AtomStoreProvider, createStore as createAtomStore, getDefaultStore as getDefaultAtomStore, useAtom, useStore as useAtomStore, useAtomValue, useSetAtom, type Atom, type Getter as AtomGetter, type Setter as AtomSetter, type ExtractAtomArgs, type ExtractAtomResult, type ExtractAtomValue, type PrimitiveAtom, type SetStateAction, type WritableAtom } from 'jotai';

package/dist/types/src/state-machine/index.d.ts

@@ -0,0 +1,15 @@
+import { ActorOptions, AnyActorLogic, ConditionalRequired, IsNotNever, RequiredActorOptionsKeys, SnapshotFrom, Actor } from 'xstate';
+/**
+ * Custom hook for creating and using an XState actor with state selection.
+ * Combines actor creation with selector-based state subscription.
+ *
+ * @param logic - The actor logic (state machine or other actor logic)
+ * @param selector - Function to select specific data from the actor's snapshot
+ * @param options - Optional actor configuration options
+ * @returns A tuple containing [selectedState, sendFunction, actorRef]
+ */
+export declare function useActor<TLogic extends AnyActorLogic, TSelected>(logic: TLogic, selector: (snapshot: SnapshotFrom<TLogic>) => TSelected, ...[options]: ConditionalRequired<[
+    options?: ActorOptions<TLogic> & Record<RequiredActorOptionsKeys<TLogic>, unknown>
+], IsNotNever<RequiredActorOptionsKeys<TLogic>>>): [TSelected, Actor<TLogic>["send"], Actor<TLogic>];
+export { useActorRef } from '@xstate/react';
+export { Actor, createActor, createMachine, assign as updateContext, type ActorLogic, type ActorOptions, type AnyActorLogic, type AnyMachineSnapshot, type AnyStateMachine, type MachineConfig, type MachineContext, type MachineSnapshot, type RequiredActorOptionsKeys, type SnapshotFrom, type StateMachine } from 'xstate';

package/dist/types/src/store/bound.d.ts

@@ -0,0 +1,28 @@
+import { StateCreator } from 'zustand';
+import { PersistenceOptions, UseBoundStore, UseBoundStoreWithPersist } from './types';
+/**
+ * Create a store with the given initializer
+ *
+ * @param initializer - The initializer for the store
+ * @returns The store
+ */
+export declare function createStore<TState extends {
+    name: string;
+}>(initializer: StateCreator<TState, [
+    ["zustand/subscribeWithSelector", never],
+    ["zustand/immer", never]
+], [
+]>): UseBoundStore<TState>;
+/**
+ * Create a persisted store with the given initializer and persistence options
+ *
+ * @param initializer - The initializer for the store
+ * @param persistenceOptions - The persistence options for the store
+ * @returns The store
+ */
+export declare function createPersistedStore<TState>(initializer: StateCreator<TState, [
+    ["zustand/subscribeWithSelector", never],
+    ["zustand/persist", unknown],
+    ["zustand/immer", never]
+], [
+]>, persistenceOptions: PersistenceOptions<TState, unknown>): UseBoundStoreWithPersist<TState>;

package/dist/types/src/store/index.d.ts

@@ -0,0 +1,5 @@
+export { createPersistedStore, createStore } from './bound';
+export type * from './types';
+export { createComponentStore, type ComponentStoreResult as ReturnedComponentStoreResult, type UseStore } from './unbound';
+export { useDeep } from './use-deep';
+export { useShallow } from 'zustand/shallow';

package/dist/types/src/store/types.d.ts

@@ -0,0 +1,50 @@
+import { If, IsNever } from '@vef-framework/shared';
+import { PropsWithChildren } from 'react';
+import { Mutate, StateCreator, StoreApi, UseBoundStore as UseBoundStoreInternal } from 'zustand';
+export type SliceStateCreator<TState, TSlice, TPersist extends boolean = false> = StateCreator<TState, [
+    [
+        "zustand/subscribeWithSelector",
+        never
+    ],
+    If<TPersist, ["zustand/persist", unknown], never>,
+    [
+        "zustand/immer",
+        never
+    ]
+], [
+    If<TPersist, never, ["zustand/immer", never]>
+], TSlice>;
+export type UnboundStore<TState> = Mutate<StoreApi<TState>, [["zustand/subscribeWithSelector", never], ["zustand/immer", never]]>;
+export type UseBoundStore<TState> = UseBoundStoreInternal<Mutate<StoreApi<TState>, [["zustand/subscribeWithSelector", never], ["zustand/immer", never]]>>;
+export type UseBoundStoreWithPersist<TState> = UseBoundStoreInternal<Mutate<StoreApi<TState>, [["zustand/subscribeWithSelector", never], ["zustand/persist", unknown], ["zustand/immer", never]]>>;
+/**
+ * The options for the persistence
+ */
+export interface PersistenceOptions<TState, TSelectedState = TState> {
+    /**
+     * The unique name of the store
+     */
+    name: string;
+    /**
+     * The storage type of the store
+     */
+    storage?: "local" | "session";
+    /**
+     * The selector of the store
+     */
+    selector?: (state: TState) => TSelectedState;
+}
+/**
+ * The props of the store provider
+ */
+export type StoreProviderProps<TInitialState> = PropsWithChildren<If<IsNever<TInitialState>, {
+    /**
+     * The initial state of the store
+     */
+    initialState?: never;
+}, {
+    /**
+     * The initial state of the store
+     */
+    initialState: TInitialState;
+}>>;