@zyncat/ui 0.8.0

package/dist/toast-store.d.ts

@@ -0,0 +1,86 @@
+type ToastTone = 'default' | 'success' | 'danger' | 'warning' | 'info' | 'loading' | 'custom';
+interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+interface ToastOptions {
+    id?: string | number;
+    duration?: number;
+    description?: string | null;
+    action?: ToastAction | null;
+}
+interface ToastRecord {
+    id: string;
+    tone: ToastTone;
+    message: string | null;
+    description: string | null;
+    action: ToastAction | null;
+    duration: number;
+    remaining: number;
+    count: number;
+    timerKey: number;
+    node: unknown;
+    dismissible: boolean;
+    expiresAt?: number;
+}
+interface ToastSnapshot {
+    toasts: ToastRecord[];
+    paused: boolean;
+    expanded: boolean;
+}
+type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+interface ToasterConfig {
+    position: ToastPosition;
+    duration: number;
+    visibleToasts: number;
+    gap: number;
+    offset: number;
+    expand: boolean;
+}
+declare const DEFAULT_TOASTER_CONFIG: ToasterConfig;
+interface ToastStore {
+    toasts: ToastRecord[];
+    paused: boolean;
+    expanded: boolean;
+    mounted: boolean;
+    config: ToasterConfig;
+    snap: ToastSnapshot;
+    listeners: Set<() => void>;
+    subscribe(l: () => void): () => void;
+    get(): ToastSnapshot;
+    emit(): void;
+    add(t: ToastRecord): string;
+    update(id: string, patch: Partial<ToastRecord>): string;
+    dismiss(id?: string | null): void;
+    schedule(t: ToastRecord): void;
+    pause(): void;
+    resume(): void;
+    setExpanded(v: boolean): void;
+}
+type PromiseMsg<V> = string | ((v: V) => string);
+interface ToastPromiseMsgs<T> {
+    loading?: string;
+    success?: PromiseMsg<T>;
+    error?: PromiseMsg<unknown>;
+}
+interface ToastApi {
+    (message: string, opts?: ToastOptions): string;
+    success(m: string, o?: ToastOptions): string;
+    error(m: string, o?: ToastOptions): string;
+    warning(m: string, o?: ToastOptions): string;
+    info(m: string, o?: ToastOptions): string;
+    loading(m: string, o?: ToastOptions): string;
+    dismiss(id?: string | null): void;
+    update(id: string, patch?: Partial<ToastRecord>): string;
+    promise<T>(promise: Promise<T>, msgs?: ToastPromiseMsgs<T>): Promise<T>;
+    custom(node: unknown, opts?: {
+        id?: string | number;
+        duration?: number;
+        dismissible?: boolean;
+    }): string;
+}
+declare const toast: ToastApi;
+
+declare const UIToast: ToastStore;
+
+export { DEFAULT_TOASTER_CONFIG, type ToastAction, type ToastApi, type ToastOptions, type ToastPosition, type ToastPromiseMsgs, type ToastRecord, type ToastSnapshot, type ToastTone, type ToasterConfig, UIToast, toast };

package/dist/toast-store.js

@@ -0,0 +1,3 @@
+export { DEFAULT_TOASTER_CONFIG, UIToast, toast } from './chunk-TYHR4VNM.js';
+//# sourceMappingURL=toast-store.js.map
+//# sourceMappingURL=toast-store.js.map

package/dist/toast-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"toast-store.js"}

package/dist/toast.css

@@ -0,0 +1,257 @@
+/* toast.css - the glass notification card, tinted per tone (a draining timer ring). */
+
+.toast-viewport {
+  position: fixed;
+  width: min(22.5rem, calc(100vw - 2 * var(--toast-offset, var(--space-6))));
+  z-index: var(--layer-toast);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  pointer-events: none; /* only the cards themselves are live */
+}
+
+/* Anchored by [data-position]; --toast-offset (set by <Toaster offset>) overrides the edge inset. */
+.toast-viewport[data-position^='top'] {
+  top: var(--toast-offset, var(--space-6));
+}
+.toast-viewport[data-position^='bottom'] {
+  bottom: var(--toast-offset, var(--space-6));
+}
+.toast-viewport[data-position$='right'] {
+  right: var(--toast-offset, var(--space-6));
+}
+.toast-viewport[data-position$='left'] {
+  left: var(--toast-offset, var(--space-6));
+}
+.toast-viewport[data-position$='center'] {
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+/* The card - a glass consumer (.glass is set in JSX). */
+.toast {
+  /* tone hooks - set by [data-tone] below */
+  --toast-hue: var(--text-subtle);
+  --glass-fg: var(--text-strong);
+  --glass-tint: color-mix(in oklab, var(--glass-tint-neutral) 75%, transparent);
+  --glass-sheen-rest: 0.45;
+
+  position: absolute;
+  left: 0;
+  width: 100%;
+  box-sizing: border-box;
+  overflow: hidden; /* custom content stays in the pane   */
+  pointer-events: auto;
+  border-radius: var(--radius-lg);
+
+  /* Motion owns transform - keep only the color/shadow transitions (never smooth Motion's writes) */
+  transition:
+    background-color var(--duration-base) var(--ease-standard),
+    box-shadow var(--duration-base) var(--ease-standard);
+}
+
+/* Cards pin to the stack's edge; Motion offsets each one away from it (up from bottom, down from top). */
+.toast-viewport[data-position^='bottom'] .toast {
+  bottom: 0;
+  transform-origin: center bottom;
+}
+.toast-viewport[data-position^='top'] .toast {
+  top: 0;
+  transform-origin: center top;
+}
+
+/* rich panes for genuine status, diluted to stay glass; neutral otherwise */
+.toast[data-tone='success'] {
+  --toast-hue: var(--success);
+  --glass-fg: var(--success-text);
+  --glass-tint: color-mix(in oklab, var(--glass-tint-success) 70%, transparent);
+}
+.toast[data-tone='danger'] {
+  --toast-hue: var(--danger);
+  --glass-fg: var(--danger-text);
+  --glass-tint: color-mix(in oklab, var(--glass-tint-danger) 70%, transparent);
+}
+.toast[data-tone='warning'] {
+  --toast-hue: var(--warning);
+  --glass-fg: var(--warning-text);
+  --glass-tint: color-mix(in oklab, var(--glass-tint-warning) 70%, transparent);
+}
+.toast[data-tone='info'] {
+  --toast-hue: var(--info);
+  --glass-fg: var(--info-text);
+  --glass-tint: color-mix(in oklab, var(--glass-tint-info) 70%, transparent);
+}
+
+/* receding cards fall quiet: tone drains out, sheen dims, content fades */
+.toast[data-behind] {
+  --glass-tint: color-mix(in oklab, var(--glass-tint-neutral) 75%, transparent);
+  --glass-sheen-rest: 0.3;
+}
+.toast[data-behind] .toast__inner,
+.toast[data-behind] .toast__custom {
+  opacity: 0;
+}
+
+.toast__inner {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+  padding: var(--space-3) var(--space-4);
+  transition: var(--transition-opacity);
+}
+
+/* the dial - glyph centered in the timer ring; one instrument, not two */
+.toast__icon {
+  position: relative;
+  flex: none;
+  display: grid;
+  place-items: center;
+  width: calc(var(--icon-md) + 2 * var(--space-2));
+  height: calc(var(--icon-md) + 2 * var(--space-2));
+  color: var(--toast-hue);
+}
+.toast__icon-glyph {
+  display: grid;
+  place-items: center;
+}
+
+/* the ring - a draining arc; linear by design, animation-duration set at runtime to the toast's lifetime */
+.toast__ring {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  transform: rotate(-90deg); /* arc starts at 12 o'clock           */
+  pointer-events: none;
+}
+.toast__ring circle {
+  fill: none;
+  stroke-width: var(--border-emphasis);
+}
+.toast__ring-track {
+  stroke: color-mix(in oklab, var(--toast-hue) 16%, transparent);
+}
+.toast__ring-arc {
+  stroke: var(--toast-hue);
+  stroke-linecap: round;
+  stroke-dasharray: 1; /* pathLength=1 - offset is a fraction */
+  animation-name: toast-ring;
+  animation-timing-function: linear;
+  animation-fill-mode: both;
+}
+.toast-viewport.is-paused .toast__ring-arc {
+  animation-play-state: paused;
+}
+@keyframes toast-ring {
+  from {
+    stroke-dashoffset: 0;
+  }
+  to {
+    stroke-dashoffset: 1;
+  }
+}
+
+.toast__text {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.toast__message {
+  margin: 0;
+  font: var(--type-label);
+  color: var(--glass-fg);
+  text-wrap: pretty;
+}
+.toast__desc {
+  margin: var(--space-1) 0 0;
+  font: var(--type-caption);
+  color: color-mix(in oklab, var(--glass-fg) 76%, transparent);
+  text-wrap: pretty;
+}
+
+/* coalesce counter - same toast refired becomes a xN counter (mono) */
+.toast__count {
+  flex: none;
+  font-family: var(--font-mono);
+  font-size: var(--size-micro);
+  line-height: var(--leading-micro);
+  font-variant-numeric: tabular-nums;
+  color: var(--glass-fg);
+  background: color-mix(in oklab, var(--glass-fg) 9%, transparent);
+  border-radius: var(--radius-sm);
+  padding: 0 var(--space-1);
+}
+
+.toast__action {
+  flex: none;
+}
+
+/* dismiss - appears only while the card is hovered or holds focus */
+.toast__close {
+  flex: none;
+  appearance: none;
+  display: grid;
+  place-items: center;
+  width: var(--space-6);
+  height: var(--space-6);
+  margin: 0;
+  padding: 0;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: color-mix(in oklab, var(--glass-fg) 64%, transparent);
+  cursor: pointer;
+  opacity: 0;
+  transition:
+    var(--transition-control),
+    opacity var(--duration-fast) var(--ease-standard);
+}
+.toast:hover .toast__close,
+.toast:focus-within .toast__close {
+  opacity: 1;
+}
+.toast__close:hover {
+  background: color-mix(in oklab, var(--glass-fg) 9%, transparent);
+  color: var(--glass-fg);
+}
+.toast__close:active {
+  background: color-mix(in oklab, var(--glass-fg) 14%, transparent);
+}
+.toast__close:focus-visible {
+  outline: none;
+  box-shadow: var(--focus-ring);
+  opacity: 1;
+}
+
+/* Loading spinner - continuous --duration-spin (linear is allowed for loops; reduced motion slows, never freezes) */
+.toast__spinner {
+  display: block;
+  box-sizing: border-box;
+  width: var(--icon-sm);
+  height: var(--icon-sm);
+  border-radius: var(--radius-full);
+  border: var(--border-emphasis) solid currentColor;
+  border-right-color: transparent;
+  color: var(--text-muted);
+  animation: toast-spin var(--duration-spin) linear infinite;
+}
+@keyframes toast-spin {
+  to {
+    transform: rotate(1turn);
+  }
+}
+
+/* Custom slot - bare neutral glass; the consumer owns the interior. */
+.toast__custom {
+  padding: var(--space-3) var(--space-4);
+  transition: var(--transition-opacity);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  /* travel/gestures collapse via the tokens; the ring is data, so it keeps running */
+  .toast,
+  .toast__close,
+  .toast__inner,
+  .toast__custom {
+    transition: none;
+  }
+}

package/dist/toast.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes, ReactElement } from 'react';
+import { ToasterConfig } from './toast-store.js';
+export { toast } from './toast-store.js';
+import { D as DataAttributes } from './dom-props-C0jrllBw.js';
+
+interface ToasterProps extends Partial<ToasterConfig> {
+    /** Standard <ol> attributes (className, style, data-*, ...) forwarded to the toast viewport. */
+    htmlProps?: HTMLAttributes<HTMLOListElement> & DataAttributes;
+}
+declare function Toaster({ htmlProps, ...props }: ToasterProps): ReactElement;
+
+export { Toaster, type ToasterProps };

package/dist/toast.js

@@ -0,0 +1,310 @@
+'use client';import { DEFAULT_TOASTER_CONFIG, UIToast } from './chunk-TYHR4VNM.js';
+export { toast } from './chunk-TYHR4VNM.js';
+import { tokenPx } from './chunk-UE63OOVG.js';
+import { Motion } from './chunk-36WVAQKL.js';
+import { Presence } from './chunk-MXOPCFWR.js';
+import './chunk-W3SHPKSB.js';
+import './chunk-JSKXZMLH.js';
+import { animate, startDrag } from './chunk-L3Q3VDIW.js';
+import { Icon } from './chunk-3SBCBYB7.js';
+import { fireGlint } from './chunk-S7B34VGN.js';
+import { UIMotion } from './chunk-S5ZTZANS.js';
+import { Button } from './chunk-U5QQZC3U.js';
+import { cx } from './chunk-QGNC7LH5.js';
+import './toast.css';
+import { useEffect, useSyncExternalStore, useState, useRef, useLayoutEffect } from 'react';
+import { createPortal } from 'react-dom';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var SM = UIMotion;
+var store = UIToast;
+var COLLAPSE_GRACE = 140;
+var SWIPE_X = 64;
+var SWIPE_V = 480;
+var GAP = 0;
+function stackGap() {
+  if (!GAP) GAP = tokenPx("--space-3") || 12;
+  return GAP;
+}
+var TONE_ICON = {
+  success: "check-circle",
+  danger: "warning-circle",
+  warning: "warning",
+  info: "info"
+};
+function useToneGesture(tone, ref) {
+  const prevTone = useRef(null);
+  useEffect(() => {
+    const prev = prevTone.current;
+    prevTone.current = tone;
+    if (tone === prev) return;
+    if (tone === "success") return fireGlint(ref.current);
+    if (tone === "danger" && ref.current) {
+      const shake = ref.current.firstElementChild;
+      if (!shake) return;
+      const fall = animate(shake, {
+        x: [0, -7, 5, -2, 0],
+        timing: { duration: SM.dur.slow, ease: SM.ease.standard, delay: SM.dur.base }
+      });
+      fall.finished.then(() => fall.stop());
+      return () => fall.stop();
+    }
+  }, [tone]);
+}
+function useReplay(token, build) {
+  const ref = useRef(null);
+  const latest = useRef(build);
+  latest.current = build;
+  useLayoutEffect(() => {
+    if (ref.current) animate(ref.current, ...latest.current());
+  }, [token]);
+  return ref;
+}
+function ToastItem({
+  t,
+  depth,
+  offset,
+  hidden,
+  behind,
+  frameHeight,
+  isTop,
+  onHeight
+}) {
+  const ref = useRef(null);
+  const settled = useRef(false);
+  const swipeBack = useRef(null);
+  useToneGesture(t.tone, ref);
+  useLayoutEffect(() => {
+    if (ref.current && ref.current.firstElementChild)
+      onHeight(t.id, ref.current.firstElementChild.offsetHeight);
+  });
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.style.pointerEvents = hidden ? "none" : "auto";
+    const y = isTop ? offset : -offset;
+    const scale = 1 - depth * 0.05;
+    if (settled.current) {
+      animate(
+        el,
+        { y: [y], scale: [scale], height: [frameHeight ?? "auto"], timing: SM.t.settle },
+        { opacity: [hidden ? 0 : 1], timing: SM.t.enter }
+      );
+      return;
+    }
+    settled.current = true;
+    animate(
+      el,
+      { y: [isTop ? -24 : 24, y], scale: [0.97, scale], timing: SM.t.settle },
+      { opacity: [0, hidden ? 0 : 1], timing: SM.t.enter }
+    );
+  }, [offset, depth, hidden, frameHeight, isTop]);
+  const onPointerDown = (e) => {
+    const inner = ref.current?.firstElementChild;
+    if (!t.dismissible || e.button !== 0 || !inner) return;
+    swipeBack.current?.stop();
+    startDrag(e, {
+      onMove: (info) => {
+        const dx = info.offset.x;
+        inner.style.translate = `${dx > 0 ? dx * 0.9 : dx * 0.04}px 0px`;
+      },
+      onEnd: (info) => {
+        if (info.offset.x > SWIPE_X || info.velocity.x > SWIPE_V) {
+          animate(inner, { x: [420], timing: SM.t.exit }).finished.then(() => store.dismiss(t.id));
+          return;
+        }
+        const back = animate(inner, { x: [0], timing: SM.t.settle });
+        swipeBack.current = back;
+        back.finished.then(() => back.stop());
+      }
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    Motion,
+    {
+      as: "li",
+      ref,
+      exit: { opacity: [0], scale: [0.96], timing: SM.t.exit },
+      className: "toast glass",
+      "data-tone": t.tone,
+      "data-behind": behind ? "" : void 0,
+      role: t.tone === "danger" ? "alert" : "status",
+      "aria-atomic": "true",
+      onPointerDown,
+      onKeyDown: (e) => {
+        if (e.key === "Escape" && t.dismissible) store.dismiss(t.id);
+      },
+      children: t.node ? /* @__PURE__ */ jsx("div", { className: "toast__custom", children: t.node }) : /* @__PURE__ */ jsx(ToastBody, { t })
+    }
+  );
+}
+function ToastBody({ t }) {
+  const glyphRef = useReplay(t.tone, () => [
+    { scale: [0.5, 1], timing: SM.t.settle },
+    { opacity: [0, 1], timing: SM.t.enter }
+  ]);
+  const textRef = useReplay(String(t.message) + "-" + String(t.description), () => [
+    { opacity: [0, 1], timing: SM.t.enter }
+  ]);
+  const countRef = useReplay(t.count, () => [{ scale: [0.6, 1], timing: SM.t.settle }]);
+  return /* @__PURE__ */ jsxs("div", { className: "toast__inner", children: [
+    (t.tone !== "default" || isFinite(t.duration)) && /* @__PURE__ */ jsxs("span", { className: "toast__icon", children: [
+      t.tone !== "default" && /* @__PURE__ */ jsx("span", { ref: glyphRef, className: "toast__icon-glyph", children: t.tone === "loading" ? /* @__PURE__ */ jsx("span", { className: "toast__spinner", "aria-hidden": "true" }) : /* @__PURE__ */ jsx(Icon, { name: TONE_ICON[t.tone] || "info", weight: "fill" }) }),
+      isFinite(t.duration) && /* @__PURE__ */ jsxs("svg", { className: "toast__ring", viewBox: "0 0 36 36", "aria-hidden": "true", children: [
+        /* @__PURE__ */ jsx("circle", { className: "toast__ring-track", cx: "18", cy: "18", r: "16.5" }),
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            className: "toast__ring-arc",
+            cx: "18",
+            cy: "18",
+            r: "16.5",
+            pathLength: 1,
+            style: { animationDuration: t.duration + "ms" }
+          }
+        )
+      ] }, "ring-" + t.timerKey)
+    ] }),
+    /* @__PURE__ */ jsxs("div", { ref: textRef, className: "toast__text", children: [
+      /* @__PURE__ */ jsx("p", { className: "toast__message", children: t.message }),
+      t.description != null && /* @__PURE__ */ jsx("p", { className: "toast__desc", children: t.description })
+    ] }),
+    t.count > 1 && /* @__PURE__ */ jsxs("span", { ref: countRef, className: "toast__count", children: [
+      "\xD7",
+      t.count
+    ] }),
+    t.action && /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "secondary",
+        size: "sm",
+        className: "toast__action",
+        onClick: () => {
+          if (t.action.onClick) t.action.onClick();
+          store.dismiss(t.id);
+        },
+        children: t.action.label
+      }
+    ),
+    t.dismissible && /* @__PURE__ */ jsx("button", { type: "button", className: "toast__close", "aria-label": "Dismiss", onClick: () => store.dismiss(t.id), children: /* @__PURE__ */ jsx(Icon, { name: "close", size: "sm" }) })
+  ] });
+}
+function ToastHost({ config, htmlProps }) {
+  const { toasts, paused, expanded: hoverExpanded } = useSyncExternalStore(store.subscribe, store.get, store.get);
+  const [heights, setHeights] = useState({});
+  const [ready, setReady] = useState(false);
+  const collapseTimer = useRef(0);
+  const hovering = useRef(false);
+  useEffect(() => setReady(true), []);
+  const onHeight = (id, h) => setHeights((prev) => prev[id] === h ? prev : { ...prev, [id]: h });
+  const onHold = () => {
+    hovering.current = true;
+    clearTimeout(collapseTimer.current);
+    store.setExpanded(true);
+    store.pause();
+  };
+  const onRelease = (graced) => {
+    hovering.current = false;
+    clearTimeout(collapseTimer.current);
+    collapseTimer.current = setTimeout(
+      () => {
+        store.setExpanded(false);
+        store.resume();
+      },
+      graced ? COLLAPSE_GRACE : 0
+    );
+  };
+  useEffect(() => {
+    const onVis = () => {
+      if (document.hidden) store.pause();
+      else if (!hovering.current) store.resume();
+    };
+    document.addEventListener("visibilitychange", onVis);
+    return () => document.removeEventListener("visibilitychange", onVis);
+  }, []);
+  useEffect(() => {
+    if (toasts.length === 0) {
+      hovering.current = false;
+      clearTimeout(collapseTimer.current);
+      store.setExpanded(false);
+      store.resume();
+    }
+  }, [toasts.length]);
+  if (!ready) return null;
+  const isTop = config.position.startsWith("top");
+  const visible = config.visibleToasts;
+  const rendered = visible * 2;
+  const gap = config.gap || stackGap();
+  const expanded = config.expand || hoverExpanded;
+  const slice = toasts.slice(-rendered);
+  const n = slice.length;
+  const frontH = n ? heights[slice[n - 1].id] || 0 : 0;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "ol",
+      {
+        ...htmlProps,
+        className: cx("toast-viewport", paused && "is-paused", htmlProps?.className),
+        "data-position": config.position,
+        style: config.offset ? { ...htmlProps?.style, "--toast-offset": `${config.offset}px` } : htmlProps?.style,
+        "aria-label": "Notifications",
+        onPointerOver: (e) => {
+          if (e.pointerType !== "touch") onHold();
+        },
+        onPointerOut: (e) => {
+          if (!e.relatedTarget || !e.currentTarget.contains(e.relatedTarget)) onRelease(true);
+        },
+        onFocus: onHold,
+        onBlur: (e) => {
+          if (!e.relatedTarget || !e.currentTarget.contains(e.relatedTarget)) onRelease(false);
+        },
+        children: /* @__PURE__ */ jsx(Presence, { children: slice.map((t, i) => {
+          const depth = n - 1 - i;
+          let offset = depth * gap;
+          if (expanded) {
+            offset = 0;
+            for (let j = i + 1; j < n; j++) offset += (heights[slice[j].id] || 0) + gap;
+          }
+          return /* @__PURE__ */ jsx(
+            ToastItem,
+            {
+              t,
+              depth: expanded ? 0 : depth,
+              offset,
+              hidden: !expanded && depth >= visible,
+              behind: !expanded && depth > 0,
+              frameHeight: !expanded && depth > 0 && frontH ? frontH : null,
+              isTop,
+              onHeight
+            },
+            t.id
+          );
+        }) })
+      }
+    ),
+    document.body
+  );
+}
+function stripUndefined(o) {
+  const out = {};
+  Object.keys(o).forEach((k) => {
+    if (o[k] !== void 0) out[k] = o[k];
+  });
+  return out;
+}
+function Toaster({ htmlProps, ...props }) {
+  const config = { ...DEFAULT_TOASTER_CONFIG, ...stripUndefined(props) };
+  useEffect(() => {
+    store.config = config;
+    store.mounted = true;
+    if (config.expand) store.setExpanded(true);
+    return () => {
+      store.mounted = false;
+    };
+  }, [config.position, config.duration, config.visibleToasts, config.gap, config.offset, config.expand]);
+  return /* @__PURE__ */ jsx(ToastHost, { config, htmlProps });
+}
+
+export { Toaster };
+//# sourceMappingURL=toast.js.map
+//# sourceMappingURL=toast.js.map