@vef-framework/starter 2.0.10 → 2.1.0

package/dist/types/src/components/pro-table/props.d.ts

@@ -0,0 +1,127 @@
+import { TableColumn, TableProps } from '@vef-framework/components';
+import { PaginationResult, QueryFunction } from '@vef-framework/core';
+import { AnyObject, DeepKeys, Key } from '@vef-framework/shared';
+import { CSSProperties, ReactNode } from 'react';
+import { ColumnSettingsProp, OperationColumnConfig, ParamsWithPagination, ParamsWithSort, RowSelectionConfig } from './types';
+/**
+ * Base props for ProTable component
+ *
+ * @template TRow - The type of table row data
+ * @template TParams - The type of query parameters
+ */
+interface BaseProTableProps<TRow extends AnyObject, TParams extends AnyObject> extends Pick<TableProps<TRow>, "size"> {
+    /**
+     * Class name for the table container
+     */
+    className?: string;
+    /**
+     * Inline styles for the table container
+     */
+    style?: CSSProperties;
+    /**
+     * Table column definitions
+     */
+    columns: Array<TableColumn<NoInfer<TRow>>>;
+    /**
+     * Column settings configuration.
+     * - `false`: Disable column settings feature
+     * - `{ storageKey?: string }`: Enable with optional localStorage persistence
+     *
+     * @default {}
+     */
+    columnSettings?: ColumnSettingsProp;
+    /**
+     * Whether to show the sequence (row number) column. Default is true.
+     */
+    showSequenceColumn?: boolean;
+    /**
+     * Row key extractor: either a deep key of the row model or a function
+     */
+    rowKey?: DeepKeys<NoInfer<TRow>> | ((row: NoInfer<TRow>) => Key);
+    /**
+     * Enable virtual scrolling for the table to improve performance with large datasets
+     *
+     * @default false
+     */
+    virtual?: boolean;
+    /**
+     * Currently selected row keys
+     */
+    selectedRowKeys?: Key[];
+    /**
+     * Operation column configuration for per-row actions
+     */
+    operationColumn?: OperationColumnConfig<NoInfer<TRow>>;
+    /**
+     * Row selection configuration
+     * - `true`: Enable row selection with default configuration
+     * - `RowSelectionConfig<TRow>`: Enable row selection with custom configuration
+     * - `undefined`: Disable row selection (default)
+     */
+    rowSelection?: RowSelectionConfig<NoInfer<TRow>> | true;
+    /**
+     * Function to determine whether the query should be enabled
+     */
+    queryEnabled?: (params?: TParams) => boolean;
+    /**
+     * Query parameters that trigger re-fetching when changed.
+     */
+    queryParams?: TParams;
+    /**
+     * Custom header content to be rendered above the title
+     */
+    header?: ReactNode;
+    /**
+     * Title to be displayed above the table
+     */
+    title?: ReactNode;
+    /**
+     * Summary information to be displayed below the table
+     */
+    summary?: ReactNode;
+    /**
+     * Custom footer content to be rendered below the summary
+     */
+    footer?: ReactNode;
+    /**
+     * Callback when selected row keys change
+     */
+    onSelectedRowKeysChange?: (keys: Key[], rows: TRow[]) => void;
+}
+/**
+ * Props for paginated ProTable
+ *
+ * @template TRow - The type of table row data
+ * @template TParams - The type of query parameters
+ */
+export interface PaginatedProTableProps<TRow extends AnyObject, TParams extends AnyObject> extends BaseProTableProps<TRow, TParams> {
+    /**
+     * Enable pagination mode. Default is true.
+     */
+    isPaginated?: true;
+    /**
+     * Query function for fetching paginated data
+     */
+    queryFn: QueryFunction<PaginationResult<TRow>, ParamsWithSort<ParamsWithPagination<TParams>>>;
+}
+/**
+ * Props for non-paginated ProTable
+ *
+ * @template TRow - The type of table row data
+ * @template TParams - The type of query parameters
+ */
+export interface NonPaginatedProTableProps<TRow extends AnyObject, TParams extends AnyObject> extends BaseProTableProps<TRow, TParams> {
+    /**
+     * Disable pagination mode for this variant
+     */
+    isPaginated: false;
+    /**
+     * Query function for fetching the full list data
+     */
+    queryFn: QueryFunction<TRow[], ParamsWithSort<TParams>>;
+}
+/**
+ * Discriminated union of paginated and non-paginated ProTable props
+ */
+export type ProTableProps<TRow extends AnyObject, TParams extends AnyObject> = PaginatedProTableProps<TRow, TParams> | NonPaginatedProTableProps<TRow, TParams>;
+export {};

package/dist/types/src/components/pro-table/store.d.ts

@@ -0,0 +1,105 @@
+import { TableColumn } from '@vef-framework/components';
+import { DragDropEvents, PaginationParams, StoreProviderProps, UseStore, UnboundStore } from '@vef-framework/core';
+import { EventEmitter, Key } from '@vef-framework/shared';
+import { ReactNode, ComponentType } from 'react';
+import { OrderSpec } from '../../types';
+import { ProTableEvents } from './event';
+/**
+ * Column setting configuration
+ */
+export interface ColumnSetting {
+    /**
+     * Column unique identifier
+     */
+    id: Key;
+    /**
+     * Column display title
+     */
+    title: ReactNode;
+    /**
+     * Column fixed position
+     */
+    fixed?: "start" | "end" | false;
+    /**
+     * Column width in pixels
+     */
+    width?: number;
+    /**
+     * Whether the column is visible
+     */
+    visible: boolean;
+    /**
+     * Original column index for reference
+     */
+    originalIndex: number;
+}
+/**
+ * State for the ProTable component
+ */
+export interface ProTableState {
+    /**
+     * Internal event bus used for cross-part communication within ProTable.
+     */
+    eventEmitter: EventEmitter<ProTableEvents>;
+    /**
+     * Current pagination parameters
+     */
+    paginationParams: PaginationParams;
+    /**
+     * Update pagination parameters
+     */
+    setPaginationParams: (params: PaginationParams) => void;
+    /**
+     * Current sort order specifications
+     */
+    sort: OrderSpec[];
+    /**
+     * Update sort order specifications
+     */
+    setSort: (sort: OrderSpec[]) => void;
+    /**
+     * Refetch data with current query params, current pagination and sort parameters
+     */
+    refetch: () => void;
+    /**
+     * Column settings state for customization
+     */
+    columnSettings: ColumnSetting[];
+    /**
+     * Original column settings for reset functionality
+     */
+    originalColumnSettings: ColumnSetting[];
+    /**
+     * Initialize column settings from columns prop
+     */
+    initColumnSettings: (columns: TableColumn[]) => void;
+    /**
+     * Set column settings directly
+     */
+    setColumnSettings: (settings: ColumnSetting[]) => void;
+    /**
+     * Reorder columns by drag event
+     */
+    reorderColumns: (event: Parameters<DragDropEvents["dragend"]>[0]) => void;
+    /**
+     * Toggle column fixed state
+     */
+    setColumnFixed: (id: Key, fixed: "start" | "end" | false) => void;
+    /**
+     * Update column width
+     */
+    setColumnWidth: (id: Key, width: number) => void;
+    /**
+     * Toggle column visibility
+     */
+    setColumnVisible: (id: Key, visible: boolean) => void;
+    /**
+     * Reset column settings to original state
+     *
+     * @param clearStorage - Optional callback to clear localStorage
+     */
+    resetColumnSettings: (clearStorage?: () => void) => void;
+}
+export declare function getColumnId(column: TableColumn, index: number): string;
+export declare function createColumnSetting(column: TableColumn, index: number): ColumnSetting;
+export declare const ProTableStoreProvider: ComponentType<StoreProviderProps<never>>, useProTableStore: UseStore<ProTableState>, useProTableStoreApi: <TStrictState extends ProTableState = ProTableState>() => UnboundStore<TStrictState>;

package/dist/types/src/components/pro-table/types.d.ts

@@ -0,0 +1,103 @@
+import { Length } from '@vef-framework/components';
+import { PaginationParams } from '@vef-framework/core';
+import { Key } from '@vef-framework/shared';
+import { ReactNode } from 'react';
+import { SYMBOL_PAGINATION, SYMBOL_SORT } from '../../constants';
+import { OrderSpec } from '../../types';
+/**
+ * Configuration for column settings feature
+ */
+export interface ColumnSettingsConfig {
+    /**
+     * Storage key for persisting column settings to localStorage.
+     * If provided, settings will be saved with key: `__VEF_PRO_TABLE_COLUMN_SETTINGS__${storageKey}`
+     * If not provided, settings will not be persisted.
+     */
+    storageKey?: string;
+}
+/**
+ * Column settings prop type.
+ * - `false`: Disable column settings feature, hide settings icon
+ * - `ColumnSettingsConfig`: Enable column settings with optional persistence
+ */
+export type ColumnSettingsProp = false | ColumnSettingsConfig;
+/**
+ * Imperative handle for ProTable component.
+ * Exposed via ref to allow parent components to programmatically control the table.
+ */
+export interface ProTableRef {
+    /**
+     * Manually trigger a data refetch.
+     * Useful when you need to refresh the table data after external changes.
+     */
+    refetch: () => void;
+    /**
+     * Register a callback to be invoked when table starts loading data
+     */
+    onLoading: (callback: () => void) => () => void;
+    /**
+     * Register a callback to be invoked when table finishes loading data
+     */
+    onLoaded: (callback: () => void) => () => void;
+}
+/**
+ * Represents request parameters enhanced with pagination metadata.
+ */
+export type ParamsWithPagination<TParams> = TParams & {
+    [SYMBOL_PAGINATION]?: PaginationParams;
+};
+/**
+ * Represents request parameters enhanced with sort metadata.
+ */
+export type ParamsWithSort<TParams> = TParams & {
+    [SYMBOL_SORT]?: OrderSpec[];
+};
+/**
+ * Configuration for the operation column which renders per-row actions
+ */
+export interface OperationColumnConfig<TRow> {
+    /**
+     * Column width. Accepts any valid `Length` value.
+     */
+    width?: Length;
+    /**
+     * Column header title. Can be plain text or a React node.
+     */
+    title?: ReactNode;
+    /**
+     * Permission tokens required to display the operation content.
+     * Use this to conditionally hide actions based on authorization.
+     */
+    permTokens?: string[];
+    /**
+     * Render function for the operation cell of a row.
+     * Receives the current row data and its index, and should return a React node
+     * that contains operation elements (e.g., buttons, menus).
+     */
+    render: (row: TRow, index: number) => ReactNode;
+}
+/**
+ * The configuration for the row selection of the table.
+ */
+export interface RowSelectionConfig<TRow> {
+    /**
+     * If set, row selection will be disabled for the row with the function returns true
+     */
+    rowSelectDisabled?: (model: TRow) => boolean;
+    /**
+     * Keep the selection keys in list even the key not exist in `dataSource` anymore
+     */
+    checkStrictly?: boolean;
+    /**
+     * Whether hide select all checkbox
+     */
+    hideSelectAll?: boolean;
+    /**
+     * Keep the selection keys in list even the key not exist in `dataSource` anymore
+     */
+    preserveSelectedRowKeys?: boolean;
+    /**
+     * The default selected row keys
+     */
+    defaultSelectedRowKeys?: Key[];
+}

package/dist/types/src/components/router-provider/context.d.ts

@@ -0,0 +1,7 @@
+import { AnyRouter, RegisteredRouter, RouterProps } from '@tanstack/react-router';
+import { MaybeNull } from '@vef-framework/shared';
+import { Provider } from 'react';
+export type RouterContext<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> = NonNullable<RouterProps<TRouter, TDehydrated>["context"]>;
+export type UseRouterContext<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> = () => RouterContext<TRouter, TDehydrated>;
+export declare function useRouterContextHook(): MaybeNull<UseRouterContext>;
+export declare const RouterContextHookProvider: Provider<MaybeNull<UseRouterContext<AnyRouter, Record<string, any>>>>;

package/dist/types/src/components/router-provider/index.d.ts

@@ -0,0 +1,5 @@
+import { AnyRouter, RegisteredRouter } from '@tanstack/react-router';
+import { RouterProviderProps } from './props';
+export declare function RouterProvider<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>>({ router }: RouterProviderProps<TRouter, TDehydrated>): React.ReactNode;
+export { RouterContextHookProvider, type RouterContext, type UseRouterContext } from './context';
+export { type RouterProviderProps } from './props';

package/dist/types/src/components/router-provider/props.d.ts

@@ -0,0 +1,7 @@
+import { AnyRouter, RegisteredRouter } from '@tanstack/react-router';
+import { AppProps } from '../app';
+/**
+ * The props for the RouterProvider component.
+ */
+export interface RouterProviderProps<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> extends Pick<AppProps<TRouter, TDehydrated>, "router"> {
+}

package/dist/types/src/components/theme-config-provider/global-style.d.ts

@@ -0,0 +1,2 @@
+import { SerializedStyles } from '@emotion/serialize';
+export declare const globalStyle: SerializedStyles;

package/dist/types/src/components/theme-config-provider/index.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from 'react';
+export declare function ThemeConfigProvider({ children }: PropsWithChildren): React.JSX.Element;

package/dist/types/src/components/theme-config-provider/use-color-mode-effect.d.ts

@@ -0,0 +1 @@
+export declare function useColorModeEffect(): void;

package/dist/types/src/components/theme-config-provider/use-theme-config.d.ts

@@ -0,0 +1,2 @@
+import { ThemeConfig } from '@vef-framework/components';
+export declare function useThemeConfig(): ThemeConfig;

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

@@ -0,0 +1,3 @@
+export declare const RELOAD_PAGE_EVENT = "__vef_reload_page_event";
+export declare const ACCESS_DENIED_EVENT = "__vef_access_denied_event";
+export declare const UNAUTHENTICATED_EVENT = "__vef_unauthenticated_event";

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

@@ -0,0 +1,4 @@
+export { ACCESS_DENIED_EVENT, RELOAD_PAGE_EVENT, UNAUTHENTICATED_EVENT } from './event';
+export { ACCESS_DENIED_ROUTE_ID, ACCESS_DENIED_ROUTE_PATH, INDEX_ROUTE_ID, INDEX_ROUTE_PATH, LOGIN_ROUTE_ID, LOGIN_ROUTE_PATH } from './router';
+export { STORAGE_KEY_PREFIX_STORE, STORAGE_KEY_SUFFIX_STORE } from './storage';
+export { SYMBOL_PAGINATION, SYMBOL_SORT } from './symbols';

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

@@ -0,0 +1,6 @@
+export declare const LOGIN_ROUTE_PATH = "/login";
+export declare const LOGIN_ROUTE_ID = "/_common/login";
+export declare const INDEX_ROUTE_PATH = "/";
+export declare const INDEX_ROUTE_ID = "/_layout";
+export declare const ACCESS_DENIED_ROUTE_PATH = "/access-denied";
+export declare const ACCESS_DENIED_ROUTE_ID = "/_common/access-denied";

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

@@ -0,0 +1,2 @@
+export declare const STORAGE_KEY_PREFIX_STORE = "__VEF_STORE__";
+export declare const STORAGE_KEY_SUFFIX_STORE = "__";

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

@@ -0,0 +1,2 @@
+export declare const SYMBOL_PAGINATION: unique symbol;
+export declare const SYMBOL_SORT: unique symbol;

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

@@ -0,0 +1,6 @@
+import { HttpClientOptions, QueryClientOptions, ApiClient } from '@vef-framework/core';
+export interface ApiClientOptions {
+    http: Pick<HttpClientOptions, "baseUrl" | "timeout" | "okCode" | "tokenExpiredCode" | "refreshToken">;
+    query?: Pick<QueryClientOptions, "gcTime" | "staleTime">;
+}
+export declare function createApiClient({ http, query }: ApiClientOptions): ApiClient;

package/dist/types/src/helpers/app-version.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+export interface AppChangelog {
+    version: string;
+    date?: string;
+    description?: string;
+    changes?: string[];
+}
+export interface AppVersionNotificationOptions {
+    enabled?: boolean;
+    basePath?: string;
+    checkInterval?: number;
+    title?: ReactNode;
+    description?: ReactNode;
+    confirmText?: ReactNode;
+    cancelText?: ReactNode;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+}
+export declare function setupAppVersionNotification(options?: AppVersionNotificationOptions): (() => void) | undefined;

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

@@ -0,0 +1,11 @@
+import { AnyRouter, RegisteredRouter } from '@tanstack/react-router';
+import { AppProps, UseRouterContext } from '../components';
+export interface AppOptions<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, unknown> = Record<string, unknown>> {
+    strictMode?: boolean;
+    useRouterContext?: UseRouterContext<TRouter, TDehydrated>;
+}
+export interface AppInstance {
+    render: (props: AppProps) => void;
+    unmount: () => void;
+}
+export declare function createApp<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, unknown> = Record<string, unknown>>({ strictMode, useRouterContext }?: AppOptions<TRouter, TDehydrated>): AppInstance;

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

@@ -0,0 +1,2 @@
+import { AnyRouter } from '@tanstack/react-router';
+export declare function handleClientLogout(router: AnyRouter): Promise<void>;

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

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@vef-framework/shared';
+export declare const eventEmitter: EventEmitter<{
+    __vef_reload_page_event: string;
+    __vef_access_denied_event: void;
+    __vef_unauthenticated_event: void;
+}>;
+export declare function dispatchCustomEvent<T = unknown>(type: string, options?: CustomEventInit<T>): boolean;
+export declare function reloadPage(key: string): void;
+export declare function emitAccessDenied(): void;
+export declare function emitUnauthenticated(): void;

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

@@ -0,0 +1,7 @@
+export { createApiClient, type ApiClientOptions } from './api';
+export { createApp } from './app';
+export { setupAppVersionNotification, type AppChangelog, type AppVersionNotificationOptions } from './app-version';
+export { handleClientLogout } from './auth';
+export { dispatchCustomEvent, eventEmitter, reloadPage } from './event';
+export { extractQueryParams, noopMutationFn } from './query';
+export { createRouter, type RouterOptions } from './router';

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

@@ -0,0 +1,13 @@
+import { PaginationParams } from '@vef-framework/core';
+import { AnyObject, MaybeUndefined } from '@vef-framework/shared';
+import { OrderSpec } from '../types';
+import { SYMBOL_PAGINATION, SYMBOL_SORT } from '../constants';
+export declare function noopMutationFn<TResult = unknown, TArgs extends unknown[] = unknown[]>(..._args: TArgs): Promise<TResult>;
+export declare namespace noopMutationFn {
+    var key: string;
+}
+export declare function extractQueryParams<TParams extends AnyObject>(queryParams: TParams): {
+    params: Omit<TParams, typeof SYMBOL_PAGINATION | typeof SYMBOL_SORT>;
+    pagination: MaybeUndefined<PaginationParams>;
+    sort: MaybeUndefined<OrderSpec[]>;
+};

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

@@ -0,0 +1,10 @@
+import { AnyRouteWithContext } from '@tanstack/react-router';
+import { RouterContext } from '../types';
+import { RouterCore } from '@tanstack/router-core';
+import { RouterHistory } from '@tanstack/history';
+export interface RouterOptions {
+    history: "hash" | "browser";
+    routeTree: AnyRouteWithContext<RouterContext>;
+    context: RouterContext;
+}
+export declare function createRouter({ history, routeTree, context }: RouterOptions): RouterCore<AnyRouteWithContext<RouterContext>, "never", true, RouterHistory, Record<string, any>>;

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

@@ -0,0 +1 @@
+export { useRouteFullPath } from './use-route-full-path';

package/dist/types/src/hooks/use-route-full-path.d.ts

@@ -0,0 +1 @@
+export declare function useRouteFullPath(): string;

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

@@ -0,0 +1,6 @@
+export { createCrudKit, Crud, CrudPage, FlexCard, FormDrawer, FormModal, OperationButtonGroup, Page, ProSearch, ProTable, ProTableSubscriber, useViewportHeight, type CrudActionButtonGroupProps, type CrudBasicFormScene, type CrudBasicSceneFormValues, type CrudFormMutationFns, type CrudFormScene, type CrudKit, type CrudOperationButtonGroupProps, type CrudPageProps, type CrudProps, type FlexCardProps, type FormDrawerProps, type FormModalProps, type LoginParams, type LoginResult, type OperationButtonGroupProps, type OperationColumnConfig, type PageProps, type PaginatedQueryParams, type ParamsWithPagination, type ParamsWithSort, type ProSearchProps, type ProTableProps, type ProTableRef, type ProTableState, type ProTableSubscriberProps, type QueryParams, type RowSelectionConfig } from './components';
+export * from './constants';
+export * from './helpers';
+export * from './routes';
+export * from './stores';
+export type * from './types';

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

@@ -0,0 +1 @@
+export type { AuthTokens } from '@vef-framework/core';

package/dist/types/src/routes/access-denied.d.ts

@@ -0,0 +1,11 @@
+import { AnyRouter, ParsedLocation } from '@tanstack/react-router';
+import { AccessDenied } from '../components';
+export declare function createAccessDeniedRouteOptions(): {
+    readonly component: typeof AccessDenied;
+    readonly beforeLoad: ({ location, context: { router } }: {
+        location: ParsedLocation;
+        context: {
+            router: AnyRouter;
+        };
+    }) => void;
+};

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

@@ -0,0 +1,4 @@
+export { createAccessDeniedRouteOptions } from './access-denied';
+export { createLayoutRouteOptions } from './layout';
+export { createLoginRouteOptions } from './login';
+export { createRootRouteOptions } from './root';

package/dist/types/src/routes/layout.d.ts

@@ -0,0 +1,22 @@
+import { ParsedLocation } from '@tanstack/react-router';
+import { Awaitable, Except } from '@vef-framework/shared';
+import { LayoutProps, Error, NotFound } from '../components';
+import { UserInfo } from '../types';
+interface LayoutRouteOptions extends Except<LayoutProps, "children"> {
+    fetchUserInfo: () => Awaitable<UserInfo>;
+}
+export declare function createLayoutRouteOptions({ fetchUserInfo, ...layoutProps }: LayoutRouteOptions): {
+    readonly beforeLoad: ({ location }: {
+        location: ParsedLocation;
+    }) => void;
+    readonly loader: ({ location }: {
+        location: ParsedLocation;
+    }) => Promise<void>;
+    readonly pendingComponent: () => import("@emotion/react/jsx-runtime").JSX.Element;
+    readonly errorComponent: typeof Error;
+    readonly notFoundComponent: typeof NotFound;
+    readonly component: () => import("@emotion/react/jsx-runtime").JSX.Element;
+    readonly staleTime: number;
+    readonly shouldReload: false;
+};
+export {};

package/dist/types/src/routes/login.d.ts

@@ -0,0 +1,13 @@
+import { LoginProps } from '../components';
+import { z } from '@vef-framework/shared';
+export declare function createLoginRouteOptions(props: LoginProps): {
+    readonly validateSearch: z.ZodObject<{
+        redirect: z.ZodCatch<z.ZodDefault<z.ZodOptional<z.ZodString>>>;
+    }, z.core.$strip>;
+    readonly beforeLoad: ({ search }: {
+        search: {
+            redirect: string;
+        };
+    }) => void;
+    readonly component: () => import("@emotion/react/jsx-runtime").JSX.Element;
+};

package/dist/types/src/routes/root.d.ts

@@ -0,0 +1,8 @@
+interface RootProps {
+    appTitle: string;
+}
+export declare function createRootRouteOptions({ appTitle }: RootProps): {
+    readonly component: () => import("@emotion/react/jsx-runtime").JSX.Element;
+    readonly ssr: false;
+};
+export {};

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

@@ -0,0 +1,14 @@
+import { MenuItem } from '@vef-framework/components';
+import { AuthTokens, UseBoundStoreWithPersist } from '@vef-framework/core';
+import { Except } from '@vef-framework/shared';
+import { UserInfo, UserMenu } from '../types';
+export interface AppState {
+    isAuthenticated: boolean;
+    authTokens?: Readonly<AuthTokens>;
+    userInfo?: Readonly<Except<UserInfo, "permTokens">>;
+    userMenuMap?: Readonly<Map<string, Readonly<UserMenu>>>;
+    menuPathMap?: Readonly<Map<string, readonly string[]>>;
+    menuItems?: ReadonlyArray<Readonly<MenuItem>>;
+    permTokens?: Readonly<Set<string>>;
+}
+export declare const useAppStore: UseBoundStoreWithPersist<AppState>;

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

@@ -0,0 +1,6 @@
+export { useAppStore } from './app';
+export type { AppState } from './app';
+export { useTabStore } from './tab';
+export type { Tab, TabState } from './tab';
+export { useThemeStore } from './theme';
+export type { ColorScheme, ThemeColors, ThemeState } from './theme';

package/dist/types/src/stores/tab.d.ts

@@ -0,0 +1,22 @@
+import { AnyObject } from '@vef-framework/shared';
+import { UseBoundStoreWithPersist } from '@vef-framework/core';
+export interface Tab {
+    id: string;
+    fullPath: string;
+    params: AnyObject;
+    search: AnyObject;
+    label: string;
+}
+export interface TabState {
+    activeTabId?: string;
+    tabs: Tab[];
+    setActiveTabId: (id: string) => void;
+    setTabs: (tabs: Tab[]) => void;
+    addTab: (tab: Tab) => void;
+    removeTab: (id: string, navigate: (tab?: Tab) => void) => void;
+    removeAllTabs: (navigate: (tab?: Tab) => void) => void;
+    removeAllTabsExcept: (id: string, navigate: (tab?: Tab) => void) => void;
+    removeLeftTabs: (id: string, navigate: (tab?: Tab) => void) => void;
+    removeRightTabs: (id: string, navigate: (tab?: Tab) => void) => void;
+}
+export declare const useTabStore: UseBoundStoreWithPersist<TabState>;

package/dist/types/src/stores/theme.d.ts

@@ -0,0 +1,16 @@
+import { Orientation, SemanticColor } from '@vef-framework/components';
+import { UseBoundStoreWithPersist } from '@vef-framework/core';
+export type ColorScheme = "system" | "light" | "dark";
+export type ThemeColors = Record<SemanticColor, string>;
+export interface ThemeState {
+    isThemeConfigVisible: boolean;
+    colorScheme: ColorScheme;
+    colors: ThemeColors;
+    isGrayscaleMode: boolean;
+    isColorBlindMode: boolean;
+    isMenuAccordionMode: boolean;
+    menuLayout: Orientation;
+    isSidebarCollapsed: boolean;
+    isMainContentMaximum: boolean;
+}
+export declare const useThemeStore: UseBoundStoreWithPersist<ThemeState>;