@vuetify/v0 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/useNotifications-vSJE6z6t.mjs

@@ -0,0 +1,880 @@
+import { t as IN_BROWSER } from "./globals-zEjWBKCr.mjs";
+import { isFunction, isNull, isUndefined, useId as useId$1 } from "./utilities/index.mjs";
+import { i as useContext, t as createTrinity } from "./createTrinity-BTCs1pYx.mjs";
+import { o as createPluginContext } from "./useLogger-DvdRTrqC.mjs";
+import { t as createRegistry } from "./createRegistry-BXzdXAjq.mjs";
+import { onScopeDispose, shallowRef, toValue } from "vue";
+//#region src/composables/useTimer/index.ts
+/**
+* @module useTimer
+*
+* @see https://0.vuetifyjs.com/composables/system/use-timer
+*
+* @remarks
+* A reactive timer composable with pause/resume support.
+*
+* Key features:
+* - Start/stop/pause/resume controls
+* - Reactive remaining time tracking
+* - Reactive `duration` via `MaybeRefOrGetter` — read fresh on each `start()`
+* - One-shot (default) or repeating mode
+* - Automatic cleanup on scope disposal
+* - SSR-safe
+*
+* @example
+* ```ts
+* import { useTimer } from '@vuetify/v0'
+*
+* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
+* timer.start()
+* ```
+*/
+/**
+* Creates a reactive timer with pause/resume support.
+*
+* @param handler Callback invoked when the timer fires.
+* @param options Timer configuration.
+* @returns Timer controls and reactive state.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-timer
+*
+* @example
+* ```ts
+* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
+*
+* timer.start()
+* timer.pause()
+* timer.resume()
+* timer.stop()
+*
+* // Reactive duration — re-read on each start()
+* const duration = shallowRef(1000)
+* const reactive = useTimer(handler, { duration })
+* duration.value = 2000
+* reactive.start() // fires after 2000ms
+* ```
+*/
+function useTimer(handler, options = {}) {
+	const { duration = 1e3, repeat = false } = options;
+	function resolveDuration() {
+		return toValue(duration);
+	}
+	const remaining = shallowRef(resolveDuration());
+	const isActive = shallowRef(false);
+	const isPaused = shallowRef(false);
+	let timeoutId;
+	let trackingId;
+	let startedAt = 0;
+	let budget = remaining.value;
+	function clearTimer() {
+		if (!/* @__PURE__ */ isUndefined(timeoutId)) {
+			globalThis.clearTimeout(timeoutId);
+			timeoutId = void 0;
+		}
+	}
+	function startTracking() {
+		stopTracking();
+		if (!IN_BROWSER) return;
+		trackingId = globalThis.setInterval(() => {
+			if (!isActive.value || isPaused.value) return;
+			const elapsed = Date.now() - startedAt;
+			remaining.value = Math.max(0, budget - elapsed);
+		}, 100);
+	}
+	function stopTracking() {
+		if (!/* @__PURE__ */ isUndefined(trackingId)) {
+			globalThis.clearInterval(trackingId);
+			trackingId = void 0;
+		}
+	}
+	function fire() {
+		clearTimer();
+		stopTracking();
+		handler();
+		if (repeat) begin(resolveDuration());
+		else {
+			isActive.value = false;
+			remaining.value = 0;
+		}
+	}
+	function begin(ms) {
+		clearTimer();
+		stopTracking();
+		budget = ms;
+		startedAt = Date.now();
+		remaining.value = ms;
+		isActive.value = true;
+		isPaused.value = false;
+		timeoutId = globalThis.setTimeout(fire, ms);
+		startTracking();
+	}
+	function start() {
+		const ms = resolveDuration();
+		if (ms < 0) return;
+		begin(ms);
+	}
+	function stop() {
+		clearTimer();
+		stopTracking();
+		isActive.value = false;
+		isPaused.value = false;
+		remaining.value = resolveDuration();
+	}
+	function pause() {
+		if (!isActive.value || isPaused.value) return;
+		const elapsed = Date.now() - startedAt;
+		budget = Math.max(0, budget - elapsed);
+		remaining.value = budget;
+		clearTimer();
+		stopTracking();
+		isPaused.value = true;
+	}
+	function resume() {
+		if (!isPaused.value) return;
+		isPaused.value = false;
+		startedAt = Date.now();
+		timeoutId = globalThis.setTimeout(fire, budget);
+		startTracking();
+	}
+	onScopeDispose(() => {
+		clearTimer();
+		stopTracking();
+	}, true);
+	return {
+		start,
+		stop,
+		pause,
+		resume,
+		remaining,
+		isActive,
+		isPaused
+	};
+}
+//#endregion
+//#region src/composables/createQueue/index.ts
+/**
+* @module createQueue
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @remarks
+* A queue composable for managing time-based collections with:
+* - Automatic timeout-based removal
+* - Pause/resume functionality
+* - FIFO (First In, First Out) ordering
+* - Manual dismissal support
+* - Queue progression management
+*
+* Built on top of createRegistry, the queue automatically manages timeouts for tickets,
+* ensuring only the first ticket in the queue is active at any time. When a ticket
+* expires or is removed, the next ticket in the queue automatically becomes active.
+*
+* @example
+* ```ts
+* import { createQueue } from '@vuetify/v0'
+*
+* const queue = createQueue()
+* queue.register({ value: 'Notification 1', timeout: 3000 })
+* queue.register({ value: 'Notification 2', timeout: 3000 })
+* ```
+*/
+/**
+* Creates a new queue instance
+*
+* @param options The options for the queue instance
+* @returns A new queue instance
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @example
+* ```ts
+* import { useQueue } from '@vuetify/v0'
+*
+* const queue = useQueue()
+*
+* // Register an ticket with default timeout (3000ms)
+* const ticket1 = queue.register({ value: 'Ticket 1' })
+*
+* // Register an ticket with custom timeout
+* const ticket2 = queue.register({ value: 'Ticket 2', timeout: 5000 })
+*
+* // Register a persistent ticket that must be manually dismissed
+* const ticket3 = queue.register({ value: 'Ticket 3', timeout: -1 })
+*
+* // Dismiss an ticket using the convenience method
+* ticket3.dismiss()
+*
+* console.log(queue.size) // 2
+* ```
+*/
+function createQueue(_options = {}) {
+	const { timeout: _timeout = 3e3, ...options } = _options;
+	const registry = createRegistry({
+		...options,
+		events: true
+	});
+	const timers = /* @__PURE__ */ new Map();
+	function createTicketTimer(ticket) {
+		if (/* @__PURE__ */ isUndefined(ticket.timeout) || ticket.timeout < 0 || ticket.isPaused) return;
+		const timer = useTimer(() => {
+			timers.delete(ticket.id);
+			registry.unregister(ticket.id);
+			resume();
+		}, { duration: ticket.timeout });
+		timers.set(ticket.id, timer);
+		timer.start();
+	}
+	function stopTimer(id) {
+		const timer = timers.get(id);
+		if (timer) {
+			timer.stop();
+			timers.delete(id);
+		}
+	}
+	function register(registration = {}) {
+		const id = registration.id ?? /* @__PURE__ */ useId$1();
+		const timeout = Object.prototype.hasOwnProperty.call(registration, "timeout") ? registration.timeout : _timeout;
+		const ticket = {
+			...registration,
+			id,
+			timeout,
+			isPaused: registry.size > 0,
+			dismiss: () => unregister(id)
+		};
+		const registered = registry.register(ticket);
+		createTicketTimer(registered);
+		return registered;
+	}
+	function unregister(id) {
+		const ticket = /* @__PURE__ */ isUndefined(id) ? registry.seek("first") : registry.get(id);
+		if (!ticket) return void 0;
+		const wasFirst = ticket.index === 0;
+		stopTimer(ticket.id);
+		registry.unregister(ticket.id);
+		if (wasFirst) resume();
+		return ticket;
+	}
+	function offboard(ids) {
+		let hadFirst = false;
+		for (const id of ids) {
+			const ticket = registry.get(id);
+			if (!ticket) continue;
+			if (ticket.index === 0) hadFirst = true;
+			stopTimer(ticket.id);
+		}
+		registry.offboard(ids);
+		if (hadFirst) resume();
+	}
+	function pause() {
+		const ticket = registry.seek("first");
+		if (!ticket || ticket.isPaused) return void 0;
+		timers.get(ticket.id)?.pause();
+		return registry.upsert(ticket.id, { isPaused: true });
+	}
+	function resume() {
+		const ticket = registry.seek("first");
+		if (!ticket || ticket.index !== 0 || !ticket.isPaused) return void 0;
+		const updated = registry.upsert(ticket.id, { isPaused: false });
+		const timer = timers.get(updated.id);
+		if (timer) timer.start();
+		else createTicketTimer(updated);
+		return updated;
+	}
+	function clear() {
+		for (const timer of timers.values()) timer.stop();
+		timers.clear();
+		registry.clear();
+	}
+	function dispose() {
+		clear();
+		registry.dispose();
+	}
+	onScopeDispose(dispose, true);
+	function onboard(registrations) {
+		return registry.batch(() => registrations.map((registration) => register(registration)));
+	}
+	return {
+		...registry,
+		register,
+		unregister,
+		onboard,
+		offboard,
+		pause,
+		resume,
+		clear,
+		dispose,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+/**
+* Creates a new queue context.
+*
+* @param options The options for the queue context.
+* @returns A new queue context.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @example
+* ```ts
+* import { createQueueContext } from '@vuetify/v0'
+*
+* export const [useQueue, provideQueue, context] = createQueueContext({
+*   timeout: 5000,
+* })
+* ```
+*/
+function createQueueContext(_options = {}) {
+	const { namespace = "v0:queue", ...options } = _options;
+	return createTrinity(namespace, createQueue(options));
+}
+/**
+* Returns the current queue instance.
+*
+* @param namespace The namespace for the queue context. Defaults to `'v0:queue'`.
+* @returns The current queue instance.
+*
+* @see https://0.vuetifyjs.com/composables/registration/create-queue
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useQueue } from '@vuetify/v0'
+*
+*   const queue = useQueue()
+* <\/script>
+* ```
+*/
+function useQueue(namespace = "v0:queue") {
+	return useContext(namespace);
+}
+//#endregion
+//#region src/composables/useNotifications/index.ts
+/**
+* @module useNotifications
+* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+*
+* @remarks
+* Notification management composable built on createRegistry and createQueue.
+* Registry stores the full notification lifecycle (permanent record).
+* Queue manages the display surface (toasts) with FIFO ordering and auto-dismiss.
+*
+* Supports:
+* - Push notifications with severity levels and configurable timeouts
+* - State mutations: read, seen, archived, snoozed
+* - Bulk operations: readAll, archiveAll, clear
+* - Toast queue with pause/resume and auto-dismiss
+* - Adapter integration via event system
+* - Plugin installation via createNotificationsPlugin
+*
+* @example
+* ```ts
+* import { useNotifications } from '@vuetify/v0'
+*
+* const notifications = useNotifications()
+* notifications.send({ subject: 'Saved', severity: 'success' })
+* ```
+*/
+function createNotifications(options = {}) {
+	const { timeout = 3e3, ...registryOptions } = options;
+	const registry = createRegistry({
+		...registryOptions,
+		events: true,
+		reactive: true
+	});
+	const queue = createQueue({
+		timeout,
+		events: true,
+		reactive: true
+	});
+	registry.on("unregister:ticket", (ticket) => {
+		if (queue.has(ticket.id)) queue.unregister(ticket.id);
+	});
+	/**
+	* Build a full {@link NotificationTicket} from raw input
+	*
+	* @param input The notification input to hydrate.
+	* @returns A partial ticket with timestamps, lifecycle methods, and an ID.
+	* @internal Used by {@link send}, {@link register}, and {@link onboard}.
+	*/
+	function hydrate(input) {
+		const id = input.id ?? /* @__PURE__ */ useId$1();
+		const now = /* @__PURE__ */ new Date();
+		return {
+			...input,
+			id,
+			createdAt: now,
+			readAt: null,
+			seenAt: null,
+			archivedAt: null,
+			snoozedUntil: null,
+			read: () => read(id),
+			unread: () => unread(id),
+			seen: () => seen(id),
+			archive: () => archive(id),
+			unarchive: () => unarchive(id),
+			snooze: (until) => snooze(id, until),
+			wake: () => wake(id),
+			dismiss: () => queue.unregister(id)
+		};
+	}
+	/**
+	* Create a notification and enqueue it for toast display
+	*
+	* @param input The notification input to create.
+	* @returns The hydrated notification ticket.
+	* @remarks Hydrates the input with timestamps and lifecycle methods, registers
+	* it in the registry, adds it to the display queue, and emits
+	* `notification:received`. The ticket auto-dismisses after the configured
+	* timeout unless paused.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* // Basic toast
+	* notifications.send({ subject: 'Changes saved', severity: 'success' })
+	*
+	* // With custom timeout
+	* const ticket = notifications.send({ subject: 'Connection lost', severity: 'error', timeout: 10000 })
+	*
+	* console.log(ticket.id)        // 'generated-id'
+	* console.log(ticket.createdAt) // Date
+	* console.log(ticket.readAt)    // null
+	*
+	* // Ticket convenience methods
+	* ticket.read()    // marks as read
+	* ticket.dismiss() // removes from toast queue, keeps in registry
+	* ```
+	*/
+	function send(input) {
+		const ticket = registry.register(hydrate(input));
+		queue.register(/* @__PURE__ */ isUndefined(input.timeout) ? { id: ticket.id } : {
+			id: ticket.id,
+			timeout: input.timeout
+		});
+		registry.emit("notification:received", ticket);
+		return ticket;
+	}
+	/**
+	* Register a notification in the registry without adding it to the toast queue
+	*
+	* @param input The notification input to register.
+	* @returns The hydrated notification ticket.
+	* @remarks Overrides the base registry `register` to hydrate the input with
+	* timestamps and lifecycle methods. Use for historical or pre-existing items
+	* that should appear in an inbox but not pop up as toasts.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* // Register a historical item (appears in inbox, not as toast)
+	* const ticket = notifications.register({ id: 'old-1', subject: 'Deployed v2.1' })
+	*
+	* console.log(ticket.createdAt) // Date
+	* console.log(ticket.readAt)    // null
+	*
+	* // Lifecycle methods work the same as send()
+	* ticket.read()
+	* ticket.archive()
+	* ```
+	*/
+	function register(input) {
+		return registry.register(hydrate(input));
+	}
+	/**
+	* Bulk version of {@link register}
+	*
+	* @param inputs Array of notification inputs to register.
+	* @returns Array of hydrated notification tickets.
+	* @remarks Registers multiple notifications into the registry without toast
+	* display. Wraps all registrations in a single `registry.batch()` call so
+	* reactive updates are deferred until the entire batch completes.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* // Load historical items on mount
+	* const tickets = notifications.onboard([
+	*   { id: 'n1', subject: 'Welcome to the team' },
+	*   { id: 'n2', subject: 'Setup complete', severity: 'success' },
+	* ])
+	*
+	* console.log(tickets.length)              // 2
+	* console.log(notifications.queue.values()) // [] (no toasts)
+	* console.log(notifications.values().length) // 2 (in registry)
+	* ```
+	*/
+	function onboard(inputs) {
+		return registry.batch(() => inputs.map((input) => register(input)));
+	}
+	/**
+	* Mark a notification as read
+	*
+	* @param id The ID of the notification to mark as read.
+	* @remarks Sets `readAt` to the current time and emits `notification:read`.
+	* Adapters listen to this event for outbound sync.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* const ticket = notifications.send({ subject: 'New message' })
+	*
+	* notifications.read(ticket.id)
+	* console.log(ticket.readAt) // Date
+	*
+	* // Or via ticket convenience method
+	* ticket.read()
+	* ```
+	*/
+	function read(id) {
+		registry.upsert(id, { readAt: /* @__PURE__ */ new Date() }, "notification:read");
+	}
+	/**
+	* Mark a notification as unread
+	*
+	* @param id The ID of the notification to mark as unread.
+	* @remarks Clears `readAt` and emits `notification:unread`.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* notifications.unread('notif-1')
+	* ```
+	*/
+	function unread(id) {
+		registry.upsert(id, { readAt: null }, "notification:unread");
+	}
+	/**
+	* Mark a notification as seen
+	*
+	* @param id The ID of the notification to mark as seen.
+	* @remarks Sets `seenAt` to the current time and emits `notification:seen`.
+	* Distinct from read — seen tracks whether the notification appeared in the
+	* user's viewport, while read indicates the user actively engaged with it.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* // Mark as seen when visible in inbox viewport
+	* notifications.seen('notif-1')
+	* ```
+	*/
+	function seen(id) {
+		registry.upsert(id, { seenAt: /* @__PURE__ */ new Date() }, "notification:seen");
+	}
+	/**
+	* Archive a notification
+	*
+	* @param id The ID of the notification to archive.
+	* @remarks Sets `archivedAt` to the current time and emits `notification:archived`.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* notifications.archive('notif-1')
+	* ```
+	*/
+	function archive(id) {
+		registry.upsert(id, { archivedAt: /* @__PURE__ */ new Date() }, "notification:archived");
+	}
+	/**
+	* Restore an archived notification
+	*
+	* @param id The ID of the notification to unarchive.
+	* @remarks Clears `archivedAt` and emits `notification:unarchived`.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* notifications.unarchive('notif-1')
+	* ```
+	*/
+	function unarchive(id) {
+		registry.upsert(id, { archivedAt: null }, "notification:unarchived");
+	}
+	/**
+	* Snooze a notification until a given time
+	*
+	* @param id The ID of the notification to snooze.
+	* @param until The time at which the snooze expires.
+	* @remarks Sets `snoozedUntil` and emits `notification:snoozed`. The composable
+	* does not auto-wake — consumers are responsible for calling {@link wake} when
+	* the snooze expires (e.g., via a timer or server push).
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* const tomorrow = new Date(Date.now() + 86_400_000)
+	* notifications.snooze('notif-1', tomorrow)
+	* ```
+	*/
+	function snooze(id, until) {
+		registry.upsert(id, { snoozedUntil: until }, "notification:snoozed");
+	}
+	/**
+	* Cancel a snooze
+	*
+	* @param id The ID of the notification to wake.
+	* @remarks Clears `snoozedUntil` and emits `notification:unsnoozed`.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* notifications.wake('notif-1')
+	* ```
+	*/
+	function wake(id) {
+		registry.upsert(id, { snoozedUntil: null }, "notification:unsnoozed");
+	}
+	/**
+	* Mark all unread notifications as read
+	*
+	* @remarks Iterates all notifications and marks unread ones as read in a single
+	* batch. Skips already-read notifications to preserve their original `readAt`
+	* timestamp. Emits `notification:read` for each affected notification.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* notifications.send({ subject: 'Message 1' })
+	* notifications.send({ subject: 'Message 2' })
+	*
+	* notifications.readAll()
+	*
+	* console.log(notifications.values().every(t => t.readAt !== null)) // true
+	* ```
+	*/
+	function readAll() {
+		const now = /* @__PURE__ */ new Date();
+		registry.batch(() => {
+			for (const ticket of registry.values()) if (/* @__PURE__ */ isNull(ticket.readAt)) registry.upsert(ticket.id, { readAt: now }, "notification:read");
+		});
+	}
+	/**
+	* Archive all unarchived notifications
+	*
+	* @remarks Iterates all notifications and archives unarchived ones in a single
+	* batch. Skips already-archived notifications to preserve their original
+	* `archivedAt` timestamp. Emits `notification:archived` for each affected notification.
+	*
+	* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+	*
+	* @example
+	* ```ts
+	* import { useNotifications } from '@vuetify/v0'
+	*
+	* const notifications = useNotifications()
+	*
+	* notifications.send({ subject: 'Alert 1' })
+	* notifications.send({ subject: 'Alert 2' })
+	*
+	* notifications.archiveAll()
+	*
+	* console.log(notifications.values().every(t => t.archivedAt !== null)) // true
+	* ```
+	*/
+	function archiveAll() {
+		const now = /* @__PURE__ */ new Date();
+		registry.batch(() => {
+			for (const ticket of registry.values()) if (/* @__PURE__ */ isNull(ticket.archivedAt)) registry.upsert(ticket.id, { archivedAt: now }, "notification:archived");
+		});
+	}
+	return {
+		...registry,
+		send,
+		register,
+		onboard,
+		queue,
+		read,
+		unread,
+		seen,
+		archive,
+		unarchive,
+		snooze,
+		wake,
+		readAll,
+		archiveAll,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+function noop() {}
+const EMPTY = [];
+function createNotificationsFallback() {
+	const stub = {
+		id: "",
+		index: 0,
+		value: 0,
+		valueIsIndex: true,
+		createdAt: /* @__PURE__ */ new Date(0),
+		readAt: null,
+		seenAt: null,
+		archivedAt: null,
+		snoozedUntil: null,
+		read: noop,
+		unread: noop,
+		seen: noop,
+		archive: noop,
+		unarchive: noop,
+		snooze: noop,
+		wake: noop,
+		dismiss: noop,
+		unregister: noop
+	};
+	return {
+		collection: /* @__PURE__ */ new Map(),
+		size: 0,
+		send: () => stub,
+		queue: {
+			collection: /* @__PURE__ */ new Map(),
+			size: 0,
+			register: () => ({}),
+			unregister: () => void 0,
+			has: () => false,
+			get: () => void 0,
+			keys: () => EMPTY,
+			values: () => EMPTY,
+			entries: () => EMPTY,
+			browse: () => void 0,
+			lookup: () => void 0,
+			upsert: () => ({}),
+			seek: () => void 0,
+			move: () => void 0,
+			on: noop,
+			off: noop,
+			emit: noop,
+			dispose: noop,
+			clear: noop,
+			reindex: noop,
+			batch: (fn) => fn(),
+			onboard: () => EMPTY,
+			offboard: noop,
+			pause: () => void 0,
+			resume: () => void 0
+		},
+		read: noop,
+		unread: noop,
+		seen: noop,
+		archive: noop,
+		unarchive: noop,
+		snooze: noop,
+		wake: noop,
+		readAll: noop,
+		archiveAll: noop,
+		clear: noop,
+		has: () => false,
+		get: () => void 0,
+		keys: () => EMPTY,
+		values: () => EMPTY,
+		entries: () => EMPTY,
+		browse: () => void 0,
+		lookup: () => void 0,
+		upsert: () => stub,
+		register: () => stub,
+		unregister: noop,
+		reindex: noop,
+		move: () => void 0,
+		seek: () => void 0,
+		on: noop,
+		off: noop,
+		emit: noop,
+		dispose: noop,
+		batch: (fn) => fn(),
+		onboard: () => EMPTY,
+		offboard: noop
+	};
+}
+/**
+* Notification management with registry, event system, and optional adapters.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-notifications
+*
+* @example
+* ```ts
+* import { createNotificationsPlugin, useNotifications } from '@vuetify/v0'
+*
+* // Install as plugin
+* app.use(createNotificationsPlugin())
+*
+* // Use in components
+* const notifications = useNotifications()
+* notifications.send({ subject: 'Saved', severity: 'success' })
+* ```
+*/
+const [createNotificationsContext, createNotificationsPlugin, useNotifications] = createPluginContext("v0:notifications", (options) => createNotifications(options), {
+	fallback: () => createNotificationsFallback(),
+	setup: (context, app, options) => {
+		app.onUnmount(() => {
+			context.dispose();
+			context.queue.dispose();
+		});
+		const { adapter } = options;
+		if (!adapter) return;
+		adapter.setup({
+			send: context.send,
+			register: context.register,
+			on: context.on,
+			off: context.off
+		});
+		if (/* @__PURE__ */ isFunction(adapter.dispose)) app.onUnmount(() => adapter.dispose());
+	}
+});
+//#endregion
+export { createQueue as a, useTimer as c, useNotifications as i, createNotificationsContext as n, createQueueContext as o, createNotificationsPlugin as r, useQueue as s, createNotifications as t };