@object-ui/react 2.0.0 → 3.0.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @object-ui/react@2.0.0 build /home/runner/work/objectui/objectui/packages/react
+> @object-ui/react@3.0.0 build /home/runner/work/objectui/objectui/packages/react
 > tsc
 

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @object-ui/react
 
+## 3.0.0
+
+### Minor Changes
+
+- 87979c3: Upgrade to @objectstack v3.0.0 and console bundle optimization
+  - Upgraded all @objectstack/\* packages from ^2.0.7 to ^3.0.0
+  - Breaking change migrations: Hub → Cloud namespace, definePlugin removed, PaginatedResult.value → .records, PaginatedResult.count → .total, client.meta.getObject() → client.meta.getItem()
+  - Console bundle optimization: split monolithic 3.7 MB chunk into 17 granular cacheable chunks (95% main entry reduction)
+  - Added gzip + brotli pre-compression via vite-plugin-compression2
+  - Lazy MSW loading for build:server (~150 KB gzip saved)
+  - Added bundle analysis with rollup-plugin-visualizer
+
+### Patch Changes
+
+- Updated dependencies [87979c3]
+  - @object-ui/types@3.0.0
+  - @object-ui/core@3.0.0
+  - @object-ui/i18n@3.0.0
+
 ## 2.0.0
 
 ### Major Changes

package/dist/SchemaRenderer.d.ts

@@ -5,8 +5,27 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import React from 'react';
+import React, { Component } from 'react';
 import { SchemaNode } from '@object-ui/core';
+/**
+ * Per-component Error Boundary for SchemaRenderer.
+ * Catches render errors in individual components, preventing one broken
+ * component from crashing the entire page.
+ */
+interface SchemaErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+export declare class SchemaErrorBoundary extends Component<{
+    componentType?: string;
+    children: React.ReactNode;
+}, SchemaErrorBoundaryState> {
+    state: SchemaErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): SchemaErrorBoundaryState;
+    handleRetry: () => void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
 export declare const SchemaRenderer: React.ForwardRefExoticComponent<Omit<{
     schema: SchemaNode;
 } & Record<string, any>, "ref"> & React.RefAttributes<any>>;
+export {};

package/dist/SchemaRenderer.js

@@ -1,4 +1,4 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * ObjectUI
  * Copyright (c) 2024-present ObjectStack Inc.
@@ -6,9 +6,63 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import React, { forwardRef, useContext, useMemo } from 'react';
-import { ComponentRegistry, ExpressionEvaluator } from '@object-ui/core';
+import React, { forwardRef, useContext, useMemo, Component } from 'react';
+import { ComponentRegistry, ExpressionEvaluator, isObjectUIError, ERROR_CODES, debugLog, debugTime, debugTimeEnd, } from '@object-ui/core';
 import { SchemaRendererContext } from './context/SchemaRendererContext';
+import { resolveI18nLabel } from './utils/i18n';
+/**
+ * Extract AriaPropsSchema properties from a schema node and convert
+ * them to standard HTML ARIA attributes.
+ *
+ * @objectstack/spec AriaPropsSchema defines:
+ *   ariaLabel: string | I18nLabel (→ aria-label)
+ *   ariaDescribedBy: string (→ aria-describedby)
+ *   role: string (→ role)
+ */
+function resolveAriaProps(schema) {
+    const aria = {};
+    if (schema.ariaLabel) {
+        aria['aria-label'] = resolveI18nLabel(schema.ariaLabel);
+    }
+    if (schema.ariaDescribedBy) {
+        aria['aria-describedby'] = schema.ariaDescribedBy;
+    }
+    if (schema.role) {
+        aria['role'] = schema.role;
+    }
+    return aria;
+}
+export class SchemaErrorBoundary extends Component {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { hasError: false, error: null }
+        });
+        Object.defineProperty(this, "handleRetry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.setState({ hasError: false, error: null });
+            }
+        });
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    render() {
+        if (this.state.hasError && this.state.error) {
+            const error = this.state.error;
+            const isDev = process.env.NODE_ENV !== 'production';
+            const objuiError = isObjectUIError(error) ? error : null;
+            return (_jsxs("div", { className: "p-4 border border-orange-400 rounded bg-orange-50 text-orange-700 my-2", role: "alert", children: [_jsxs("p", { className: "font-medium", children: ["Component", this.props.componentType ? ` "${this.props.componentType}"` : '', " failed to render"] }), _jsx("p", { className: "text-sm mt-1", children: error.message }), isDev && objuiError?.code && (_jsxs("p", { className: "text-xs mt-1 text-orange-500", children: ["Error code: ", objuiError.code, objuiError.details?.suggestion ? (_jsxs("span", { className: "block mt-0.5", children: ["\uD83D\uDCA1 ", String(objuiError.details.suggestion)] })) : null] })), _jsx("button", { onClick: this.handleRetry, className: "mt-2 text-sm underline hover:no-underline", children: "Retry" })] }));
+        }
+        return this.props.children;
+    }
+}
 export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     const context = useContext(SchemaRendererContext);
     const dataSource = context?.dataSource || {};
@@ -43,22 +97,31 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // If schema is just a string, render it as text
     if (typeof evaluatedSchema === 'string')
         return _jsx(_Fragment, { children: evaluatedSchema });
+    debugLog('schema', 'Rendering schema node', { type: evaluatedSchema.type, id: evaluatedSchema.id });
     const Component = ComponentRegistry.get(evaluatedSchema.type);
     if (!Component) {
-        return (_jsxs("div", { className: "p-4 border border-red-500 rounded text-red-500 bg-red-50 my-2", children: ["Unknown component type: ", _jsx("strong", { children: evaluatedSchema.type }), _jsx("pre", { className: "text-xs mt-2 overflow-auto", children: JSON.stringify(evaluatedSchema, null, 2) })] }));
+        debugLog('schema', 'Component not found in registry', { type: evaluatedSchema.type });
+        const errorInfo = ERROR_CODES['OBJUI-001'];
+        return (_jsxs("div", { className: "p-4 border border-red-500 rounded text-red-500 bg-red-50 my-2", role: "alert", children: [_jsxs("p", { className: "font-medium", children: ["Unknown component type: ", _jsx("strong", { children: evaluatedSchema.type })] }), process.env.NODE_ENV !== 'production' && (_jsxs("p", { className: "text-xs mt-1", children: ["\uD83D\uDCA1 ", errorInfo.suggestion, " (OBJUI-001)"] })), _jsx("pre", { className: "text-xs mt-2 overflow-auto", children: JSON.stringify(evaluatedSchema, null, 2) })] }));
     }
     // Note: We don't forward the ref to the Component because components in the registry
     // may not support refs. The SchemaRenderer itself can still receive refs for its own use.
     // Extract schema metadata properties that should NOT be passed as React props
     const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleOn: _visibleOn, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, ...componentProps } = evaluatedSchema;
-    return React.createElement(Component, {
-        schema: evaluatedSchema,
-        ...componentProps, // Spread non-metadata schema properties as props
-        ...(evaluatedSchema.props || {}), // Override with explicit props if provided
-        className: evaluatedSchema.className,
-        'data-obj-id': evaluatedSchema.id,
-        'data-obj-type': evaluatedSchema.type,
-        ...props
-    });
+    // Extract AriaPropsSchema properties for accessibility
+    const ariaProps = resolveAriaProps(evaluatedSchema);
+    debugTime(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
+    const rendered = (_jsx(SchemaErrorBoundary, { componentType: evaluatedSchema.type, children: React.createElement(Component, {
+            schema: evaluatedSchema,
+            ...componentProps, // Spread non-metadata schema properties as props
+            ...(evaluatedSchema.props || {}), // Override with explicit props if provided
+            ...ariaProps, // Inject ARIA attributes from AriaPropsSchema
+            className: evaluatedSchema.className,
+            'data-obj-id': evaluatedSchema.id,
+            'data-obj-type': evaluatedSchema.type,
+            ...props
+        }) }));
+    debugTimeEnd(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
+    return rendered;
 });
 SchemaRenderer.displayName = 'SchemaRenderer';

package/dist/context/DndContext.d.ts

@@ -0,0 +1,135 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Drag and Drop Context
+ *
+ * Provides a unified DnD configuration system to the component tree.
+ * Implements DndConfigSchema, DragItemSchema, DropZoneSchema,
+ * DragConstraintSchema, and DropEffectSchema from @objectstack/spec v2.0.7.
+ */
+import React from 'react';
+/** Drop effect types aligned with DropEffectSchema */
+export type DropEffectType = 'move' | 'copy' | 'link' | 'none';
+/** Drag constraint axis aligned with DragConstraintSchema */
+export type DragAxis = 'x' | 'y' | 'both';
+/** Drag item metadata */
+export interface DragItemData {
+    /** Unique identifier for the dragged item */
+    id: string;
+    /** Type of the dragged item (for drop zone filtering) */
+    type: string;
+    /** Arbitrary data associated with the drag */
+    data?: Record<string, unknown>;
+    /** Source container/zone identifier */
+    sourceId?: string;
+}
+/** Drop zone configuration */
+export interface DropZoneConfig {
+    /** Unique identifier for the drop zone */
+    id: string;
+    /** Accepted drag item types */
+    acceptTypes: string[];
+    /** Drop effect to apply */
+    effect?: DropEffectType;
+    /** Whether the zone is currently disabled */
+    disabled?: boolean;
+    /** Maximum number of items this zone can hold */
+    maxItems?: number;
+}
+/** Drag constraints configuration */
+export interface DragConstraintConfig {
+    /** Constrain movement to an axis */
+    axis?: DragAxis;
+    /** Minimum distance before drag starts (in pixels) */
+    activationDistance?: number;
+    /** Whether to show a drag handle */
+    showHandle?: boolean;
+    /** Container bounds (CSS selector) */
+    containerId?: string;
+}
+/** Overall DnD configuration aligned with DndConfigSchema */
+export interface DndSystemConfig {
+    /** Whether DnD is enabled */
+    enabled?: boolean;
+    /** Default drag constraints */
+    defaultConstraints?: DragConstraintConfig;
+    /** Whether to show drag overlay/preview */
+    showPreview?: boolean;
+    /** Auto-scroll when dragging near edges */
+    autoScroll?: boolean;
+}
+/** Drag event information */
+export interface DragEvent {
+    /** The dragged item */
+    item: DragItemData;
+    /** Target drop zone (null if not over a zone) */
+    targetZoneId: string | null;
+    /** The applied drop effect */
+    effect: DropEffectType;
+}
+export interface DndProviderProps {
+    children: React.ReactNode;
+    /** System-wide DnD configuration */
+    config?: DndSystemConfig;
+    /** Called when a drag starts */
+    onDragStart?: (event: DragEvent) => void;
+    /** Called when an item is dropped */
+    onDrop?: (event: DragEvent) => void;
+    /** Called when a drag is cancelled */
+    onDragCancel?: (event: DragEvent) => void;
+}
+interface DndContextValue {
+    /** System-wide DnD configuration */
+    config: DndSystemConfig;
+    /** Whether DnD is enabled */
+    enabled: boolean;
+    /** Currently dragging item (null if not dragging) */
+    activeItem: DragItemData | null;
+    /** Registered drop zones */
+    dropZones: Map<string, DropZoneConfig>;
+    /** Start a drag operation */
+    startDrag: (item: DragItemData) => void;
+    /** End the current drag operation */
+    endDrag: (targetZoneId?: string) => void;
+    /** Cancel the current drag */
+    cancelDrag: () => void;
+    /** Register a drop zone */
+    registerDropZone: (zone: DropZoneConfig) => void;
+    /** Unregister a drop zone */
+    unregisterDropZone: (zoneId: string) => void;
+    /** Check if a drop zone accepts a drag item type */
+    canDrop: (zoneId: string, itemType: string) => boolean;
+}
+/**
+ * DndProvider — Provides a unified DnD system aligned with @objectstack/spec v2.0.7.
+ *
+ * This is a coordination layer; actual drag mechanics are delegated to
+ * libraries like @dnd-kit/core or react-grid-layout in individual plugins.
+ *
+ * @example
+ * ```tsx
+ * <DndProvider
+ *   config={{ enabled: true, showPreview: true, autoScroll: true }}
+ *   onDrop={(event) => handleDrop(event.item, event.targetZoneId)}
+ * >
+ *   <KanbanBoard />
+ * </DndProvider>
+ * ```
+ */
+export declare const DndProvider: React.FC<DndProviderProps>;
+/**
+ * Hook to consume the DnD context.
+ *
+ * @throws Error if used outside a DndProvider
+ */
+export declare function useDnd(): DndContextValue;
+/**
+ * Hook to check if a DndProvider is available.
+ */
+export declare function useHasDndProvider(): boolean;
+export {};

package/dist/context/DndContext.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Drag and Drop Context
+ *
+ * Provides a unified DnD configuration system to the component tree.
+ * Implements DndConfigSchema, DragItemSchema, DropZoneSchema,
+ * DragConstraintSchema, and DropEffectSchema from @objectstack/spec v2.0.7.
+ */
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+const DndCtx = createContext(null);
+/**
+ * DndProvider — Provides a unified DnD system aligned with @objectstack/spec v2.0.7.
+ *
+ * This is a coordination layer; actual drag mechanics are delegated to
+ * libraries like @dnd-kit/core or react-grid-layout in individual plugins.
+ *
+ * @example
+ * ```tsx
+ * <DndProvider
+ *   config={{ enabled: true, showPreview: true, autoScroll: true }}
+ *   onDrop={(event) => handleDrop(event.item, event.targetZoneId)}
+ * >
+ *   <KanbanBoard />
+ * </DndProvider>
+ * ```
+ */
+export const DndProvider = ({ children, config: userConfig = {}, onDragStart, onDrop, onDragCancel, }) => {
+    const config = useMemo(() => ({
+        enabled: true,
+        showPreview: true,
+        autoScroll: true,
+        ...userConfig,
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(userConfig)]);
+    const [activeItem, setActiveItem] = useState(null);
+    const [dropZones] = useState(() => new Map());
+    const startDrag = useCallback((item) => {
+        if (!config.enabled)
+            return;
+        setActiveItem(item);
+        onDragStart?.({ item, targetZoneId: null, effect: 'move' });
+    }, [config.enabled, onDragStart]);
+    const endDrag = useCallback((targetZoneId) => {
+        if (!activeItem)
+            return;
+        const zone = targetZoneId ? dropZones.get(targetZoneId) : undefined;
+        const effect = zone?.effect ?? 'move';
+        onDrop?.({ item: activeItem, targetZoneId: targetZoneId ?? null, effect });
+        setActiveItem(null);
+    }, [activeItem, dropZones, onDrop]);
+    const cancelDrag = useCallback(() => {
+        if (!activeItem)
+            return;
+        onDragCancel?.({ item: activeItem, targetZoneId: null, effect: 'none' });
+        setActiveItem(null);
+    }, [activeItem, onDragCancel]);
+    const registerDropZone = useCallback((zone) => {
+        dropZones.set(zone.id, zone);
+    }, [dropZones]);
+    const unregisterDropZone = useCallback((zoneId) => {
+        dropZones.delete(zoneId);
+    }, [dropZones]);
+    const canDrop = useCallback((zoneId, itemType) => {
+        const zone = dropZones.get(zoneId);
+        if (!zone || zone.disabled)
+            return false;
+        return zone.acceptTypes.includes(itemType);
+    }, [dropZones]);
+    const value = useMemo(() => ({
+        config,
+        enabled: config.enabled ?? true,
+        activeItem,
+        dropZones,
+        startDrag,
+        endDrag,
+        cancelDrag,
+        registerDropZone,
+        unregisterDropZone,
+        canDrop,
+    }), [
+        config,
+        activeItem,
+        dropZones,
+        startDrag,
+        endDrag,
+        cancelDrag,
+        registerDropZone,
+        unregisterDropZone,
+        canDrop,
+    ]);
+    return _jsx(DndCtx.Provider, { value: value, children: children });
+};
+DndProvider.displayName = 'DndProvider';
+/**
+ * Hook to consume the DnD context.
+ *
+ * @throws Error if used outside a DndProvider
+ */
+export function useDnd() {
+    const ctx = useContext(DndCtx);
+    if (!ctx) {
+        throw new Error('useDnd must be used within a <DndProvider>. ' +
+            'Wrap your app with <DndProvider> to use the drag and drop system.');
+    }
+    return ctx;
+}
+/**
+ * Hook to check if a DndProvider is available.
+ */
+export function useHasDndProvider() {
+    return useContext(DndCtx) !== null;
+}

package/dist/context/NotificationContext.d.ts

@@ -0,0 +1,113 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Notification Context
+ *
+ * Provides a spec-driven notification system to the component tree.
+ * Implements NotificationSchema, NotificationConfigSchema, and
+ * NotificationActionSchema from @objectstack/spec v2.0.7.
+ */
+import React from 'react';
+/** Notification severity levels aligned with NotificationSeveritySchema */
+export type NotificationSeverityLevel = 'info' | 'success' | 'warning' | 'error';
+/** Notification display type aligned with NotificationTypeSchema */
+export type NotificationDisplayType = 'toast' | 'banner' | 'snackbar' | 'modal';
+/** Notification position aligned with NotificationPositionSchema */
+export type NotificationPositionValue = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+/** Action button on a notification */
+export interface NotificationActionButton {
+    label: string;
+    onClick: () => void;
+    variant?: 'default' | 'destructive' | 'outline';
+}
+/** A single notification item */
+export interface NotificationItem {
+    id: string;
+    title: string;
+    message?: string;
+    severity: NotificationSeverityLevel;
+    displayType?: NotificationDisplayType;
+    actions?: NotificationActionButton[];
+    /** Duration in ms (0 = persistent). Default: 5000 */
+    duration?: number;
+    /** Whether the notification has been read */
+    read?: boolean;
+    /** Timestamp */
+    createdAt: Date;
+    /** Optional icon name (lucide icon) */
+    icon?: string;
+}
+/** Configuration for the notification system */
+export interface NotificationSystemConfig {
+    /** Default position for toast notifications */
+    position?: NotificationPositionValue;
+    /** Default duration in ms */
+    defaultDuration?: number;
+    /** Maximum number of visible notifications */
+    maxVisible?: number;
+    /** Whether to stack notifications */
+    stacking?: boolean;
+}
+export interface NotificationProviderProps {
+    children: React.ReactNode;
+    /** System configuration */
+    config?: NotificationSystemConfig;
+    /** External toast handler (e.g., Sonner) for rendering toasts */
+    onToast?: (notification: NotificationItem) => void;
+}
+interface NotificationContextValue {
+    /** All notifications (including history) */
+    notifications: NotificationItem[];
+    /** Unread notification count */
+    unreadCount: number;
+    /** Add a notification */
+    notify: (notification: Omit<NotificationItem, 'id' | 'createdAt' | 'read'>) => string;
+    /** Convenience: show info notification */
+    info: (title: string, message?: string) => string;
+    /** Convenience: show success notification */
+    success: (title: string, message?: string) => string;
+    /** Convenience: show warning notification */
+    warning: (title: string, message?: string) => string;
+    /** Convenience: show error notification */
+    error: (title: string, message?: string) => string;
+    /** Mark a notification as read */
+    markAsRead: (id: string) => void;
+    /** Mark all notifications as read */
+    markAllAsRead: () => void;
+    /** Dismiss a notification */
+    dismiss: (id: string) => void;
+    /** Clear all notifications */
+    clearAll: () => void;
+    /** System configuration */
+    config: NotificationSystemConfig;
+}
+/**
+ * NotificationProvider — Provides a spec-driven notification system.
+ *
+ * @example
+ * ```tsx
+ * <NotificationProvider
+ *   config={{ position: 'top-right', defaultDuration: 5000, maxVisible: 5 }}
+ *   onToast={(n) => toast[n.severity](n.title, { description: n.message })}
+ * >
+ *   <App />
+ * </NotificationProvider>
+ * ```
+ */
+export declare const NotificationProvider: React.FC<NotificationProviderProps>;
+/**
+ * Hook to consume the NotificationProvider context.
+ *
+ * @throws Error if used outside a NotificationProvider
+ */
+export declare function useNotifications(): NotificationContextValue;
+/**
+ * Hook to check if a NotificationProvider is available.
+ */
+export declare function useHasNotificationProvider(): boolean;
+export {};

package/dist/context/NotificationContext.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/react - Notification Context
+ *
+ * Provides a spec-driven notification system to the component tree.
+ * Implements NotificationSchema, NotificationConfigSchema, and
+ * NotificationActionSchema from @objectstack/spec v2.0.7.
+ */
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+let notificationCounter = 0;
+const NotificationCtx = createContext(null);
+/**
+ * NotificationProvider — Provides a spec-driven notification system.
+ *
+ * @example
+ * ```tsx
+ * <NotificationProvider
+ *   config={{ position: 'top-right', defaultDuration: 5000, maxVisible: 5 }}
+ *   onToast={(n) => toast[n.severity](n.title, { description: n.message })}
+ * >
+ *   <App />
+ * </NotificationProvider>
+ * ```
+ */
+export const NotificationProvider = ({ children, config: userConfig = {}, onToast, }) => {
+    const config = useMemo(() => ({
+        position: 'top-right',
+        defaultDuration: 5000,
+        maxVisible: 5,
+        stacking: true,
+        ...userConfig,
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(userConfig)]);
+    const [notifications, setNotifications] = useState([]);
+    const notify = useCallback((input) => {
+        const id = `notification-${++notificationCounter}`;
+        const notification = {
+            ...input,
+            id,
+            createdAt: new Date(),
+            read: false,
+        };
+        setNotifications((prev) => [notification, ...prev]);
+        // Delegate to external toast handler if provided
+        if (onToast) {
+            onToast(notification);
+        }
+        // Auto-dismiss non-persistent notifications
+        const duration = input.duration ?? config.defaultDuration ?? 5000;
+        if (duration > 0) {
+            setTimeout(() => {
+                setNotifications((prev) => prev.filter((n) => n.id !== id));
+            }, duration);
+        }
+        return id;
+    }, [config.defaultDuration, onToast]);
+    const info = useCallback((title, message) => notify({ title, message, severity: 'info' }), [notify]);
+    const success = useCallback((title, message) => notify({ title, message, severity: 'success' }), [notify]);
+    const warning = useCallback((title, message) => notify({ title, message, severity: 'warning' }), [notify]);
+    const error = useCallback((title, message) => notify({ title, message, severity: 'error' }), [notify]);
+    const markAsRead = useCallback((id) => {
+        setNotifications((prev) => prev.map((n) => (n.id === id ? { ...n, read: true } : n)));
+    }, []);
+    const markAllAsRead = useCallback(() => {
+        setNotifications((prev) => prev.map((n) => ({ ...n, read: true })));
+    }, []);
+    const dismiss = useCallback((id) => {
+        setNotifications((prev) => prev.filter((n) => n.id !== id));
+    }, []);
+    const clearAll = useCallback(() => {
+        setNotifications([]);
+    }, []);
+    const unreadCount = useMemo(() => notifications.filter((n) => !n.read).length, [notifications]);
+    const value = useMemo(() => ({
+        notifications,
+        unreadCount,
+        notify,
+        info,
+        success,
+        warning,
+        error,
+        markAsRead,
+        markAllAsRead,
+        dismiss,
+        clearAll,
+        config,
+    }), [
+        notifications,
+        unreadCount,
+        notify,
+        info,
+        success,
+        warning,
+        error,
+        markAsRead,
+        markAllAsRead,
+        dismiss,
+        clearAll,
+        config,
+    ]);
+    return (_jsx(NotificationCtx.Provider, { value: value, children: children }));
+};
+NotificationProvider.displayName = 'NotificationProvider';
+/**
+ * Hook to consume the NotificationProvider context.
+ *
+ * @throws Error if used outside a NotificationProvider
+ */
+export function useNotifications() {
+    const ctx = useContext(NotificationCtx);
+    if (!ctx) {
+        throw new Error('useNotifications must be used within a <NotificationProvider>. ' +
+            'Wrap your app with <NotificationProvider> to use the notification system.');
+    }
+    return ctx;
+}
+/**
+ * Hook to check if a NotificationProvider is available.
+ */
+export function useHasNotificationProvider() {
+    return useContext(NotificationCtx) !== null;
+}

package/dist/context/index.d.ts

@@ -8,3 +8,5 @@
 export * from './SchemaRendererContext';
 export * from './ActionContext';
 export * from './ThemeContext';
+export * from './NotificationContext';
+export * from './DndContext';