@codeandfunction/callaloo 4.7.3 → 4.7.5

package/dist/composables/useTheme.js

@@ -1,32 +1,41 @@
 import '../assets/core.css';
-import { ref as t, inject as n } from "vue";
-import { D as o } from "../chunks/base-theme--kHiV8Yr.js";
-const a = t(o.borderRadius), r = t(o.darkMode), l = t(o.fontFamily), s = t(o.colors || {
-  primary: {},
-  secondary: {},
-  neutral: {},
-  danger: {},
-  warning: {},
-  success: {},
-  info: {}
-}), c = (e) => {
-  a.value = e;
-}, u = (e) => {
-  s.value = { ...s.value, ...e };
-}, d = (e) => {
-  r.value = e;
-}, i = (e) => {
-  l.value = e;
-}, D = () => n("clll-theme", {
-  borderRadius: a,
-  colors: s,
-  darkMode: r,
-  fontFamily: l,
-  setBorderRadius: c,
-  setColors: u,
-  setDarkMode: d,
-  setFontFamily: i
-});
+import { ref as a, inject as i } from "vue";
+import { D as o, T as c } from "../chunks/context-CEvx70FY.js";
+const l = a(
+  o.borderRadius
+), s = a(o.darkMode), n = a(o.fontFamily), r = a(
+  o.colors || {
+    primary: {},
+    secondary: {},
+    neutral: {},
+    danger: {},
+    warning: {},
+    success: {},
+    info: {}
+  }
+), m = () => {
+  const t = i(c, null);
+  return t || (console.warn(
+    "[Callaloo]: useTheme() must be used within a <CLThemeProvider />."
+  ), {
+    borderRadius: l,
+    colors: r,
+    darkMode: s,
+    fontFamily: n,
+    setBorderRadius: (e) => {
+      l.value = e;
+    },
+    setColors: (e) => {
+      r.value = { ...r.value, ...e };
+    },
+    setDarkMode: (e) => {
+      s.value = e;
+    },
+    setFontFamily: (e) => {
+      n.value = e;
+    }
+  });
+};
 export {
-  D as useTheme
+  m as useTheme
 };

package/dist/composables/useTheme.spec.js

@@ -0,0 +1,88 @@
+import '../assets/core.css';
+import { defineComponent as r, h as e } from "vue";
+import { d as p, b as f, a as v, i, m, g as s, v as o } from "../chunks/vue-test-utils.esm-bundler-BeQTU4qG.js";
+import { useTheme as a } from "./useTheme.js";
+import { _ as l } from "../chunks/CLThemeProvider.vue_vue_type_script_setup_true_lang-jaJYKZL8.js";
+import { CLBorderRadius as n } from "../index.js";
+p("useTheme", () => {
+  f(() => {
+    o.spyOn(console, "warn").mockImplementation(() => {
+    }), Object.defineProperty(window, "matchMedia", {
+      writable: !0,
+      value: o.fn().mockImplementation((t) => ({
+        matches: !1,
+        media: t,
+        onchange: null,
+        addListener: o.fn(),
+        // deprecated
+        removeListener: o.fn(),
+        // deprecated
+        addEventListener: o.fn(),
+        removeEventListener: o.fn(),
+        dispatchEvent: o.fn()
+      }))
+    });
+  }), v(() => {
+    o.restoreAllMocks();
+  }), i("should warn when used outside of CLThemeProvider", () => {
+    const t = r({
+      setup() {
+        return a(), () => e("div");
+      }
+    });
+    m(t), s(console.warn).toHaveBeenCalledWith(
+      "[Callaloo]: useTheme() must be used within a <CLThemeProvider />."
+    );
+  }), i("should not warn when used inside CLThemeProvider", () => {
+    const t = r({
+      setup() {
+        return a(), () => e("div");
+      }
+    });
+    m(l, {
+      slots: {
+        default: () => e(t)
+      }
+    }), s(console.warn).not.toHaveBeenCalled();
+  }), i("should provide theme state from the provider", () => {
+    let t;
+    const d = r({
+      setup() {
+        return t = a(), () => e("div");
+      }
+    });
+    m(l, {
+      props: {
+        themeConfig: {
+          borderRadius: n.Large
+        }
+      },
+      slots: {
+        default: () => e(d)
+      }
+    }), s(t.borderRadius.value).toBe(n.Large);
+  }), i("should allow multiple providers with isolated state", () => {
+    let t, d;
+    const u = r({
+      setup() {
+        return t = a(), () => e("div");
+      }
+    }), h = r({
+      setup() {
+        return d = a(), () => e("div");
+      }
+    });
+    m(r({
+      setup() {
+        return () => e("div", [
+          e(l, { themeConfig: { borderRadius: n.Small } }, {
+            default: () => e(u)
+          }),
+          e(l, { themeConfig: { borderRadius: n.Large } }, {
+            default: () => e(h)
+          })
+        ]);
+      }
+    })), s(t.borderRadius.value).toBe(n.Small), s(d.borderRadius.value).toBe(n.Large);
+  });
+});

package/dist/composables/useToast.d.ts

@@ -1,6 +1,6 @@
 import { CLToastProps } from '../index.ts';
 export declare const useToast: () => {
-    visible: boolean | undefined;
+    visible: globalThis.ComputedRef<boolean>;
     showToast: (input: Omit<CLToastProps, "onDismiss">) => void;
-    hideToast: (() => void) | undefined;
+    hideToast: () => void | undefined;
 };

package/dist/composables/useToast.js

@@ -1,15 +1,18 @@
 import '../assets/core.css';
-import { inject as e } from "vue";
-const a = () => {
-  const o = e("clll-toast"), s = (t) => {
+import { inject as e, computed as a } from "vue";
+import { T as i } from "../chunks/context-dkA4VoF7.js";
+const l = () => {
+  const o = e(i, null);
+  o || console.warn("[Callaloo]: useToast() must be used within a <CLToastProvider />.");
+  const s = (t) => {
     o?.showToast?.(t);
   };
   return {
-    visible: o?.visible?.value,
+    visible: a(() => o?.visible.value ?? !1),
     showToast: s,
-    hideToast: o?.hideToast
+    hideToast: () => o?.hideToast()
   };
 };
 export {
-  a as useToast
+  l as useToast
 };

package/dist/composables/useToast.spec.js

@@ -0,0 +1,45 @@
+import '../assets/core.css';
+import { defineComponent as t, h as s, nextTick as l } from "vue";
+import { d as m, b as v, a as c, i as a, m as n, g as o, v as r } from "../chunks/vue-test-utils.esm-bundler-BeQTU4qG.js";
+import { useToast as i } from "./useToast.js";
+import { _ as u } from "../chunks/CLToastProvider.vue_vue_type_script_setup_true_lang-DkGK0H4Z.js";
+m("useToast", () => {
+  v(() => {
+    r.spyOn(console, "warn").mockImplementation(() => {
+    });
+  }), c(() => {
+    r.restoreAllMocks();
+  }), a("should warn when used outside of CLToastProvider", () => {
+    const e = t({
+      setup() {
+        return i(), () => s("div");
+      }
+    });
+    n(e), o(console.warn).toHaveBeenCalledWith(
+      "[Callaloo]: useToast() must be used within a <CLToastProvider />."
+    );
+  }), a("should not warn when used inside CLToastProvider", () => {
+    const e = t({
+      setup() {
+        return i(), () => s("div");
+      }
+    });
+    n(u, {
+      slots: {
+        default: () => s(e)
+      }
+    }), o(console.warn).not.toHaveBeenCalled();
+  }), a("should have reactive visible state", async () => {
+    let e;
+    const d = t({
+      setup() {
+        return e = i(), () => s("div");
+      }
+    });
+    n(u, {
+      slots: {
+        default: () => s(d)
+      }
+    }), o(e.visible.value).toBe(!1), e.showToast({ message: "Test" }), await l(), o(e.visible.value).toBe(!0), e.hideToast(), await l(), o(e.visible.value).toBe(!1);
+  });
+});