@vef-framework/core 2.0.11 → 2.1.0

package/dist/types/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/http/index.d.ts

@@ -1,4 +1,5 @@
-export { HttpClient, skipAuthenticationHeader, skipAuthenticationValue } from './client';
+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/index.d.ts

@@ -1,4 +1,5 @@
-export { ApiClient, createApiClient, type ApiClientOptions, type MutationFunction, type QueryFunction, type QueryKey } from './api';
+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';
@@ -6,8 +7,9 @@ export { AxisModifier, DragDropContext, DragDropProvider, Draggable, DragOverlay
 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, useInView, type MotionProps, type ResolvedValues, type TargetAndTransition, type Transition, type Variant, type VariantLabels, type Variants } from './motion';
+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';

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

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

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

@@ -1,5 +1,10 @@
-import { PropsWithChildren } from 'react';
-interface MotionProviderProps extends PropsWithChildren {
+import { ReactNode } from 'react';
+interface MotionProviderProps {
+    children: ReactNode;
 }
-export default function MotionProvider({ children }: MotionProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+/**
+ * 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/query/helpers.d.ts

@@ -1,10 +1,7 @@
 import { QueryClientOptions } from './types';
 import { QueryClient } from '@tanstack/react-query';
 /**
- * Creates a new query client.
- *
- * @param options - The options for the query client.
- * @returns The query client.
+ * 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/query/hooks.d.ts

@@ -1,66 +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';
-/**
- * The hook for the query.
- *
- * @param options - The options for the query.
- * @returns The result of the query.
- */
 export declare function useQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(options: DefinedInitialDataOptions<TQueryFnData, Error, TData, QueryKey<TParams>>): DefinedUseQueryResult<NoInfer<TData>, Error>;
-/**
- * The hook for the query.
- *
- * @param options - The options for the query.
- * @returns The result of the query.
- */
 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>;
-/**
- * The hook for the infinite query.
- *
- * @param options - The options for the infinite query.
- * @returns The result of the infinite query.
- */
 export declare function useInfiniteQuery<TQueryFnData, TData = InfiniteData<TQueryFnData>, TParams = never, TPageParam = never>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>): DefinedUseInfiniteQueryResult<TData, Error>;
-/**
- * The hook for the infinite query.
- *
- * @param options - The options for the infinite query.
- * @returns The result of the infinite query.
- */
 export declare function useInfiniteQuery<TQueryFnData, TData = InfiniteData<TQueryFnData>, TParams = never, TPageParam = never>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>): UseInfiniteQueryResult<TData, Error>;
 /**
- * The hook for the queries.
- *
- * @param options - The options for the queries.
- * @returns The results of the queries.
+ * Hook for executing multiple queries in parallel
  */
-export declare function useQueries<T extends any[], TCombinedResult = QueriesResults<T>>(options: Parameters<typeof useQueriesInternal<T, TCombinedResult>>[0]): TCombinedResult;
+export declare function useQueries<T extends unknown[], TCombinedResult = QueriesResults<T>>(options: Parameters<typeof useQueriesInternal<T, TCombinedResult>>[0]): TCombinedResult;
 /**
- * The hook for the mutation.
- *
- * @param mutationOptions - The options for the mutation.
- * @returns The result of the mutation.
+ * 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>;
 /**
- * The hook for the mutation state.
- *
- * @param options - The options for the mutation state.
- * @returns The state of the mutations.
+ * Hook for accessing mutation state across the application
  */
 export declare function useMutationState<TResult = MutationState>(options?: Parameters<typeof useMutationStateInternal<TResult>>[0]): TResult[];
 /**
- * The hook for getting the number of queries that are fetching.
- *
- * @param filters - The filters for the queries.
- * @returns The number of queries that are fetching.
+ * Hook for getting the count of currently fetching queries
  */
 export declare function useIsFetching(filters?: QueryFilters): number;
 /**
- * The hook for getting the number of mutations that are mutating.
- *
- * @param filters - The filters for the mutations.
- * @returns The number of mutations that are mutating.
+ * 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/query/types.d.ts

@@ -5,47 +5,47 @@ declare module "@tanstack/react-query" {
     interface Register {
         mutationMeta: {
             /**
-             * The query keys that will be invalidated when the mutation is successful.
+             * Query keys to invalidate on successful mutation
              */
-            invalidates?: QueryKey[];
+            invalidates?: Array<QueryKey<never> | QueryKey<unknown>>;
             /**
-             * The should show success feedback.
+             * Whether to show success feedback (default: true)
              */
             shouldShowSuccessFeedback?: boolean;
         };
     }
 }
 /**
- * The options for the query client.
+ * Options for creating a QueryClient instance
  */
 export interface QueryClientOptions {
     /**
-     * The stale time.
+     * Time in ms before data is considered stale (default: 5000)
      */
     staleTime?: number;
     /**
-     * The gc time.
+     * Time in ms before inactive queries are garbage collected (default: 300000)
      */
     gcTime?: number;
     /**
-     * The show success message when the mutation is successful.
+     * Callback to display success message from mutation response
      */
     showSuccessMessage?: (message: string) => void;
 }
-export type RetryValue = boolean | number | ShouldRetryFunction;
 export type ShouldRetryFunction = (failureCount: number, error: Error) => boolean;
-export type RetryDelayValue = number | RetryDelayFunction;
+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 UseMutationResult<TData = unknown, TParams = unknown, TOnMutateResult = unknown> = UseMutationResultInternal<TData, Error, TParams, TOnMutateResult>;
+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 DefinedUseQueryResult<TData = unknown> = DefinedUseQueryResultInternal<TData, Error>;
 export type UseInfiniteQueryOptions<TQueryFnData, TData = TQueryFnData, TParams = never, TPageParam = never> = UseInfiniteQueryOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>;
-export { type InitialDataFunction, type MutationFunctionContext, type MutationMeta, type MutationScope, type QueryMeta, type SkipToken as SkipQueryToken, type StaleTime } from '@tanstack/react-query';
+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/ai/index.d.ts

@@ -0,0 +1,6 @@
+export { DefaultChatTransport, TextStreamChatTransport, type ChatTransport } from 'ai';
+export type { DataUIPart, DynamicToolUIPart, FileUIPart, ReasoningUIPart, SourceDocumentUIPart, SourceUrlUIPart, StepStartUIPart, TextUIPart, ToolUIPart, UIMessage, UIMessageChunk, UIMessagePart } from 'ai';
+export type { UIToolInvocation, UITools } from 'ai';
+export { getToolName, getToolOrDynamicToolName } from 'ai';
+export { isDataUIPart, isFileUIPart, isReasoningUIPart, isTextUIPart, isToolOrDynamicToolUIPart, isToolUIPart } from 'ai';
+export { isDeepEqualData, parsePartialJson } from 'ai';

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

@@ -0,0 +1,55 @@
+import { FetchQueryOptions, MutationOptions, QueryClient, QueryMeta } from '@tanstack/react-query';
+import { Awaitable, Except, If, IsNever, IsOptional } from '@vef-framework/shared';
+import { HttpClient } from '../http';
+import { ApiClientOptions, MutationFunction, QueryFunction, QueryKey } from './types';
+import { HTTP_CLIENT, QUERY_CLIENT } from './constants';
+/**
+ * API client that combines HttpClient and QueryClient for data fetching.
+ */
+export declare class ApiClient {
+    #private;
+    /**
+     * Access the underlying QueryClient.
+     */
+    get [QUERY_CLIENT](): QueryClient;
+    /**
+     * Access the underlying HttpClient.
+     */
+    get [HTTP_CLIENT](): Readonly<HttpClient>;
+    constructor(options: ApiClientOptions);
+    /**
+     * Create a proxied HttpClient that injects the current abort signal.
+     */
+    private createProxiedHttpClient;
+    /**
+     * Create a query function with automatic signal injection.
+     */
+    createQueryFn<TResult = unknown, TParams = never, TPageParam = never>(key: string, factory: (http: Readonly<HttpClient>) => (queryParams: TParams, pageParam: TPageParam, meta?: QueryMeta) => Awaitable<TResult>): QueryFunction<TResult, TParams, TPageParam>;
+    /**
+     * Create a mutation function.
+     */
+    createMutationFn<TResult = unknown, TParams = never>(key: string, factory: (http: Readonly<HttpClient>) => (params: TParams) => Awaitable<TResult>): MutationFunction<TResult, TParams>;
+    /**
+     * Fetch a query and return the result.
+     */
+    fetchQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = unknown, TPageParam = never>(options: Except<FetchQueryOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>, "queryHash" | "queryKeyHashFn">): Promise<TData>;
+    /**
+     * Prefetch a query and store the result in cache.
+     */
+    prefetchQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = unknown, TPageParam = never>(options: Except<FetchQueryOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>, "queryHash" | "queryKeyHashFn">): Promise<void>;
+    /**
+     * Execute a mutation imperatively outside of React components.
+     *
+     * Useful for scenarios like login flows, event handlers, or any code outside React components.
+     * Lifecycle callbacks (onMutate, onSuccess, etc.) still fire.
+     */
+    executeMutation<TData = unknown, TParams = unknown, TOnMutateResult = unknown>({ mutationFn, params, ...options }: Except<MutationOptions<TData, Error, TParams, TOnMutateResult>, "mutationKey" | "mutationFn"> & {
+        mutationFn: MutationFunction<TData, TParams>;
+    } & If<IsNever<TParams>, {
+        params?: never;
+    }, If<IsOptional<TParams>, {
+        params?: TParams;
+    }, {
+        params: TParams;
+    }>>): Promise<TData>;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * HTTP methods that should have the abort signal injected.
+ */
+export declare const PROXIED_METHODS: Set<string>;
+/**
+ * Symbol for accessing the query client.
+ */
+export declare const QUERY_CLIENT: unique symbol;
+/**
+ * Symbol for accessing the HTTP client.
+ */
+export declare const HTTP_CLIENT: unique symbol;

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

@@ -0,0 +1,9 @@
+import { ApiClientOptions } from './types';
+import { ApiClient } from './client';
+/**
+ * Creates a new API client.
+ *
+ * @param options - The options for the API client.
+ * @returns The API client.
+ */
+export declare function createApiClient(options: ApiClientOptions): ApiClient;

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

@@ -0,0 +1,4 @@
+export { ApiClient } from './client';
+export { HTTP_CLIENT, QUERY_CLIENT } from './constants';
+export { createApiClient } from './helpers';
+export type * from './types';

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

@@ -0,0 +1,48 @@
+import { MutationFunction as MutationFunctionInternal, QueryFunction as QueryFunctionInternal } from '@tanstack/react-query';
+import { If, IsNever, Key } from '@vef-framework/shared';
+import { HttpClientOptions } from '../http';
+import { QueryClientOptions } from '../query';
+/**
+ * The options for the API client.
+ */
+export interface ApiClientOptions {
+    /**
+     * The options for the HTTP client.
+     */
+    http: HttpClientOptions;
+    /**
+     * The options for the query client.
+     */
+    query?: QueryClientOptions;
+}
+/**
+ * The key of the query.
+ *
+ * @param TParams - The parameters of the query.
+ */
+export type QueryKey<TParams = never> = readonly [Key, ...If<IsNever<TParams>, [], [TParams]>];
+/**
+ * The query function.
+ *
+ * @param TResult - The result of the query.
+ * @param TParams - The parameters of the query.
+ * @param TPageParam - The page parameter of the query.
+ */
+export interface QueryFunction<TData = unknown, TParams = never, TPageParam = never> extends QueryFunctionInternal<TData, QueryKey<TParams>, TPageParam> {
+    /**
+     * The API identifier.
+     */
+    key: Key;
+}
+/**
+ * The mutation function.
+ *
+ * @param TResult - The result of the mutation.
+ * @param TParams - The parameters of the mutation.
+ */
+export interface MutationFunction<TData = unknown, TParams = never> extends MutationFunctionInternal<TData, TParams> {
+    /**
+     * The API identifier.
+     */
+    key: Key;
+}

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

@@ -0,0 +1,11 @@
+import { MaybeArray } from '@vef-framework/shared';
+import { PermissionCheckMode } from './types.js';
+/**
+ * Check if the user is authorized to access the resource identified by the permission token.
+ *
+ * @param hasPermission - Function to check if the user has a specific permission token.
+ * @param permTokens - Single token or array of tokens to check. If nullish, returns true (no permission required).
+ * @param checkMode - "any" requires at least one token match, "all" requires all tokens to match.
+ * @returns True if the user has the required permission(s), false otherwise.
+ */
+export declare function checkPermission(hasPermission: (token: string) => boolean, permTokens?: MaybeArray<string>, checkMode?: PermissionCheckMode): boolean;

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

@@ -0,0 +1,2 @@
+export { checkPermission } from './helpers.js';
+export type * from './types.js';

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

@@ -0,0 +1 @@
+export type PermissionCheckMode = "any" | "all";

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

@@ -0,0 +1 @@
+export type * from './types.js';

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

@@ -0,0 +1,98 @@
+import { AnyObject, EmptyObject, Except, Key } from '@vef-framework/shared';
+/**
+ * Pagination parameters for list queries.
+ * Used to specify which page and how many items per page to retrieve.
+ */
+export interface PaginationParams {
+    /**
+     * The page number, starting from 1
+     *
+     * @default 1
+     */
+    page?: number;
+    /**
+     * The number of items per page
+     *
+     * @default 15
+     */
+    size?: number;
+}
+/**
+ * Pagination result wrapper for paginated list responses.
+ * Contains the items for the current page and the total count across all pages.
+ *
+ * @template T - The type of items in the paginated list
+ */
+export interface PaginationResult<T = unknown> {
+    /**
+     * Total number of items across all pages
+     */
+    readonly total: number;
+    /**
+     * Items in the current page
+     */
+    readonly items: T[];
+}
+/**
+ * Base data option type for select, tree-select, cascader and other data-driven components.
+ *
+ * @template T - Additional custom fields that can be merged into the option
+ * @template M - Type of the metadata field
+ */
+export type DataOption<T = EmptyObject, M extends AnyObject = AnyObject> = T & {
+    /**
+     * Display text of the option
+     */
+    label: string;
+    /**
+     * Unique identifier of the option
+     */
+    value: Key;
+    /**
+     * Whether the option is disabled
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Additional description or help text for the option
+     */
+    description?: string;
+    /**
+     * Additional metadata for the option
+     */
+    meta?: M;
+    /**
+     * Child options for tree-like structures (e.g., TreeSelect, Cascader)
+     */
+    children?: Array<DataOption<T, M>>;
+};
+/**
+ * Data option with pinyin fields for Chinese character search and sorting.
+ * Extends {@link DataOption} with pinyin support to enable fuzzy search by pronunciation.
+ *
+ * @template T - Additional custom fields that can be merged into the option
+ * @template M - Type of the metadata field
+ */
+export type DataOptionWithPinyin<T = EmptyObject, M extends AnyObject = AnyObject> = Except<DataOption<T, M>, "children"> & {
+    /**
+     * Pinyin representation of the label
+     */
+    labelPinyin: string;
+    /**
+     * Initials of the pinyin representation of the label
+     */
+    labelPinyinInitials: string;
+    /**
+     * Pinyin representation of the description
+     */
+    descriptionPinyin?: string;
+    /**
+     * Initials of the pinyin representation of the description
+     */
+    descriptionPinyinInitials?: string;
+    /**
+     * Child options with pinyin support
+     */
+    children?: Array<DataOptionWithPinyin<T, M>>;
+};

package/dist/types/src/context/api-client.d.ts

@@ -0,0 +1,17 @@
+import { PropsWithChildren } from 'react';
+import { ApiClient } from '../api';
+interface ApiClientProviderProps extends PropsWithChildren {
+    value: ApiClient;
+}
+/**
+ * Provider for the API client context.
+ * Wraps children with both ApiClient context and React Query's QueryClientProvider.
+ */
+export declare function ApiClientProvider({ value, children }: ApiClientProviderProps): React.JSX.Element;
+/**
+ * Hook to access the API client from context.
+ *
+ * @throws Error if used outside of ApiClientProvider.
+ */
+export declare function useApiClient(): ApiClient;
+export {};

package/dist/types/src/context/app.d.ts

@@ -0,0 +1,12 @@
+import { AppContext } from './types';
+import { Context, Provider } from 'react';
+declare const AppContext: Context<AppContext>;
+/**
+ * Provider for the VEF app context.
+ */
+export declare const AppContextProvider: Provider<AppContext>;
+/**
+ * Hook to access the VEF app context.
+ */
+export declare function useAppContext(): AppContext;
+export {};

package/dist/types/src/context/context-selector.d.ts

@@ -0,0 +1,32 @@
+import { ComponentType, PropsWithChildren } from 'react';
+/**
+ * Props for the selector context provider component.
+ */
+export interface SelectorContextProviderProps<TValue> extends PropsWithChildren {
+    value: TValue;
+}
+/**
+ * Context hook interface with optional selector support.
+ */
+export interface UseSelectorContext<in out TValue> {
+    /**
+     * Returns the full context value.
+     */
+    <TStrictValue extends TValue = TValue>(): TStrictValue;
+    /**
+     * Returns the selected portion of the context value.
+     */
+    <TStrictValue extends TValue = TValue, TSelected = TStrictValue>(selector: (value: TStrictValue) => TSelected): NoInfer<TSelected>;
+}
+/**
+ * Result of creating a selector context.
+ */
+export interface SelectorContextResult<TValue> {
+    Provider: ComponentType<SelectorContextProviderProps<TValue>>;
+    useContext: UseSelectorContext<TValue>;
+}
+/**
+ * Creates a context with selector support for optimal re-rendering.
+ * Consuming components can select specific parts of the context value.
+ */
+export declare function createContextWithSelector<TValue>(defaultValue: TValue): SelectorContextResult<TValue>;

package/dist/types/src/context/disabled.d.ts

@@ -0,0 +1,9 @@
+import { Provider } from 'react';
+/**
+ * Hook to access the disabled state from context.
+ */
+export declare function useDisabled(): boolean;
+/**
+ * Provider for the disabled state context.
+ */
+export declare const DisabledProvider: Provider<boolean>;

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

@@ -0,0 +1,6 @@
+export { ApiClientProvider, useApiClient } from './api-client';
+export { AppContextProvider, useAppContext } from './app';
+export type { SelectorContextProviderProps, SelectorContextResult, UseSelectorContext } from './context-selector';
+export { createContextWithSelector } from './context-selector';
+export { DisabledProvider, useDisabled } from './disabled';
+export type { AppContext } from './types';

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

@@ -0,0 +1,26 @@
+import { QueryFunction } from '../api';
+import { DataOption } from '../common';
+/**
+ * The context of the vef app.
+ */
+export interface AppContext {
+    /**
+     * Whether the user is authorized to access the resource identified by the token.
+     *
+     * @example
+     * ```ts
+     * const isAuthorized = hasPermission("user:query");
+     * ```
+     * @param token - The permission token.
+     * @returns Whether the user has the permission to access the resource identified by the token.
+     */
+    hasPermission?: (token: string) => boolean;
+    /**
+     * The query function for the data dictionary.
+     */
+    dataDictQueryFn?: QueryFunction<DataOption[], string>;
+    /**
+     * The base URL for file access.
+     */
+    fileBaseUrl?: string;
+}

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

@@ -0,0 +1,8 @@
+export { AxisModifier, restrictShapeToBoundingRectangle, RestrictToHorizontalAxis, RestrictToVerticalAxis, SnapModifier } from '@dnd-kit/abstract/modifiers';
+export { RestrictToElement, RestrictToWindow } from '@dnd-kit/dom/modifiers';
+export { arrayMove as moveArrayItem, move as moveDragItem, arraySwap as swapArrayItem, swap as swapDragItem } from '@dnd-kit/helpers';
+export type { DragDropEventHandlers, DragDropEvents } from '@dnd-kit/react';
+export { DragDropProvider, DragOverlay, KeyboardSensor, PointerSensor, useDragDropMonitor, useDraggable, useDroppable } from '@dnd-kit/react';
+export { useSortable } from '@dnd-kit/react/sortable';
+export type { DragDropContextProps, DraggableChildrenFn, DraggableId, DraggableLocation, DraggableProps, DraggableProvided, DraggableProvidedDraggableProps, DraggableProvidedDragHandleProps, DraggableRubric, DraggableStateSnapshot, DroppableId, DroppableProps, DroppableProvided, DroppableProvidedProps, DroppableStateSnapshot, DropResult, OnBeforeCaptureResponder, OnBeforeDragStartResponder, OnDragEndResponder, OnDragStartResponder, OnDragUpdateResponder } from '@hello-pangea/dnd';
+export { DragDropContext, Draggable, Droppable } from '@hello-pangea/dnd';