varsel 0.5.1 → 0.5.4

package/dist/VarselItem.svelte.d.ts

@@ -0,0 +1,23 @@
+import { type PositionedToast } from "./internals";
+type $$ComponentProps = {
+    toast: PositionedToast;
+    onRemove: (id: string) => void;
+    isGroupHovered?: boolean;
+    expandedOffset?: number;
+    expandedGap?: number;
+    collapsedOffset?: number;
+    hiddenCollapsedOffset?: number;
+    onHeightChange?: (id: string, height: number) => void;
+    onGroupHoverEnter?: () => void;
+    onGroupHoldChange?: (holding: boolean) => void;
+    defaultDuration?: number;
+    defaultShowClose?: boolean;
+    pauseOnHover?: boolean;
+    offset?: number | string;
+    expand?: boolean;
+    visibleToasts?: number;
+};
+declare const VarselItem: import("svelte").Component<$$ComponentProps, {}, "">;
+type VarselItem = ReturnType<typeof VarselItem>;
+export default VarselItem;
+//# sourceMappingURL=VarselItem.svelte.d.ts.map

package/dist/VarselItem.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VarselItem.svelte.d.ts","sourceRoot":"","sources":["../src/lib/VarselItem.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAYN,KAAK,eAAe,EAIpB,MAAM,aAAa,CAAC;AAUpB,KAAK,gBAAgB,GAAI;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,cAAc,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAywBF,QAAA,MAAM,UAAU,sDAAwC,CAAC;AACzD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAChD,eAAe,UAAU,CAAC"}

package/dist/VarselManager.svelte

@@ -0,0 +1,451 @@
+<script lang="ts">
+/**
+ * @component
+ * @description
+ * Internal component responsible for grouping toasts by position and calculating
+ * their stacking offsets (both collapsed and expanded).
+ * It handles the "hover to expand" logic and manages the lifecycle of toast groups.
+ */
+import VarselItem from "./VarselItem.svelte";
+import {
+	ANIMATION_CONFIG,
+	type PositionedToast,
+	type ToastData,
+	type ToastPosition,
+} from "./internals";
+
+let {
+	toasts = [],
+	onRemove,
+	expandedGap = ANIMATION_CONFIG.EXPANDED_GAP,
+	position: defaultPosition = 'bottom-center',
+	visibleToasts = 3,
+	expand = true,
+	duration = 5000,
+	closeButton = true,
+	pauseOnHover = true,
+	offset = undefined,
+	dir = 'auto'
+}: {
+	toasts?: ToastData[];
+	onRemove: (id: string) => void;
+	expandedGap?: number;
+	position?: ToastPosition;
+	visibleToasts?: number;
+	expand?: boolean;
+	duration?: number;
+	closeButton?: boolean;
+	pauseOnHover?: boolean;
+	offset?: number | string;
+	dir?: 'ltr' | 'rtl' | 'auto';
+} = $props();
+
+const createPositionMap = <T>(value: () => T): Record<ToastPosition, T> => ({
+	"top-left": value(),
+	"top-center": value(),
+	"top-right": value(),
+	"bottom-left": value(),
+	"bottom-center": value(),
+	"bottom-right": value(),
+});
+
+let heights = $state<Record<string, number>>({});
+let hovered = $state<Record<ToastPosition, boolean>>(
+	createPositionMap(() => false),
+);
+let heldToasts = $state<Record<ToastPosition, Set<string>>>(
+	createPositionMap(() => new Set<string>()),
+);
+
+// Non-reactive internal state for "previous" values (mimicking legacy behavior)
+let previousStackIndex: Record<string, number> = {};
+let previousCollapsedOffsets: Record<string, number> = {};
+let previousExpandedOffsets: Record<string, number> = {};
+
+let toastsByPosition = $state<Record<ToastPosition, PositionedToast[]>>(
+	createPositionMap<PositionedToast[]>(() => []),
+);
+
+let collapsedOffsetData = $state<{
+	byPosition: Record<ToastPosition, number[]>;
+	byId: Record<string, number>;
+}>({ byPosition: createPositionMap<number[]>(() => []), byId: {} });
+
+let expandedOffsetData = $state<{
+	byPosition: Record<ToastPosition, number[]>;
+	byId: Record<string, number>;
+}>({ byPosition: createPositionMap<number[]>(() => []), byId: {} });
+
+let positionEntries = $derived(
+	Object.entries(toastsByPosition) as [ToastPosition, PositionedToast[]][],
+);
+let latestPositionEntries = $derived(positionEntries);
+let latestHovered = $derived(hovered);
+
+const updateHoldState = (
+	position: ToastPosition,
+	toastId: string,
+	isHolding: boolean,
+) => {
+	const current = heldToasts[position] ?? new Set<string>();
+	const next = new Set(current);
+	if (isHolding) {
+		next.add(toastId);
+	} else {
+		next.delete(toastId);
+	}
+	if (next.size !== current.size) {
+		heldToasts = { ...heldToasts, [position]: next };
+	}
+};
+
+// Calculate toastsByPosition based on toasts
+$effect(() => {
+	const grouped = createPositionMap<ToastData[]>(() => []);
+	for (const toast of toasts) {
+		const pos = toast.position || defaultPosition;
+		grouped[pos].push(toast);
+	}
+
+	const nextStackIndices: Record<string, number> = {};
+	const positioned = createPositionMap<PositionedToast[]>(() => []);
+
+	for (const position of Object.keys(grouped) as ToastPosition[]) {
+		const list = grouped[position];
+		const activeToasts = list.filter(
+			(toast) => !toast.isLeaving && !toast.shouldClose,
+		);
+		const activeIndexMap = new Map<string, number>();
+		activeToasts.forEach((toast, activeIndex) => {
+			activeIndexMap.set(toast.id, activeIndex);
+		});
+
+		positioned[position] = list.map((toast, orderIndex) => {
+			let stackIndex =
+				activeIndexMap.get(toast.id) ?? previousStackIndex[toast.id];
+			if (stackIndex == null || Number.isNaN(stackIndex)) {
+				stackIndex = orderIndex;
+			}
+
+			nextStackIndices[toast.id] = stackIndex;
+
+			return {
+				...toast,
+				position: position,
+				index: stackIndex,
+				renderIndex: orderIndex,
+				total: list.length,
+			};
+		}) as PositionedToast[];
+	}
+
+	previousStackIndex = nextStackIndices;
+	toastsByPosition = positioned;
+});
+
+// Update hovered state based on empty groups
+$effect(() => {
+	const next = { ...hovered };
+	let changed = false;
+	for (const pos of Object.keys(hovered) as ToastPosition[]) {
+		const hasToast = (toastsByPosition[pos]?.length ?? 0) > 0;
+		if (!hasToast && next[pos]) {
+			next[pos] = false;
+			changed = true;
+		}
+	}
+	if (changed) {
+		hovered = next;
+	}
+});
+
+// Calculate collapsedOffsetData
+$effect(() => {
+	const byPosition = createPositionMap<number[]>(() => []);
+	const byId: Record<string, number> = {};
+
+	for (const [pos, group] of positionEntries) {
+		const isTopPosition = pos.startsWith("top-");
+		const activeToasts = group.filter((toast) => !toast.shouldClose);
+		const offsetsForActive: number[] = [];
+
+		for (let i = 0; i < activeToasts.length; i++) {
+			if (i === 0) {
+				offsetsForActive.push(0);
+				continue;
+			}
+
+			const prevToast = activeToasts[i - 1];
+			const currentToast = activeToasts[i];
+			const prevOffset = offsetsForActive[i - 1] ?? 0;
+			if (!prevToast || !currentToast) {
+				offsetsForActive.push(prevOffset);
+				continue;
+			}
+			const prevHeight = heights[prevToast.id];
+			const currentHeight = heights[currentToast.id];
+			const fallbackOffset =
+				prevOffset + (isTopPosition ? 1 : -1) * ANIMATION_CONFIG.STACK_OFFSET;
+
+			if (
+				prevHeight == null ||
+				currentHeight == null ||
+				Number.isNaN(prevHeight) ||
+				Number.isNaN(currentHeight)
+			) {
+				offsetsForActive.push(fallbackOffset);
+				continue;
+			}
+
+			if (isTopPosition) {
+				offsetsForActive.push(
+					prevOffset +
+						(prevHeight - currentHeight + ANIMATION_CONFIG.STACK_OFFSET),
+				);
+			} else {
+				offsetsForActive.push(
+					prevOffset +
+						(currentHeight - prevHeight - ANIMATION_CONFIG.STACK_OFFSET),
+				);
+			}
+		}
+
+		for (let i = 0; i < activeToasts.length; i++) {
+			const toast = activeToasts[i];
+			if (!toast) continue;
+			byId[toast.id] = offsetsForActive[i] ?? 0;
+		}
+
+		for (const toast of group) {
+			if (byId[toast.id] != null) continue;
+			const previousOffset = previousCollapsedOffsets[toast.id];
+			if (typeof previousOffset === "number") {
+				byId[toast.id] = previousOffset;
+				continue;
+			}
+
+			const defaultOffset = isTopPosition
+				? toast.index * ANIMATION_CONFIG.STACK_OFFSET
+				: -(toast.index * ANIMATION_CONFIG.STACK_OFFSET);
+			byId[toast.id] = defaultOffset;
+		}
+
+		byPosition[pos] = group.map((toast) => byId[toast.id] ?? 0);
+	}
+
+	previousCollapsedOffsets = byId;
+	collapsedOffsetData = { byPosition, byId };
+});
+
+// Calculate expandedOffsetData
+$effect(() => {
+	const byPosition = createPositionMap<number[]>(() => []);
+	const byId: Record<string, number> = {};
+
+	for (const [pos, group] of positionEntries) {
+		const offsets: number[] = [];
+		const activeToasts = group.filter((toast) => !toast.shouldClose);
+		let acc = 0;
+
+		for (let i = 0; i < activeToasts.length; i++) {
+			if (i === 0) {
+				offsets.push(0);
+				continue;
+			}
+			const prevToast = activeToasts[i - 1];
+			const prevHeight = prevToast ? (heights[prevToast.id] ?? 0) : 0;
+			acc += prevHeight + expandedGap;
+			offsets.push(acc);
+		}
+
+		for (let i = 0; i < activeToasts.length; i++) {
+			const toast = activeToasts[i];
+			if (!toast) continue;
+			byId[toast.id] = offsets[i] ?? 0;
+		}
+
+		for (const toast of group) {
+			if (byId[toast.id] != null) continue;
+
+			const previousOffset = previousExpandedOffsets[toast.id];
+			if (typeof previousOffset === "number") {
+				byId[toast.id] = previousOffset;
+				continue;
+			}
+
+			let fallback = 0;
+			for (const candidate of group) {
+				if (candidate.id === toast.id) break;
+				const height = heights[candidate.id] ?? 0;
+				fallback += height + expandedGap;
+			}
+			byId[toast.id] = fallback;
+		}
+
+		byPosition[pos] = group.map((toast) => byId[toast.id] ?? 0);
+	}
+
+	previousExpandedOffsets = byId;
+	expandedOffsetData = { byPosition, byId };
+});
+
+$effect(() => {
+	let hoverFrameId: number | null = null;
+	let pointerX = 0;
+	let pointerY = 0;
+
+	const updateHoverState = (x: number, y: number) => {
+		if (latestPositionEntries.length === 0) return;
+		const next: Record<ToastPosition, boolean> = {
+			...latestHovered,
+		};
+		for (const [pos, group] of latestPositionEntries) {
+			let top = Number.POSITIVE_INFINITY;
+			let left = Number.POSITIVE_INFINITY;
+			let right = Number.NEGATIVE_INFINITY;
+			let bottom = Number.NEGATIVE_INFINITY;
+			let any = false;
+			for (const t of group) {
+				if (t.index >= visibleToasts) continue;
+				const el = document.querySelector(
+					`[data-toast-id="${t.id}"]`,
+				) as HTMLElement | null;
+				if (!el) continue;
+				const rect = el.getBoundingClientRect();
+				top = Math.min(top, rect.top);
+				left = Math.min(left, rect.left);
+				right = Math.max(right, rect.right);
+				bottom = Math.max(bottom, rect.bottom);
+				any = true;
+			}
+
+			if (!any) {
+				next[pos] = false;
+				continue;
+			}
+
+			const inside = x >= left && x <= right && y >= top && y <= bottom;
+			next[pos] = inside;
+		}
+
+		const changed = (Object.keys(next) as ToastPosition[]).some(
+			(key) => next[key] !== hovered[key],
+		);
+		if (changed) {
+			hovered = next;
+		}
+	};
+
+	const flushHoverUpdate = () => {
+		hoverFrameId = null;
+		updateHoverState(pointerX, pointerY);
+	};
+
+	const handleMouseMove = (event: MouseEvent) => {
+		pointerX = event.clientX;
+		pointerY = event.clientY;
+		if (hoverFrameId == null) {
+			hoverFrameId = requestAnimationFrame(flushHoverUpdate);
+		}
+	};
+
+	const handleKeyDown = (event: KeyboardEvent) => {
+		if (event.key !== "Escape") return;
+		for (const [, group] of latestPositionEntries) {
+			const latestToast = group?.[0];
+			if (!latestToast) continue;
+			const container = document.querySelector(
+				`[data-toast-id="${latestToast.id}"]`,
+			) as HTMLElement | null;
+			if (!container) continue;
+			const active = document.activeElement as HTMLElement | null;
+			if (active && container.contains(active)) {
+				const closeBtn = container.querySelector(
+					'[aria-label="Close toast"]',
+				) as HTMLButtonElement | null;
+				if (closeBtn) {
+					event.preventDefault();
+					closeBtn.click();
+				}
+			}
+		}
+	};
+
+	document.addEventListener("mousemove", handleMouseMove);
+	document.addEventListener("keydown", handleKeyDown);
+	return () => {
+		if (hoverFrameId != null) {
+			cancelAnimationFrame(hoverFrameId);
+			hoverFrameId = null;
+		}
+		document.removeEventListener("mousemove", handleMouseMove);
+		document.removeEventListener("keydown", handleKeyDown);
+	};
+});
+
+const handleHeightChange = (id: string, height: number) => {
+	if (heights[id] === height) return;
+	heights = { ...heights, [id]: height };
+};
+</script>
+
+{#if toasts.length > 0}
+	<div 
+		class="pointer-events-none fixed inset-0 z-50"
+		{dir}
+	>
+		{#each positionEntries as [position, positionToasts]}
+			{@const pos = position}
+			{@const expandedOffsets = expandedOffsetData.byPosition[pos]}
+			{@const collapsedOffsets = collapsedOffsetData.byPosition[pos]}
+			{@const isHovered = hovered[pos]}
+			{@const isHeld = (heldToasts[pos]?.size ?? 0) > 0}
+			{@const isGroupActive = isHovered || isHeld}
+			{@const activeToasts = positionToasts.filter((toast) => !toast.shouldClose)}
+			{@const visibleStackLimit = Math.max(visibleToasts - 1, 0)}
+			{@const maxVisibleStackIndex = Math.min(
+				Math.max(activeToasts.length - 1, 0),
+				visibleStackLimit,
+			)}
+			{@const lastVisibleToastId = activeToasts[maxVisibleStackIndex]?.id}
+			{@const lastVisibleRenderIndex = lastVisibleToastId != null
+				? positionToasts.findIndex(
+						(candidate) => candidate.id === lastVisibleToastId,
+					)
+				: -1}
+			{@const sharedHiddenCollapsedOffset =
+				lastVisibleRenderIndex >= 0
+					? collapsedOffsets?.[lastVisibleRenderIndex]
+					: undefined}
+			{#each positionToasts as toast, idx (toast.id)}
+				{@const toastIsHidden =
+					toast.index >= visibleToasts}
+				{@const hiddenCollapsedOffset = toastIsHidden
+					? sharedHiddenCollapsedOffset ?? collapsedOffsets?.[idx]
+					: collapsedOffsets?.[idx]}
+				{@const collapsedOffsetValue = collapsedOffsets?.[idx]}
+				<VarselItem
+					{toast}
+					{onRemove}
+					isGroupHovered={isGroupActive}
+					expandedOffset={expandedOffsets?.[idx] ?? 0}
+					{expandedGap}
+					onHeightChange={handleHeightChange}
+					onGroupHoverEnter={() => {
+						hovered = { ...hovered, [pos]: true };
+					}}
+					onGroupHoldChange={(holding) =>
+						updateHoldState(pos, toast.id, holding)}
+					collapsedOffset={collapsedOffsetValue}
+					hiddenCollapsedOffset={hiddenCollapsedOffset}
+					defaultDuration={duration}
+					defaultShowClose={closeButton}
+					{pauseOnHover}
+					{offset}
+					{expand}
+					{visibleToasts}
+				/>
+			{/each}
+		{/each}
+	</div>
+{/if}

package/dist/VarselManager.svelte.d.ts

@@ -0,0 +1,18 @@
+import { type ToastData, type ToastPosition } from "./internals";
+type $$ComponentProps = {
+    toasts?: ToastData[];
+    onRemove: (id: string) => void;
+    expandedGap?: number;
+    position?: ToastPosition;
+    visibleToasts?: number;
+    expand?: boolean;
+    duration?: number;
+    closeButton?: boolean;
+    pauseOnHover?: boolean;
+    offset?: number | string;
+    dir?: 'ltr' | 'rtl' | 'auto';
+};
+declare const VarselManager: import("svelte").Component<$$ComponentProps, {}, "">;
+type VarselManager = ReturnType<typeof VarselManager>;
+export default VarselManager;
+//# sourceMappingURL=VarselManager.svelte.d.ts.map

package/dist/VarselManager.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VarselManager.svelte.d.ts","sourceRoot":"","sources":["../src/lib/VarselManager.svelte.ts"],"names":[],"mappings":"AAWA,OAAO,EAGN,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,MAAM,aAAa,CAAC;AAEpB,KAAK,gBAAgB,GAAI;IACzB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;CAC7B,CAAC;AA4ZF,QAAA,MAAM,aAAa,sDAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}

package/dist/VarselToaster.svelte

@@ -0,0 +1,104 @@
+<script lang="ts" module>
+/**
+ * Main module exports for the Varsel library.
+ */
+export {
+	toast,
+	type ToastData,
+	type ToastInvoker,
+	type ToastPosition,
+} from "./internals";
+</script>
+
+<script lang="ts">
+	/**
+	 * @component
+	 * @description
+	 * The root component for the Varsel notification system.
+	 * It subscribes to the global toast state and renders the `VarselManager`
+	 * which handles the positioning and layout of individual toasts.
+	 *
+ * Place this component once in your application's root layout (e.g., `+layout.svelte`).
+ */
+	import { onMount } from 'svelte';
+	import VarselManager from './VarselManager.svelte';
+	import {
+		toastState,
+		toasterInstanceManager,
+		type ToastData,
+		type ToastPosition,
+	} from './internals';
+
+	let { 
+		expandedGap = undefined,
+		position = 'bottom-center',
+		visibleToasts = 3,
+		expand = true,
+		duration = 5000,
+		closeButton = true,
+		pauseOnHover = true,
+		offset = undefined,
+		dir = 'auto'
+	}: { 
+		/**
+		 * The gap (in pixels) between expanded toasts when hovering over the stack.
+		 * If undefined, uses the default value from animation config.
+		 */
+		expandedGap?: number;
+		/** Default position for toasts. */
+		position?: ToastPosition;
+		/** Maximum number of visible toasts in the stack. */
+		visibleToasts?: number;
+		/** Whether to expand the stack on hover. */
+		expand?: boolean;
+		/** Default duration in milliseconds. */
+		duration?: number;
+		/** Whether to show the close button by default. */
+		closeButton?: boolean;
+		/** Whether to pause the timer on hover. */
+		pauseOnHover?: boolean;
+		/** Offset from the edge of the screen. */
+		offset?: number | string;
+		/** Directionality of the text. */
+		dir?: 'ltr' | 'rtl' | 'auto';
+	} = $props();
+
+	let toasts = $state<ToastData[]>([]);
+	let instanceId = $state<string | null>(null);
+
+	const handleRemove = (id: string) => {
+		toastState.remove(id);
+	};
+
+	onMount(() => {
+		const registeredInstanceId = toasterInstanceManager.registerInstance();
+		instanceId = registeredInstanceId;
+		toasts = toastState.getToasts();
+		const unsubscribe = toastState.subscribe((value) => {
+			toasts = value;
+		});
+		return () => {
+			unsubscribe();
+			toasterInstanceManager.unregisterInstance(registeredInstanceId);
+			if (instanceId === registeredInstanceId) {
+				instanceId = null;
+			}
+		};
+	});
+</script>
+
+{#if instanceId && toasterInstanceManager.isActiveInstance(instanceId)}
+	<VarselManager 
+		{toasts} 
+		onRemove={handleRemove} 
+		{expandedGap}
+		{position}
+		{visibleToasts}
+		{expand}
+		{duration}
+		{closeButton}
+		{pauseOnHover}
+		{offset}
+		{dir}
+	/>
+{/if}

package/dist/VarselToaster.svelte.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Main module exports for the Varsel library.
+ */
+export { toast, type ToastData, type ToastInvoker, type ToastPosition, } from "./internals";
+import { type ToastPosition } from './internals';
+type $$ComponentProps = {
+    /**
+     * The gap (in pixels) between expanded toasts when hovering over the stack.
+     * If undefined, uses the default value from animation config.
+     */
+    expandedGap?: number;
+    /** Default position for toasts. */
+    position?: ToastPosition;
+    /** Maximum number of visible toasts in the stack. */
+    visibleToasts?: number;
+    /** Whether to expand the stack on hover. */
+    expand?: boolean;
+    /** Default duration in milliseconds. */
+    duration?: number;
+    /** Whether to show the close button by default. */
+    closeButton?: boolean;
+    /** Whether to pause the timer on hover. */
+    pauseOnHover?: boolean;
+    /** Offset from the edge of the screen. */
+    offset?: number | string;
+    /** Directionality of the text. */
+    dir?: 'ltr' | 'rtl' | 'auto';
+};
+declare const VarselToaster: import("svelte").Component<$$ComponentProps, {}, "">;
+type VarselToaster = ReturnType<typeof VarselToaster>;
+export default VarselToaster;
+//# sourceMappingURL=VarselToaster.svelte.d.ts.map

package/dist/VarselToaster.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VarselToaster.svelte.d.ts","sourceRoot":"","sources":["../src/lib/VarselToaster.svelte.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,OAAO,EACN,KAAK,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,aAAa,GAClB,MAAM,aAAa,CAAC;AAcrB,OAAO,EAIL,KAAK,aAAa,EAClB,MAAM,aAAa,CAAC;AAErB,KAAK,gBAAgB,GAAI;IACxB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,kCAAkC;IAClC,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;CAC7B,CAAC;AAmDH,QAAA,MAAM,aAAa,sDAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}

package/dist/core/accessibility.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CSS selectors used to identify focusable elements within a toast.
+ * Used for managing keyboard focus when interacting with toasts containing actions.
+ */
+export declare const FOCUSABLE_SELECTORS: string;
+//# sourceMappingURL=accessibility.d.ts.map

package/dist/core/accessibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibility.d.ts","sourceRoot":"","sources":["../../src/lib/core/accessibility.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,QAOpB,CAAC"}

package/dist/core/accessibility.js

@@ -0,0 +1,12 @@
+/**
+ * CSS selectors used to identify focusable elements within a toast.
+ * Used for managing keyboard focus when interacting with toasts containing actions.
+ */
+export const FOCUSABLE_SELECTORS = [
+    "button:not([disabled])",
+    "input:not([disabled])",
+    "textarea:not([disabled])",
+    "select:not([disabled])",
+    "a[href]",
+    '[tabindex]:not([tabindex="-1"])',
+].join(", ");

package/dist/core/animations.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Global configuration constants for toast animations and stacking behavior.
+ * These values control timing, spacing, scaling, and easing of toast transitions.
+ */
+export declare const ANIMATION_CONFIG: {
+    /** Duration of the entry animation in seconds. */
+    readonly ENTER_DURATION: 0.75;
+    /** Duration of the exit animation in seconds. */
+    readonly EXIT_DURATION: 0.75;
+    /** Duration of the stack reorganization animation in seconds. */
+    readonly STACK_DURATION: 0.75;
+    /** Vertical offset (in pixels) between stacked toasts in collapsed state. */
+    readonly STACK_OFFSET: 16;
+    /** Vertical gap (in pixels) between toasts in expanded (hover) state. */
+    readonly EXPANDED_GAP: 12;
+    /** Scale reduction factor for each subsequent toast in the stack. */
+    readonly SCALE_FACTOR: 0.04;
+    /** Minimum scale value for the furthest toast in the stack. */
+    readonly MIN_SCALE: 0.92;
+    /** Maximum number of toasts visible in the stack at once. */
+    readonly MAX_VISIBLE_TOASTS: 3;
+    /** Base z-index for the toast layer. */
+    readonly Z_INDEX_BASE: 50;
+    /** Default cubic-bezier easing function for animations. */
+    readonly EASING_DEFAULT: "var(--ease-vs-toast)";
+    /** Easing function for exit animations. */
+    readonly EASING_EXIT: "var(--ease-vs-toast)";
+};
+//# sourceMappingURL=animations.d.ts.map