@vef-framework/core 1.0.135 → 2.0.1

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

@@ -0,0 +1,4 @@
+export { HttpClient, skipAuthenticationHeader, skipAuthenticationValue } from './client';
+export { BusinessError } from './errors';
+export { createHttpClient, isBusinessError } from './helpers';
+export type * from './types';

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

@@ -0,0 +1,14 @@
+export { ApiClient, createApiClient, 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, 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 { 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/motion/features.d.ts

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

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

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

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

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+interface MotionProviderProps extends PropsWithChildren {
+}
+export default function MotionProvider({ children }: MotionProviderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,10 @@
+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.
+ */
+export declare function createQueryClient(options?: QueryClientOptions): QueryClient;
+export { keepPreviousData } from '@tanstack/react-query';

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

@@ -0,0 +1,66 @@
+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.
+ */
+export declare function useQueries<T extends any[], 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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+export declare function useIsMutating(filters?: MutationFilters): number;
+export { matchMutation, matchQuery, skipToken as skipQueryToken, useQueryErrorResetBoundary } from '@tanstack/react-query';

package/dist/types/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/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: {
+            /**
+             * The query keys that will be invalidated when the mutation is successful.
+             */
+            invalidates?: QueryKey[];
+            /**
+             * The should show success feedback.
+             */
+            shouldShowSuccessFeedback?: boolean;
+        };
+    }
+}
+/**
+ * The options for the query client.
+ */
+export interface QueryClientOptions {
+    /**
+     * The stale time.
+     */
+    staleTime?: number;
+    /**
+     * The gc time.
+     */
+    gcTime?: number;
+    /**
+     * The show success message when the mutation is successful.
+     */
+    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 RetryDelayFunction = (failureCount: number, error: Error) => number;
+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 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';

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

@@ -0,0 +1,14 @@
+import { ActorOptions, AnyActorLogic, ConditionalRequired, IsNotNever, RequiredActorOptionsKeys, SnapshotFrom, Actor } from 'xstate';
+/**
+ * Custom hook for creating and using an XState actor with state selection
+ *
+ * @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/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/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/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;
+}>>;

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

@@ -0,0 +1,26 @@
+import { ComponentType } from 'react';
+import { StateCreator } from 'zustand';
+import { StoreProviderProps, UnboundStore } from './types';
+/**
+ * The type for the useStore hook
+ */
+export interface UseStore<in out TState> {
+    (): TState;
+    <TSelected>(selector: (state: TState) => TSelected): NoInfer<TSelected>;
+}
+/**
+ * The type for the returned component store result
+ */
+export interface ComponentStoreResult<TState, TInitialState extends Partial<TState> = never> {
+    StoreProvider: ComponentType<StoreProviderProps<TInitialState>>;
+    useStoreApi: <TStrictState extends TState = TState>() => UnboundStore<TStrictState>;
+    useStore: UseStore<TState>;
+}
+/**
+ * Creates a component store
+ *
+ * @param name - The name of the store
+ * @param initializer - The initializer for the store
+ * @returns The component store result
+ */
+export declare function createComponentStore<TState, TInitialState extends Partial<TState> = never>(name: string, initializer: StateCreator<TState, [["zustand/subscribeWithSelector", never], ["zustand/immer", never]], []>): ComponentStoreResult<TState, TInitialState>;

package/dist/types/store/use-deep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook that returns a memoized selector function that is deeply equal to the previous selector function.
+ *
+ * @param selector - The selector function to memoize.
+ * @returns The memoized selector function.
+ */
+export declare function useDeep<TState, TSelected>(selector: (state: TState) => TSelected): (state: TState) => TSelected;

package/package.json

@@ -1,56 +1,78 @@
 {
   "name": "@vef-framework/core",
   "type": "module",
-  "version": "1.0.135",
+  "version": "2.0.1",
   "private": false,
-  "description": "The core of the VEF framework",
-  "author": "Venus",
+  "description": "Core features for VEF framework",
+  "author": {
+    "name": "Venus",
+    "email": "iweixiaopeng@163.com",
+    "url": "https://github.com/ilxqx"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://vef.ilxqx.com",
   "keywords": [
     "vef",
-    "vef-framework",
-    "vef-core"
+    "framework",
+    "react",
+    "core"
   ],
   "sideEffects": false,
-  "main": "cjs/index.cjs",
-  "types": "types/index.d.ts",
-  "files": [
-    "*"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "@emotion/cache": "11.14.0",
-    "@emotion/react": "11.14.0",
-    "@emotion/styled": "11.14.0",
-    "antd": "5.24.7",
-    "use-sync-external-store": "^1.5.0",
-    "@tanstack/react-query": "5.74.3",
-    "@tanstack/react-router": "1.116.0",
-    "@vef-framework/shared": "1.0.135",
-    "axios": "1.8.4",
-    "qs": "6.14.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "import": {
-        "types": "./types/index.d.ts",
-        "default": "./esm/index.js"
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/es/index.js"
       },
       "require": {
-        "types": "./types/index.d.ts",
-        "default": "./cjs/index.cjs"
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
-  "module": "esm/index.js",
-  "packageManager": "pnpm@10.8.1",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/es/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "peerDependencies": {
-    "react": "18.3.1",
-    "react-dom": "18.3.1"
+    "react": ">=19"
+  },
+  "dependencies": {
+    "@dnd-kit/abstract": "^0.1.21",
+    "@dnd-kit/dom": "^0.1.21",
+    "@dnd-kit/helpers": "^0.1.21",
+    "@dnd-kit/react": "^0.1.21",
+    "@emotion/react": "^11.14.0",
+    "@hello-pangea/dnd": "^18.0.1",
+    "@tanstack/react-query": "^5.90.10",
+    "@xstate/react": "^6.0.0",
+    "axios": "^1.13.2",
+    "clsx": "^2.1.1",
+    "immer": "^11.0.0",
+    "jotai": "^2.15.1",
+    "motion": "^12.23.24",
+    "use-immer": "^0.11.0",
+    "xstate": "^5.24.0",
+    "zustand": "^5.0.8",
+    "@vef-framework/shared": "2.0.1"
+  },
+  "devDependencies": {
+    "react": "^19.2.0"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
+    "build": "vite build",
+    "pub": "tsx ../../scripts/publish.ts"
   }
-}
+}

package/README.md

@@ -1,25 +0,0 @@
-# The Core of VEF Framework
-
-VEF framework made by Venus is built on top of React, and it provides a set of components that are essential for building a modern web application. These components are designed to be highly customizable and reusable, allowing developers to build complex and dynamic user interfaces with ease.
-
-## Installation
-
-To install the VEF framework core, you can use pnpm or any other package manager you like:
-
-```bash
-pnpm add @vef-framework/core
-```
-
-## Usage
-
-To use the VEF framework core in your project, you can import them from the package, for example:
-
-```ts
-import { xxx } from "@vef-framework/core";
-
-const result = xxx();
-```
-
-## Documentation
-
-For more details on how to use the VEF framework core, please refer to the [official documentation](https://vef.ilxqx.com/docs).

package/cjs/api/api-client.cjs

@@ -1,2 +0,0 @@
-"use strict";
-"use strict";var f=require("@tanstack/react-query"),K=require("react"),C=require("./query-client.cjs"),I=require("./request-client.cjs"),R=Object.defineProperty,P=r=>{throw TypeError(r)},x=(r,e,i)=>e in r?R(r,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):r[e]=i,A=(r,e,i)=>x(r,typeof e!="symbol"?e+"":e,i),q=(r,e,i)=>e.has(r)||P("Cannot "+i),n=(r,e,i)=>(q(r,e,"read from private field"),i?i.call(r):e.get(r)),D=(r,e,i)=>e.has(r)?P("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(r):e.set(r,i),o=(r,e,i,t)=>(q(r,e,"write to private field"),t?t.call(r,i):e.set(r,i),i),m=(r,e,i)=>(q(r,e,"access private method"),i),c,y,b,h,g,k,M,S,F;class E{constructor(e){this.options=e,D(this,g),A(this,"useApiQuery"),A(this,"useSuspenseApiQuery"),A(this,"useApiMutation"),A(this,"useIsFetching"),A(this,"useIsMutating"),A(this,"QueryClientProvider"),D(this,c),D(this,y),D(this,b),D(this,h),o(this,c,C.createQueryClient(e)),o(this,y,I.createRequestClient(e)),o(this,b,{get:async(t,s)=>{const a=n(this,h);return o(this,h,void 0),await n(this,y).get(t,{...s,signal:a})},post:async(t,s,a)=>{const u=n(this,h);return o(this,h,void 0),await n(this,y).post(t,s,{...a,signal:u})},put:async(t,s,a)=>{const u=n(this,h);return o(this,h,void 0),await n(this,y).put(t,s,{...a,signal:u})},delete:async(t,s)=>{const a=n(this,h);return o(this,h,void 0),await n(this,y).delete(t,{...s,signal:a})},upload:async(t,s,a)=>{const u=n(this,h);return o(this,h,void 0),await n(this,y).upload(t,s,{...a,signal:u})},download:async(t,s)=>{const a=n(this,h);return o(this,h,void 0),await n(this,y).download(t,{...s,signal:a})}});const i=this;this.useApiQuery=function(t,s,a){var u;const{keepPreviousData:p,placeholderData:Q,initialData:l,...v}=a??{},d=f.useQuery({queryKey:[t.key,s],queryFn:({signal:w})=>t(s,{signal:w}),select:m(i,g,k),placeholderData:Q??p===!0?f.keepPreviousData:void 0,initialData:l?{code:0,message:"ok",data:l}:void 0,...v});return m(u=i,g,S).call(u,d)},this.useSuspenseApiQuery=function(t,s,a){const{keepPreviousData:u,initialData:p,...Q}=a??{},{data:l,refetch:v}=f.useSuspenseQuery({queryKey:[t.key,s],queryFn:({signal:d})=>t(s,{signal:d}),select:m(i,g,k),initialData:p?{code:0,message:"ok",data:p}:void 0,...Q});return{data:l,refetch:m(this,g,M).call(this,v)}},this.useApiMutation=function(t){const{isPending:s,isIdle:a,isError:u,isSuccess:p,error:Q,data:l,mutateAsync:v}=f.useMutation({mutationKey:[t.key],mutationFn:d=>t(d)});return{mutate:async d=>await v(d),isPending:s,isIdle:a,isError:u,isSuccess:p,message:l?.message,error:Q??void 0,data:l?.data}},this.useIsFetching=function(t,s){return f.useIsFetching({queryKey:arguments.length>1?[t,s]:[t],type:"active",exact:!1})>0},this.useIsMutating=function(t){return f.useIsMutating({mutationKey:[t],exact:!1})>0},this.QueryClientProvider=function({children:t}){return K.createElement(f.QueryClientProvider,{client:n(i,c)},t)}}async fetchApiQuery(e,i,t){const{initialData:s,...a}=t??{};return(await n(this,c).fetchQuery({queryKey:[e.key,i],queryFn:({signal:u})=>e(i,{signal:u}),initialData:s?{code:0,message:"ok",data:s}:void 0,...a})).data}createQueryApi(e,i){const t=m(this,g,F).call(this,e,i);return t.useQuery=this.useApiQuery.bind(this,t),t.useSuspenseQuery=this.useSuspenseApiQuery.bind(this,t),t.fetchQuery=this.fetchApiQuery.bind(this,t),t.getQueryData=this.getApiQueryData.bind(this,e),t.getQueriesData=this.getApiQueriesData.bind(this,e),t.setQueryData=(s,a)=>this.setApiQueryData(s,e,a),t.ensureQueryData=this.ensureApiQueryData.bind(this,t),t.removeQueries=this.removeApiQueries.bind(this,e),t.invalidateQueries=this.invalidateApiQueries.bind(this,e),t.resetQueries=this.resetApiQueries.bind(this,e),t.refetchQueries=this.refetchApiQueries.bind(this,e),t.cancelQueries=this.cancelApiQueries.bind(this,e),t.isFetching=this.isFetching.bind(this,e),t.useIsFetching=this.useIsFetching.bind(void 0,e),Object.freeze(t)}createMutationApi(e,i,t=[]){const s=m(this,g,F).call(this,e,i);return s.relatedQueries=Object.freeze(t),s.useMutation=this.useApiMutation.bind(this,s),s.refetchRelatedQueries=function(){return Promise.all(t.map(a=>a.refetchQueries()))},s.invalidateRelatedQueries=function(){return Promise.all(t.map(a=>a.invalidateQueries()))},s.isMutating=this.isMutating.bind(this,e),s.useIsMutating=this.useIsMutating.bind(void 0,e),Object.freeze(s)}getApiQueryData(e,i){return n(this,c).getQueryData(arguments.length>1?[e,i]:[e])}getApiQueriesData(e,i){return n(this,c).getQueriesData({queryKey:arguments.length>1?[e,i]:[e],type:"active",exact:!1})}setApiQueryData(e,i,t){n(this,c).setQueryData(arguments.length>2?[i,t]:[i],e)}async ensureApiQueryData(e,i,t){const{initialData:s,...a}=t??{};return(await n(this,c).ensureQueryData({queryKey:[e.key,i],queryFn:({signal:u})=>e(i,{signal:u}),initialData:s?{code:0,message:"ok",data:s}:void 0,...a,revalidateIfStale:!0})).data}removeApiQueries(e,i){n(this,c).removeQueries({type:"all",exact:!1,queryKey:arguments.length>1?[e,i]:[e]})}invalidateApiQueries(e,i){return n(this,c).invalidateQueries({queryKey:arguments.length>1?[e,i]:[e],type:"all",exact:!1,stale:!1,refetchType:"active"},{throwOnError:!1,cancelRefetch:!1})}resetApiQueries(e,i){return n(this,c).resetQueries({queryKey:arguments.length>1?[e,i]:[e],type:"active",exact:!1},{cancelRefetch:!0,throwOnError:!1})}refetchApiQueries(e,i){return n(this,c).refetchQueries({queryKey:arguments.length>1?[e,i]:[e],type:"active",exact:!1},{throwOnError:!1,cancelRefetch:!1})}cancelApiQueries(e,i){return n(this,c).cancelQueries({queryKey:arguments.length>1?[e,i]:[e],type:"active",exact:!1},{revert:!0,silent:!0})}isFetching(e,i){return n(this,c).isFetching({queryKey:arguments.length>1?[e,i]:[e],type:"active",exact:!1})>0}isMutating(e){return n(this,c).isMutating({mutationKey:[e],exact:!1})>0}}c=new WeakMap,y=new WeakMap,b=new WeakMap,h=new WeakMap,g=new WeakSet,k=function(r){return r.data},M=function(r){return async e=>{const i=await r(e);return{isSuccess:i.isSuccess,isError:i.isError,error:i.error,data:i.data}}},S=function({isPending:r,isFetching:e,isLoading:i,isRefetching:t,isSuccess:s,isPlaceholderData:a,isError:u,isLoadingError:p,isRefetchError:Q,isStale:l,error:v,data:d,refetch:w}){return{isPending:r,isSuccess:s,isError:u,isLoadingError:p,isRefetchError:Q,isLoading:i,isFetching:e,isRefetching:t,isPlaceholderData:a,isStale:l,error:v??void 0,data:d,refetch:m(this,g,M).call(this,w)}},F=function(r,e){const i=e(n(this,b)),t=async(s,a)=>(o(this,h,a?.signal),await i(s));return t.key=r,t};function O(r){return Object.freeze(new E(r))}exports.ApiClient=E,exports.createApiClient=O;

package/cjs/api/api-context.cjs

@@ -1,2 +0,0 @@
-"use strict";
-"use strict";var l=require("@vef-framework/shared"),t=require("react");const A=t.createContext(null),g=({client:e,dataDictionaryApi:n,loginApi:u,logoutApi:a,fetchAuthenticatedUserApi:s,children:p})=>{const o=t.useMemo(()=>{const c=e.createQueryApi("_vefStubQueryApi",()=>i=>Promise.resolve({code:0,message:"ok",data:i})),d=e.createQueryApi("_vefAsyncFnQueryApi",()=>async({args:i,fn:r})=>({code:0,message:"ok",data:await r(...i)})),Q=e.createMutationApi("_vefStubMutationApi",()=>i=>Promise.resolve({code:0,message:"ok",data:i})),y=e.createMutationApi("_vefAsyncFnMutationApi",()=>async({args:i,fn:r})=>({code:0,message:"ok",data:await r(...i)}));return Object.freeze({useApiQuery:e.useApiQuery,useSuspenseApiQuery:e.useSuspenseApiQuery,useApiMutation:e.useApiMutation,useIsFetching:e.useIsFetching,useIsMutating:e.useIsMutating,fetchApiQuery:e.fetchApiQuery.bind(e),createQueryApi:e.createQueryApi.bind(e),createMutationApi:e.createMutationApi.bind(e),getApiQueryData:e.getApiQueryData.bind(e),getApiQueriesData:e.getApiQueriesData.bind(e),setApiQueryData:e.setApiQueryData.bind(e),ensureApiQueryData:e.ensureApiQueryData.bind(e),removeApiQueries:e.removeApiQueries.bind(e),invalidateApiQueries:e.invalidateApiQueries.bind(e),resetApiQueries:e.resetApiQueries.bind(e),refetchApiQueries:e.refetchApiQueries.bind(e),cancelApiQueries:e.cancelApiQueries.bind(e),isFetching:e.isFetching.bind(e),isMutating:e.isMutating.bind(e),stubQueryApi:c,asyncFnQueryApi:d,stubMutationApi:Q,asyncFnMutationApi:y,dataDictionaryApi:n,loginApi:u,logoutApi:a,fetchAuthenticatedUserApi:s})},[e,n,u,a,s]);return t.createElement(A.Provider,{value:o},t.createElement(e.QueryClientProvider,{},p))};function b(){const e=t.useContext(A);if(e===null)throw new l.VefError(-1,"Api context not found: Please ensure useApiContext is called within an ApiContextProvider");return e}exports.ApiContextProvider=g,exports.useApiContext=b;

package/cjs/api/index.cjs

@@ -1,2 +0,0 @@
-"use strict";
-"use strict";var e=require("./api-client.cjs"),r=require("./api-context.cjs"),t=require("@tanstack/react-query");exports.ApiClient=e.ApiClient,exports.createApiClient=e.createApiClient,exports.ApiContextProvider=r.ApiContextProvider,exports.useApiContext=r.useApiContext,Object.defineProperty(exports,"useQueryErrorResetBoundary",{enumerable:!0,get:function(){return t.useQueryErrorResetBoundary}});

package/cjs/api/query-client.cjs

@@ -1,2 +0,0 @@
-"use strict";
-"use strict";var n=require("@tanstack/react-query");function c(e){const r=e?.staleTime??1/0,t=e?.gcTime??10*60*1e3;return new n.QueryClient({defaultOptions:{queries:{networkMode:"always",staleTime:r,gcTime:t,retry:!1,structuralSharing:!0,throwOnError:!1,refetchOnMount:!1,refetchOnReconnect:!0,refetchOnWindowFocus:!0},mutations:{networkMode:"always",gcTime:r,retry:!1,throwOnError:!1}}})}exports.createQueryClient=c;