@spinjs/components 0.0.0-stage → 0.1.0-preview.1

package/dist/toast/toast.presentation.js

@@ -0,0 +1,532 @@
+import { toast as toast$1 } from "./toast.machine.js";
+import { ariaDescribedBy, ariaLabelledBy, dataAttr, defineComponent, liveRegion } from "@spinjs/runtime";
+// src/toast/toast.presentation.ts
+const isToastType = (raw) => raw === "info" || raw === "success" || raw === "warning" || raw === "error" || raw === "loading";
+/** The toast's own record test: it accepts an array, which the
+* framework's record test rejects. */
+const isRecordOrArray = (value) => typeof value === "object" && value !== null;
+const asType = (raw) => isToastType(raw) ? raw : "info";
+const asText = (raw) => typeof raw === "string" ? raw : "";
+const asCount = (raw, fallback) => typeof raw === "number" && Number.isFinite(raw) ? Math.trunc(raw) : fallback;
+/** Unlike the record test above, an array is not a record. */
+const asRecord = (raw) => typeof raw === "object" && raw !== null && !Array.isArray(raw);
+const toEntry = (raw) => {
+	if (!asRecord(raw)) return void 0;
+	const id = asText(raw["id"]);
+	if (id.length === 0) return void 0;
+	return {
+		id,
+		title: asText(raw["title"]),
+		description: asText(raw["description"]),
+		type: asType(raw["type"]),
+		duration: asCount(raw["duration"], 0),
+		priority: asCount(raw["priority"], 0),
+		action: asText(raw["action"])
+	};
+};
+const parseItems = (raw) => {
+	if (!Array.isArray(raw)) return [];
+	return raw.map(toEntry).filter((item) => item !== void 0);
+};
+const sameEntry = (a, b) => a.id === b.id && a.title === b.title && a.description === b.description && a.type === b.type && a.action === b.action && a.priority === b.priority && (a.duration <= 0 || a.duration === b.remaining);
+/** Toasts the machine removed on its own; a host write never revives them.
+* Keyed by the context object, which is stable per service — assigns
+* replace fields, never the object. */
+const removedByBridge = /* @__PURE__ */ new WeakMap();
+const removedOf = (context) => {
+	let ids = removedByBridge.get(context);
+	if (ids === void 0) {
+		ids = /* @__PURE__ */ new Set();
+		removedByBridge.set(context, ids);
+	}
+	return ids;
+};
+const posture = (placement) => {
+	const [side, align] = placement.split("-");
+	return {
+		side: side === "top" ? "top" : "bottom",
+		align: align === "start" || align === "end" ? align : "center"
+	};
+};
+/** Zag's `setLastFocusedEl` / `restoreFocusIfPointerOut`: the element focus
+* came from is remembered, and given back when the region is left by both
+* the pointer and the keyboard. Keyed by bridge send — the def-built api may
+* rebuild, the memory must not. */
+const focusedByBridge = /* @__PURE__ */ new WeakMap();
+const lastFocusedOf = (scope) => {
+	let slot = focusedByBridge.get(scope.send);
+	if (slot === void 0) {
+		slot = { current: void 0 };
+		focusedByBridge.set(scope.send, slot);
+	}
+	return slot;
+};
+const onGroupFocus = (scope, event) => {
+	const related = event.relatedTarget;
+	if (related !== null && related instanceof Element && scope.root().contains(related)) return;
+	lastFocusedOf(scope).current = related instanceof Element ? related : void 0;
+	scope.send({ type: "REGION.FOCUS" });
+};
+const onGroupBlur = (scope, event) => {
+	const related = event.relatedTarget;
+	if (!(related !== null && related instanceof Element && scope.root().contains(related))) scope.send({ type: "REGION.BLUR" });
+	const last = lastFocusedOf(scope).current;
+	if (!scope.context.pointerWithin && last instanceof HTMLElement) {
+		last.focus({ preventScroll: true });
+		lastFocusedOf(scope).current = void 0;
+	}
+};
+const onGroupPointerLeave = (scope) => {
+	scope.send({ type: "REGION.POINTER_LEAVE" });
+	const last = lastFocusedOf(scope).current;
+	if (!scope.context.focusWithin && last instanceof HTMLElement) {
+		last.focus({ preventScroll: true });
+		lastFocusedOf(scope).current = void 0;
+	}
+};
+const placementOf = (context) => context.placement;
+const stackOffset = (scope, index) => {
+	const gap = scope.context.gap;
+	const list = scope.context.toasts;
+	let before = index * gap;
+	for (let position = 0; position < index; position += 1) before += list[position]?.height ?? 0;
+	return before;
+};
+/**
+* How far behind the front a row sits, as the transform the recipe reads.
+* A settled row is at its offset: the arrival and the exit are the fade
+* and the scale, so a row never waits outside the viewport for its entry
+* beat.
+*/
+const offsetY = (scope, index) => {
+	const placement = placementOf(scope.context);
+	const { side } = posture(placement);
+	const gap = scope.context.gap;
+	const distance = scope.state === "overlap" ? index * gap : stackOffset(scope, index);
+	return `${side === "top" ? distance : -distance || 0}px`;
+};
+/** A row that has not settled into place is slightly small and clear. A
+* paused row holds its clocks but stays put: only the exit clears it. */
+const settledRow = (entry) => entry.status !== "dismissing" && entry.mounted;
+const opacityOf = (entry) => settledRow(entry) ? "1" : "0";
+const scaleOf = (entry, index, overlapped) => {
+	if (!settledRow(entry)) return "0.96";
+	if (!overlapped || index === 0) return "1";
+	return String(Math.max(.6, 1 - index * .05));
+};
+const toast = defineComponent({
+	name: "toast",
+	machine: (props, authored) => toast$1(props, authored),
+	establish: (props) => props["overlap"] === true ? [{ type: "REGION.OVERLAP" }] : [],
+	reconcile: ({ context, state, parsed, send }) => {
+		const ctx = context;
+		let moved = false;
+		const max = Math.max(1, asCount(parsed["max"], 24));
+		if (ctx.max !== max) {
+			ctx.max = max;
+			moved = true;
+		}
+		const removeDelay = Math.max(0, asCount(parsed["removeDelay"], 200));
+		if (ctx.removeDelay !== removeDelay) {
+			ctx.removeDelay = removeDelay;
+			moved = true;
+		}
+		const overlap = parsed["overlap"] === true;
+		if (overlap && state !== "overlap") {
+			send({ type: "REGION.OVERLAP" });
+			moved = true;
+		}
+		if (!overlap && state === "overlap") {
+			send({ type: "REGION.STACK" });
+			moved = true;
+		}
+		const incoming = parseItems(parsed["items"]);
+		const before = [...ctx.toasts, ...ctx.queued];
+		const removed = removedOf(context);
+		for (const item of incoming) {
+			const current = before.find((entry) => entry.id === item.id);
+			if (current === void 0) {
+				if (removed.has(item.id)) continue;
+				send({
+					type: "TOAST.CREATE",
+					id: item.id,
+					title: item.title,
+					description: item.description,
+					toastType: asType(item.type),
+					duration: item.duration,
+					priority: item.priority,
+					action: item.action
+				});
+				moved = true;
+			} else if (!sameEntry(item, current)) {
+				send({
+					type: "TOAST.UPDATE",
+					id: item.id,
+					title: item.title,
+					description: item.description,
+					toastType: asType(item.type),
+					duration: item.duration,
+					priority: item.priority,
+					action: item.action
+				});
+				moved = true;
+			}
+		}
+		for (const entry of before) {
+			if (incoming.some((item) => item.id === entry.id)) continue;
+			send({
+				type: "TOAST.REMOVE",
+				id: entry.id
+			});
+			moved = true;
+		}
+		return moved;
+	},
+	parts: { group: { attrs: (scope) => {
+		const ctx = scope.context;
+		const placement = ctx.placement;
+		const { side, align } = posture(placement);
+		const offset = ctx.offsets;
+		const count = ctx.toasts.length;
+		const overlapped = scope.state === "overlap";
+		const hotkey = ctx.hotkey;
+		const label = ctx.label;
+		return {
+			id: scope.id("group"),
+			role: "region",
+			tabindex: -1,
+			"aria-label": hotkey.length > 0 ? `${label}, ${placement} (${hotkey})` : `${label}, ${placement}`,
+			...liveRegion({
+				live: "polite",
+				relevant: "additions text",
+				atomic: "false"
+			}),
+			"data-placement": placement,
+			"data-side": side,
+			"data-align": align,
+			"data-count": String(count),
+			"data-empty": dataAttr(count === 0),
+			"data-overlap": dataAttr(overlapped),
+			"data-stack": dataAttr(!overlapped),
+			style: {
+				gap: `${ctx.gap}px`,
+				...side === "top" ? { top: offset } : { bottom: offset },
+				...align === "start" ? { left: offset } : align === "end" ? { right: offset } : {
+					left: offset,
+					right: offset
+				}
+			},
+			"use:toast-region": {
+				hotkey: hotkey.split(",").map((key) => key.trim()).filter((key) => key.length > 0),
+				pauseOnPageIdle: ctx.pauseOnPageIdle,
+				onIdleChange: (idle) => {
+					scope.send({ type: idle ? "PAGE.IDLE" : "PAGE.ACTIVE" });
+				}
+			},
+			onMouseEnter: () => scope.send({ type: "REGION.POINTER_ENTER" }),
+			onMouseMove: () => scope.send({ type: "REGION.POINTER_ENTER" }),
+			onMouseLeave: () => onGroupPointerLeave(scope),
+			onFocus: (event) => onGroupFocus(scope, event),
+			onBlur: (event) => onGroupBlur(scope, event)
+		};
+	} } },
+	slots: {
+		toast: {
+			indexes: (context) => [...context.toasts],
+			attrs: (scope) => {
+				const entry = scope.slot;
+				const ctx = scope.context;
+				const placement = ctx.placement;
+				const { side, align } = posture(placement);
+				const index = ctx.toasts.findIndex((candidate) => candidate.id === entry.id);
+				const at = index === -1 ? ctx.toasts.length : index;
+				const frontmost = at === 0;
+				const current = ctx.toasts.find((candidate) => candidate.id === entry.id) ?? entry;
+				const visible = current.status !== "dismissing";
+				const paused = current.status === "persist";
+				const overlapped = scope.state === "overlap";
+				return {
+					id: scope.id("toast", entry.id),
+					role: "status",
+					tabindex: 0,
+					...liveRegion({ atomic: "true" }),
+					...ariaLabelledBy(scope, {
+						part: "toast",
+						slot: `${entry.id}:title`
+					}),
+					...ariaDescribedBy(scope, entry.description.length > 0 ? {
+						part: "toast",
+						slot: `${entry.id}:description`
+					} : void 0),
+					"data-state": visible ? "open" : "closed",
+					"data-placement": placement,
+					"data-side": side,
+					"data-align": align,
+					"data-mounted": dataAttr(current.mounted),
+					"data-paused": dataAttr(paused),
+					"data-first": dataAttr(frontmost),
+					"data-sibling": dataAttr(!frontmost),
+					"data-stack": dataAttr(!overlapped),
+					"data-overlap": dataAttr(overlapped),
+					style: {
+						transform: `translateY(${offsetY(scope, at)})`,
+						scale: scaleOf(current, at, overlapped),
+						opacity: opacityOf(current),
+						zIndex: String(ctx.toasts.length - at)
+					},
+					onKeydown: (event) => {
+						if (event.defaultPrevented) return;
+						if (event.key === "Escape") {
+							event.preventDefault();
+							scope.send({
+								type: "TOAST.DISMISS",
+								id: entry.id,
+								src: "keyboard"
+							});
+						}
+					},
+					"use:toast-timer": {
+						remaining: current.remaining,
+						paused,
+						dismissing: current.status === "dismissing",
+						removeDelay: ctx.removeDelay,
+						onTimeout: () => scope.send({
+							type: "TIMER.ELAPSED",
+							id: entry.id
+						}),
+						onRemove: () => scope.send({
+							type: "TIMER.REMOVED",
+							id: entry.id
+						}),
+						onPause: (remaining) => {
+							scope.send({
+								type: "TOAST.PAUSE",
+								id: entry.id,
+								remaining
+							});
+						},
+						onReady: () => scope.send({
+							type: "TOAST.MOUNTED",
+							id: entry.id
+						})
+					},
+					"use:toast-row": { onHeight: (height) => {
+						scope.send({
+							type: "HEIGHT.SET",
+							id: entry.id,
+							height
+						});
+					} }
+				};
+			}
+		},
+		title: {
+			id: "toast",
+			indexes: (context) => [...context.toasts],
+			attrs: (scope) => {
+				const entry = scope.slot;
+				return { id: scope.id("toast", `${entry.id}:title`) };
+			}
+		},
+		description: {
+			id: "toast",
+			indexes: (context) => [...context.toasts],
+			attrs: (scope) => {
+				const entry = scope.slot;
+				return { id: scope.id("toast", `${entry.id}:description`) };
+			}
+		},
+		actionTrigger: {
+			id: "toast",
+			indexes: (context) => [...context.toasts],
+			attrs: (scope) => {
+				const entry = scope.slot;
+				return {
+					id: scope.id("toast", `${entry.id}:action`),
+					type: "button",
+					"aria-label": entry.action,
+					hidden: entry.action.length === 0,
+					onClick: (event) => {
+						if (event.defaultPrevented) return;
+						scope.root().dispatchEvent(new CustomEvent("toast-action", {
+							bubbles: true,
+							detail: { id: entry.id }
+						}));
+						scope.send({
+							type: "TOAST.DISMISS",
+							id: entry.id,
+							src: "user"
+						});
+					}
+				};
+			}
+		},
+		closeTrigger: {
+			id: "toast",
+			indexes: (context) => [...context.toasts],
+			attrs: (scope) => {
+				const entry = scope.slot;
+				return {
+					id: scope.id("toast", `${entry.id}:close`),
+					type: "button",
+					"aria-label": "Dismiss notification",
+					hidden: scope.context.closable === false,
+					onClick: (event) => {
+						if (event.defaultPrevented) return;
+						scope.send({
+							type: "TOAST.DISMISS",
+							id: entry.id,
+							src: "user"
+						});
+					}
+				};
+			}
+		}
+	},
+	commands: {
+		create: { event: (args) => {
+			const item = args[0];
+			if (typeof item !== "object" || item === null) throw new Error("[toast] create requires an item object");
+			if (!isRecordOrArray(item)) throw new Error("[toast] create requires an object item");
+			const field = (name) => item[name];
+			const id = field("id");
+			if (typeof id !== "string" || id.length === 0) throw new Error("[toast] create requires a string id");
+			const text = (name) => {
+				const v = field(name);
+				return typeof v === "string" ? v : "";
+			};
+			const count = (name) => {
+				const v = field(name);
+				return typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : 0;
+			};
+			return {
+				type: "TOAST.CREATE",
+				id,
+				title: text("title"),
+				description: text("description"),
+				toastType: asType(field("type")),
+				duration: count("duration"),
+				priority: count("priority"),
+				action: text("action")
+			};
+		} },
+		update: { event: (args, context) => {
+			const id = args[0];
+			const item = args[1];
+			if (typeof id !== "string") throw new Error("[toast] update requires a string id");
+			if (!isRecordOrArray(item)) throw new Error("[toast] update requires a partial item object");
+			const field = (name) => item[name];
+			const textOr = (name, fallback) => {
+				const v = field(name);
+				return typeof v === "string" ? v : fallback;
+			};
+			const count = (name) => {
+				const v = field(name);
+				return typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : 0;
+			};
+			const current = context.toasts.find((entry) => entry.id === id) ?? context.queued.find((entry) => entry.id === id);
+			return {
+				type: "TOAST.UPDATE",
+				id,
+				title: textOr("title", current?.title ?? ""),
+				description: textOr("description", current?.description ?? ""),
+				toastType: asType(field("type") ?? current?.type),
+				duration: count("duration"),
+				priority: count("priority"),
+				action: textOr("action", current?.action ?? "")
+			};
+		} },
+		dismiss: { event: (args) => {
+			const id = args[0];
+			const src = args[1];
+			return {
+				type: "TOAST.DISMISS",
+				id: typeof id === "string" ? id : "",
+				src: typeof src === "string" ? src : "programmatic"
+			};
+		} },
+		remove: { event: (args) => {
+			const id = args[0];
+			return {
+				type: "TOAST.REMOVE",
+				id: typeof id === "string" ? id : ""
+			};
+		} },
+		dismissAll: { event: () => ({ type: "DISMISS.ALL" }) },
+		pause: { event: (args, context) => {
+			const id = args[0];
+			if (typeof id !== "string") return {
+				type: "TOAST.PAUSE",
+				id: "",
+				remaining: 0
+			};
+			return {
+				type: "TOAST.PAUSE",
+				id,
+				remaining: context.toasts.find((entry) => entry.id === id)?.remaining ?? 0
+			};
+		} },
+		resume: { event: (args) => {
+			const id = args[0];
+			return {
+				type: "TOAST.RESUME",
+				id: typeof id === "string" ? id : ""
+			};
+		} }
+	},
+	readers: {
+		count: { read: (context) => context.toasts.length },
+		layout: { read: (_context, state) => state === "overlap" ? "overlap" : "stack" },
+		placement: { read: (context) => placementOf(context) },
+		overlapping: { read: (_context, state) => state === "overlap" },
+		paused: { read: (context) => {
+			const ctx = context;
+			return ctx.pointerWithin || ctx.focusWithin || ctx.pageIdle;
+		} }
+	},
+	methods: { getToasts: { call: (context) => {
+		return [...context.toasts];
+	} } },
+	events: { "status-change": {
+		prop: "onStatusChange",
+		watch: () => [],
+		detail: (watched) => {
+			const v = watched[0];
+			return { id: typeof v === "string" ? v : "" };
+		},
+		select: (event, before, after, _states, source) => {
+			const beforeList = before.toasts;
+			const afterList = after.toasts;
+			const remembered = source !== "reconcile";
+			const src = event.type === "TOAST.DISMISS" ? event["src"] : "";
+			const reports = [];
+			for (const entry of beforeList) {
+				const now = afterList.find((candidate) => candidate.id === entry.id);
+				if (now === void 0) {
+					if (remembered) removedOf(after).add(entry.id);
+					reports.push({
+						id: entry.id,
+						status: "unmounted",
+						src
+					});
+				} else if (now.status !== entry.status) reports.push({
+					id: entry.id,
+					status: now.status,
+					src
+				});
+			}
+			for (const entry of afterList) {
+				if (beforeList.some((candidate) => candidate.id === entry.id)) continue;
+				reports.push({
+					id: entry.id,
+					status: "visible",
+					src
+				});
+			}
+			return reports.length === 0 ? null : reports;
+		}
+	} }
+});
+export { toast };
+
+//# sourceMappingURL=toast.presentation.js.map

package/dist/toast/toast.state.d.ts

@@ -0,0 +1,65 @@
+import { ToastEvent, ToastEvents, ToastType } from "./toast.events.js";
+export type ToastStatus = "visible" | "persist" | "dismissing";
+export type ToastState = "stack" | "overlap";
+export interface ToastEntry {
+  readonly id: string;
+  readonly title: string;
+  readonly description: string;
+  readonly type: ToastType;
+  readonly status: ToastStatus;
+  /** The dismissal clock's remainder; Infinity never fires. */
+  readonly remaining: number;
+  /** Queue order: lower sorts first. */
+  readonly priority: number;
+  /** The action trigger's label; empty means no trigger. */
+  readonly action: string;
+  readonly height: number;
+  /** False until the frame after the row attached. */
+  readonly mounted: boolean;
+}
+export interface ToastContext {
+  /** Newest first — the front toast is index 0. */
+  toasts: ToastEntry[];
+  /** Entries waiting for room; `max` full means held, not dropped. */
+  queued: ToastEntry[];
+  /** The region's stacking mode; mirrored on rows as `data-stack`. */
+  overlap: boolean;
+  max: number;
+  removeDelay: number;
+  pointerWithin: boolean;
+  focusWithin: boolean;
+  pageIdle: boolean;
+  placement: string;
+  gap: number;
+  offsets: string;
+  hotkey: string;
+  label: string;
+  pauseOnPageIdle: boolean;
+  closable: boolean;
+}
+export interface ToastArgs {
+  readonly overlap?: boolean;
+  readonly max?: number;
+  readonly removeDelay?: number;
+  readonly placement?: string;
+  readonly gap?: number;
+  readonly offsets?: string;
+  readonly hotkey?: string;
+  readonly label?: string;
+  readonly pauseOnPageIdle?: boolean;
+  readonly closable?: boolean;
+}
+export declare const durationFor: (type: ToastType, authored: number) => number;
+export declare const priorityFor: (type: ToastType, authored: number, hasAction: boolean) => number;
+export declare const forever: (entry: ToastEntry) => boolean;
+export declare const projectedCount: (ctx: ToastContext, e: ToastEvent) => number;
+export declare const makeEntry: (e: Extract<ToastEvent, {
+  type: "TOAST.CREATE";
+}>) => ToastEntry;
+export declare const promote: (ctx: ToastContext) => Pick<ToastContext, "toasts" | "queued">;
+export declare const amend: (toasts: readonly ToastEntry[], id: string, make: (entry: ToastEntry) => ToastEntry) => ToastEntry[] | undefined;
+export declare const resumeEntry: (entry: ToastEntry) => ToastEntry;
+declare const asCountMachine: (raw: unknown, fallback: number) => number;
+export declare function initial(args: ToastArgs, authored: (name: string) => boolean): ToastContext;
+export { type ToastEvent, type ToastEvents, type ToastType, asCountMachine };
+//# sourceMappingURL=toast.state.d.ts.map

package/dist/toast/toast.state.js

@@ -0,0 +1,88 @@
+import { defaultTwin } from "@spinjs/runtime";
+// src/toast/toast.state.ts
+const DURATIONS = {
+	info: 5e3,
+	error: 5e3,
+	success: 2e3,
+	warning: 5e3,
+	loading: Infinity
+};
+const PRIORITIES = {
+	error: [1, 2],
+	warning: [3, 6],
+	loading: [4, 5],
+	success: [5, 7],
+	info: [6, 8]
+};
+const durationFor = (type, authored) => authored > 0 && type !== "loading" ? authored : DURATIONS[type];
+const priorityFor = (type, authored, hasAction) => authored > 0 ? authored : PRIORITIES[type][hasAction ? 0 : 1];
+const forever = (entry) => entry.type === "loading" || entry.remaining === Infinity;
+const projectedCount = (ctx, e) => {
+	if (e.type === "TOAST.CREATE") return ctx.toasts.length + 1;
+	if (e.type === "TOAST.REMOVE" || e.type === "TIMER.REMOVED") return ctx.toasts.length - 1;
+	return ctx.toasts.length;
+};
+const makeEntry = (e) => ({
+	id: e.id,
+	title: e.title,
+	description: e.description,
+	type: e.toastType,
+	status: "visible",
+	remaining: durationFor(e.toastType, e.duration),
+	action: e.action,
+	height: 0,
+	priority: priorityFor(e.toastType, e.priority, e.action.length > 0),
+	mounted: false
+});
+const promote = (ctx) => {
+	const toasts = [...ctx.toasts];
+	const waiting = [...ctx.queued].sort((a, b) => a.priority - b.priority);
+	while (waiting.length > 0 && toasts.length < ctx.max) {
+		const next = waiting.shift();
+		if (next === void 0) break;
+		toasts.unshift(next);
+	}
+	return {
+		toasts,
+		queued: waiting
+	};
+};
+const amend = (toasts, id, make) => {
+	const at = toasts.findIndex((entry) => entry.id === id);
+	const current = at === -1 ? void 0 : toasts[at];
+	if (current === void 0) return void 0;
+	return [
+		...toasts.slice(0, at),
+		make(current),
+		...toasts.slice(at + 1)
+	];
+};
+const resumeEntry = (entry) => entry.status !== "persist" || forever(entry) ? entry : {
+	...entry,
+	status: "visible"
+};
+const asCountMachine = (raw, fallback) => typeof raw === "number" && Number.isFinite(raw) ? Math.trunc(raw) : fallback;
+function initial(args, authored) {
+	const written = (field) => authored(field) || authored(defaultTwin(field)) || args[defaultTwin(field)] !== void 0;
+	const text = (value, fallback) => typeof value === "string" && value.length > 0 ? value : fallback;
+	return {
+		toasts: [],
+		queued: [],
+		overlap: written("overlap") ? args.overlap === true : false,
+		max: written("max") ? Math.max(1, asCountMachine(args.max, 24)) : 24,
+		removeDelay: written("removeDelay") ? Math.max(0, asCountMachine(args.removeDelay, 200)) : 200,
+		pointerWithin: false,
+		focusWithin: false,
+		pageIdle: false,
+		placement: text(args.placement, "bottom"),
+		gap: typeof args.gap === "number" && Number.isFinite(args.gap) ? Math.trunc(args.gap) : 16,
+		offsets: text(args.offsets, "1rem"),
+		hotkey: text(args.hotkey, ""),
+		label: text(args.label, "Notifications"),
+		pauseOnPageIdle: args.pauseOnPageIdle !== false,
+		closable: args.closable !== false
+	};
+}
+export { amend, asCountMachine, durationFor, forever, initial, makeEntry, priorityFor, projectedCount, promote, resumeEntry };
+
+//# sourceMappingURL=toast.state.js.map