@tetherto/mdk-react-devkit 0.0.0-stage → 0.12.1

package/dist/domain/utils/chart-data-check.d.ts

@@ -0,0 +1,77 @@
+import type { ChartDataset, UnknownRecord } from '../../primitives/index.js';
+/**
+ * Chart data with multiple datasets (e.g., LineChart)
+ */
+type ChartDataWithDatasets = {
+    datasets: ChartDataset[];
+    [key: string]: unknown;
+};
+/**
+ * Chart data with single dataset (e.g., some custom charts)
+ */
+type ChartDataWithDataset = {
+    dataset: UnknownRecord | unknown[];
+    [key: string]: unknown;
+};
+/**
+ * Generic chart data type
+ */
+type ChartData = ChartDataWithDatasets | ChartDataWithDataset | Record<string, unknown> | unknown[];
+type UseChartDataCheckParams = {
+    /**
+     * Direct dataset for BarChart components
+     */
+    dataset?: UnknownRecord | unknown[];
+    /**
+     * Data object containing datasets or dataset
+     */
+    data?: ChartData;
+};
+/**
+ * Hook to check if chart data is empty or unavailable
+ *
+ * Returns `true` if data is empty/unavailable (should show empty state)
+ * Returns `false` if data exists (should show chart)
+ *
+ * @param dataset - Direct dataset for BarChart components
+ * @param dataset.dataset - Dataset property inside the dataset parameter (for custom charts)
+ * @param dataset.data - Data property inside the dataset parameter (for charts with data object)
+ * @returns Boolean indicating if data is empty
+ *
+ * @example
+ * // BarChart with direct dataset
+ * ```tsx
+ * const isEmpty = useChartDataCheck({ dataset: barChartDataset })
+ *
+ * if (isEmpty) {
+ *   return <EmptyState message="No data available" />
+ * }
+ *
+ * return <BarChart data={dataset} />
+ * ```
+ *
+ * @example
+ * // LineChart with data.datasets
+ * ```tsx
+ * const isEmpty = useChartDataCheck({ data: lineChartData })
+ *
+ * if (isEmpty) {
+ *   return <EmptyState message="No chart data" />
+ * }
+ *
+ * return <LineChart data={data} />
+ * ```
+ *
+ * @example
+ * // Custom chart with data.dataset
+ * ```tsx
+ * const isEmpty = useChartDataCheck({ data: { dataset: customData } })
+ *
+ * return isEmpty ? <EmptyState /> : <CustomChart data={data} />
+ * ```
+ * @category charts
+ * @domain generic
+ * @tier agent-ready
+ */
+export declare const useChartDataCheck: ({ dataset, data }: UseChartDataCheckParams) => boolean;
+export {};

package/dist/domain/utils/chart-data-check.js

@@ -0,0 +1,79 @@
+import { getChartDataAvailability, hasDataValues, isNil } from '../../primitives/index.js';
+/**
+ * Type guard to check if data has datasets property (LineChart)
+ */
+const hasDatasets = (data) => {
+    return (typeof data === 'object' &&
+        !isNil(data) &&
+        !Array.isArray(data) &&
+        'datasets' in data &&
+        Array.isArray(data.datasets));
+};
+/**
+ * Type guard to check if data has dataset property (custom charts)
+ */
+const hasDataset = (data) => {
+    return typeof data === 'object' && !isNil(data) && !Array.isArray(data) && 'dataset' in data;
+};
+/**
+ * Hook to check if chart data is empty or unavailable
+ *
+ * Returns `true` if data is empty/unavailable (should show empty state)
+ * Returns `false` if data exists (should show chart)
+ *
+ * @param dataset - Direct dataset for BarChart components
+ * @param dataset.dataset - Dataset property inside the dataset parameter (for custom charts)
+ * @param dataset.data - Data property inside the dataset parameter (for charts with data object)
+ * @returns Boolean indicating if data is empty
+ *
+ * @example
+ * // BarChart with direct dataset
+ * ```tsx
+ * const isEmpty = useChartDataCheck({ dataset: barChartDataset })
+ *
+ * if (isEmpty) {
+ *   return <EmptyState message="No data available" />
+ * }
+ *
+ * return <BarChart data={dataset} />
+ * ```
+ *
+ * @example
+ * // LineChart with data.datasets
+ * ```tsx
+ * const isEmpty = useChartDataCheck({ data: lineChartData })
+ *
+ * if (isEmpty) {
+ *   return <EmptyState message="No chart data" />
+ * }
+ *
+ * return <LineChart data={data} />
+ * ```
+ *
+ * @example
+ * // Custom chart with data.dataset
+ * ```tsx
+ * const isEmpty = useChartDataCheck({ data: { dataset: customData } })
+ *
+ * return isEmpty ? <EmptyState /> : <CustomChart data={data} />
+ * ```
+ * @category charts
+ * @domain generic
+ * @tier agent-ready
+ */
+export const useChartDataCheck = ({ dataset, data }) => {
+    // Priority 1: Check direct dataset (BarChart pattern)
+    if (dataset !== undefined) {
+        return !hasDataValues(dataset);
+    }
+    // Priority 2: Check data.datasets (LineChart pattern)
+    if (data !== undefined && hasDatasets(data)) {
+        return !getChartDataAvailability(data.datasets);
+    }
+    // Priority 3: Check data.dataset (custom chart pattern)
+    if (data !== undefined && hasDataset(data)) {
+        return !hasDataValues(data.dataset);
+    }
+    // No valid data provided - show empty state
+    return true;
+};

package/dist/domain/utils/container-utils.d.ts

@@ -0,0 +1 @@
+export declare const getContainerName: (container: string | undefined, type?: string) => string;

package/dist/domain/utils/container-utils.js

@@ -0,0 +1,58 @@
+import _capitalize from 'lodash/capitalize';
+import _includes from 'lodash/includes';
+import _isEmpty from 'lodash/isEmpty';
+import _slice from 'lodash/slice';
+import _split from 'lodash/split';
+import _toLower from 'lodash/toLower';
+import _toUpper from 'lodash/toUpper';
+import { COMPLETE_CONTAINER_TYPE, CONTAINER_MODEL, CONTAINER_TYPE, CONTAINER_TYPE_NAME_MAP, MAINTENANCE_CONTAINER, } from '../constants/container-constants';
+import { separateByHyphenRegExp, separateByTwoHyphensRegExp } from './device-utils';
+const isBitdeer = (type) => _includes(_toLower(type), CONTAINER_TYPE.BITDEER) ||
+    _includes(_toLower(type), CONTAINER_MODEL.BITDEER);
+const isMicroBT = (type) => _includes(_toLower(type), CONTAINER_TYPE.MICROBT) ||
+    _includes(_toLower(type), CONTAINER_MODEL.MICROBT);
+export const getContainerName = (container, type) => {
+    if (_isEmpty(container)) {
+        return '';
+    }
+    if (container === MAINTENANCE_CONTAINER) {
+        return 'Maintenance';
+    }
+    const isBitdeerContainer = isBitdeer(container) || isBitdeer(type);
+    const isMicroBTContainer = isMicroBT(container) || isMicroBT(type);
+    if (isBitdeerContainer || isMicroBTContainer) {
+        const [name, id] = _slice((container || '').match(separateByHyphenRegExp) || [], 1);
+        const containerName = `${_capitalize(name)} ${id}`;
+        if (!type) {
+            return containerName;
+        }
+        const [, containerModel] = _slice((type || '').match(separateByHyphenRegExp) || [], 1);
+        if (isMicroBTContainer) {
+            let typeKey;
+            if (_includes(COMPLETE_CONTAINER_TYPE.MICROBT_ALPHA, containerModel)) {
+                typeKey = COMPLETE_CONTAINER_TYPE.MICROBT_ALPHA;
+            }
+            else if (_includes(COMPLETE_CONTAINER_TYPE.MICROBT_BETA, containerModel)) {
+                typeKey = COMPLETE_CONTAINER_TYPE.MICROBT_BETA;
+            }
+            if (!typeKey) {
+                return `MicroBT ${id}`;
+            }
+            const [name, model] = _split(CONTAINER_TYPE_NAME_MAP[typeKey], ' ');
+            return `${name} ${id} ${model}`;
+        }
+        // Bitdeer labels
+        return `${containerName} ${_toUpper(containerModel)}`;
+    }
+    const twoHyphenMatch = (container || '').match(separateByTwoHyphensRegExp);
+    if (twoHyphenMatch) {
+        const [name, model, id] = _slice(twoHyphenMatch, 1);
+        return `${_capitalize(name)} ${_capitalize(model)} ${id}`;
+    }
+    const singleHyphenMatch = (container || '').match(separateByHyphenRegExp);
+    if (singleHyphenMatch) {
+        const [name, id] = _slice(singleHyphenMatch, 1);
+        return `${_capitalize(name)} ${id}`;
+    }
+    return _capitalize(container);
+};

package/dist/domain/utils/device-utils.d.ts

@@ -0,0 +1,46 @@
+import type { UnknownRecord } from '../../primitives/index.js';
+import { appendContainerToTag, appendIdToTag, appendIdToTags, isAntminer, isAvalon, isContainer, isMiner, isWhatsminer, removeContainerPrefix } from '@tetherto/mdk-ui-foundation';
+import type { Device, DeviceData } from '../types/device';
+import { MINER_POWER_MODE } from './status-utils';
+export declare const separateByHyphenRegExp: RegExp;
+export declare const separateByTwoHyphensRegExp: RegExp;
+export declare const getMinerName: (type: string) => string;
+export { removeContainerPrefix };
+export declare const isMinerOffline: (device: UnknownRecord) => boolean;
+export declare const PowerModeColors: Record<(typeof MINER_POWER_MODE)[keyof typeof MINER_POWER_MODE], string>;
+export declare const getPowerModeColor: (powerMode: keyof typeof PowerModeColors) => string;
+export declare const formatPowerConsumption: (powerW: number, forceUnit?: string | null) => {
+    value: number | null;
+    unit: string;
+    realValue: number;
+};
+export declare const getHashrateUnit: (hashRateMHS: number, decimal?: number, forceUnit?: string | null, treatZeroAsNoData?: boolean) => {
+    value: number | null;
+    unit: string;
+    realValue: number;
+};
+export declare const getHashrateString: (value: number, treatZeroAsNoData?: boolean) => string;
+export declare const getOnOffText: (isOn: unknown, fallback?: string) => string;
+/**
+ * Extract and normalize device data from a Device object
+ *
+ * @param device - Device object to extract data from
+ * @returns Tuple of [error, deviceData]
+ *
+ * @example
+ * ```ts
+ * const [error, deviceData] = getDeviceData(device)
+ * if (error) {
+ *   console.error('Device error:', error)
+ * }
+ * if (deviceData) {
+ *   console.log('Device stats:', deviceData.snap.stats)
+ * }
+ * ```
+ */
+export declare const getDeviceData: (device: Device | null | undefined) => [error: string | undefined | null, data: DeviceData | undefined];
+export { appendContainerToTag };
+export { isContainer, isMiner };
+export { appendIdToTag, appendIdToTags };
+export { isAntminer, isAvalon, isWhatsminer };
+export declare const getMinerShortCode: (code: string | undefined, tags: string[] | undefined, defaultValue?: string) => string;

package/dist/domain/utils/device-utils.js

@@ -0,0 +1,164 @@
+import { FALLBACK, formatHashrateUnit, HASHRATE_LABEL_DIVISOR, UNITS, } from '../../primitives/index.js';
+import { appendContainerToTag, appendIdToTag, appendIdToTags, isAntminer, isAvalon, isContainer, isMiner, isWhatsminer, removeContainerPrefix } from '@tetherto/mdk-ui-foundation';
+import _capitalize from 'lodash/capitalize';
+import _find from 'lodash/find';
+import _isBoolean from 'lodash/isBoolean';
+import _isEmpty from 'lodash/isEmpty';
+import _isFinite from 'lodash/isFinite';
+import _map from 'lodash/map';
+import _orderBy from 'lodash/orderBy';
+import _round from 'lodash/round';
+import _slice from 'lodash/slice';
+import _toUpper from 'lodash/toUpper';
+import { MINER_MODEL_TO_TYPE_MAP, MinerStatuses, } from '../constants/device-constants';
+import { MINER_POWER_MODE } from './status-utils';
+const FLOAT_PRECISION = 2;
+const DEVICE_NOT_FOUND_MESSAGE = 'Device Not Found';
+export const separateByHyphenRegExp = /^([^_]+)-([^_-]+)$/;
+export const separateByTwoHyphensRegExp = /^([^_]+)-([^_-]+)-([^_-]+)$/;
+const allUnits = _orderBy(_map(HASHRATE_LABEL_DIVISOR, (value, unit) => ({ unit, value })), ['value'], ['desc']);
+export const getMinerName = (type) => {
+    const [, name, id] = _slice(type.match(separateByTwoHyphensRegExp), 1);
+    return `${_capitalize(MINER_MODEL_TO_TYPE_MAP[name])} ${_toUpper(id)}`;
+};
+const getLast = (data) => data?.last || {};
+const getSnap = (data) => getLast(data)?.snap || {};
+const getStats = (data) => getSnap(data)?.stats || {};
+const getConfig = (data) => getSnap(data)?.config || {};
+export { removeContainerPrefix };
+export const isMinerOffline = (device) => {
+    const stats = getStats(device);
+    const isEmptyStats = _isEmpty(stats);
+    const isEmptyConfig = _isEmpty(getConfig(device));
+    const isOffline = stats?.status === MinerStatuses.OFFLINE;
+    return (isEmptyStats && isEmptyConfig) || isOffline;
+};
+export const PowerModeColors = {
+    [MINER_POWER_MODE.SLEEP]: 'rgb(var(--mdk-power-mode-sleep-color))',
+    [MINER_POWER_MODE.LOW]: 'var(--mdk-power-mode-low-color)',
+    [MINER_POWER_MODE.NORMAL]: 'var(--mdk-power-mode-normal-color)',
+    [MINER_POWER_MODE.HIGH]: 'var(--mdk-power-mode-high-color)',
+};
+export const getPowerModeColor = (powerMode) => PowerModeColors[powerMode];
+export const formatPowerConsumption = (powerW, forceUnit = null) => {
+    if (!_isFinite(powerW)) {
+        return { value: null, unit: '', realValue: powerW };
+    }
+    // If a unit is forced, use it
+    if (forceUnit === UNITS.ENERGY_MW) {
+        return { value: powerW / 1e6, unit: UNITS.ENERGY_MW, realValue: powerW };
+    }
+    if (forceUnit === UNITS.POWER_KW) {
+        return { value: powerW / 1e3, unit: UNITS.POWER_KW, realValue: powerW };
+    }
+    if (forceUnit === UNITS.POWER_W) {
+        return { value: powerW, unit: UNITS.POWER_W, realValue: powerW };
+    }
+    // Default behavior: auto-select unit based on magnitude
+    if (Math.abs(powerW) >= 1e6) {
+        return { value: powerW / 1e6, unit: UNITS.ENERGY_MW, realValue: powerW };
+    }
+    if (Math.abs(powerW) >= 1e3) {
+        return { value: powerW / 1e3, unit: UNITS.POWER_KW, realValue: powerW };
+    }
+    return { value: powerW, unit: UNITS.POWER_W, realValue: powerW };
+};
+export const getHashrateUnit = (hashRateMHS, decimal = FLOAT_PRECISION, forceUnit = null, treatZeroAsNoData = false) => {
+    if (!_isFinite(hashRateMHS) || (treatZeroAsNoData && hashRateMHS === 0)) {
+        return { value: null, unit: '', realValue: hashRateMHS };
+    }
+    // If a unit is forced, use it
+    if (forceUnit) {
+        const divisor = HASHRATE_LABEL_DIVISOR[forceUnit];
+        if (divisor !== undefined) {
+            return {
+                value: _round(hashRateMHS / divisor, decimal),
+                unit: forceUnit,
+                realValue: hashRateMHS,
+            };
+        }
+    }
+    // Default behavior: auto-select unit based on magnitude
+    const absHash = Math.abs(hashRateMHS);
+    const unitToUse = _find(allUnits, (item) => absHash >= item.value) || {
+        unit: UNITS.HASHRATE_MH_S,
+        value: 1,
+    };
+    return {
+        value: _round(hashRateMHS / unitToUse.value, decimal),
+        unit: unitToUse.unit,
+        realValue: hashRateMHS,
+    };
+};
+export const getHashrateString = (value, treatZeroAsNoData = false) => formatHashrateUnit(getHashrateUnit(value, FLOAT_PRECISION, null, treatZeroAsNoData));
+export const getOnOffText = (isOn, fallback = FALLBACK) => {
+    if (!_isBoolean(isOn)) {
+        return fallback;
+    }
+    if (isOn) {
+        return 'On';
+    }
+    return 'Off';
+};
+/**
+ * Extract and normalize device data from a Device object
+ *
+ * @param device - Device object to extract data from
+ * @returns Tuple of [error, deviceData]
+ *
+ * @example
+ * ```ts
+ * const [error, deviceData] = getDeviceData(device)
+ * if (error) {
+ *   console.error('Device error:', error)
+ * }
+ * if (deviceData) {
+ *   console.log('Device stats:', deviceData.snap.stats)
+ * }
+ * ```
+ */
+export const getDeviceData = (device) => {
+    if (!device) {
+        return [DEVICE_NOT_FOUND_MESSAGE, undefined];
+    }
+    const { id, type, tags, last, info, address } = device;
+    // If no last data, return error with empty snap
+    if (!last) {
+        return [
+            undefined,
+            {
+                id,
+                type,
+                tags,
+                info,
+                address,
+                snap: { stats: {}, config: {} },
+                err: 'Last Device info not found',
+            },
+        ];
+    }
+    const { err, snap, alerts } = last;
+    return [
+        err,
+        {
+            id,
+            type,
+            tags,
+            snap: snap ?? { stats: {}, config: {} },
+            alerts,
+            info,
+            address,
+            err,
+        },
+    ];
+};
+export { appendContainerToTag };
+export { isContainer, isMiner };
+export { appendIdToTag, appendIdToTags };
+export { isAntminer, isAvalon, isWhatsminer };
+export const getMinerShortCode = (code, tags, defaultValue = 'N/A') => {
+    if (code)
+        return code;
+    const codeTag = tags?.find((tag) => tag.startsWith('code-') && !tag.endsWith('undefined'));
+    return codeTag ? codeTag.replace('code-', '') : defaultValue;
+};

package/dist/domain/utils/list-view-utils.d.ts

@@ -0,0 +1,5 @@
+import type { CascaderOption } from '../../primitives/index.js';
+export type FilterOption = CascaderOption & {
+    tab?: string[];
+    order?: number;
+};

package/dist/domain/utils/list-view-utils.js

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

package/dist/domain/utils/notification-utils.d.ts

@@ -0,0 +1,26 @@
+import type { ToastPosition, ToastVariant } from '../../primitives/index.js';
+/**
+ * This service uses static notification API which cannot consume React context.
+ * For React components and hooks, use the `useNotification` hook instead.
+ * This service is kept only for utility functions that cannot use React hooks.
+ */
+type ToastItem = {
+    id: string;
+    title: string;
+    duration: number;
+    description?: string;
+    variant: ToastVariant;
+    onClose: VoidFunction;
+    position: ToastPosition;
+};
+export declare const addToast: (toast: Omit<ToastItem, 'id'>) => void;
+/**
+ * Tears down the static toast portal (React root, DOM node, in-memory queue).
+ * Used by tests so auto-close timers cannot flush after the environment is destroyed.
+ */
+export declare const resetToastPortalForTests: () => void;
+export declare const notifySuccess: (message: string, description: string) => void;
+export declare const notifyError: (message: string, description: string, dontClose?: boolean) => void;
+export declare const notifyInfo: (message: string, description: string) => void;
+export declare const notifyWarning: (message: string, description: string) => void;
+export {};

package/dist/domain/utils/notification-utils.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { notificationStore } from '@tetherto/mdk-ui-foundation';
+import { createRoot } from 'react-dom/client';
+import { Toast, Toaster } from '../../primitives/index.js';
+import { useEffect, useState } from 'react';
+const TOAST_DURATION = 3_000;
+// Global toast container management
+let toastContainer = null;
+let toastRoot = null;
+let toasts = [];
+let setToastsCallback = null;
+const getToastContainer = () => {
+    if (!toastContainer) {
+        toastContainer = document.createElement('div');
+        toastContainer.id = 'notification-service-container';
+        document.body.appendChild(toastContainer);
+    }
+    return toastContainer;
+};
+const ToastContainer = ({ position = 'top-left' }) => {
+    const [currentToasts, setCurrentToasts] = useState(toasts);
+    useEffect(() => {
+        setToastsCallback = setCurrentToasts;
+        return () => {
+            setToastsCallback = null;
+        };
+    }, []);
+    const removeToast = (id) => {
+        toasts = toasts.filter((toast) => toast.id !== id);
+        setToastsCallback?.(toasts);
+    };
+    return (_jsx(Toaster, { position: position, children: currentToasts.map((toast) => (_jsx(Toast, { variant: toast.variant, title: toast.title, description: toast.description, duration: toast.duration, onOpenChange: (open) => {
+                if (!open) {
+                    removeToast(toast.id);
+                    toast.onClose();
+                }
+            } }, toast.id))) }));
+};
+export const addToast = (toast) => {
+    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const newToast = { ...toast, id };
+    toasts = [...toasts, newToast];
+    // Initialize container on first toast
+    if (!toastRoot) {
+        const container = getToastContainer();
+        toastRoot = createRoot(container);
+    }
+    toastRoot.render(_jsx(ToastContainer, { position: toast.position }));
+    setToastsCallback?.(toasts);
+};
+/**
+ * Tears down the static toast portal (React root, DOM node, in-memory queue).
+ * Used by tests so auto-close timers cannot flush after the environment is destroyed.
+ */
+export const resetToastPortalForTests = () => {
+    if (toastRoot) {
+        toastRoot.unmount();
+        toastRoot = null;
+    }
+    if (toastContainer) {
+        toastContainer.remove();
+        toastContainer = null;
+    }
+    toasts = [];
+    setToastsCallback = null;
+};
+const openNotification = (variant, message, description, duration, position) => {
+    notificationStore.getState().increment();
+    addToast({
+        variant,
+        title: message,
+        duration,
+        description,
+        position,
+        onClose() {
+            notificationStore.getState().decrement();
+        },
+    });
+};
+export const notifySuccess = (message, description) => {
+    openNotification('success', message, description, TOAST_DURATION, 'top-left');
+};
+export const notifyError = (message, description, dontClose) => {
+    openNotification('error', message, description, dontClose ? 0 : TOAST_DURATION, 'top-left');
+};
+export const notifyInfo = (message, description) => {
+    openNotification('info', message, description, TOAST_DURATION, 'top-left');
+};
+export const notifyWarning = (message, description) => {
+    openNotification('warning', message, description, TOAST_DURATION, 'top-left');
+};

package/dist/domain/utils/status-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Re-exports of the data-layer status literals now owned by
+ * `@tetherto/mdk-ui-foundation`. Kept here so existing imports under
+ * `foundation/utils/status-utils` keep resolving.
+ *
+ * `THRESHOLD_LEVEL` is presentation-only (the alarm gradient the
+ * heatmap uses) and stays in devkit.
+ */
+export { CONTAINER_STATUS, MINER_POWER_MODE, SOCKET_STATUSES } from '@tetherto/mdk-ui-foundation';
+export type { MinerStatus, SocketStatus } from '@tetherto/mdk-ui-foundation';
+export declare const THRESHOLD_LEVEL: {
+    readonly CRITICAL_LOW: 'criticalLow';
+    readonly ALARM_LOW: 'alarmLow';
+    readonly ALERT: 'alert';
+    readonly NORMAL: 'normal';
+    readonly ALARM: 'alarm';
+    readonly ALARM_HIGH: 'alarmHigh';
+    readonly CRITICAL_HIGH: 'criticalHigh';
+};

package/dist/domain/utils/status-utils.js

@@ -0,0 +1,18 @@
+/**
+ * Re-exports of the data-layer status literals now owned by
+ * `@tetherto/mdk-ui-foundation`. Kept here so existing imports under
+ * `foundation/utils/status-utils` keep resolving.
+ *
+ * `THRESHOLD_LEVEL` is presentation-only (the alarm gradient the
+ * heatmap uses) and stays in devkit.
+ */
+export { CONTAINER_STATUS, MINER_POWER_MODE, SOCKET_STATUSES } from '@tetherto/mdk-ui-foundation';
+export const THRESHOLD_LEVEL = {
+    CRITICAL_LOW: 'criticalLow',
+    ALARM_LOW: 'alarmLow',
+    ALERT: 'alert',
+    NORMAL: 'normal',
+    ALARM: 'alarm',
+    ALARM_HIGH: 'alarmHigh',
+    CRITICAL_HIGH: 'criticalHigh',
+};

package/dist/domain/utils/use-notification.d.ts

@@ -0,0 +1,39 @@
+import type { ToastPosition } from '../../primitives/index.js';
+export type NotificationOptions = {
+    /**
+     * Duration in milliseconds (0 = no auto-close)
+     * @default 3000
+     */
+    duration?: number;
+    /**
+     * Toast position on screen
+     * @default 'top-left'
+     */
+    position?: ToastPosition;
+    /**
+     * Prevent auto-close (keeps toast open until manually closed)
+     * @default false
+     */
+    dontClose?: boolean;
+};
+/**
+ * Custom hook for showing notifications backed by the headless `notificationStore`.
+ * Uses `@tetherto/mdk-react-devkit/primitives` Toast and Toaster components.
+ *
+ * @example
+ * ```tsx
+ * const { notifySuccess, notifyError } = useNotification()
+ *
+ * notifySuccess('Success', 'Your changes were saved.')
+ * notifyError('Error', 'Something went wrong.', { dontClose: true })
+ * ```
+ * @category feedback
+ * @domain generic
+ * @tier agent-ready
+ */
+export declare const useNotification: () => {
+    notifySuccess: (message: string, description?: string, options?: NotificationOptions) => void;
+    notifyError: (message: string, description?: string, options?: NotificationOptions) => void;
+    notifyInfo: (message: string, description?: string, options?: NotificationOptions) => void;
+    notifyWarning: (message: string, description?: string, options?: NotificationOptions) => void;
+};