@fgv/ts-app-shell 5.1.0-1

package/lib/packlets/editing/useTypeaheadMatch.js

@@ -0,0 +1,105 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTypeaheadMatch = useTypeaheadMatch;
+/**
+ * Reusable typeahead matching hook with tiered priority support.
+ * @packageDocumentation
+ */
+const react_1 = require("react");
+// ============================================================================
+// Hook
+// ============================================================================
+/**
+ * Hook that provides typeahead matching and filtering with tiered priority support.
+ *
+ * `findExactMatch` matches by exact id or case-insensitive name (checks priority first).
+ * `resolveOnBlur` tries exact match, then single partial match (priority first).
+ * `filterSuggestions` returns suggestions split by tier, filtered by substring match.
+ *
+ * @param suggestions - The full catalog of suggestions
+ * @param prioritySuggestions - Optional priority suggestions shown first (e.g. recipe alternates)
+ * @returns Match and filter functions
+ * @public
+ */
+function useTypeaheadMatch(suggestions, prioritySuggestions) {
+    // Pre-compute priority IDs for efficient catalog deduplication
+    const priorityIds = (0, react_1.useMemo)(() => { var _a; return new Set((_a = prioritySuggestions === null || prioritySuggestions === void 0 ? void 0 : prioritySuggestions.map((s) => s.id)) !== null && _a !== void 0 ? _a : []); }, [prioritySuggestions]);
+    const findExactMatch = (0, react_1.useCallback)((input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return undefined;
+        const lower = trimmed.toLowerCase();
+        if (prioritySuggestions) {
+            const match = prioritySuggestions.find((s) => s.id === trimmed || s.name.toLowerCase() === lower);
+            if (match)
+                return match;
+        }
+        return suggestions.find((s) => s.id === trimmed || s.name.toLowerCase() === lower);
+    }, [suggestions, prioritySuggestions]);
+    const resolveOnBlur = (0, react_1.useCallback)((input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return undefined;
+        const lower = trimmed.toLowerCase();
+        // Try exact match (priority first, then all)
+        if (prioritySuggestions) {
+            const priorityExact = prioritySuggestions.find((s) => s.id === trimmed || s.name.toLowerCase() === lower);
+            if (priorityExact)
+                return priorityExact;
+        }
+        const exact = suggestions.find((s) => s.id === trimmed || s.name.toLowerCase() === lower);
+        if (exact)
+            return exact;
+        // Try partial match in priority suggestions first
+        if (prioritySuggestions) {
+            const priorityPartials = prioritySuggestions.filter((s) => s.name.toLowerCase().includes(lower) || s.id.toLowerCase().includes(lower));
+            if (priorityPartials.length === 1)
+                return priorityPartials[0];
+        }
+        // Fall back to partial match in all suggestions
+        const partials = suggestions.filter((s) => s.name.toLowerCase().includes(lower) || s.id.toLowerCase().includes(lower));
+        if (partials.length === 1)
+            return partials[0];
+        return undefined;
+    }, [suggestions, prioritySuggestions]);
+    const filterSuggestions = (0, react_1.useCallback)((input) => {
+        var _a;
+        const trimmed = input.trim();
+        const lower = trimmed.toLowerCase();
+        // No input — return all suggestions split by tier
+        if (!trimmed) {
+            return {
+                priority: prioritySuggestions !== null && prioritySuggestions !== void 0 ? prioritySuggestions : [],
+                catalog: suggestions.filter((s) => !priorityIds.has(s.id))
+            };
+        }
+        // Filter by substring match
+        const matchesSuggestion = (s) => s.name.toLowerCase().includes(lower) || s.id.toLowerCase().includes(lower);
+        const priority = (_a = prioritySuggestions === null || prioritySuggestions === void 0 ? void 0 : prioritySuggestions.filter(matchesSuggestion)) !== null && _a !== void 0 ? _a : [];
+        const catalog = suggestions.filter((s) => !priorityIds.has(s.id) && matchesSuggestion(s));
+        return { priority, catalog };
+    }, [suggestions, prioritySuggestions, priorityIds]);
+    return { findExactMatch, resolveOnBlur, filterSuggestions };
+}
+//# sourceMappingURL=useTypeaheadMatch.js.map

package/lib/packlets/keyboard/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Keyboard shortcut packlet - registry, context, and hooks.
+ * @packageDocumentation
+ */
+export { type IKeyBinding, type IShortcut, type IShortcutRegistration, KeyboardShortcutRegistry, matchesBinding } from './registry';
+export { type IKeyboardShortcutProviderProps, KeyboardShortcutProvider, useKeyboardRegistry, useKeyboardShortcuts } from './useKeyboardShortcuts';
+//# sourceMappingURL=index.d.ts.map

package/lib/packlets/keyboard/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Keyboard shortcut packlet - registry, context, and hooks.
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeyboardShortcuts = exports.useKeyboardRegistry = exports.KeyboardShortcutProvider = exports.matchesBinding = exports.KeyboardShortcutRegistry = void 0;
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "KeyboardShortcutRegistry", { enumerable: true, get: function () { return registry_1.KeyboardShortcutRegistry; } });
+Object.defineProperty(exports, "matchesBinding", { enumerable: true, get: function () { return registry_1.matchesBinding; } });
+var useKeyboardShortcuts_1 = require("./useKeyboardShortcuts");
+Object.defineProperty(exports, "KeyboardShortcutProvider", { enumerable: true, get: function () { return useKeyboardShortcuts_1.KeyboardShortcutProvider; } });
+Object.defineProperty(exports, "useKeyboardRegistry", { enumerable: true, get: function () { return useKeyboardShortcuts_1.useKeyboardRegistry; } });
+Object.defineProperty(exports, "useKeyboardShortcuts", { enumerable: true, get: function () { return useKeyboardShortcuts_1.useKeyboardShortcuts; } });
+//# sourceMappingURL=index.js.map

package/lib/packlets/keyboard/registry.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Keyboard shortcut registry infrastructure.
+ *
+ * Provides a centralized registry for keyboard shortcuts with:
+ * - Modifier-aware key matching (Cmd/Ctrl, Shift, Alt)
+ * - Priority-based handler resolution (higher priority wins)
+ * - React hook for component-scoped shortcut registration
+ * - Global listener that dispatches to registered handlers
+ *
+ * @packageDocumentation
+ */
+/**
+ * Describes a keyboard shortcut binding.
+ * @public
+ */
+export interface IKeyBinding {
+    /** The key (e.g., 'k', 'z', 'Escape'). Case-insensitive. */
+    readonly key: string;
+    /** Require Cmd (Mac) / Ctrl (Windows/Linux) */
+    readonly meta?: boolean;
+    /** Require Shift */
+    readonly shift?: boolean;
+    /** Require Alt/Option */
+    readonly alt?: boolean;
+}
+/**
+ * A registered keyboard shortcut.
+ * @public
+ */
+export interface IShortcut {
+    /** The key binding */
+    readonly binding: IKeyBinding;
+    /** Human-readable description (for command palette / help) */
+    readonly description: string;
+    /** Handler function. Return true to indicate the event was handled. */
+    readonly handler: () => boolean | void;
+    /** Priority (higher wins when multiple shortcuts match). Default: 0 */
+    readonly priority?: number;
+}
+/**
+ * A registration handle returned when a shortcut is registered.
+ * Call `unregister()` to remove the shortcut.
+ * @public
+ */
+export interface IShortcutRegistration {
+    readonly unregister: () => void;
+}
+/**
+ * Tests whether a keyboard event matches a key binding.
+ * @param event - The keyboard event
+ * @param binding - The binding to match against
+ * @returns true if the event matches
+ * @public
+ */
+export declare function matchesBinding(event: KeyboardEvent, binding: IKeyBinding): boolean;
+/**
+ * Centralized keyboard shortcut registry.
+ *
+ * Components register shortcuts via `register()` and receive a handle
+ * to unregister when they unmount. The registry attaches a single global
+ * keydown listener that dispatches to the highest-priority matching handler.
+ *
+ * @public
+ */
+export declare class KeyboardShortcutRegistry {
+    private readonly _shortcuts;
+    private _listener;
+    private _nextId;
+    /**
+     * Registers a keyboard shortcut.
+     * @param shortcut - The shortcut to register
+     * @returns A registration handle with an `unregister()` method
+     */
+    register(shortcut: IShortcut): IShortcutRegistration;
+    /**
+     * Returns all currently registered shortcuts (for command palette / help display).
+     */
+    getAll(): ReadonlyArray<IShortcut>;
+    /**
+     * Dispatches a keyboard event to the highest-priority matching handler.
+     * @param event - The keyboard event
+     * @returns true if a handler consumed the event
+     */
+    dispatch(event: KeyboardEvent): boolean;
+    /**
+     * Removes all shortcuts and the global listener.
+     */
+    dispose(): void;
+    private _ensureListener;
+    private _removeListener;
+}
+//# sourceMappingURL=registry.d.ts.map

package/lib/packlets/keyboard/registry.js

@@ -0,0 +1,138 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardShortcutRegistry = void 0;
+exports.matchesBinding = matchesBinding;
+// ============================================================================
+// Key Matching
+// ============================================================================
+/**
+ * Tests whether a keyboard event matches a key binding.
+ * @param event - The keyboard event
+ * @param binding - The binding to match against
+ * @returns true if the event matches
+ * @public
+ */
+function matchesBinding(event, binding) {
+    var _a, _b, _c;
+    const keyMatch = event.key.toLowerCase() === binding.key.toLowerCase();
+    const metaMatch = ((_a = binding.meta) !== null && _a !== void 0 ? _a : false) === (event.metaKey || event.ctrlKey);
+    const shiftMatch = ((_b = binding.shift) !== null && _b !== void 0 ? _b : false) === event.shiftKey;
+    const altMatch = ((_c = binding.alt) !== null && _c !== void 0 ? _c : false) === event.altKey;
+    return keyMatch && metaMatch && shiftMatch && altMatch;
+}
+// ============================================================================
+// Registry
+// ============================================================================
+/**
+ * Centralized keyboard shortcut registry.
+ *
+ * Components register shortcuts via `register()` and receive a handle
+ * to unregister when they unmount. The registry attaches a single global
+ * keydown listener that dispatches to the highest-priority matching handler.
+ *
+ * @public
+ */
+class KeyboardShortcutRegistry {
+    constructor() {
+        this._shortcuts = new Map();
+        this._nextId = 0;
+    }
+    /**
+     * Registers a keyboard shortcut.
+     * @param shortcut - The shortcut to register
+     * @returns A registration handle with an `unregister()` method
+     */
+    register(shortcut) {
+        const id = `ks-${++this._nextId}`;
+        this._shortcuts.set(id, shortcut);
+        this._ensureListener();
+        return {
+            unregister: () => {
+                this._shortcuts.delete(id);
+                if (this._shortcuts.size === 0) {
+                    this._removeListener();
+                }
+            }
+        };
+    }
+    /**
+     * Returns all currently registered shortcuts (for command palette / help display).
+     */
+    getAll() {
+        return Array.from(this._shortcuts.values());
+    }
+    /**
+     * Dispatches a keyboard event to the highest-priority matching handler.
+     * @param event - The keyboard event
+     * @returns true if a handler consumed the event
+     */
+    dispatch(event) {
+        var _a;
+        // Skip if the event target is an input/textarea/contenteditable
+        const target = event.target;
+        if (target) {
+            const tagName = (_a = target.tagName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (tagName === 'input' || tagName === 'textarea' || target.isContentEditable) {
+                return false;
+            }
+        }
+        // Find all matching shortcuts, sorted by priority (highest first)
+        const matches = Array.from(this._shortcuts.values())
+            .filter((s) => matchesBinding(event, s.binding))
+            .sort((a, b) => { var _a, _b; return ((_a = b.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = a.priority) !== null && _b !== void 0 ? _b : 0); });
+        for (const shortcut of matches) {
+            const result = shortcut.handler();
+            if (result !== false) {
+                event.preventDefault();
+                event.stopPropagation();
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Removes all shortcuts and the global listener.
+     */
+    dispose() {
+        this._shortcuts.clear();
+        this._removeListener();
+    }
+    _ensureListener() {
+        if (this._listener) {
+            return;
+        }
+        this._listener = (e) => {
+            this.dispatch(e);
+        };
+        document.addEventListener('keydown', this._listener);
+    }
+    _removeListener() {
+        if (this._listener) {
+            document.removeEventListener('keydown', this._listener);
+            this._listener = undefined;
+        }
+    }
+}
+exports.KeyboardShortcutRegistry = KeyboardShortcutRegistry;
+//# sourceMappingURL=registry.js.map

package/lib/packlets/keyboard/useKeyboardShortcuts.d.ts

@@ -0,0 +1,50 @@
+/**
+ * React context and hooks for the keyboard shortcut registry.
+ * @packageDocumentation
+ */
+import React from 'react';
+import { KeyboardShortcutRegistry, type IShortcut } from './registry';
+/**
+ * Props for the KeyboardShortcutProvider.
+ * @public
+ */
+export interface IKeyboardShortcutProviderProps {
+    readonly children: React.ReactNode;
+}
+/**
+ * Provides a KeyboardShortcutRegistry to the component tree.
+ * Should be mounted once at the app root.
+ * @public
+ */
+export declare function KeyboardShortcutProvider(props: IKeyboardShortcutProviderProps): React.ReactElement;
+/**
+ * Returns the keyboard shortcut registry.
+ * Must be used within a KeyboardShortcutProvider.
+ * @public
+ */
+export declare function useKeyboardRegistry(): KeyboardShortcutRegistry;
+/**
+ * Registers one or more keyboard shortcuts for the lifetime of the component.
+ * Shortcuts are automatically unregistered on unmount.
+ *
+ * @example
+ * ```tsx
+ * useKeyboardShortcuts([
+ *   {
+ *     binding: { key: 'k', meta: true },
+ *     description: 'Open command palette',
+ *     handler: () => { setCommandPaletteOpen(true); }
+ *   },
+ *   {
+ *     binding: { key: 'z', meta: true },
+ *     description: 'Undo',
+ *     handler: () => { workspace.undo(); }
+ *   }
+ * ]);
+ * ```
+ *
+ * @param shortcuts - Array of shortcuts to register
+ * @public
+ */
+export declare function useKeyboardShortcuts(shortcuts: ReadonlyArray<IShortcut>): void;
+//# sourceMappingURL=useKeyboardShortcuts.d.ts.map

package/lib/packlets/keyboard/useKeyboardShortcuts.js

@@ -0,0 +1,155 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardShortcutProvider = KeyboardShortcutProvider;
+exports.useKeyboardRegistry = useKeyboardRegistry;
+exports.useKeyboardShortcuts = useKeyboardShortcuts;
+/**
+ * React context and hooks for the keyboard shortcut registry.
+ * @packageDocumentation
+ */
+const react_1 = __importStar(require("react"));
+const registry_1 = require("./registry");
+// ============================================================================
+// Context
+// ============================================================================
+const KeyboardContext = react_1.default.createContext(undefined);
+/**
+ * Provides a KeyboardShortcutRegistry to the component tree.
+ * Should be mounted once at the app root.
+ * @public
+ */
+function KeyboardShortcutProvider(props) {
+    const registry = (0, react_1.useMemo)(() => new registry_1.KeyboardShortcutRegistry(), []);
+    (0, react_1.useEffect)(() => {
+        return () => registry.dispose();
+    }, [registry]);
+    return react_1.default.createElement(KeyboardContext.Provider, { value: registry }, props.children);
+}
+// ============================================================================
+// Hooks
+// ============================================================================
+/**
+ * Returns the keyboard shortcut registry.
+ * Must be used within a KeyboardShortcutProvider.
+ * @public
+ */
+function useKeyboardRegistry() {
+    const ctx = (0, react_1.useContext)(KeyboardContext);
+    if (ctx === undefined) {
+        throw new Error('useKeyboardRegistry must be used within a KeyboardShortcutProvider');
+    }
+    return ctx;
+}
+/**
+ * Registers one or more keyboard shortcuts for the lifetime of the component.
+ * Shortcuts are automatically unregistered on unmount.
+ *
+ * @example
+ * ```tsx
+ * useKeyboardShortcuts([
+ *   {
+ *     binding: { key: 'k', meta: true },
+ *     description: 'Open command palette',
+ *     handler: () => { setCommandPaletteOpen(true); }
+ *   },
+ *   {
+ *     binding: { key: 'z', meta: true },
+ *     description: 'Undo',
+ *     handler: () => { workspace.undo(); }
+ *   }
+ * ]);
+ * ```
+ *
+ * @param shortcuts - Array of shortcuts to register
+ * @public
+ */
+function useKeyboardShortcuts(shortcuts) {
+    const registry = useKeyboardRegistry();
+    const shortcutsRef = (0, react_1.useRef)(shortcuts);
+    shortcutsRef.current = shortcuts;
+    (0, react_1.useEffect)(() => {
+        // Register stable wrapper shortcuts that delegate to the current ref entries.
+        // This means the effect only runs when the registry changes or the number of
+        // shortcuts changes — not on every render when the array identity changes.
+        const registrations = shortcutsRef.current.map((__item, index) => registry.register({
+            get binding() {
+                var _a, _b;
+                return (_b = (_a = shortcutsRef.current[index]) === null || _a === void 0 ? void 0 : _a.binding) !== null && _b !== void 0 ? _b : { key: '' };
+            },
+            get description() {
+                var _a, _b;
+                return (_b = (_a = shortcutsRef.current[index]) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : '';
+            },
+            get priority() {
+                var _a;
+                return (_a = shortcutsRef.current[index]) === null || _a === void 0 ? void 0 : _a.priority;
+            },
+            handler: () => {
+                var _a;
+                return (_a = shortcutsRef.current[index]) === null || _a === void 0 ? void 0 : _a.handler();
+            }
+        }));
+        return () => {
+            for (const reg of registrations) {
+                reg.unregister();
+            }
+        };
+        // Re-register only when the registry instance or the number of shortcuts changes.
+        // Handler/binding updates are picked up via the ref without re-registration.
+    }, [registry, shortcuts.length]);
+}
+//# sourceMappingURL=useKeyboardShortcuts.js.map

package/lib/packlets/messages/MessagesContext.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import { IMessage, IMessageAction, MessageSeverity } from './model';
+/**
+ * Value provided by the MessagesContext.
+ * @public
+ */
+export interface IMessagesContextValue {
+    /** All messages in the stream (newest last) */
+    readonly messages: ReadonlyArray<IMessage>;
+    /** Add a message to the stream */
+    readonly addMessage: (severity: MessageSeverity, text: string, action?: IMessageAction) => IMessage;
+    /** Dismiss a specific message (removes from toast display, keeps in log) */
+    readonly dismissMessage: (id: string) => void;
+    /** Clear all messages */
+    readonly clearMessages: () => void;
+    /** Messages currently visible as toasts (not yet dismissed) */
+    readonly activeToasts: ReadonlyArray<IMessage>;
+}
+/**
+ * Props for the MessagesProvider.
+ * @public
+ */
+export interface IMessagesProviderProps {
+    /** Maximum number of messages to retain in the log */
+    readonly maxMessages?: number;
+    /** Children */
+    readonly children: React.ReactNode;
+}
+/**
+ * Provides the global message stream to the component tree.
+ * @public
+ */
+export declare function MessagesProvider(props: IMessagesProviderProps): React.ReactElement;
+/**
+ * Hook to access the messages context.
+ * Must be used within a MessagesProvider.
+ * @public
+ */
+export declare function useMessages(): IMessagesContextValue;
+//# sourceMappingURL=MessagesContext.d.ts.map