@televet/kibble-ui 4.0.0-beta.4 → 4.0.0-beta.40

package/dist/chunks/toaster.records-BSRUGTiS.js

@@ -0,0 +1,824 @@
+import { ac as Q, ad as A, ae as j, c as q, f as Z, a1 as J, af as z, a as tt, r as U, ag as N, ah as et, e as I, Y as V } from "./index-DLvqBeH6.js";
+import { a as st } from "./index-Cz4pncg8.js";
+var ot = Z("toast").parts(
+  "group",
+  "root",
+  "title",
+  "description",
+  "actionTrigger",
+  "closeTrigger"
+), D = ot.build(), it = (t) => `toast-group:${t}`, G = (t, e) => t.getById(`toast-group:${e}`), X = (t) => `toast:${t.id}`, $ = (t) => t.getById(X(t)), B = (t) => `toast:${t.id}:title`, K = (t) => `toast:${t.id}:description`, nt = (t) => `toast${t.id}:close`, _ = {
+  info: 5e3,
+  error: 5e3,
+  success: 2e3,
+  loading: 1 / 0,
+  DEFAULT: 5e3
+};
+function L(t, e) {
+  return t ?? _[e] ?? _.DEFAULT;
+}
+var at = (t) => typeof t == "string" ? { left: t, right: t, bottom: t, top: t } : t;
+function rt(t, e) {
+  const { prop: o, computed: s, context: n } = t, { offsets: r, gap: c } = o("store").attrs, l = n.get("heights"), d = at(r), T = o("dir") === "rtl", u = e.replace("-start", T ? "-right" : "-left").replace("-end", T ? "-left" : "-right"), p = u.includes("right"), v = u.includes("left"), m = {
+    position: "fixed",
+    pointerEvents: s("count") > 0 ? void 0 : "none",
+    display: "flex",
+    flexDirection: "column",
+    "--gap": `${c}px`,
+    "--first-height": `${l[0]?.height || 0}px`,
+    zIndex: z
+  };
+  let f = "center";
+  if (p && (f = "flex-end"), v && (f = "flex-start"), m.alignItems = f, u.includes("top")) {
+    const h = d.top;
+    m.top = `max(env(safe-area-inset-top, 0px), ${h})`;
+  }
+  if (u.includes("bottom")) {
+    const h = d.bottom;
+    m.bottom = `max(env(safe-area-inset-bottom, 0px), ${h})`;
+  }
+  if (!u.includes("left")) {
+    const h = d.right;
+    m.insetInlineEnd = `calc(env(safe-area-inset-right, 0px) + ${h})`;
+  }
+  if (!u.includes("right")) {
+    const h = d.left;
+    m.insetInlineStart = `calc(env(safe-area-inset-left, 0px) + ${h})`;
+  }
+  return m;
+}
+function ct(t, e) {
+  const { prop: o, context: s, computed: n } = t, r = o("parent"), c = r.computed("placement"), { gap: l } = r.prop("store").attrs, [d] = c.split("-"), T = s.get("mounted"), u = s.get("remainingTime"), p = n("height"), v = n("frontmost"), m = !v, f = !o("stacked"), h = o("stacked"), M = o("type") === "loading" ? Number.MAX_SAFE_INTEGER : u, C = n("heightIndex") * l + n("heightBefore"), k = {
+    position: "absolute",
+    pointerEvents: "auto",
+    "--opacity": "0",
+    "--remove-delay": `${o("removeDelay")}ms`,
+    "--duration": `${M}ms`,
+    "--initial-height": `${p}px`,
+    "--offset": `${C}px`,
+    "--index": o("index"),
+    "--z-index": n("zIndex"),
+    "--lift-amount": "calc(var(--lift) * var(--gap))",
+    "--y": "100%",
+    "--x": "0"
+  }, g = (H) => Object.assign(k, H);
+  return d === "top" ? g({
+    top: "0",
+    "--sign": "-1",
+    "--y": "-100%",
+    "--lift": "1"
+  }) : d === "bottom" && g({
+    bottom: "0",
+    "--sign": "1",
+    "--y": "100%",
+    "--lift": "-1"
+  }), T && (g({
+    "--y": "0",
+    "--opacity": "1"
+  }), h && g({
+    "--y": "calc(var(--lift) * var(--offset))",
+    "--height": "var(--initial-height)"
+  })), e || g({
+    "--opacity": "0",
+    pointerEvents: "none"
+  }), m && f && (g({
+    "--base-scale": "var(--index) * 0.05 + 1",
+    "--y": "calc(var(--lift-amount) * var(--index))",
+    "--scale": "calc(-1 * var(--base-scale))",
+    "--height": "var(--first-height)"
+  }), e || g({
+    "--y": "calc(var(--sign) * 40%)"
+  })), m && h && !e && g({
+    "--y": "calc(var(--lift) * var(--offset) + var(--lift) * -100%)"
+  }), v && !e && g({
+    "--y": "calc(var(--lift) * -100%)"
+  }), k;
+}
+function lt(t, e) {
+  const { computed: o } = t, s = {
+    position: "absolute",
+    inset: "0",
+    scale: "1 2",
+    pointerEvents: e ? "none" : "auto"
+  }, n = (r) => Object.assign(s, r);
+  return o("frontmost") && !e && n({
+    height: "calc(var(--initial-height) + 80%)"
+  }), s;
+}
+function ut() {
+  return {
+    position: "absolute",
+    left: "0",
+    height: "calc(var(--gap) + 2px)",
+    bottom: "100%",
+    width: "100%"
+  };
+}
+function dt(t, e) {
+  const { context: o, prop: s, send: n, refs: r, computed: c } = t;
+  return {
+    getCount() {
+      return o.get("toasts").length;
+    },
+    getToasts() {
+      return o.get("toasts");
+    },
+    getGroupProps(l = {}) {
+      const { label: d = "Notifications" } = l, { hotkey: T } = s("store").attrs, u = T.join("+").replace(/Key/g, "").replace(/Digit/g, ""), p = c("placement"), [v, m = "center"] = p.split("-");
+      return e.element({
+        ...D.group.attrs,
+        dir: s("dir"),
+        tabIndex: -1,
+        "aria-label": `${p} ${d} ${u}`,
+        id: it(p),
+        "data-placement": p,
+        "data-side": v,
+        "data-align": m,
+        "aria-live": "polite",
+        role: "region",
+        style: rt(t, p),
+        onMouseMove() {
+          n({ type: "REGION.POINTER_ENTER", placement: p });
+        },
+        onMouseLeave() {
+          n({ type: "REGION.POINTER_LEAVE", placement: p });
+        },
+        onFocus(f) {
+          n({ type: "REGION.FOCUS", target: f.relatedTarget });
+        },
+        onBlur(f) {
+          r.get("isFocusWithin") && !J(f.currentTarget, f.relatedTarget) && queueMicrotask(() => n({ type: "REGION.BLUR" }));
+        }
+      });
+    },
+    subscribe(l) {
+      return s("store").subscribe(() => l(o.get("toasts")));
+    }
+  };
+}
+var gt = q({
+  props({ props: t }) {
+    return {
+      dir: "ltr",
+      id: j(),
+      ...t,
+      store: t.store
+    };
+  },
+  initialState({ prop: t }) {
+    return t("store").attrs.overlap ? "overlap" : "stack";
+  },
+  refs() {
+    return {
+      lastFocusedEl: null,
+      isFocusWithin: !1,
+      dismissableCleanup: void 0
+    };
+  },
+  context({ bindable: t }) {
+    return {
+      toasts: t(() => ({
+        defaultValue: [],
+        sync: !0,
+        hash: (e) => e.map((o) => o.id).join(",")
+      })),
+      heights: t(() => ({
+        defaultValue: [],
+        sync: !0
+      }))
+    };
+  },
+  computed: {
+    count: ({ context: t }) => t.get("toasts").length,
+    overlap: ({ prop: t }) => t("store").attrs.overlap,
+    placement: ({ prop: t }) => t("store").attrs.placement
+  },
+  effects: ["subscribeToStore", "trackDocumentVisibility", "trackHotKeyPress"],
+  watch({ track: t, context: e, action: o }) {
+    t([() => e.hash("toasts")], () => {
+      queueMicrotask(() => {
+        o(["collapsedIfEmpty", "setDismissableBranch"]);
+      });
+    });
+  },
+  exit: ["clearDismissableBranch", "clearLastFocusedEl"],
+  on: {
+    "DOC.HOTKEY": {
+      actions: ["focusRegionEl"]
+    },
+    "REGION.BLUR": [
+      {
+        guard: "isOverlapping",
+        target: "overlap",
+        actions: ["collapseToasts", "resumeToasts", "restoreLastFocusedEl"]
+      },
+      {
+        target: "stack",
+        actions: ["resumeToasts", "restoreLastFocusedEl"]
+      }
+    ],
+    "TOAST.REMOVE": {
+      actions: ["removeToast", "removeHeight"]
+    },
+    "TOAST.PAUSE": {
+      actions: ["pauseToasts"]
+    }
+  },
+  states: {
+    stack: {
+      on: {
+        "REGION.POINTER_LEAVE": [
+          {
+            guard: "isOverlapping",
+            target: "overlap",
+            actions: ["resumeToasts", "collapseToasts"]
+          },
+          {
+            actions: ["resumeToasts"]
+          }
+        ],
+        "REGION.OVERLAP": {
+          target: "overlap",
+          actions: ["collapseToasts"]
+        },
+        "REGION.FOCUS": {
+          actions: ["setLastFocusedEl", "pauseToasts"]
+        },
+        "REGION.POINTER_ENTER": {
+          actions: ["pauseToasts"]
+        }
+      }
+    },
+    overlap: {
+      on: {
+        "REGION.STACK": {
+          target: "stack",
+          actions: ["expandToasts"]
+        },
+        "REGION.POINTER_ENTER": {
+          target: "stack",
+          actions: ["pauseToasts", "expandToasts"]
+        },
+        "REGION.FOCUS": {
+          target: "stack",
+          actions: ["setLastFocusedEl", "pauseToasts", "expandToasts"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isOverlapping: ({ computed: t }) => t("overlap")
+    },
+    effects: {
+      subscribeToStore({ context: t, prop: e }) {
+        return e("store").subscribe((o) => {
+          if (o.dismiss) {
+            t.set("toasts", (s) => s.filter((n) => n.id !== o.id));
+            return;
+          }
+          t.set("toasts", (s) => {
+            const n = s.findIndex((r) => r.id === o.id);
+            return n !== -1 ? [...s.slice(0, n), { ...s[n], ...o }, ...s.slice(n + 1)] : [o, ...s];
+          });
+        });
+      },
+      trackHotKeyPress({ prop: t, send: e }) {
+        return V(document, "keydown", (s) => {
+          const { hotkey: n } = t("store").attrs;
+          n.every((c) => s[c] || s.code === c) && e({ type: "DOC.HOTKEY" });
+        }, { capture: !0 });
+      },
+      trackDocumentVisibility({ prop: t, send: e, scope: o }) {
+        const { pauseOnPageIdle: s } = t("store").attrs;
+        if (!s) return;
+        const n = o.getDoc();
+        return V(n, "visibilitychange", () => {
+          const r = n.visibilityState === "hidden";
+          e({ type: r ? "PAUSE_ALL" : "RESUME_ALL" });
+        });
+      }
+    },
+    actions: {
+      setDismissableBranch({ refs: t, context: e, computed: o, scope: s }) {
+        const n = e.get("toasts"), r = o("placement"), c = n.length > 0;
+        if (!c) {
+          t.get("dismissableCleanup")?.();
+          return;
+        }
+        if (c && t.get("dismissableCleanup"))
+          return;
+        const d = st(() => G(s, r), { defer: !0 });
+        t.set("dismissableCleanup", d);
+      },
+      clearDismissableBranch({ refs: t }) {
+        t.get("dismissableCleanup")?.();
+      },
+      focusRegionEl({ scope: t, computed: e }) {
+        queueMicrotask(() => {
+          G(t, e("placement"))?.focus();
+        });
+      },
+      pauseToasts({ prop: t }) {
+        t("store").pause();
+      },
+      resumeToasts({ prop: t }) {
+        t("store").resume();
+      },
+      expandToasts({ prop: t }) {
+        t("store").expand();
+      },
+      collapseToasts({ prop: t }) {
+        t("store").collapse();
+      },
+      removeToast({ prop: t, event: e }) {
+        t("store").remove(e.id);
+      },
+      removeHeight({ event: t, context: e }) {
+        t?.id != null && queueMicrotask(() => {
+          e.set("heights", (o) => o.filter((s) => s.id !== t.id));
+        });
+      },
+      collapsedIfEmpty({ send: t, computed: e }) {
+        !e("overlap") || e("count") > 1 || t({ type: "REGION.OVERLAP" });
+      },
+      setLastFocusedEl({ refs: t, event: e }) {
+        t.get("isFocusWithin") || !e.target || (t.set("isFocusWithin", !0), t.set("lastFocusedEl", e.target));
+      },
+      restoreLastFocusedEl({ refs: t }) {
+        t.get("lastFocusedEl") && (t.get("lastFocusedEl")?.focus({ preventScroll: !0 }), t.set("lastFocusedEl", null), t.set("isFocusWithin", !1));
+      },
+      clearLastFocusedEl({ refs: t }) {
+        t.get("lastFocusedEl") && (t.get("lastFocusedEl")?.focus({ preventScroll: !0 }), t.set("lastFocusedEl", null), t.set("isFocusWithin", !1));
+      }
+    }
+  }
+});
+function Ot(t, e) {
+  const { state: o, send: s, prop: n, scope: r, context: c, computed: l } = t, d = o.hasTag("visible"), T = o.hasTag("paused"), u = c.get("mounted"), p = l("frontmost"), v = n("parent").computed("placement"), m = n("type"), f = n("stacked"), h = n("title"), F = n("description"), M = n("action"), [C, k = "center"] = v.split("-");
+  return {
+    type: m,
+    title: h,
+    description: F,
+    placement: v,
+    visible: d,
+    paused: T,
+    closable: !!n("closable"),
+    pause() {
+      s({ type: "PAUSE" });
+    },
+    resume() {
+      s({ type: "RESUME" });
+    },
+    dismiss() {
+      s({ type: "DISMISS", src: "programmatic" });
+    },
+    getRootProps() {
+      return e.element({
+        ...D.root.attrs,
+        dir: n("dir"),
+        id: X(r),
+        "data-state": d ? "open" : "closed",
+        "data-type": m,
+        "data-placement": v,
+        "data-align": k,
+        "data-side": C,
+        "data-mounted": I(u),
+        "data-paused": I(T),
+        "data-first": I(p),
+        "data-sibling": I(!p),
+        "data-stack": I(f),
+        "data-overlap": I(!f),
+        role: "status",
+        "aria-atomic": "true",
+        "aria-describedby": F ? K(r) : void 0,
+        "aria-labelledby": h ? B(r) : void 0,
+        tabIndex: 0,
+        style: ct(t, d),
+        onKeyDown(g) {
+          g.defaultPrevented || g.key == "Escape" && (s({ type: "DISMISS", src: "keyboard" }), g.preventDefault());
+        }
+      });
+    },
+    /* Leave a ghost div to avoid setting hover to false when transitioning out */
+    getGhostBeforeProps() {
+      return e.element({
+        "data-ghost": "before",
+        style: lt(t, d)
+      });
+    },
+    /* Needed to avoid setting hover to false when in between toasts */
+    getGhostAfterProps() {
+      return e.element({
+        "data-ghost": "after",
+        style: ut()
+      });
+    },
+    getTitleProps() {
+      return e.element({
+        ...D.title.attrs,
+        id: B(r)
+      });
+    },
+    getDescriptionProps() {
+      return e.element({
+        ...D.description.attrs,
+        id: K(r)
+      });
+    },
+    getActionTriggerProps() {
+      return e.button({
+        ...D.actionTrigger.attrs,
+        type: "button",
+        onClick(g) {
+          g.defaultPrevented || (M?.onClick?.(), s({ type: "DISMISS", src: "user" }));
+        }
+      });
+    },
+    getCloseTriggerProps() {
+      return e.button({
+        id: nt(r),
+        ...D.closeTrigger.attrs,
+        type: "button",
+        "aria-label": "Dismiss notification",
+        onClick(g) {
+          g.defaultPrevented || s({ type: "DISMISS", src: "user" });
+        }
+      });
+    }
+  };
+}
+var { not: pt } = tt(), Rt = q({
+  props({ props: t }) {
+    return et(t, ["id", "type", "parent", "removeDelay"], "toast"), {
+      closable: !0,
+      ...t,
+      duration: L(t.duration, t.type)
+    };
+  },
+  initialState({ prop: t }) {
+    return t("type") === "loading" || t("duration") === 1 / 0 ? "visible:persist" : "visible";
+  },
+  context({ prop: t, bindable: e }) {
+    return {
+      remainingTime: e(() => ({
+        defaultValue: L(t("duration"), t("type"))
+      })),
+      createdAt: e(() => ({
+        defaultValue: Date.now()
+      })),
+      mounted: e(() => ({
+        defaultValue: !1
+      })),
+      initialHeight: e(() => ({
+        defaultValue: 0
+      }))
+    };
+  },
+  refs() {
+    return {
+      closeTimerStartTime: Date.now(),
+      lastCloseStartTimerStartTime: 0
+    };
+  },
+  computed: {
+    zIndex: ({ prop: t }) => {
+      const e = t("parent").context.get("toasts"), o = e.findIndex((s) => s.id === t("id"));
+      return e.length - o;
+    },
+    height: ({ prop: t }) => t("parent").context.get("heights").find((s) => s.id === t("id"))?.height ?? 0,
+    heightIndex: ({ prop: t }) => t("parent").context.get("heights").findIndex((o) => o.id === t("id")),
+    frontmost: ({ prop: t }) => t("index") === 0,
+    heightBefore: ({ prop: t }) => {
+      const e = t("parent").context.get("heights"), o = e.findIndex((s) => s.id === t("id"));
+      return e.reduce((s, n, r) => r >= o ? s : s + n.height, 0);
+    },
+    shouldPersist: ({ prop: t }) => t("type") === "loading" || t("duration") === 1 / 0
+  },
+  watch({ track: t, prop: e, send: o }) {
+    t([() => e("message")], () => {
+      const s = e("message");
+      s && o({ type: s, src: "programmatic" });
+    }), t([() => e("type"), () => e("duration")], () => {
+      o({ type: "UPDATE" });
+    });
+  },
+  on: {
+    UPDATE: [
+      {
+        guard: "shouldPersist",
+        target: "visible:persist",
+        actions: ["resetCloseTimer"]
+      },
+      {
+        target: "visible:updating",
+        actions: ["resetCloseTimer"]
+      }
+    ],
+    MEASURE: {
+      actions: ["measureHeight"]
+    }
+  },
+  entry: ["setMounted", "measureHeight", "invokeOnVisible"],
+  effects: ["trackHeight"],
+  states: {
+    "visible:updating": {
+      tags: ["visible", "updating"],
+      effects: ["waitForNextTick"],
+      on: {
+        SHOW: {
+          target: "visible"
+        }
+      }
+    },
+    "visible:persist": {
+      tags: ["visible", "paused"],
+      on: {
+        RESUME: {
+          guard: pt("isLoadingType"),
+          target: "visible",
+          actions: ["setCloseTimer"]
+        },
+        DISMISS: {
+          target: "dismissing"
+        }
+      }
+    },
+    visible: {
+      tags: ["visible"],
+      effects: ["waitForDuration"],
+      on: {
+        DISMISS: {
+          target: "dismissing"
+        },
+        PAUSE: {
+          target: "visible:persist",
+          actions: ["syncRemainingTime"]
+        }
+      }
+    },
+    dismissing: {
+      entry: ["invokeOnDismiss"],
+      effects: ["waitForRemoveDelay"],
+      on: {
+        REMOVE: {
+          target: "unmounted",
+          actions: ["notifyParentToRemove"]
+        }
+      }
+    },
+    unmounted: {
+      entry: ["invokeOnUnmount"]
+    }
+  },
+  implementations: {
+    effects: {
+      waitForRemoveDelay({ prop: t, send: e }) {
+        return N(() => {
+          e({ type: "REMOVE", src: "timer" });
+        }, t("removeDelay"));
+      },
+      waitForDuration({ send: t, context: e, computed: o }) {
+        if (!o("shouldPersist"))
+          return N(() => {
+            t({ type: "DISMISS", src: "timer" });
+          }, e.get("remainingTime"));
+      },
+      waitForNextTick({ send: t }) {
+        return N(() => {
+          t({ type: "SHOW", src: "timer" });
+        }, 0);
+      },
+      trackHeight({ scope: t, prop: e }) {
+        let o;
+        return U(() => {
+          const s = $(t);
+          if (!s) return;
+          const n = () => {
+            const l = s.style.height;
+            s.style.height = "auto";
+            const d = s.getBoundingClientRect().height;
+            s.style.height = l;
+            const T = { id: e("id"), height: d };
+            W(e("parent"), T);
+          }, r = t.getWin(), c = new r.MutationObserver(n);
+          c.observe(s, {
+            childList: !0,
+            subtree: !0,
+            characterData: !0
+          }), o = () => c.disconnect();
+        }), () => o?.();
+      }
+    },
+    guards: {
+      isLoadingType: ({ prop: t }) => t("type") === "loading",
+      shouldPersist: ({ computed: t }) => t("shouldPersist")
+    },
+    actions: {
+      setMounted({ context: t }) {
+        U(() => {
+          t.set("mounted", !0);
+        });
+      },
+      measureHeight({ scope: t, prop: e, context: o }) {
+        queueMicrotask(() => {
+          const s = $(t);
+          if (!s) return;
+          const n = s.style.height;
+          s.style.height = "auto";
+          const r = s.getBoundingClientRect().height;
+          s.style.height = n, o.set("initialHeight", r);
+          const c = { id: e("id"), height: r };
+          W(e("parent"), c);
+        });
+      },
+      setCloseTimer({ refs: t }) {
+        t.set("closeTimerStartTime", Date.now());
+      },
+      resetCloseTimer({ context: t, refs: e, prop: o }) {
+        e.set("closeTimerStartTime", Date.now()), t.set("remainingTime", L(o("duration"), o("type")));
+      },
+      syncRemainingTime({ context: t, refs: e }) {
+        t.set("remainingTime", (o) => {
+          const s = e.get("closeTimerStartTime"), n = Date.now() - s;
+          return e.set("lastCloseStartTimerStartTime", Date.now()), o - n;
+        });
+      },
+      notifyParentToRemove({ prop: t }) {
+        t("parent").send({ type: "TOAST.REMOVE", id: t("id") });
+      },
+      invokeOnDismiss({ prop: t, event: e }) {
+        t("onStatusChange")?.({ status: "dismissing", src: e.src });
+      },
+      invokeOnUnmount({ prop: t }) {
+        t("onStatusChange")?.({ status: "unmounted" });
+      },
+      invokeOnVisible({ prop: t }) {
+        t("onStatusChange")?.({ status: "visible" });
+      }
+    }
+  }
+});
+function W(t, e) {
+  const { id: o, height: s } = e;
+  t.context.set("heights", (n) => n.find((c) => c.id === o) ? n.map((c) => c.id === o ? { ...c, height: s } : c) : [{ id: o, height: s }, ...n]);
+}
+var mt = (t, e) => ({ ...e, ...Q(t) });
+function ft(t) {
+  const e = mt(t, {
+    placement: "bottom",
+    overlap: !1,
+    max: 24,
+    gap: 16,
+    offsets: "1rem",
+    hotkey: ["altKey", "KeyT"],
+    removeDelay: 200,
+    pauseOnPageIdle: !0
+  });
+  let o = [], s = [], n = /* @__PURE__ */ new Set(), r = [];
+  const c = (i) => (o.push(i), () => {
+    const a = o.indexOf(i);
+    o.splice(a, 1);
+  }), l = (i) => (o.forEach((a) => a(i)), i), d = (i) => {
+    if (s.length >= e.max) {
+      r.push(i);
+      return;
+    }
+    l(i), s.unshift(i);
+  }, T = () => {
+    for (; r.length > 0 && s.length < e.max; ) {
+      const i = r.shift();
+      i && (l(i), s.unshift(i));
+    }
+  }, u = (i) => {
+    const a = i.id ?? `toast:${j()}`, b = s.find((y) => y.id === a);
+    return n.has(a) && n.delete(a), b ? s = s.map((y) => y.id === a ? l({ ...y, ...i, id: a }) : y) : d({
+      id: a,
+      duration: e.duration,
+      removeDelay: e.removeDelay,
+      type: "info",
+      ...i,
+      stacked: !e.overlap,
+      gap: e.gap
+    }), a;
+  }, p = (i) => (n.add(i), i ? (o.forEach((a) => a({ id: i, dismiss: !0 })), s = s.filter((a) => a.id !== i), T()) : (s.forEach((a) => {
+    o.forEach((b) => b({ id: a.id, dismiss: !0 }));
+  }), s = [], r = []), i);
+  return {
+    attrs: e,
+    subscribe: c,
+    create: u,
+    update: (i, a) => u({ id: i, ...a }),
+    remove: p,
+    dismiss: (i) => {
+      i != null ? s = s.map((a) => a.id === i ? l({ ...a, message: "DISMISS" }) : a) : s = s.map((a) => l({ ...a, message: "DISMISS" }));
+    },
+    error: (i) => u({ ...i, type: "error" }),
+    success: (i) => u({ ...i, type: "success" }),
+    info: (i) => u({ ...i, type: "info" }),
+    warning: (i) => u({ ...i, type: "warning" }),
+    loading: (i) => u({ ...i, type: "loading" }),
+    getVisibleToasts: () => s.filter((i) => !n.has(i.id)),
+    getCount: () => s.length,
+    promise: (i, a, b = {}) => {
+      if (!a) return;
+      let y;
+      a.loading !== void 0 && (y = u({
+        ...b,
+        ...a.loading,
+        promise: i,
+        type: "loading"
+      }));
+      let w = y !== void 0, P;
+      const Y = A(i).then(async (E) => {
+        if (P = ["resolve", E], ht(E) && !E.ok) {
+          w = !1;
+          const S = A(a.error, `HTTP Error! status: ${E.status}`);
+          u({ ...b, ...S, id: y, type: "error" });
+        } else if (a.success !== void 0) {
+          w = !1;
+          const S = A(a.success, E);
+          u({ ...b, ...S, id: y, type: "success" });
+        }
+      }).catch(async (E) => {
+        if (P = ["reject", E], a.error !== void 0) {
+          w = !1;
+          const S = A(a.error, E);
+          u({ ...b, ...S, id: y, type: "error" });
+        }
+      }).finally(() => {
+        w && (p(y), y = void 0), a.finally?.();
+      });
+      return { id: y, unwrap: () => new Promise(
+        (E, S) => Y.then(() => P[0] === "reject" ? S(P[1]) : E(P[1])).catch(S)
+      ) };
+    },
+    pause: (i) => {
+      i != null ? s = s.map((a) => a.id === i ? l({ ...a, message: "PAUSE" }) : a) : s = s.map((a) => l({ ...a, message: "PAUSE" }));
+    },
+    resume: (i) => {
+      i != null ? s = s.map((a) => a.id === i ? l({ ...a, message: "RESUME" }) : a) : s = s.map((a) => l({ ...a, message: "RESUME" }));
+    },
+    isVisible: (i) => !n.has(i) && !!s.find((a) => a.id === i),
+    isDismissed: (i) => n.has(i),
+    expand: () => {
+      s = s.map((i) => l({ ...i, stacked: !0 }));
+    },
+    collapse: () => {
+      s = s.map((i) => l({ ...i, stacked: !1 }));
+    }
+  };
+}
+var ht = (t) => t && typeof t == "object" && "ok" in t && typeof t.ok == "boolean" && "status" in t && typeof t.status == "number", kt = {
+  connect: dt,
+  machine: gt
+};
+const O = (t) => ft(t), x = {
+  duration: 5e3,
+  gap: 16,
+  hotkey: void 0,
+  max: 24,
+  offsets: "1rem",
+  overlap: !1,
+  pauseOnPageIdle: !0,
+  removeDelay: 200
+}, R = {
+  bottom: {
+    ...x,
+    placement: "bottom"
+  },
+  "bottom-end": {
+    ...x,
+    placement: "bottom-end"
+  },
+  "bottom-start": {
+    ...x,
+    placement: "bottom-start"
+  },
+  top: {
+    ...x,
+    placement: "top"
+  },
+  "top-end": {
+    ...x,
+    placement: "top-end"
+  },
+  "top-start": {
+    ...x,
+    placement: "top-start"
+  }
+}, Pt = O(R.bottom), Ft = O(R["bottom-end"]), Mt = O(
+  R["bottom-start"]
+), Ct = O(R.top), wt = O(R["top-end"]), At = O(R["top-start"]);
+export {
+  Ft as a,
+  Pt as b,
+  Ot as c,
+  Mt as d,
+  wt as e,
+  At as f,
+  kt as g,
+  Rt as m,
+  Ct as t
+};
+//# sourceMappingURL=toaster.records-BSRUGTiS.js.map