@tenorlab/react-dashboard 1.0.0

package/README.md

@@ -0,0 +1,44 @@
+# @tenorlab/react-dashboard
+
+Foundation components for creating user-configurable, high-performance dashboards in React.
+
+---
+
+### Part of the Built With JavaScript Ecosystem
+**Tenorlab** is the specialized software foundry for the [@builtwithjavascript](https://github.com/builtwithjavascript) ecosystem, focusing on modular, type-safe utilities and UI kits.
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+Install the package via npm or pnpm:
+
+```bash
+npm install @tenorlab/react-dashboard
+# or
+pnpm add @tenorlab/react-dashboard
+```
+
+## Basic Usage
+TODO
+
+
+## Features
+
+- **Type-Safe:** Built with TypeScript for excellent IDE support and error catching.
+- **Configurable:** Allow end-users to add/remove widgets.
+- **Vite Optimized:** Tree-shakeable and lightweight for modern build pipelines.
+- **Themeable:** Easy integration with Tailwind CSS or CSS Variables.
+
+
+
+## Licensing
+
+This project is dual-licensed:
+
+1. **Non-Commercial / Personal Use:** Licensed under the [Polyform Non-Commercial 1.0.0](https://polyformproject.org/licenses/non-commercial/1.0.0/). Free to use for students, hobbyists, and open-source projects.
+2. **Commercial Use:** Requires a **Tenorlab Commercial License**.
+
+If you are using this library to build a product that generates revenue, or within a commercial entity, please visit [tenorlab.com/license](https://tenorlab.com/license) to purchase a commercial seat.

package/dist/components/DashboardGrid.d.ts

@@ -0,0 +1,2 @@
+import { IDashboardGridProps } from './interfaces';
+export declare const DashboardGrid: import("react").ForwardRefExoticComponent<IDashboardGridProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/DashboardWidgetBase.d.ts

@@ -0,0 +1,4 @@
+import { IDashboardWidgetProps } from './interfaces';
+export declare const DashboardWidgetBase: (props: IDashboardWidgetProps & {
+    ref?: React.ForwardedRef<HTMLDivElement>;
+}) => React.ReactElement | null;

package/dist/components/DynamicWidgetLoader.d.ts

@@ -0,0 +1,23 @@
+import type { IChildWidgetConfigEntry, TDashboardWidgetCatalog, TDashboardWidgetKey } from './interfaces';
+type TDynamicWidgetLoaderProps = {
+    index: number;
+    maxIndex: number;
+    widgetKey: TDashboardWidgetKey;
+    parentWidgetKey?: TDashboardWidgetKey;
+    targetContainerKey?: TDashboardWidgetKey;
+    childWidgetsConfig?: IChildWidgetConfigEntry[];
+    widgetCatalog: TDashboardWidgetCatalog;
+    isEditing: boolean;
+    onRemoveClick?: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    onMoveClick?: (direction: -1 | 1, widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    selectContainer?: (containerKey: TDashboardWidgetKey) => void;
+};
+/**
+ * Component to safely load and render dynamic widgets.
+ * This ensures the widget component (and its hooks) is called consistently.
+ * @param {object} props
+ * @param {string} props.widgetKey
+ * @param {(key: string) => Promise<void>} props.onRemoveClick
+ */
+export declare function DynamicWidgetLoader({ index, maxIndex, widgetKey, parentWidgetKey, targetContainerKey, childWidgetsConfig, widgetCatalog, isEditing, onRemoveClick, onMoveClick, selectContainer, }: TDynamicWidgetLoaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/WidgetContainer.d.ts

@@ -0,0 +1,4 @@
+import { IDashboardWidgetProps, IDashboardWidget } from './interfaces';
+export declare function WidgetContainerColumn(props: IDashboardWidgetProps): IDashboardWidget;
+export declare function WidgetContainerLarge(props: IDashboardWidgetProps): IDashboardWidget;
+export declare function WidgetContainerRow(props: IDashboardWidgetProps): IDashboardWidget;

package/dist/components/WidgetsCatalogFlyout.d.ts

@@ -0,0 +1,14 @@
+import { IDashboardConfig, IDashboardSettingEntry, TDashboardUndoStatus, TDashboardWidgetCatalog, TDashboardWidgetKey } from './interfaces/';
+export type TWidgetsCatalogFlyoutProps = {
+    targetContainerKey?: TDashboardWidgetKey;
+    widgetsCatalog: TDashboardWidgetCatalog;
+    currentDashboardConfig: IDashboardConfig;
+    undoStatus: TDashboardUndoStatus;
+    addWidget: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => any;
+    addContainer: (widgetKey: TDashboardWidgetKey) => any;
+    onSettingItemsUpdated: (items: IDashboardSettingEntry[]) => any;
+    onResetToDefaultDashboardClick: () => any;
+    onUndoOrRedo: (operation: 'Undo' | 'Redo') => any;
+    onDoneClick: () => any;
+};
+export declare function WidgetsCatalogFlyout({ targetContainerKey, widgetsCatalog, currentDashboardConfig, undoStatus, addWidget, addContainer, onSettingItemsUpdated, onResetToDefaultDashboardClick, onUndoOrRedo, onDoneClick, }: TWidgetsCatalogFlyoutProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboard-primitives/Buttons.d.ts

@@ -0,0 +1,2 @@
+import { IButtonProps } from './interfaces';
+export declare function Button(props: IButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboard-primitives/DraggablePanel.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties } from 'react';
+type DraggablePanelProps = {
+    testId?: string;
+    className: string;
+    style?: CSSProperties;
+    onDraggingChange?: (isDragging: boolean) => void;
+    children: React.ReactNode;
+};
+export declare const DraggablePanel: import("react").ForwardRefExoticComponent<DraggablePanelProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/dashboard-primitives/ListItem.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { TStackProps } from './Stack';
+export declare const ListItem: import("react").ForwardRefExoticComponent<TStackProps & {
+    innerClass?: string;
+} & import("react").RefAttributes<HTMLDivElement>>;
+type TListItemChildProps = {
+    testId?: string;
+    className?: string;
+    children?: ReactNode;
+};
+export declare const ListItemLeftChild: import("react").ForwardRefExoticComponent<TListItemChildProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ListItemMiddleChild: import("react").ForwardRefExoticComponent<TListItemChildProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ListItemRightChild: import("react").ForwardRefExoticComponent<TListItemChildProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/dashboard-primitives/Stack.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'react';
+export type TStackProps = {
+    testId?: string;
+    classNames?: string;
+    direction?: 'row' | 'column';
+    style?: CSSProperties;
+    children: React.ReactNode;
+};
+export declare function Stack(props: TStackProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboard-primitives/TextField.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { ITextFieldProps } from './interfaces';
+/**
+ * A reusable, styled TextField component built with Tailwind CSS.
+ */
+export declare const TextField: React.FC<ITextFieldProps>;

package/dist/components/dashboard-primitives/color-utils.d.ts

@@ -0,0 +1,12 @@
+export declare const resolveColorFromClass: (classNames: string | string[], property?: "color" | "backgroundColor") => string;
+export declare const resolvedColors: {
+    primary: string;
+    secondary: string;
+    success: string;
+    danger: string;
+    warning: string;
+    info: string;
+    disabled: string;
+    neutral: string;
+    body: string;
+};

package/dist/components/dashboard-primitives/css-vars-utils.d.ts

@@ -0,0 +1,6 @@
+import { IDashboardSettingEntry } from '../interfaces';
+export declare const cssVarsUtils: {
+    getCssVariableValue: (cssPropertyName: string) => string | null;
+    setCssVariableValue: (cssPropertyName: string, value: string) => void;
+    restoreCssVarsFromSettings: (settings: IDashboardSettingEntry[]) => void;
+};

package/dist/components/dashboard-primitives/icons/index.d.ts

@@ -0,0 +1,29 @@
+export declare function SvgBaseWrapper({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+type TIconProps = {
+    className?: string;
+};
+export declare function AddIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function DeleteIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function GridIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function MonitorIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function MonitorSmartphoneIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function MoveLeftIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function MoveRightIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function SettingsIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabletSmartphoneIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function XCircleIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function ZoomInIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function ZoomOutIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function TimerResetIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function UndoIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function RedoIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function HandIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function HandGrabIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function CrosshairIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function TargetIcon({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function CircleQuestionMark({ className }: TIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/dashboard-primitives/index.d.ts

@@ -0,0 +1,12 @@
+export * from './interfaces';
+export * from './icons';
+export * from './use-distinct-css-classes';
+export * from './color-utils';
+export * from './css-vars-utils';
+export * from './parse-container-title';
+export * from './TextField';
+export * from './Buttons';
+export * from './Stack';
+export * from './ListItem';
+export * from './DraggablePanel';
+export declare const showToast: (options: any) => void;

package/dist/components/dashboard-primitives/interfaces.d.ts

@@ -0,0 +1,46 @@
+export interface ITooltipProps {
+    placement: string;
+    title: string;
+}
+export type TButtonType = 'normal' | 'ghost';
+export type TButtonJustifyCss = 'justify-start' | 'justify-center' | 'justify-end';
+export interface IButtonProps {
+    disabled?: boolean;
+    className?: string;
+    tooltip?: ITooltipProps;
+    isIconButton?: boolean;
+    buttonType?: TButtonType;
+    category?: string;
+    font?: string;
+    border?: number;
+    borderHover?: number;
+    borderColor?: string;
+    px?: number;
+    py?: number;
+    justifyCss?: TButtonJustifyCss;
+    shadow?: string;
+    shadowHover?: string;
+    addCss?: string;
+    onClick: () => any;
+    children: React.ReactNode;
+}
+export interface ITooltipProps {
+    placement: string;
+    title: string;
+}
+export interface IButtonProps {
+    disabled?: boolean;
+    className?: string;
+    tooltip?: ITooltipProps;
+}
+type TSize = 'small' | 'medium';
+export interface ITextFieldProps {
+    label: string;
+    size?: TSize;
+    value: string;
+    className?: string;
+    placeholder?: string;
+    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+}
+export {};

package/dist/components/dashboard-primitives/parse-container-title.d.ts

@@ -0,0 +1,2 @@
+import { TDashboardWidgetKey } from '../interfaces';
+export declare const parseContainerTitle: (containerWidgetKey: TDashboardWidgetKey) => string;

package/dist/components/dashboard-primitives/use-distinct-css-classes.d.ts

@@ -0,0 +1 @@
+export declare const getDistinctCssClasses: (defaultClasses: string, ...additionalClasses: string[]) => string;

package/dist/components/dashboard-settings/dashboard-settings-utils.d.ts

@@ -0,0 +1,4 @@
+import { IDashboardSettingEntry } from '../interfaces';
+export declare const dashboardSettingsUtils: {
+    incrementOrDecrementValue: (item: IDashboardSettingEntry, direction: -1 | 1) => IDashboardSettingEntry;
+};

package/dist/components/dashboard-settings/dashboard-settings.d.ts

@@ -0,0 +1,2 @@
+import { IDashboardSettingEntry } from '../interfaces';
+export declare const cssSettingsCatalog: IDashboardSettingEntry[];

package/dist/components/dashboard-settings/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dashboard-settings';
+export * from './dashboard-settings-utils';

package/dist/components/index.d.ts

@@ -0,0 +1,11 @@
+export * from './interfaces';
+export * from './dashboard-settings';
+export * from './use-dashboard-store';
+export * from './use-dashboard-storage-service';
+export * from './use-dashboard-undo-service';
+export * from './dashboard-primitives/';
+export * from './DashboardGrid';
+export * from './DynamicWidgetLoader';
+export * from './DashboardWidgetBase';
+export * from './WidgetContainer';
+export * from './WidgetsCatalogFlyout';

package/dist/components/interfaces/core-react.interfaces.d.ts

@@ -0,0 +1,20 @@
+import type { TDashboardWidgetKey, TWidgetMetaInfoBase, IDashboardWidgetPropsBase, IDashboardGridPropsBase, TWidgetFactoryBase, IDynamicWidgetCatalogEntryBase } from './core.base';
+import type { ReactNode, ElementType, JSX } from 'react';
+export type TWidgetMetaInfo = TWidgetMetaInfoBase<ElementType | undefined>;
+export interface IDashboardGridProps extends IDashboardGridPropsBase {
+    children?: ReactNode;
+}
+export interface IDashboardWidgetProps extends IDashboardWidgetPropsBase {
+    children?: ReactNode;
+    onRemoveClick?: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    onMoveClick?: (direction: -1 | 1, widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    selectContainer?: (containerKey?: TDashboardWidgetKey) => void;
+}
+export interface IDashboardWidget extends JSX.Element {
+}
+type TFrameworkComponentType = React.ComponentType<any>;
+export type TWidgetFactory = TWidgetFactoryBase<TFrameworkComponentType>;
+export interface IDynamicWidgetCatalogEntry extends IDynamicWidgetCatalogEntryBase<TWidgetMetaInfo, TWidgetFactory, TFrameworkComponentType> {
+}
+export type TDashboardWidgetCatalog = Map<TDashboardWidgetKey, IDynamicWidgetCatalogEntry>;
+export {};

package/dist/components/interfaces/core.base.d.ts

@@ -0,0 +1,62 @@
+export type TDashboardWidgetKey = string;
+export type TWidgetCategory = 'Widget' | 'Chart' | 'Container';
+export type TWidgetMetaInfoBase<T> = {
+    displayName: string;
+    description: string;
+    categories: TWidgetCategory[];
+    noDuplicatedWidgets?: boolean;
+    icon: T | undefined;
+};
+export interface IDashboardGridPropsBase {
+    isEditing: boolean;
+    zoomScale: number;
+    responsiveGrid: boolean;
+}
+export type TWidgetSize = 'default' | 'large' | 'xlarge';
+export type TWidgetDirection = 'row' | 'column';
+export interface IDashboardWidgetPropsBase {
+    index: number;
+    maxIndex: number;
+    widgetKey: TDashboardWidgetKey;
+    parentWidgetKey?: TDashboardWidgetKey;
+    isEditing: boolean;
+    highlight?: boolean;
+    testId?: string;
+    title?: string;
+    size?: TWidgetSize;
+    borderCssClasses?: string;
+    backgroundCssClasses?: string;
+    hideTitle?: boolean;
+    noShadow?: boolean;
+    noBorder?: boolean;
+    noPadding?: boolean;
+    direction?: TWidgetDirection;
+}
+/**
+ * 1. Define the Async Loader type
+ * Type for the function that performs the asynchronous dynamic import.
+ * It must return a promise that resolves to the module containing the widget component
+ * as its default export (or a named export if you change the loading strategy).
+ *
+ * T could be "React.ComponentType<any>"" or "VueComponent" etc
+ */
+export type TWidgetFactoryBase<T> = () => Promise<{
+    default: T;
+}>;
+/**
+ * 2. Define the flexible Catalog Entry
+ * Definition of a single widget or container in the catalog.
+ * It must have EITHER a direct 'component' reference OR a 'loader' function.
+ *
+ * TWidgetMetaInfo: see TWidgetMetaInfoBase
+ * TWidgetFactory: see TWidgetFactoryBase
+ * TComponent: i.e. React.ComponentType<any>
+ */
+export interface IDynamicWidgetCatalogEntryBase<TMeta, TFactory, TComponent> {
+    key: TDashboardWidgetKey;
+    title: string;
+    isContainer?: boolean;
+    meta?: TMeta;
+    component?: TComponent;
+    loader?: TFactory;
+}

package/dist/components/interfaces/core.interfaces.d.ts

@@ -0,0 +1,40 @@
+export * from './core-react.interfaces';
+import type { TDashboardWidgetKey } from './core.base';
+export interface IChildWidgetConfigEntry {
+    parentWidgetKey: TDashboardWidgetKey;
+    widgetKey: TDashboardWidgetKey;
+}
+export interface IDashboardSettingEntry {
+    key: string;
+    displayName: string;
+    description: string;
+    cssProperty: string;
+    step: number;
+    defaultUnit: string;
+    minValue: number;
+    defaultValue: string;
+    value: string;
+}
+export interface IDashboardConfig {
+    userID: number | string;
+    clientAppKey: string;
+    dashboardId: string;
+    dashboardName: string;
+    zoomScale: number;
+    responsiveGrid: boolean;
+    widgets: TDashboardWidgetKey[];
+    childWidgetsConfig: IChildWidgetConfigEntry[];
+    cssSettings: IDashboardSettingEntry[];
+    _version?: number;
+    _stateDescription?: string;
+}
+export type TUndoHistoryEntry = {
+    undoIndex: number;
+    config: IDashboardConfig;
+};
+export type TDashboardUndoStatus = {
+    isUndoDisabled: boolean;
+    isRedoDisabled: boolean;
+    _currentIndex?: number;
+    _historyLength?: number;
+};

package/dist/components/interfaces/core.utils.d.ts

@@ -0,0 +1,28 @@
+import type { TDashboardWidgetKey } from './core.base';
+import type { IDashboardConfig, TWidgetMetaInfo, TDashboardWidgetCatalog } from './core.interfaces';
+export declare const blankDashboardConfig: IDashboardConfig;
+export declare const DashboardMinZoomScale: 0.7;
+export declare const DashboardMaxZoomScale: 1;
+export declare const DashboardZoomStep: 0.05;
+export declare const ensureZoomScaleIsWithinRange: (value: number) => number;
+export declare const getNewZoomScaleWithinRange: (currentZoomScale: number, direction: -1 | 1) => number;
+/**
+ * @name getDefaultWidgetMetaFromMap
+ * @description Helper to get widget meta info from the catalog by key.
+ */
+export declare const getDefaultWidgetMetaFromMap: (widgetKey: TDashboardWidgetKey, defaultWidgetMetaMap: Record<TDashboardWidgetKey, TWidgetMetaInfo>, options?: {
+    title?: string;
+    description?: string;
+}) => TWidgetMetaInfo;
+/**
+ * @name getWidgetMetaFromCatalog
+ * @description Helper to get widget meta info from the catalog by key.
+ */
+export declare const getWidgetMetaFromCatalog: (widgetKey: TDashboardWidgetKey, widgetsCatalog: TDashboardWidgetCatalog) => TWidgetMetaInfo;
+export declare const removeEmptyContainers: (dashboardConfig: IDashboardConfig) => IDashboardConfig;
+/**
+ * @name ensureContainersSequence
+ * @description
+ * Ensures that the container widgets are numbered sequentially in the dashboardConfig, but the original order is preserved.
+ */
+export declare const ensureContainersSequence: (dashboardConfig: IDashboardConfig) => IDashboardConfig;

package/dist/components/interfaces/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core.base';
+export * from './core.interfaces';
+export * from './storage-service.interfaces';
+export * from './core.utils';
+import type { TDashboardWidgetKey } from './core.base';
+import type { IDynamicWidgetCatalogEntry } from './core-react.interfaces';
+export type TDashboardWidgetCatalog = Map<TDashboardWidgetKey, IDynamicWidgetCatalogEntry>;

package/dist/components/interfaces/storage-service.interfaces.d.ts

@@ -0,0 +1,7 @@
+import type { TDashboardWidgetCatalog, IDashboardConfig } from './core.interfaces';
+export type TGetSavedDashboards = (userID: number | string, clientAppKey: string, widgetCatalog: TDashboardWidgetCatalog, defaultDashboardConfig: IDashboardConfig) => Promise<IDashboardConfig[]>;
+export type TSaveDashboards = (userID: number | string, clientAppKey: string, dashboardConfigs: IDashboardConfig[], widgetCatalog: TDashboardWidgetCatalog) => Promise<boolean>;
+export interface IDashboardStorageService {
+    getSavedDashboards: TGetSavedDashboards;
+    saveDashboards: TSaveDashboards;
+}

package/dist/components/use-dashboard-storage-service.d.ts

@@ -0,0 +1,2 @@
+import { IDashboardStorageService } from './interfaces';
+export declare const useDashboardStorageService: () => IDashboardStorageService;

package/dist/components/use-dashboard-store.d.ts

@@ -0,0 +1,33 @@
+import { IDashboardConfig, TDashboardWidgetKey } from './interfaces';
+type TAddWidgetResponse = {
+    success: boolean;
+    message?: string;
+    updatedDashboardConfig: IDashboardConfig;
+    allUpdatedDashboardConfigs: IDashboardConfig[];
+};
+type TRemoveWidgetResponse = TAddWidgetResponse;
+type TDashboardSlice = {
+    isLoading: boolean;
+    isEditing: boolean;
+    allDashboardConfigs: IDashboardConfig[];
+    currentDashboardConfig: IDashboardConfig;
+    targetContainerKey?: TDashboardWidgetKey | undefined;
+    getNextContainerKey: (containerWidgetKey: TDashboardWidgetKey) => TDashboardWidgetKey;
+    setIsLoading: (value: boolean) => boolean;
+    setIsEditing: (value: boolean) => boolean;
+    setTargetContainerKey: (value: TDashboardWidgetKey | undefined) => TDashboardWidgetKey | undefined;
+    setAllDashboardConfigs: (value: IDashboardConfig[]) => IDashboardConfig[];
+    setCurrentDashboardConfig: (value: IDashboardConfig) => IDashboardConfig[];
+    addDashboardConfig: (value: IDashboardConfig) => IDashboardConfig[];
+    deleteDashboardConfigById: (value: string) => IDashboardConfig[];
+    selectDashboardById: (dashboardId: string) => IDashboardConfig | undefined;
+    addWidget: (params: {
+        widgetKey: TDashboardWidgetKey;
+        parentWidgetKey?: TDashboardWidgetKey;
+        noDuplicatedWidgets?: boolean;
+    }) => TAddWidgetResponse;
+    removeWidget: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => TRemoveWidgetResponse;
+    moveWidget: (direction: -1 | 1, widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => TRemoveWidgetResponse;
+};
+export declare const useDashboardStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TDashboardSlice>>;
+export {};

package/dist/components/use-dashboard-undo-service.d.ts

@@ -0,0 +1,13 @@
+import { IDashboardConfig, TUndoHistoryEntry, TDashboardUndoStatus } from './interfaces';
+export declare const useDashboardUndoService: () => {
+    initializeHistoryForDashboard: (initialConfig: IDashboardConfig) => void;
+    resetAllHistory: () => void;
+    addUndoEntry: (newConfig: IDashboardConfig) => void;
+    removeUndoHistoryForDashboard: (dashboardId: string) => void;
+    undo: (currentDashboardId: string) => void;
+    redo: (currentDashboardId: string) => void;
+    getUndoStatus: (currentDashboardId: string) => TDashboardUndoStatus;
+    undoHistory: Record<string, TUndoHistoryEntry[]>;
+    historyIndex: Record<string, number>;
+};
+export type TDashboardUndoService = ReturnType<typeof useDashboardUndoService>;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './components/';