@vef-framework-react/core 2.1.0

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-react/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-react/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/src/store/unbound.d.ts

@@ -0,0 +1,26 @@
+import { ComponentType } from 'react';
+import { StateCreator } from 'zustand';
+import { StoreProviderProps, UnboundStore } from './types';
+/**
+ * Hook signature for accessing store state with optional selector
+ */
+export interface UseStore<in out TState> {
+    (): TState;
+    <TSelected>(selector: (state: TState) => TSelected): NoInfer<TSelected>;
+}
+/**
+ * Result type returned by createComponentStore
+ */
+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-scoped store with React Context
+ *
+ * @param name - The name of the store (used for context display name and error messages)
+ * @param initializer - The Zustand state initializer function
+ * @returns Object containing StoreProvider, useStoreApi, and useStore
+ */
+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/src/store/use-deep.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a memoized selector that uses deep equality comparison.
+ * Returns the previous value if deeply equal to prevent unnecessary re-renders.
+ *
+ * @param selector - The selector function to memoize
+ * @returns A memoized selector function
+ */
+export declare function useDeep<TState, TSelected>(selector: (state: TState) => TSelected): (state: TState) => TSelected;

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@vef-framework-react/core",
+  "type": "module",
+  "version": "2.1.0",
+  "private": false,
+  "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",
+    "framework",
+    "react",
+    "core"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "vef": "./src/index.ts",
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/es/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "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": ">=19"
+  },
+  "dependencies": {
+    "@dnd-kit/abstract": "^0.3.2",
+    "@dnd-kit/dom": "^0.3.2",
+    "@dnd-kit/helpers": "^0.3.2",
+    "@dnd-kit/react": "^0.3.2",
+    "@emotion/react": "^11.14.0",
+    "@hello-pangea/dnd": "^18.0.1",
+    "@microsoft/fetch-event-source": "^2.0.1",
+    "@tanstack/react-query": "^5.95.2",
+    "@xstate/react": "^6.1.0",
+    "ai": "6.0.138",
+    "axios": "^1.13.6",
+    "clsx": "^2.1.1",
+    "immer": "^11.1.4",
+    "jotai": "^2.19.0",
+    "motion": "^12.38.0",
+    "use-immer": "^0.11.0",
+    "xstate": "^5.29.0",
+    "zustand": "^5.0.12",
+    "@vef-framework-react/shared": "2.1.0"
+  },
+  "devDependencies": {
+    "react": "^19.2.4"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
+    "build": "vite build"
+  }
+}