react-toolkits 2.22.8 → 2.22.9

package/lib/components.d.ts

@@ -0,0 +1,530 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { DrawerProps, Button, FormProps, FormInstance, MenuProps, SelectProps, ModalProps, ButtonProps } from 'antd';
+import * as react from 'react';
+import { ReactNode, ComponentProps, FC, PropsWithChildren, Key, ReactElement, Ref, DetailedHTMLProps, ImgHTMLAttributes, ComponentType } from 'react';
+import { AnyObject } from 'antd/es/_util/type';
+import { RecursivePartial } from './types.js';
+import * as zustand from 'zustand';
+import { ParagraphProps } from 'antd/es/typography/Paragraph';
+import { TableProps } from 'antd/es/table';
+import { ItemType, SubMenuType, MenuItemGroupType, MenuItemType } from 'antd/es/menu/interface';
+import { Merge } from 'ts-essentials';
+import { G as Game } from './types-DVKf5poe.js';
+import { Options } from 'ky';
+import { PermissionVersion } from './constants.js';
+
+interface UseDrawerOperation {
+    hide: () => void;
+}
+interface UseDrawerProps extends Omit<DrawerProps, 'open' | 'confirmLoading' | 'onClose' | 'footer'> {
+    content?: ReactNode | ((operation: UseDrawerOperation) => ReactNode);
+    onConfirm?: () => void | Promise<void>;
+    afterOpen?: () => void | Promise<void>;
+    afterClose?: () => void | Promise<void>;
+    footer?: ReactNode | null;
+    confirmText?: string;
+    cancelText?: string;
+    confirmButtonProps?: ComponentProps<typeof Button>;
+    cancelButtonProps?: ComponentProps<typeof Button>;
+}
+declare function useDrawer(props: UseDrawerProps): {
+    id: number;
+    show: () => Promise<void>;
+    hide: () => void;
+    confirmLoading: boolean;
+    drawer: react_jsx_runtime.JSX.Element;
+};
+
+interface UseFormDrawerProps<Values extends AnyObject = AnyObject, ExtraValues = any> extends Omit<UseDrawerProps, 'onConfirm' | 'content' | 'onShow' | 'afterClose'> {
+    formProps?: Omit<FormProps, 'form'>;
+    form?: FormInstance<Values>;
+    content?: ReactNode | ((extraValues: ExtraValues, operation: UseDrawerOperation) => ReactNode);
+    onConfirm?: (values: Values, extraValues: ExtraValues) => void | Promise<void>;
+    onSuccess?: () => void;
+    afterClose?: (form: FormInstance<Values>) => void;
+}
+declare function useFormDrawer<Values extends AnyObject = AnyObject, ExtraValues = any>(props: UseFormDrawerProps<Values, ExtraValues>): {
+    id: number;
+    show: (options?: {
+        initialValues?: RecursivePartial<Values>;
+        extraValues?: ExtraValues;
+    }) => void;
+    hide: () => void;
+    drawer: react_jsx_runtime.JSX.Element;
+};
+
+interface DrawerState {
+    open: Map<number, boolean>;
+    usedIds: Set<number>;
+    isOpen: (uuid: number) => boolean;
+    show: (uuid: number) => void;
+    hide: (uuid: number) => void;
+    hideAll: () => void;
+    checkUniqueness: (uuid: number) => boolean;
+    registerIds: (uuid: number) => boolean;
+    cleanup: (uuid: number) => void;
+}
+declare const useDrawerStore: zustand.UseBoundStore<zustand.StoreApi<DrawerState>>;
+
+interface DynamicTagsProps {
+    initialTags?: string[];
+    addable?: boolean;
+    removable?: boolean;
+    addCallback?: (addedTag: string) => Promise<boolean>;
+    removeCallback?: (removedTag: string) => Promise<boolean>;
+}
+declare const DynamicTags: FC<DynamicTagsProps>;
+
+type ExpandableParagraphProps = Omit<ParagraphProps, 'ellipsis' | 'className'>;
+declare const ExpandableParagraph: FC<ExpandableParagraphProps>;
+
+interface FilterFormWrapperProps extends PropsWithChildren {
+    onConfirm?: () => void | Promise<void>;
+    onReset?: () => void;
+    extras?: {
+        key: Key;
+        children: ReactNode;
+    }[];
+    isConfirming?: boolean;
+    buttonsAlign?: 'left' | 'right' | 'bottom';
+    showReset?: boolean;
+}
+declare const FilterFormWrapper: (props: FilterFormWrapperProps) => react_jsx_runtime.JSX.Element;
+
+interface HighlightProps extends PropsWithChildren {
+    texts: Array<string | number>;
+}
+declare const Highlight: (props: HighlightProps) => react_jsx_runtime.JSX.Element;
+
+interface InfiniteListPayload<Values = any> {
+    page?: number;
+    formValue?: Values;
+}
+interface InfiniteListRequestConfig<Values = any> {
+    url: string;
+    method?: 'GET' | 'POST';
+    body?: FormData | Record<string | number, any> | ((payload: InfiniteListPayload<Values>, pageParam: any) => FormData | Record<string | number, any>);
+    params?: Record<string | number, any> | ((payload: InfiniteListPayload<Values>, pageParam: any) => Record<string | number, any>);
+    headers?: Record<string, string> | ((form: FormInstance<Values>) => Record<string, string>);
+    cacheTime?: number;
+    staleTime?: number;
+}
+declare enum InfiniteListAction {
+    Confirm = 0,
+    Reset = 1,
+    LoadMore = 2,
+    Init = 3
+}
+interface InfiniteListDataAdapter<Item = any, Values = any, Data = any> {
+    items?: (data: Data[] | undefined, form: FormInstance<Values>) => Item[] | undefined;
+    hasMore?: (lastPage: Data | undefined, allPages: Data[]) => boolean;
+    nextPageParam?: (lastPage: Data | undefined, allPages: Data[], pageParam: any) => any;
+}
+interface InfiniteListRef<Item = any, Values = any, Data = any> {
+    data: Data[] | undefined;
+    dataSource: Item[] | undefined;
+    form: FormInstance<Values>;
+    refetch: () => void;
+    fetchNextPage: () => void;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+}
+interface InfiniteListProps<Item, Values, Data> extends Pick<TableProps<Item>, 'columns' | 'rowKey' | 'tableLayout' | 'expandable' | 'rowSelection' | 'bordered'>, Pick<FilterFormWrapperProps, 'buttonsAlign' | 'showReset'> {
+    identifier: string;
+    code?: string;
+    form?: FormInstance<Values>;
+    refreshInterval?: number;
+    request: InfiniteListRequestConfig<Values>;
+    tableExtra?: ReactNode | ((form: FormInstance<Values>, data?: Data[]) => ReactNode);
+    renderForm?: (form: FormInstance<Values>) => ReactElement;
+    afterSuccess?: (action: InfiniteListAction, form: FormInstance<Values>, data?: Data[]) => void;
+    afterError?: (error: Error, action: InfiniteListAction, form: FormInstance<Values>) => void;
+    dataAdapter?: InfiniteListDataAdapter<Item, Values, Data>;
+    initialPageParam?: any;
+    footer?: (data: Data[] | undefined) => ReactNode;
+}
+declare const InfiniteList: <Item extends AnyObject = AnyObject, Values extends object | undefined = undefined, Data = any>(props: InfiniteListProps<Item, Values, Data> & {
+    ref?: Ref<InfiniteListRef<Item, Data>>;
+}) => ReactElement;
+
+type InfiniteQueryRefetchFunction = () => void | Promise<unknown>;
+type InfiniteQueryFetchNextPageFunction = () => void | Promise<unknown>;
+interface InfiniteListInstance {
+    id: string;
+    url: string;
+    queryKey: readonly unknown[];
+    payload: InfiniteListPayload;
+    refetch: InfiniteQueryRefetchFunction;
+    fetchNextPage: InfiniteQueryFetchNextPageFunction;
+}
+interface InfiniteListState {
+    instances: Map<string, InfiniteListInstance>;
+    registerInstance(id: string, url: string, queryKey: readonly unknown[], refetch: InfiniteQueryRefetchFunction, fetchNextPage: InfiniteQueryFetchNextPageFunction): void;
+    unregisterInstance(id: string): void;
+    updatePayload(id: string, payload: InfiniteListPayload): void;
+    getPayload(id: string): InfiniteListPayload;
+    refetch(id: string, payload?: InfiniteListPayload): Promise<void>;
+    fetchNextPage(id: string): Promise<void>;
+    getInstance(id: string): InfiniteListInstance | undefined;
+    getAllInstances(): InfiniteListInstance[];
+}
+declare const useInfiniteListStore: zustand.UseBoundStore<Omit<Omit<zustand.StoreApi<InfiniteListState>, "setState"> & {
+    setState(partial: InfiniteListState | Partial<InfiniteListState> | ((state: InfiniteListState) => InfiniteListState | Partial<InfiniteListState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: InfiniteListState | ((state: InfiniteListState) => InfiniteListState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: InfiniteListState, previousSelectedState: InfiniteListState) => void): () => void;
+        <U>(selector: (state: InfiniteListState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+
+type MenuItemType2 = Merge<MenuItemType, {
+    route?: string;
+}>;
+type SubMenuType2 = Merge<SubMenuType, {
+    children?: NavMenuItem[];
+}>;
+type MenuItemGroupType2 = Merge<MenuItemGroupType, {
+    children?: NavMenuItem[];
+}>;
+type NavMenuItem = Exclude<ItemType, SubMenuType | MenuItemGroupType | MenuItemType> | MenuItemType2 | SubMenuType2 | MenuItemGroupType2;
+
+interface NavMenuProps {
+    items?: NavMenuItem[];
+    theme?: MenuProps['theme'];
+    loading?: boolean;
+}
+declare const NavMenu: react.NamedExoticComponent<NavMenuProps>;
+
+interface GameSelectProps {
+    filter?: (game: Game) => boolean;
+    options?: (data?: Game[]) => SelectProps['options'];
+}
+
+type HeaderExtra = {
+    key: Key;
+    children: ReactNode;
+};
+interface LayoutProps extends Pick<GameSelectProps, 'filter'> {
+    collapsible?: boolean;
+    isMenuLoading?: boolean;
+    items?: NavMenuItem[];
+    navWidth?: string | number;
+    gameSelectOptions?: GameSelectProps['options'];
+    headerExtra?: {
+        left?: HeaderExtra[];
+        right?: HeaderExtra[];
+    };
+    title?: string;
+    subtitle?: string;
+}
+declare const Layout: FC<PropsWithChildren<LayoutProps>>;
+
+type LogoProps = Omit<DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, 'src' | 'alt'>;
+declare const Logo: FC<LogoProps>;
+
+interface UseModalOperation {
+    hide: () => void;
+}
+interface UseModalProps extends Omit<ModalProps, 'open' | 'confirmLoading' | 'onOk' | 'onCancel'> {
+    content?: ReactNode | ((operation: UseModalOperation) => ReactNode);
+    onConfirm?: () => void | Promise<void>;
+    afterOpen?: () => void | Promise<void>;
+    afterClose?: () => void | Promise<void>;
+}
+declare function useModal(props: UseModalProps): {
+    id: number;
+    show: () => Promise<void>;
+    hide: () => void;
+    modal: react_jsx_runtime.JSX.Element;
+};
+
+interface UseFormModalProps<Values extends AnyObject = AnyObject, ExtraValues = any> extends Omit<UseModalProps, 'onConfirm' | 'content' | 'onShow' | 'afterClose'> {
+    formProps?: Omit<FormProps, 'form'>;
+    form?: FormInstance<Values>;
+    content?: ReactNode | ((extraValues: ExtraValues, operation: UseModalOperation) => ReactNode);
+    onConfirm?: (values: Values, extraValues: ExtraValues) => void | Promise<void>;
+    onSuccess?: () => void;
+    afterClose?: (form: FormInstance<Values>) => void;
+}
+declare function useFormModal<Values extends AnyObject = AnyObject, ExtraValues = any>(props: UseFormModalProps<Values, ExtraValues>): {
+    id: number;
+    show: (options?: {
+        initialValues?: RecursivePartial<Values>;
+        extraValues?: ExtraValues;
+    }) => void;
+    hide: () => void;
+    modal: react_jsx_runtime.JSX.Element;
+};
+
+interface ModalState {
+    open: Map<number, boolean>;
+    usedIds: Set<number>;
+    isOpen: (uuid: number) => boolean;
+    show: (uuid: number) => void;
+    hide: (uuid: number) => void;
+    hideAll: () => void;
+    checkUniqueness: (uuid: number) => boolean;
+    registerIds: (uuid: number) => boolean;
+    cleanup: (uuid: number) => void;
+}
+declare const useModalStore: zustand.UseBoundStore<zustand.StoreApi<ModalState>>;
+
+interface PermissionButtonProps extends ButtonProps {
+    code?: string | string[];
+    showLoading?: boolean;
+    config?: Options;
+}
+declare const PermissionButton: FC<PropsWithChildren<PermissionButtonProps>>;
+
+interface QueryListPayload<Values = any> {
+    page?: number;
+    size?: number;
+    filters?: Values;
+}
+interface CacheConfig {
+    cacheTime?: number;
+    staleTime?: number;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD';
+interface QueryListRequestConfig extends CacheConfig {
+    url: string;
+    method?: HttpMethod;
+    body?: FormData | Record<string | number, any>;
+    searchParams?: Record<string | number, any>;
+    headers?: Record<string, string>;
+}
+type QueryListRequestConfigType<Values = any> = QueryListRequestConfig | ((payload: QueryListPayload<Values>) => QueryListRequestConfig);
+declare enum QueryListAction {
+    Confirm = 0,
+    Reset = 1,
+    Jump = 2,
+    Init = 3
+}
+interface QueryListRef<Item extends AnyObject = AnyObject, Values = AnyObject, Data = any> {
+    data: Data | undefined;
+    dataSource: Item[] | undefined;
+    form: FormInstance<Values>;
+}
+interface QueryListDataAdapter<Item extends AnyObject = AnyObject> {
+    total?: number;
+    items?: Item[];
+}
+type QueryListDataAdapterConfig<Item extends AnyObject = AnyObject, Data = any> = QueryListDataAdapter<Item> | ((data: Data) => QueryListDataAdapter<Item>);
+interface QueryListProps<Item extends AnyObject = AnyObject, Values = AnyObject, Data = any> extends Omit<TableProps<Item>, 'pagination' | 'dataSource' | 'loading' | 'footer'>, Pick<FilterFormWrapperProps, 'buttonsAlign' | 'showReset'> {
+    identifier?: string;
+    code?: string;
+    form?: FormInstance<Values>;
+    refreshInterval?: number;
+    onePage?: boolean;
+    defaultSize?: number;
+    pageSizeOptions?: number[];
+    request: QueryListRequestConfigType<Values>;
+    tableExtra?: ReactNode | ((form: FormInstance<Values>, data?: Data) => ReactNode);
+    renderForm?: (form: FormInstance<Values>) => ReactElement;
+    afterSuccess?: (action: QueryListAction, form: FormInstance<Values>, data?: Data) => void;
+    afterError?: (error: Error, action: QueryListAction, form: FormInstance<Values>) => void;
+    dataAdapter?: QueryListDataAdapterConfig<Item, Data>;
+    footer?: (data: Data | undefined) => ReactNode;
+}
+declare const QueryList: <Item extends AnyObject = AnyObject, Values extends object | undefined = undefined, Data = any>(props: QueryListProps<Item, Values, Data> & {
+    ref?: Ref<QueryListRef<Item, Values, Data>>;
+}) => ReactElement;
+
+type QueryRefetchFunction = () => void | Promise<unknown>;
+interface QueryListInstance {
+    id: string;
+    url: string;
+    queryKey: readonly unknown[];
+    payload: QueryListPayload;
+    refetch: QueryRefetchFunction;
+}
+interface QueryListState {
+    instances: Map<string, QueryListInstance>;
+    registerInstance(id: string, url: string, queryKey: readonly unknown[], refetch: QueryRefetchFunction): void;
+    unregisterInstance(id: string): void;
+    updatePayload(id: string, payload: QueryListPayload): void;
+    getPayload(id: string): QueryListPayload;
+    refetch(id: string, payload?: QueryListPayload): Promise<void>;
+    getInstance(id: string): QueryListInstance | undefined;
+    getAllInstances(): QueryListInstance[];
+}
+declare const useQueryListStore: zustand.UseBoundStore<Omit<Omit<zustand.StoreApi<QueryListState>, "setState"> & {
+    setState(partial: QueryListState | Partial<QueryListState> | ((state: QueryListState) => QueryListState | Partial<QueryListState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: QueryListState | ((state: QueryListState) => QueryListState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: QueryListState, previousSelectedState: QueryListState) => void): () => void;
+        <U>(selector: (state: QueryListState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+
+declare const RequireGame: FC<PropsWithChildren>;
+
+interface RequirePermissionProps {
+    code: string;
+    config?: Options;
+}
+declare const RequirePermission: FC<PropsWithChildren<RequirePermissionProps>>;
+
+type Locale = {
+    global: {
+        noEntitlement: string;
+        name: string;
+        creationTime: string;
+        operation: string;
+        update: string;
+        edit: string;
+        delete: string;
+        selectAll: string;
+        game: string;
+        user: string;
+        role: string;
+        username: string;
+        password: string;
+        label: string;
+        method: string;
+        route: string;
+        request: string;
+        response: string;
+        add: string;
+        signIn: string;
+        projectGroup: string;
+        view: string;
+    };
+    SignIn: {
+        title: string;
+        thirdParty: string;
+        signInWithIDass: string;
+        unregistered: string;
+        welcome: string;
+    };
+    NotFound: {
+        subTitle: string;
+        buttonText: string;
+    };
+    FilterFormWrapper: {
+        confirmText: string;
+        resetText: string;
+    };
+    FormModal: {
+        confirmText: string;
+        cancelText: string;
+    };
+    GameSelect: {
+        label: string;
+        placeholder: string;
+    };
+    RequireGame: {
+        description: string;
+    };
+    UserWidget: {
+        signOutText: string;
+    };
+    User: {
+        createTitle: string;
+        createSuccessfully: string;
+        updateTitle: string;
+        updateSuccessfully: string;
+        deleteTitle: string;
+        deleteContent: string;
+        deleteSuccessfully: string;
+    };
+    Role: {
+        createTitle: string;
+        createSuccessfully: string;
+        updateTitle: string;
+        updateSuccessfully: string;
+        deleteTitle: string;
+        deleteContent: string;
+        deleteSuccessfully: string;
+    };
+    PermissionList: {
+        failedDescription: string;
+        baseSectionTitle: string;
+        gameSectionTitle: string;
+        gameSectionDescription: string;
+        gameSelectPlaceholder: string;
+        removeText: string;
+        addText: string;
+    };
+    RoleDetail: {
+        title: string;
+    };
+    InfiniteList: {
+        loadingText: string;
+        reachEndText: string;
+        loadMoreText: string;
+    };
+};
+
+interface ContextSlice {
+    locale: Locale;
+    permissionVersion: PermissionVersion;
+    gameApiV2: boolean;
+    signInPath: string;
+    isGlobal: boolean;
+    navWidth?: number;
+    collapsed?: boolean;
+    collapsible?: boolean;
+    mainPagePath: string;
+    setContext(state: Partial<Omit<ContextSlice, 'setContext'>>): void;
+}
+
+interface GameSlice {
+    gameId?: string | number;
+    setGameId: (id?: string | number) => void;
+}
+
+interface UserInfo {
+    authorityId: string;
+    exp: number;
+}
+interface TokenSlice {
+    token?: string;
+    getUser: () => UserInfo | null;
+    setToken: (token: string) => void;
+}
+
+type ToolkitsState = TokenSlice & GameSlice & ContextSlice & {
+    clearToken: () => void;
+};
+
+declare function useToolkitsStore(): ToolkitsState;
+declare function useToolkitsStore<T>(selector: (state: ToolkitsState) => T): T;
+type ToolkitsProviderProps = PropsWithChildren<Partial<Omit<ContextSlice, 'setContext'>>>;
+declare const ToolkitsProvider: FC<ToolkitsProviderProps>;
+declare const withContext: (Component: ComponentType, providerProps: Omit<ToolkitsProviderProps, "children">) => {
+    (props: any): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const UserWidget: FC;
+
+export { DynamicTags, type DynamicTagsProps, ExpandableParagraph, type ExpandableParagraphProps, FilterFormWrapper, type FilterFormWrapperProps, Game, Highlight, type HighlightProps, InfiniteList, InfiniteListAction, type InfiniteListPayload, type InfiniteListProps, type InfiniteListRef, type InfiniteListRequestConfig, Layout, type LayoutProps, Logo, type LogoProps, NavMenu, type NavMenuItem, PermissionButton, type PermissionButtonProps, QueryList, QueryListAction, type QueryListPayload, type QueryListProps, type QueryListRef, RequireGame, RequirePermission, type RequirePermissionProps, ToolkitsProvider, type ToolkitsProviderProps, type UseFormDrawerProps, type UseFormModalProps, UserWidget, useDrawer, useDrawerStore, useFormDrawer, useFormModal, useInfiniteListStore, useModal, useModalStore, useQueryListStore, useToolkitsStore, withContext };

package/lib/components.js

@@ -0,0 +1 @@
+export{d as DynamicTags,f as InfiniteList,j as Layout,g as NavMenu,h as RequireGame,k as RequirePermission,i as UserWidget,b as useDrawer,a as useDrawerStore,c as useFormDrawer,e as useInfiniteListStore}from'./chunk-K5HXGCZ4.js';export{a as Highlight}from'./chunk-RITI5HRV.js';export{d as PermissionButton,c as useFormModal,b as useModal,a as useModalStore}from'./chunk-3OYXD4UE.js';export{a as ExpandableParagraph,b as Logo}from'./chunk-JTDKSGJR.js';export{a as FilterFormWrapper,d as QueryList,c as QueryListAction,b as useQueryListStore}from'./chunk-4GULXGNG.js';import'./chunk-7NM3DK6A.js';import'./chunk-X6ZI7RL7.js';export{c as ToolkitsProvider,a as useToolkitsStore,b as withContext}from'./chunk-WHOTHZUW.js';import'./chunk-LRMME3YZ.js';import'./chunk-OLM4QNJB.js';