dinocollab-core 1.0.0 → 1.0.2

package/dist/types/lab/filter-bar/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CreateFilterBar } from './create.filter-bar';
+export type { FilterBarParams } from './create.filter-bar';
+export { default as FilterBarDemo } from './demo';
+export * from './types';

package/dist/types/lab/filter-bar/types.d.ts

@@ -0,0 +1,81 @@
+export type FilterReason = 'searchInput' | 'filterButton' | 'sortButton';
+type Dictionary<T, V, E = any> = {
+    [key in keyof T | keyof E]?: V;
+};
+type SingleOrArray<T> = T | T[];
+export declare enum ESearchMatch {
+    AlwaysVisible = "AlwaysVisible",
+    MatchOnly = "MatchOnly",
+    LinkYoutube = "LinkYoutube",
+    Link = "Link",
+    Guid = "Guid"
+}
+interface ISearchMatchBase {
+    rule: ESearchMatch;
+}
+interface ISearchMatchMatchOnly extends ISearchMatchBase {
+    rule: ESearchMatch.MatchOnly;
+    match: (value: string) => boolean;
+}
+interface ISearchMatchQuickly extends ISearchMatchBase {
+    rule: ESearchMatch.AlwaysVisible | ESearchMatch.LinkYoutube | ESearchMatch.Link | ESearchMatch.Guid;
+}
+type IFieldSearchMatch = ISearchMatchMatchOnly | ISearchMatchQuickly;
+export declare enum EFieldValidate {
+    LinkYoutube = "LinkYoutube",
+    Link = "Link",
+    Custom = "Custom"
+}
+interface IFieldValidateBase {
+    rule: EFieldValidate;
+}
+interface IFieldValidateCustom extends IFieldValidateBase {
+    rule: EFieldValidate.Custom;
+    custom: (value: string) => boolean;
+}
+interface IFieldValidateQuickly extends IFieldValidateBase {
+    rule: EFieldValidate.Link | EFieldValidate.LinkYoutube;
+}
+type IFieldValidate = IFieldValidateQuickly | IFieldValidateCustom;
+interface IFilterFieldBase {
+    label?: string;
+    /** @default string */
+    type?: 'string' | 'select';
+    searchMatches?: SingleOrArray<IFieldSearchMatch>;
+    /** @default true */
+    sortable?: boolean;
+    /** @default Required */
+    validate?: SingleOrArray<IFieldValidate>;
+}
+export interface IFilterFieldString extends IFilterFieldBase {
+    type?: 'string';
+}
+export interface IFilterFieldSelect extends IFilterFieldBase {
+    type: 'select';
+    options: {
+        value: string;
+        label?: string;
+    }[];
+}
+export type IFilterField = IFilterFieldString | IFilterFieldSelect;
+export type IFilterFields<T> = Dictionary<T, IFilterField, {
+    Search?: string;
+}>;
+export interface IFilterItemModel {
+    value?: string | number | boolean;
+    label?: string;
+    /** @default true */
+    sortable?: boolean;
+}
+export type IFilterModel<T> = Dictionary<T, IFilterItemModel[], {
+    Search?: string;
+}>;
+export interface IFilterState<T> {
+    filter?: IFilterModel<T>;
+    details?: 'add' | 'remove';
+}
+export interface IFilterPanelParams<T> {
+    fields: IFilterFields<T>;
+}
+export type IFilterPannelSubmitFunc<T> = (filed: keyof IFilterModel<T>, value: IFilterItemModel) => void;
+export {};

package/dist/types/lab/filter-bar/ui.units.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { IconButtonProps } from '@mui/material';
+interface ButtonClearProps {
+    visibled?: boolean;
+    onClick: IconButtonProps['onClick'];
+}
+export declare const ButtonClear: FC<ButtonClearProps>;
+export interface FilterHelpNotesProps {
+    title?: string;
+    items?: string[];
+}
+export declare const FilterHelpNotes: FC<FilterHelpNotesProps>;
+export {};

package/dist/types/lab/grafana-dashboard/configs.d.ts

@@ -0,0 +1,4 @@
+import { ITopBarInfo } from './top-bar.types';
+import { IQuickRangeConfig } from './date-time-range';
+export declare const QuickRangeConfigs: IQuickRangeConfig[];
+export declare const DefaultTopBarInfo: ITopBarInfo;

package/dist/types/lab/grafana-dashboard/date-time-range/absolute-time-rage.d.ts

@@ -0,0 +1,14 @@
+import React, { Component } from 'react';
+import { IQuickRangeConfig } from './types';
+interface IProps {
+    data?: IQuickRangeConfig;
+    onChangeRange?: (value: IQuickRangeConfig) => void;
+}
+export default class AbsoluteTimeRage extends Component<IProps> {
+    render(): import("react/jsx-runtime").JSX.Element;
+    date1Ref: React.RefObject<HTMLInputElement>;
+    date2Ref: React.RefObject<HTMLInputElement>;
+    dateTimeRangePickerRanges(): JSX.Element;
+    handleApply: (value: Partial<IQuickRangeConfig>) => Promise<void>;
+}
+export {};

package/dist/types/lab/grafana-dashboard/date-time-range/helpers.d.ts

@@ -0,0 +1,36 @@
+import dayjs from 'dayjs';
+import { IQuickRangeConfig, IRange } from './types';
+type TDateTimeKetType = /** 'minute' | 'hour' | */ 'day' | 'month' | 'year';
+export declare const MapDateTimeKey: (count: number, type?: TDateTimeKetType) => string | undefined;
+declare class DTRHelperBase {
+    formatString: string;
+    /**
+     * getTitle generates a formatted date range string based on the input dates.
+     * @param from - Start date as a string in milliseconds.
+     * @param to - End date as a string in milliseconds.
+     * @param quickRanges - quickRanges as a ```QuickRangeConfig[]```.
+     * @returns Formatted date range or quick range title or fallback string for invalid/undefined values.
+     */
+    getTitle: (from?: string, to?: string, quickRanges?: IQuickRangeConfig[]) => string;
+    /**
+     * getTime converts a formatted date string into a timestamp in milliseconds.
+     * Returns the timestamp as a string or NaN if the date is invalid.
+     * @param value - Date string in the format 'MM/DD/YYYY'.
+     * @returns Timestamp in milliseconds as a string.
+     */
+    getTime: (value: string, options?: ((d: dayjs.Dayjs) => dayjs.Dayjs) | undefined) => string;
+    /**
+     * parseDayJS parses a date in milliseconds into a dayjs object.
+     * Returns undefined if the date is invalid or if parsing fails.
+     * @param value - String representing a date in milliseconds or other formats.
+     * @returns A valid dayjs object or undefined if invalid.
+     */
+    parseDayJS: (value?: string) => dayjs.Dayjs | undefined;
+    dayRange: (range?: number) => Required<IRange>;
+    monthRange: (range?: number) => Required<IRange>;
+    monthString: (range?: number) => string;
+    yearRange: (range?: number) => Required<IRange>;
+    yearString: (range?: number) => string;
+}
+export declare const DTRHelper: DTRHelperBase;
+export {};

package/dist/types/lab/grafana-dashboard/date-time-range/index.d.ts

@@ -0,0 +1,24 @@
+import { Component } from 'react';
+import { IQuickRangeConfig } from './types';
+import { IMenuWrap } from './menu-wrap';
+interface IProps {
+    data: IQuickRangeConfig[];
+    defaultSelected?: IQuickRangeConfig;
+    onChange?: (value: IQuickRangeConfig) => void;
+}
+interface IState {
+    selected?: IQuickRangeConfig;
+}
+export default class DateTimeRange extends Component<IProps, IState> {
+    configs: IQuickRangeConfig[];
+    constructor(props: IProps);
+    refMenuWrap: IMenuWrap | null;
+    render(): import("react/jsx-runtime").JSX.Element;
+    handleSelectItem: (item: IQuickRangeConfig) => void;
+    getTitle: () => {
+        text: string;
+        sub: string;
+    };
+}
+export * from './types';
+export * from './helpers';

package/dist/types/lab/grafana-dashboard/date-time-range/menu-wrap.d.ts

@@ -0,0 +1,19 @@
+import React, { Component, PropsWithChildren } from 'react';
+interface IProps {
+    title?: string;
+    subTitle?: string;
+}
+interface IState {
+    anchorEl: null | HTMLElement;
+}
+export interface IMenuWrap {
+    close: () => void;
+}
+export default class MenuWrap extends Component<PropsWithChildren<IProps>, IState> implements IMenuWrap {
+    constructor(props: IProps);
+    render(): import("react/jsx-runtime").JSX.Element;
+    renderTooltip: (child: JSX.Element) => import("react/jsx-runtime").JSX.Element;
+    onOpen: (event: React.MouseEvent<HTMLElement>) => void;
+    close: () => void;
+}
+export {};

package/dist/types/lab/grafana-dashboard/date-time-range/quick-ranges.d.ts

@@ -0,0 +1,20 @@
+import React, { Component } from 'react';
+import { IQuickRangeConfig } from './types';
+interface IProps {
+    selectedValue?: IQuickRangeConfig;
+    data: IQuickRangeConfig[];
+    onSelect: (item: IQuickRangeConfig) => void;
+}
+interface IState {
+    searchKey: string;
+}
+export default class QuickRanges extends Component<IProps, IState> {
+    constructor(props: IProps);
+    render: () => import("react/jsx-runtime").JSX.Element;
+    renderQuickRanges: (items: IQuickRangeConfig[]) => import("react/jsx-runtime").JSX.Element;
+    renderQuickRangeCustom: (items: IQuickRangeConfig[], selected?: IQuickRangeConfig) => import("react/jsx-runtime").JSX.Element;
+    handleChangeSearch: React.ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    getClassNameItem: (item: IQuickRangeConfig) => "" | "activated";
+    getData: () => IQuickRangeConfig[];
+}
+export {};

package/dist/types/lab/grafana-dashboard/date-time-range/types.d.ts

@@ -0,0 +1,8 @@
+export interface IRange {
+    from?: string;
+    to?: string;
+}
+export interface IQuickRangeConfig extends IRange {
+    title: string;
+    lineAbove?: boolean;
+}

package/dist/types/lab/grafana-dashboard/date-time-range/units.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const UTCTime: FC;

package/dist/types/lab/grafana-dashboard/helper.d.ts

@@ -0,0 +1,7 @@
+import { ITopBarInfo } from './top-bar.types';
+import { IGrafanaDashBoardOptions } from './types';
+interface IOptions extends ITopBarInfo, Omit<IGrafanaDashBoardOptions, 'from' | 'to'> {
+}
+export declare const TopBarInfoToQueryParam: (urlBase: string, options?: IOptions) => string;
+export declare const GetTopBarInfoQueryParam: () => IGrafanaDashBoardOptions;
+export {};

package/dist/types/lab/grafana-dashboard/hooks.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ITopBarInfo } from './top-bar.types';
+import { IQuickRangeConfig } from './date-time-range';
+declare const GrafanaDashboardHooks: {
+    useQueryParam: (data: ITopBarInfo, activated?: boolean) => void;
+    useLoading: () => [boolean, () => void, () => void];
+    useTopBarInfo: () => [ITopBarInfo, (value?: IQuickRangeConfig, callback?: () => void) => void];
+    useCustomScrollBar: (iframeRef: React.RefObject<HTMLIFrameElement>) => void;
+};
+export default GrafanaDashboardHooks;

package/dist/types/lab/grafana-dashboard/icons.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { SvgIconProps } from '@mui/material';
+export declare const SvgLoading: React.FC<SvgIconProps & {
+    fill?: string;
+}>;

package/dist/types/lab/grafana-dashboard/index.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+import { IGrafanaDashBoardOptions } from './types';
+interface IGrafanaDashboardProps {
+    url: string;
+    title?: string;
+    options?: IGrafanaDashBoardOptions;
+    topBar?: boolean;
+    queryParam?: boolean;
+    onLoadComplete?: () => void;
+}
+export declare const GrafanaDashboard: FC<IGrafanaDashboardProps>;
+export {};

package/dist/types/lab/grafana-dashboard/top-bar.d.ts

@@ -0,0 +1,19 @@
+import { Component } from 'react';
+import { IQuickRangeConfig } from './date-time-range';
+export interface ITopBar {
+    onRefresh?: () => void;
+    onDateTimeRangeChange?: (value?: IQuickRangeConfig) => void;
+}
+interface IProps extends ITopBar {
+    dateTimeRanges: {
+        data: IQuickRangeConfig[];
+        defaultValue?: IQuickRangeConfig;
+    };
+    after?: JSX.Element;
+    before?: JSX.Element;
+}
+export default class TopBar extends Component<IProps> {
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export declare const TopBarheight = 43;
+export {};

package/dist/types/lab/grafana-dashboard/top-bar.types.d.ts

@@ -0,0 +1,4 @@
+import { IQuickRangeConfig } from './date-time-range';
+export interface ITopBarInfo {
+    QuickRange?: IQuickRangeConfig;
+}

package/dist/types/lab/grafana-dashboard/types.d.ts

@@ -0,0 +1,8 @@
+export interface IGrafanaDashBoardOptions {
+    from?: string;
+    to?: string;
+    refresh?: string;
+    kiosk?: 'tv' | 'true' | 'false';
+    theme?: 'light' | 'dark';
+    orgId?: number;
+}

package/dist/types/lab/media-player.core1.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { SvgIconOwnProps } from '@mui/material';
+export interface MediaPlayerCore1Slots {
+    autoPlay?: boolean;
+    muted?: boolean;
+    iconPlayProps?: SvgIconOwnProps;
+}
+interface IProps {
+    src: string;
+    className?: string;
+    slots?: MediaPlayerCore1Slots;
+}
+declare const MediaPlayerCore1: React.FC<IProps>;
+export default MediaPlayerCore1;

package/dist/types/lab/media-player.muted.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { MediaPlayerBaseProps, MediaPlayerBaseSlots } from './media-player.units';
+import { MediaPlayerCore1Slots } from './media-player.core1';
+interface IProps extends MediaPlayerBaseProps {
+    slots?: MediaPlayerBaseSlots & {
+        core1Props?: MediaPlayerCore1Slots;
+    };
+}
+declare const MediaPlayerMuted: FC<IProps>;
+export default MediaPlayerMuted;

package/dist/types/lab/media-player.units.d.ts

@@ -0,0 +1,36 @@
+import { ReactNode } from 'react';
+import { Breakpoint, SxProps, Theme } from '@mui/material';
+export interface IMediaStream {
+    code: number;
+    token: string;
+    StreamUrl: string;
+}
+export interface MediaPlayerBaseProps {
+    resourceId: string;
+    fetchDataStream: (resourceId: string, signal?: AbortSignal) => Promise<IMediaStream[]>;
+    loading?: boolean;
+}
+export type AspectRatioParams = number | Partial<Record<Breakpoint, number>>;
+export interface MediaPlayerBaseSlots {
+    /**
+     * Aspect ratio (height / width), used to calculate height based on width.
+     * @default 56.25 (%)
+     */
+    aspectRatio?: AspectRatioParams;
+    loading?: ReactNode;
+    loadingProps?: {
+        disabled?: boolean;
+        animationDuration?: string;
+    };
+}
+export declare enum EMediaPlayerStatus {
+    Loading = "Loading",
+    Loaded = "Loaded",
+    Error = "Error"
+}
+export declare const useStreamUrl: (resourceId: string | null, fetchDataStream: MediaPlayerBaseProps['fetchDataStream']) => {
+    status: EMediaPlayerStatus;
+    streamUrl: string | null;
+};
+export declare const getAspectRatio: (value?: AspectRatioParams, defaultAspectRatio?: string) => string | Partial<Record<Breakpoint, string>> | undefined;
+export declare const getAspectRatioStyled: (value?: AspectRatioParams) => SxProps<Theme>;

package/dist/types/lab/table-grid/create.table-grid.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TableGridParams, TableGridProps } from './types';
+declare function CreateTableGrid<T extends object>(params: TableGridParams<T>): React.ComponentType<TableGridProps<T>>;
+export default CreateTableGrid;

package/dist/types/lab/table-grid/demo.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+declare const TableGridDemo: FC;
+export default TableGridDemo;

package/dist/types/lab/table-grid/dino.d.ts

@@ -0,0 +1,6 @@
+import CreateLayoutGrid from './create.table-grid';
+declare class DinoTableGridBase {
+    createTable: typeof CreateLayoutGrid;
+}
+declare const DinoTableGrid: DinoTableGridBase;
+export default DinoTableGrid;

package/dist/types/lab/table-grid/helpers.d.ts

@@ -0,0 +1,11 @@
+export declare const tableGridClasses: {
+    root: string;
+    content: string;
+    contentPosition: string;
+    contentInner: string;
+    loading: string;
+    overlay: string;
+    item: string;
+    actions: string;
+    noItems: string;
+};

package/dist/types/lab/table-grid/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DinoTableGrid } from './dino';
+export * from './types';

package/dist/types/lab/table-grid/item-actions.d.ts

@@ -0,0 +1,93 @@
+import React, { ComponentType, ReactNode } from 'react';
+import { ListItemProps } from '@mui/material';
+import { ClosePopover, GlobalModalState } from '../../api-context';
+export type TableGridItemActionType = 'Edit' | 'Delete';
+export interface TableGridItemActionsProps<T> {
+    value: T;
+}
+type FormRenderFunc<T> = (value: T) => React.ReactNode;
+interface ListItemDef<T> {
+    name: string;
+    icon?: ReactNode;
+    /** Whether this item should trigger a close action when clicked. @default true */
+    closableOnClick?: boolean;
+    /** Handler called when item is clicked */
+    onClick?: (event: React.MouseEvent<HTMLLIElement, MouseEvent>, value: T) => void;
+    listItemProps?: ListItemProps;
+    /**
+     * Optional custom ReactNode to override the entire ListItem UI.
+     * If provided, this will be rendered instead of the default ListItem structure
+     * (icon + text + click behavior).
+     */
+    override?: ComponentType<{
+        onClose?: ClosePopover;
+    }>;
+}
+export interface TableGridItemActionsConfig<T> {
+    formEdit?: FormRenderFunc<T>;
+    formDelete?: FormRenderFunc<T>;
+    buttonEditConfig?: GlobalModalState;
+    buttonDeleteConfig?: GlobalModalState;
+    menuList?: {
+        before?: SingleOrArray<ListItemDef<T>>;
+        after?: ListItemDef<T>;
+    };
+}
+interface IProps<T> extends TableGridItemActionsProps<T>, TableGridItemActionsConfig<T> {
+}
+export declare function CreateTableGridItemActions<T>(): {
+    new (props: IProps<T>): {
+        render(): import("react/jsx-runtime").JSX.Element;
+        isVisible: () => boolean;
+        renderItems: (value?: SingleOrArray<ListItemDef<T>>) => import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];
+        renderItemWithForm: (name: TableGridItemActionType, form?: FormRenderFunc<T>, globalState?: GlobalModalState) => import("react/jsx-runtime").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<IProps<T>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: IProps<T>, context: any): {
+        render(): import("react/jsx-runtime").JSX.Element;
+        isVisible: () => boolean;
+        renderItems: (value?: SingleOrArray<ListItemDef<T>>) => import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];
+        renderItemWithForm: (name: TableGridItemActionType, form?: FormRenderFunc<T>, globalState?: GlobalModalState) => import("react/jsx-runtime").JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<IProps<T>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export {};

package/dist/types/lab/table-grid/toolbar-pannel.d.ts

@@ -0,0 +1,27 @@
+import React, { Component } from 'react';
+import { BoxProps, ButtonProps } from '@mui/material';
+import { IBreadcrumbConfig } from '../../components/breadcrumbs';
+interface SectionSlots {
+    before?: React.ReactNode;
+    after?: React.ReactNode;
+}
+export interface ToolbarPannelProps {
+    /** @default true */
+    visible?: boolean;
+    searchInclude?: string[];
+    breadcrumbs?: IBreadcrumbConfig[];
+    title?: React.ReactNode;
+    titleSlots?: SectionSlots;
+    formCreate?: React.ReactNode;
+    actionSlots?: SectionSlots;
+    slots?: {
+        rootProps?: BoxProps;
+        buttonCreateProps?: ButtonProps;
+    };
+}
+declare class ToolbarPannel extends Component<ToolbarPannelProps> {
+    render(): import("react/jsx-runtime").JSX.Element | undefined;
+    renderButtonCreate: () => import("react/jsx-runtime").JSX.Element;
+    renderTitle: () => import("react/jsx-runtime").JSX.Element;
+}
+export default ToolbarPannel;

package/dist/types/lab/table-grid/types.d.ts

@@ -0,0 +1,56 @@
+import { ComponentType, ReactNode } from 'react';
+import { GridProps, RegularBreakpoints } from '@mui/material';
+import { FilterBarParams, IFilterState } from '../filter-bar';
+import { ToolbarPannelProps } from './toolbar-pannel';
+import { TableGridItemActionsConfig, TableGridItemActionsProps } from './item-actions';
+export interface TableGridItemProps<T = any> {
+    value: T;
+}
+export type GetSelecterIdFunc<T> = (item: T) => string;
+export interface PaginationModel {
+    page: number;
+    pageSize: number;
+}
+export interface TableGridFilter<T> extends IFilterState<T> {
+    pagination: PaginationModel;
+    loading?: boolean;
+}
+export interface TableGridFlexibleSlots<T> {
+    item?: ComponentType<TableGridItemProps<T>>;
+}
+export interface TableGridSlots<T> extends TableGridFlexibleSlots<T> {
+    flex?: boolean;
+    gridContainer?: GridProps;
+    gridItem?: GridProps;
+    toolbar?: ComponentType;
+    toolbarProps?: ToolbarPannelProps;
+    action?: ComponentType<TableGridItemActionsProps<T>>;
+    actionProps?: TableGridItemActionsConfig<T>;
+}
+export interface TableGridInnerSlots<T> extends TableGridSlots<T> {
+    TableGridItem: ComponentType<TableGridItemProps<T>>;
+    ToolbarPannel: ComponentType<ToolbarPannelProps>;
+}
+export interface TableGridParams<T> extends TableGridFlexibleSlots<T> {
+    getSelecterId: GetSelecterIdFunc<T>;
+    title?: ReactNode;
+    filterBarConfig?: FilterBarParams<T>;
+    size?: RegularBreakpoints;
+    slots?: TableGridSlots<T>;
+}
+export interface TableGridData<T> {
+    items?: T[];
+    totalItems?: number;
+}
+export interface TableGridProps<T> {
+    data: TableGridData<T>;
+    filter?: TableGridFilter<T>;
+    onFilterChange?: (value: TableGridFilter<T>) => void;
+    slots?: TableGridSlots<T>;
+}
+export interface TableGridReduxState<T> {
+    tableData: TableGridData<T>;
+    tableFilter: TableGridFilter<T>;
+    tableFilterThunk: TableGridFilter<T>;
+}
+export type TableGridStateRedux<T, K extends keyof TableGridReduxState<T> = keyof TableGridReduxState<T>> = Pick<TableGridReduxState<T>, K>;

package/dist/types/redux/create.hoc-lazy.d.ts

@@ -0,0 +1,19 @@
+import React, { ComponentType, PropsWithChildren } from 'react';
+import { IErrorViewDefaultProps, IHocLazyWrapperProps } from './ui.units';
+import { IDinoReduxDispatch, IDinoReduxState } from './types';
+export interface IHocLazyBase<T> extends IDinoReduxState, IDinoReduxDispatch<T> {
+}
+export interface IHocLazyBaseOptions {
+    ErrorScreen?: React.ComponentType<IErrorViewDefaultProps>;
+    LazySpinner: React.ComponentType<PropsWithChildren<IHocLazyWrapperProps>>;
+}
+export interface IHocLazyOtherProps<T> {
+    param?: T;
+}
+export interface IHocLazyOptions<T> extends IHocLazyOtherProps<T>, Omit<IHocLazyBaseOptions, 'LazySpinner'> {
+    LazySpinner?: React.ComponentType<PropsWithChildren<IHocLazyWrapperProps>>;
+}
+export declare const EmptyComponent: React.FC<React.PropsWithChildren<any>>;
+export declare const defaultOptionHocLazy: IHocLazyBaseOptions;
+declare const CreateHocLazy: <P extends IHocLazyBase<T>, T = any>(ChildComponent: React.ComponentType<P>, options?: IHocLazyOptions<T> | undefined) => React.ComponentType<P>;
+export default CreateHocLazy;

package/dist/types/redux/dino.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare class DinoReduxBase {
+    createHocLazy: <P extends import("./create.hoc-lazy").IHocLazyBase<T>, T = any>(ChildComponent: import("react").ComponentType<P>, options?: import("./create.hoc-lazy").IHocLazyOptions<T> | undefined) => import("react").ComponentType<P>;
+}
+declare const DinoRedux: DinoReduxBase;
+export default DinoRedux;

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

@@ -0,0 +1,4 @@
+export * from './types';
+export { default as DinoRedux } from './dino';
+export { default as CreateHocLazy } from './create.hoc-lazy';
+export * from './create.hoc-lazy';