@gpustack/core-ui 1.0.0

package/dist/src/lib/components/x-terminal/index.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface XTerminalProps {
+    height: number;
+    url: string;
+    theme?: 'light' | 'dark' | 'realDark';
+}
+declare const XTerminal: React.FC<XTerminalProps>;
+export default XTerminal;

package/dist/src/lib/components/yaml-editor/editor.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+interface ViewerProps {
+    ref?: any;
+    defaultLang?: string;
+    config?: any;
+    value: string;
+    height?: string | number;
+    theme?: string;
+    header?: React.ReactNode;
+    placeholder?: string;
+    variant?: 'bordered' | 'borderless';
+    schema?: any;
+}
+declare const EditorInner: React.FC<ViewerProps>;
+export default EditorInner;

package/dist/src/lib/components/yaml-editor/index.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+interface ViewerProps {
+    ref?: any;
+    title?: React.ReactNode;
+    defaultLang?: string;
+    config?: any;
+    value: string;
+    height?: string | number;
+    placeholder?: string;
+    variant?: 'bordered' | 'borderless';
+    validateMessage?: React.ReactNode;
+    schema?: any;
+    isDarkTheme?: boolean;
+    onUpload?: (content: string) => void;
+}
+declare const YamlEditor: React.FC<ViewerProps>;
+export default YamlEditor;

package/dist/src/lib/config/hotkeys.d.ts

@@ -0,0 +1,40 @@
+declare const KeybindingsMap: {
+    CREATE: string[];
+    CLEAR: string[];
+    RIGHT: string[];
+    SAVE: string[];
+    SUBMIT: string[];
+    ENTER: string[];
+    SHIFT: string[];
+    CTRL: string[];
+    OPTION: string[];
+    SAVEAS: string[];
+    OPEN: string[];
+    UNDO: string[];
+    CANCEL: string[];
+    DELETE: string[];
+    COPY: string[];
+    REFRESH: string[];
+    EDIT: string[];
+    SEARCH: string[];
+    RESET: string[];
+    INPUT: string[];
+    NEW1: string[];
+    NEW2: string[];
+    NEW3: string[];
+    NEW4: string[];
+    FOCUS: string[];
+    ADD: string[];
+    ESC: string[];
+};
+type KeyBindingType = keyof typeof KeybindingsMap;
+type KeybindingValue = {
+    keybinding: string;
+    command: KeyBindingType;
+    textKeybinding: string;
+    iconKeybinding: string;
+};
+declare const KeybiningList: KeybindingValue[];
+declare const KeyMap: Record<KeyBindingType, KeybindingValue>;
+export { KeybiningList, KeyMap };
+export default KeybindingsMap;

package/dist/src/lib/config/index.d.ts

@@ -0,0 +1,20 @@
+import { StatusType } from '../types';
+export declare const breakpoints: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    xxl: number;
+};
+export declare const WatchEventType: {
+    CREATE: number;
+    UPDATE: number;
+    DELETE: number;
+};
+export declare const StatusColorMap: Record<StatusType, {
+    text: string;
+    bg: string;
+    border?: string;
+}>;
+export declare const StatusMaps: Record<string, StatusType>;

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

@@ -0,0 +1,6 @@
+export declare const INPUT_WIDTH: {
+    default: number;
+    large: number;
+    small: number;
+    mini: number;
+};

package/dist/src/lib/context/CoreUIContext.d.ts

@@ -0,0 +1,83 @@
+import { CancelTokenSource } from 'axios';
+import { TableFetchType } from '../types/table-fetch';
+export interface CoreUIConfig {
+    apiBaseUrl: string;
+    iconUrl?: string;
+    theme?: 'light' | 'realDark' | 'dark';
+    isDarkTheme?: boolean;
+    defaultColorPrimary?: string;
+}
+export interface CoreUII18n {
+    formatMessage: (descriptor: {
+        id: string;
+    }, values?: any) => string;
+}
+export interface CoreUILocale {
+    getAllLocales: () => string[];
+    setLocale: (locale: string, reload?: boolean) => void;
+}
+export interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    params?: Record<string, any>;
+    data?: any;
+    skipErrorHandler?: boolean;
+    getResponse?: boolean;
+    cancelToken?: CancelTokenSource;
+    headers?: Record<string, string>;
+    onDownloadProgress?: (progressEvent: any) => void;
+}
+export interface RequestService {
+    <T = any>(url: string, options?: RequestOptions): Promise<T>;
+}
+export interface Services {
+    request: RequestService;
+    router?: {
+        push: (path: string) => void;
+        replace: (path: string) => void;
+        goBack: () => void;
+    };
+}
+export interface CoreHooks {
+    useIntl: () => CoreUII18n;
+    usePaginationStatus?: (key: string) => {
+        pagination: any;
+        getPaginationStatus: () => any;
+        setPagination: (pagination: any) => void;
+        getPagination: () => any;
+        clearPagination: () => void;
+    };
+    useTabActive?: () => {
+        setTabActive: (tabKey: string, value: any) => void;
+        getTabActive: (tabKey: string) => any;
+        tabsMap: Record<string, string>;
+    };
+    useTableFetch?: TableFetchType;
+    useUserSettings?: () => {
+        userSettings: any;
+        setUserSettings: any;
+        setTheme: (mode: string) => void;
+        isDarkTheme: boolean;
+        themeData: any;
+        componentSize: string;
+    };
+    useUserSettingsStorage?: () => {
+        setStorageUserSettings: (value: Record<string, any>) => void;
+        getStorageUserSettings: () => any;
+    };
+}
+export interface CoreUIContextProps {
+    config: CoreUIConfig;
+    tokens?: Record<string, string>;
+    i18n: CoreUII18n;
+    locale: CoreUILocale;
+    services: Services;
+    hooks: CoreHooks;
+    localStore?: {
+        readColumnSettings: (key: string) => string[] | null;
+        readState: (key: string) => void;
+        writeColumnSettings: (key: string, value: any) => void;
+        writeState: (key: string, value: any) => void;
+    };
+}
+declare const CoreUIContext: import('react').Context<CoreUIContextProps>;
+export default CoreUIContext;

package/dist/src/lib/context/CoreUIProvider.d.ts

@@ -0,0 +1,4 @@
+import { CoreUIContextProps } from './CoreUIContext';
+export declare const CoreUIProvider: React.FC<CoreUIContextProps & {
+    children: React.ReactNode;
+}>;

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

@@ -0,0 +1,23 @@
+export { default as useActions } from './use-actions';
+export { default as useAddImage } from './use-add-image';
+export { default as useAppUtils } from './use-app-utils';
+export { default as useBodyScroll } from './use-body-scroll';
+export { default as useChunkFetch } from './use-chunk-fetch';
+export type { HandlerOptions } from './use-chunk-fetch';
+export { default as useChunkRequest } from './use-chunk-request';
+export { default as useContainerScroll } from './use-container-scroll';
+export { default as useDeferredRequest } from './use-deferred-request';
+export { default as useDownloadLogs } from './use-download-logs';
+export { default as useDownloadStream } from './use-download-stream';
+export { default as useExpandedRowKeys } from './use-expanded-row-keys';
+export { default as useOverlayScroller } from './use-overlay-scroller';
+export { useQueryData, useQueryDataList } from './use-query-data-list';
+export { default as useRequestToken } from './use-request-token';
+export { default as useResponsive } from './use-responsive';
+export { default as useTableRowSelection } from './use-table-row-selection';
+export { useTableMultiSort, default as useTableSort } from './use-table-sort';
+export { default as useUpdateChunkedList } from './use-update-chunk-list';
+export { default as useWatchList } from './use-watch-list';
+export { default as useWindowResize } from './use-window-resize';
+export { default as useCoreUIContext } from './useCoreUIContext';
+export { default as useIntl } from './useIntl';

package/dist/src/lib/hooks/json-parser-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/lib/hooks/use-actions.d.ts

@@ -0,0 +1,11 @@
+export default function useActions<T>(actions: Global.ActionItem<T>[], ctx: T): {
+    disabled: boolean | undefined;
+    label: string;
+    key: string;
+    icon: React.ReactNode;
+    locale?: boolean;
+    props?: {
+        danger?: boolean;
+    };
+    visible?: ((record: T) => boolean) | undefined;
+}[];

package/dist/src/lib/hooks/use-add-image.d.ts

@@ -0,0 +1,15 @@
+declare const useAddImage: (options: {
+    size?: "small" | "middle" | "large";
+    inputProps?: Record<string, any>;
+    handleUpdateImgList: (list: {
+        uid: number | string;
+        dataUrl: string;
+    }[]) => void;
+    updateUidCount: () => number | string;
+}) => {
+    isFromUrl: boolean;
+    ImageURLInput: import("react/jsx-runtime").JSX.Element | null;
+    dropDownOpen: boolean;
+    UploadImageButton: import("react/jsx-runtime").JSX.Element;
+};
+export default useAddImage;

package/dist/src/lib/hooks/use-app-utils.d.ts

@@ -0,0 +1,6 @@
+type MessageType = 'input' | 'select';
+declare const useAppUtils: () => {
+    getRuleMessage: (type: MessageType | MessageType[], name: string, locale?: boolean) => string;
+    showSuccess: (msg?: string) => void;
+};
+export default useAppUtils;

package/dist/src/lib/hooks/use-body-scroll.d.ts

@@ -0,0 +1,5 @@
+export default function useBodyScroll(): {
+    saveScrollHeight: () => void;
+    restoreScrollHeight: () => void;
+    bodyScroller: any;
+};

package/dist/src/lib/hooks/use-chunk-fetch.d.ts

@@ -0,0 +1,20 @@
+export interface HandlerOptions {
+    isComplete?: boolean | null;
+    percent?: number;
+    progress?: number;
+    contentLength?: number | null;
+}
+type HandlerFunction = (data: any, options?: HandlerOptions) => any;
+interface RequestConfig {
+    url: string;
+    handler: HandlerFunction;
+    errorHandler?: (error: any) => void;
+    beforeReconnect?: () => void;
+    params?: object;
+    watch?: boolean;
+    contentType?: 'json' | 'text';
+}
+declare const useSetChunkFetch: () => {
+    setChunkFetch: (this: unknown, config: RequestConfig) => import('react').MutableRefObject<any>;
+};
+export default useSetChunkFetch;

package/dist/src/lib/hooks/use-chunk-request.d.ts

@@ -0,0 +1,20 @@
+import { CancelTokenSource } from 'axios';
+interface RequestConfig {
+    url: string;
+    handler: (data: any) => any;
+    beforeReconnect?: () => void;
+    params?: object;
+    contentType?: 'json' | 'text';
+}
+export declare const sliceJsonStr: (text: string) => string[];
+export declare const createAxiosToken: () => CancelTokenSource;
+export declare const sliceData: (data: string, loaded: number, loadedSize: any) => string;
+declare const useSetChunkRequest: () => {
+    setChunkRequest: (config: RequestConfig) => import('react').MutableRefObject<any>;
+    createAxiosToken: () => {
+        id: number;
+        token: import('axios').CancelToken;
+        cancel(): void;
+    };
+};
+export default useSetChunkRequest;

package/dist/src/lib/hooks/use-container-scroll.d.ts

@@ -0,0 +1,7 @@
+export default function useContainerScroll(container: any, options?: {
+    toBottom?: boolean;
+}): {
+    handleContentWheel: (e: any) => void;
+    updateScrollerPosition: () => void;
+    scroller: import('react').MutableRefObject<any>;
+};

package/dist/src/lib/hooks/use-deferred-request.d.ts

@@ -0,0 +1 @@
+export default function useDeferredRequest<P extends any[], R>(requestFn: (...args: P) => Promise<R>, delay?: number): import('ahooks/lib/useRequest/src/types').Result<R, P>;

package/dist/src/lib/hooks/use-download-logs.d.ts

@@ -0,0 +1,8 @@
+declare const useDownloadLogs: () => {
+    onDownloadLog: (params: {
+        url: string;
+        name: string;
+    }) => Promise<void>;
+    contextHolder: import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+};
+export default useDownloadLogs;

package/dist/src/lib/hooks/use-download-stream.d.ts

@@ -0,0 +1,12 @@
+export default function useDownloadStream(): {
+    downloadStream: (props: {
+        data?: any;
+        url: string;
+        params?: any;
+        signal?: AbortSignal;
+        method?: string;
+        headers?: any;
+        filename?: string;
+        downloadNotification?: (data: any) => void;
+    }) => Promise<void>;
+};

package/dist/src/lib/hooks/use-esc-hint.d.ts

@@ -0,0 +1,7 @@
+export declare function useEscHint(options?: {
+    enabled?: boolean;
+    message?: string;
+    throttleDelay?: number;
+}): {
+    EscHint: import("react/jsx-runtime").JSX.Element | null;
+};

package/dist/src/lib/hooks/use-expanded-row-keys.d.ts

@@ -0,0 +1,10 @@
+export default function useExpandedRowKeys(defaultKeys?: React.Key[]): {
+    expandedRowKeys: import('react').Key[];
+    currentExpand: import('react').Key | null;
+    setCurrentExpand: import('react').Dispatch<import('react').SetStateAction<import('react').Key | null>>;
+    clearExpandedRowKeys: () => void;
+    updateExpandedRowKeys: (keys: React.Key[]) => void;
+    removeExpandedRowKey: (keys: React.Key[]) => void;
+    handleExpandChange: (expanded: boolean, record: any, rowKey: any) => void;
+    handleExpandAll: (expanded: boolean, keys?: React.Key[]) => void;
+};

package/dist/src/lib/hooks/use-overlay-scroller.d.ts

@@ -0,0 +1,45 @@
+import { UseOverlayScrollbarsParams } from 'overlayscrollbars-react';
+import { default as React } from 'react';
+type OverflowBehavior = 'hidden' | 'scroll' | 'visible' | 'visible-hidden' | 'visible-scroll';
+export interface OverlayScrollerOptions {
+    oppositeTheme?: boolean;
+    overflow?: {
+        x?: OverflowBehavior;
+        y?: OverflowBehavior;
+    };
+    scrollbars?: {
+        theme?: 'os-theme-light' | 'os-theme-dark';
+        autoHide?: 'never' | 'scroll' | 'leave' | 'move';
+        autoHideDelay?: number;
+        clickScroll?: boolean | 'instant';
+    };
+}
+export declare const overlaySollerOptions: UseOverlayScrollbarsParams;
+/**
+ *
+ * @param options.theme: if set theme, it will fix the theme
+ * @returns
+ */
+export default function useOverlayScroller(data?: {
+    options?: OverlayScrollerOptions;
+    events?: any;
+    defer?: boolean;
+}): {
+    initialize: (this: unknown, el: any) => any;
+    instance: React.MutableRefObject<any>;
+    scrollEventElement: React.MutableRefObject<any>;
+    initialized: React.MutableRefObject<boolean>;
+    getScrollElementScrollableHeight: () => {
+        scrollTop: any;
+        scrollHeight: number;
+    };
+    getScrollElement: () => React.MutableRefObject<any>;
+    generateInstance: () => void;
+    destroyInstance: () => void;
+    updateScrollerPosition: (this: unknown, delay?: number | undefined) => void;
+    updateScrollerPositionToTop: (this: unknown) => void;
+    scrollToBottom: (this: unknown) => void;
+    scrollToTop: (this: unknown) => void;
+    scrollToTarget: (target: any, offset?: number) => void;
+};
+export {};

package/dist/src/lib/hooks/use-query-data-list.d.ts

@@ -0,0 +1,35 @@
+/**
+
+ *  generic hook to query data list
+ * @template ListItem
+ * @param Params - query params type, e.g. { page: number; perPage: number }
+ * @param option.fetchList: (params, extra) => Promise<{ items: ListItem[] }>
+ * @returns loading, dataList, fetchData, cancelRequest
+ */
+export declare function useQueryDataList<ListItem, Params = any>(option: {
+    key: string;
+    fetchList: (params: Params, options?: any) => Promise<Global.PageResponse<ListItem>>;
+    getLabel?: (item: ListItem) => string;
+    getValue?: (item: ListItem) => any;
+    errorMsg?: string;
+}): {
+    loading: boolean;
+    dataList: Array<ListItem & {
+        label: string;
+        value: any;
+    }>;
+    cancelRequest: () => void;
+    fetchData: (params: Params, extra?: any) => Promise<ListItem[]>;
+};
+export declare function useQueryData<Detail, Params = any>(option: {
+    key: string;
+    delay?: number;
+    fetchDetail: (params: Params, options?: any) => Promise<Detail>;
+    getData?: (response: Detail, params?: any) => any;
+    errorMsg?: string;
+}): {
+    loading: boolean;
+    detailData: Detail;
+    cancelRequest: () => void;
+    fetchData: (params: Params, extra?: any) => Promise<Detail>;
+};

package/dist/src/lib/hooks/use-request-token.d.ts

@@ -0,0 +1,13 @@
+export default function useRequestToken(): () => import('axios').CancelTokenSource;
+export declare function useCancelToken(): {
+    updateCancelToken: () => void;
+    cancelRequest: () => void;
+    getCanceltToken: () => any;
+    source: () => import('axios').CancelTokenSource;
+};
+export declare function useAbortController(): {
+    getController: () => AbortController;
+    updateController: () => void;
+    abortController: () => void;
+    controller: import('react').MutableRefObject<AbortController | null>;
+};

package/dist/src/lib/hooks/use-responsive.d.ts

@@ -0,0 +1,10 @@
+declare const useResponsive: ({ defaultSpan }: {
+    defaultSpan?: number;
+}) => {
+    span: number;
+    handleResize: (this: unknown, size: {
+        width: number;
+        height: number;
+    }) => void | undefined;
+};
+export default useResponsive;

package/dist/src/lib/hooks/use-stream-core/buffer-queue.d.ts

@@ -0,0 +1,8 @@
+export declare class BufferQueue<T = any> {
+    private queue;
+    private batchSize;
+    push(item: T): void;
+    drain(): T[];
+    size(): number;
+    clear(): void;
+}

package/dist/src/lib/hooks/use-stream-core/fetch-stream.d.ts

@@ -0,0 +1 @@
+export declare function fetchStream(url: string, handler: (chunk: string, meta?: any) => void, signal?: AbortSignal): Promise<void>;

package/dist/src/lib/hooks/use-stream-core/speed-monitor.d.ts

@@ -0,0 +1,8 @@
+export declare class SpeedMonitor {
+    private lastTime;
+    private lastBytes;
+    private history;
+    private max;
+    update(totalBytes: number): void;
+    avg(): number;
+}

package/dist/src/lib/hooks/use-stream-core/stream-processor.d.ts

@@ -0,0 +1,18 @@
+export interface StreamMeta {
+    isComplete?: boolean;
+    progress?: number;
+    speed?: number;
+}
+type Handler = (data: string, meta?: StreamMeta) => void;
+export declare class StreamProcessor {
+    private handler;
+    private buffer;
+    private speed;
+    private encoder;
+    private totalBytes;
+    private flushing;
+    constructor(handler: Handler);
+    push(chunk: string): void;
+    flush(done?: boolean): Promise<void>;
+}
+export {};

package/dist/src/lib/hooks/use-stream-core/use-chunk-fetch.d.ts

@@ -0,0 +1,7 @@
+export interface RequestConfig {
+    url: string;
+    handler: (data: any, meta?: any) => void;
+}
+export declare const useChunkFetch: () => {
+    run: (this: unknown, config: RequestConfig) => Promise<void>;
+};

package/dist/src/lib/hooks/use-table-row-selection.d.ts

@@ -0,0 +1,12 @@
+export default function useTableRowSelection(): {
+    selectedRowKeys: import('react').Key[];
+    selectedRows: any[];
+    enableSelection: boolean;
+    getCheckboxProps: (record: Record<string, any>) => {
+        disabled: any;
+    };
+    clearSelections: () => void;
+    onChange: (selectedRowKeys: React.Key[], selectedRows: any[]) => void;
+    removeSelectedKeys: (rowKeys: React.Key[]) => import('react').Key[];
+    removeSelectedKey: (rowKey: React.Key | React.Key[]) => import('react').Key[];
+};

package/dist/src/lib/hooks/use-table-sort.d.ts

@@ -0,0 +1,17 @@
+import { SortOrder } from 'antd/es/table/interface';
+export default function useTableSort({ defaultSortOrder }: {
+    defaultSortOrder?: SortOrder;
+}): {
+    sortOrder: SortOrder;
+    setSortOrder: (order: SortOrder) => void;
+};
+type orderType = {
+    columnKey?: string;
+    field?: string;
+    order: SortOrder;
+};
+export declare function useTableMultiSort(): {
+    sortOrder: string[];
+    handleMultiSortChange: (order: orderType | orderType[]) => string[];
+};
+export {};

package/dist/src/lib/hooks/use-update-chunk-list.d.ts

@@ -0,0 +1,26 @@
+interface ChunkedCollection {
+    ids: string[] | number[];
+    data: any;
+    collection: any[];
+    type: string | number;
+}
+type EventsType = 'CREATE' | 'UPDATE' | 'DELETE' | 'INSERT';
+export declare function useUpdateChunkedList(options: {
+    events?: EventsType[];
+    dataList?: any[];
+    triggerAt?: React.MutableRefObject<number>;
+    limit?: number;
+    onCreate?: (args: any) => void;
+    onUpdate?: (args: any) => void;
+    onDelete?: (args: any) => void;
+    setDataList?: (args: any, opts?: any) => void;
+    callback?: (args: any) => void;
+    filterFun?: (args: any) => boolean;
+    mapFun?: (args: any) => any;
+    computedID?: (d: object) => string;
+}): {
+    updateChunkedList: (data: ChunkedCollection) => void;
+    cacheDataListRef: import('react').MutableRefObject<any[]>;
+    deletedIdsRef: import('react').MutableRefObject<Set<string | number>>;
+};
+export default useUpdateChunkedList;

package/dist/src/lib/hooks/use-watch-list.d.ts

@@ -0,0 +1,4 @@
+export default function useWatchList<T = Record<string, any>>(API: string): {
+    watchDataList: T[];
+    deleteItemFromCache: (id: number) => void;
+};

package/dist/src/lib/hooks/use-window-resize.d.ts

@@ -0,0 +1,10 @@
+export default function useWindowResize(): {
+    size: {
+        width: number;
+        height: number;
+    };
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    currentPoint: string;
+};

package/dist/src/lib/hooks/useCoreUIContext.d.ts

@@ -0,0 +1,2 @@
+declare const useCoreUIContext: () => import('../context/CoreUIContext').CoreUIContextProps;
+export default useCoreUIContext;

package/dist/src/lib/hooks/useIntl.d.ts

@@ -0,0 +1,7 @@
+export declare const useIntl: () => {
+    locale: any;
+    formatMessage: (descriptor: {
+        id: string;
+    }, values?: any) => string;
+};
+export default useIntl;

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

@@ -0,0 +1,6 @@
+export * from './components';
+export * as config from './config';
+export * from './constants';
+export * from './hooks';
+export * from './types';
+export * as utils from './utils';