@wikicasa-dev/components 2.6.11-alpha.0 → 3.0.0-alpha.0

package/dist/chunks/CheckboxGroup.vue_vue_type_script_setup_true_lang.B_9CFhd2.js

@@ -0,0 +1,111 @@
+import { defineComponent as y, ref as v, computed as i, watch as x, renderSlot as m, createElementVNode as D, normalizeClass as E, createElementBlock as $, createCommentVNode as B, openBlock as b, Fragment as I, renderList as R, createBlock as A, unref as K } from "vue";
+import "./polyline.DjpLdMaW.js";
+import L from "../CheckboxBtn.js";
+const V = (a) => !a?.length, w = (a = "") => !a || !a.trim() ? "" : (a = a.trim(), a.replace(" ", "-").toLowerCase()), G = ["id", "data-cy"], j = /* @__PURE__ */ y({
+  inheritAttrs: !1,
+  __name: "CheckboxGroup",
+  props: {
+    checkboxData: { default() {
+      return [];
+    } },
+    formCheckInline: { type: Boolean, default: !1 },
+    reset: { type: Boolean, default: !1 },
+    checkboxContainerClasses: { default: "" },
+    autoCheckResetAll: { type: Boolean, default: !1 },
+    autoCheckResetEmpty: { type: Boolean, default: !1 },
+    manualToggleResetButton: { type: Boolean, default: !1 },
+    getKey: { default() {
+      return (a) => typeof a == "string" || typeof a == "number" ? `${a}` : `${a.id}`;
+    } },
+    groupId: { default: "" },
+    dataCy: { default: "" }
+  },
+  emits: ["resetted", "update:modelValue", "checkedGroup"],
+  setup(a, { emit: C }) {
+    const c = a, s = C, l = v(/* @__PURE__ */ new Map()), r = i(() => {
+      for (const e of c.checkboxData)
+        if (e.reset) return e;
+      return null;
+    }), g = i(() => c.checkboxData.length), f = i(() => {
+      let e = 0;
+      return l.value.forEach((t) => {
+        t.checked && e++;
+      }), e;
+    });
+    (() => {
+      const e = [];
+      for (const t of c.checkboxData)
+        t.checked = !!t.checked, l.value.set(
+          `${t.id}`,
+          t
+        ), t.checked && e.push(t);
+      s("update:modelValue", e);
+    })();
+    const u = (e, t) => {
+      const o = l.value.get(e);
+      if (o) {
+        if (t) {
+          l.value.set(e, { ...o, ...t });
+          return;
+        }
+        l.value.set(e, { ...o, checked: !o.checked });
+      }
+    }, k = () => {
+      l.value.forEach((e) => {
+        e.checked = !1;
+      });
+    }, p = () => {
+      k(), s("update:modelValue", []), s("resetted");
+    }, d = (e) => l.value.get(c.getKey(e))?.checked ?? !1, h = (e) => {
+      if (V(c.checkboxData)) return;
+      const t = l.value.get(e.id);
+      t?.reset && e.checked ? k() : r.value && !t?.reset && u(c.getKey(r.value), { checked: !1 }), u(`${e.id}`), c.autoCheckResetAll && r.value && f.value === g.value - 1 && l.value.forEach((n) => {
+        n.checked = !!n.reset;
+      }), c.autoCheckResetEmpty && r.value && !f.value && (!c.manualToggleResetButton || !t?.reset) && u(c.getKey(r.value), { checked: !0 });
+      const o = [];
+      l.value.forEach((n) => {
+        n.checked && o.push(n);
+      }), s("update:modelValue", o), s("checkedGroup", c.groupId);
+    };
+    return x(
+      () => c.reset,
+      (e) => {
+        e && p();
+      }
+    ), (e, t) => m(e.$slots, "default", {
+      isActive: d,
+      handleChange: h,
+      checkboxesData: e.checkboxData
+    }, () => [
+      D("div", {
+        id: e.groupId,
+        class: E(["checkbox-group-container", e.$attrs.class || ""]),
+        "data-cy": e.dataCy
+      }, [
+        m(e.$slots, "checkbox_elements", {
+          isActive: d,
+          handleChange: h,
+          checkboxesData: e.checkboxData,
+          reset: p
+        }, () => [
+          e.checkboxData ? (b(!0), $(I, { key: 0 }, R(e.checkboxData, (o, n) => (b(), A(L, {
+            id: e.getKey(o),
+            key: n,
+            "data-cy": o.dataCy ?? `checkbox_${K(w)(`${o.label}`)}`,
+            label: o.label,
+            inline: e.formCheckInline,
+            "model-value": d(o),
+            "container-class": [
+              e.formCheckInline ? "uikit:mr-10px" : "uikit:mb-10px",
+              e.checkboxContainerClasses
+            ],
+            onChange: h
+          }, null, 8, ["id", "data-cy", "label", "inline", "model-value", "container-class"]))), 128)) : B("", !0)
+        ])
+      ], 10, G)
+    ]);
+  }
+});
+export {
+  j as _
+};

package/dist/chunks/CloseIcon.BZ4U3aiI.js

@@ -0,0 +1,38 @@
+import { h as r } from "vue";
+import { e } from "./PharmacyIcon.DEQ8mOEJ.js";
+const d = (t, { attrs: o }) => {
+  t = { ...e(), ...t };
+  const { width: i, height: s } = t;
+  return r(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 18.558 18.558",
+      width: `${i}`,
+      height: `${s}`,
+      class: t.class ?? "",
+      "aria-hidden": o["aria-hidden"] ?? "true"
+    },
+    r(
+      "g",
+      {
+        fill: "none",
+        stroke: `${t["stroke-color"] ?? "#222"}`,
+        "stroke-linecap": `${o["stroke-linecap"] ?? "round"}`,
+        "stroke-linejoin": `${o["stroke-linejoin"] ?? "round"}`,
+        "stroke-width": `${t["stroke-width"] ?? "3"}`
+      },
+      [
+        r("path", {
+          d: "m2.121 2.121 14.316 14.316"
+        }),
+        r("path", {
+          d: "M2.121 16.437 16.244 2.121"
+        })
+      ]
+    )
+  );
+};
+export {
+  d as l
+};

package/dist/chunks/DoughnutChart.vue_vue_type_script_setup_true_lang.B8wxbJBV.js

@@ -0,0 +1,27 @@
+import { defineComponent as i, onBeforeMount as p, createBlock as u, createCommentVNode as m, unref as t, openBlock as c } from "vue";
+import { Doughnut as l } from "vue-chartjs";
+import { Chart as d, DoughnutController as f, ArcElement as g } from "chart.js";
+import { useChartJsModules as h } from "../useChartjsModules.js";
+const y = /* @__PURE__ */ i({
+  __name: "DoughnutChart",
+  props: {
+    options: {},
+    data: {}
+  },
+  setup(e) {
+    d.register(f, g);
+    const r = e, { registerPlugins: n, resolved: s, executeRegistration: a } = h(
+      r.options
+    );
+    return p(async () => {
+      await a(n);
+    }), (o, C) => t(s) ? (c(), u(t(l), {
+      key: 0,
+      options: o.options,
+      data: o.data
+    }, null, 8, ["options", "data"])) : m("", !0);
+  }
+});
+export {
+  y as _
+};

package/dist/chunks/IntersectionObservable.vue_vue_type_script_setup_true_lang.DC17cx-h.js

@@ -0,0 +1,24 @@
+import { defineComponent as t, ref as n, onMounted as a, createElementBlock as i, renderSlot as s, openBlock as u, normalizeClass as f } from "vue";
+const b = /* @__PURE__ */ t({
+  __name: "IntersectionObservable",
+  props: {
+    observer: { default: null },
+    isVisible: { type: Boolean, default: !1 }
+  },
+  setup(l) {
+    const r = l, o = n(null);
+    return a(() => {
+      !r.observer || !o.value || r.observer.observe(o.value);
+    }), (e, p) => e.isVisible ? s(e.$slots, "default", { key: 1 }) : (u(), i("div", {
+      key: 0,
+      ref_key: "root",
+      ref: o,
+      class: f(e.$attrs["root-classes"])
+    }, [
+      s(e.$slots, "default")
+    ], 2));
+  }
+});
+export {
+  b as _
+};

package/dist/chunks/IntersectionObserver.vue_vue_type_script_setup_true_lang.BKewKDXG.js

@@ -0,0 +1,52 @@
+import { defineComponent as p, reactive as d, ref as m, onBeforeMount as h, onBeforeUnmount as V, createElementBlock as k, renderSlot as l, unref as t, openBlock as B, normalizeClass as O } from "vue";
+const _ = /* @__PURE__ */ p({
+  __name: "IntersectionObserver",
+  props: {
+    observeOnce: { type: Boolean, default: !0 },
+    skip: { type: Boolean, default: !1 },
+    threshold: { default: 0 }
+  },
+  emits: ["intersection"],
+  setup(a, { emit: u }) {
+    const c = u, o = a;
+    let r = d({ root: null, isVisible: !1 });
+    const e = m(null), v = (s) => {
+      s.forEach(({ target: n, isIntersecting: i }) => {
+        i && (r.isVisible = !0, c("intersection")), o.observeOnce && i && b(n);
+      });
+    }, b = (s) => {
+      e.value && e.value.unobserve(s);
+    }, f = () => {
+      e.value && e.value.disconnect();
+    };
+    return h(() => {
+      if (o.skip) {
+        r.isVisible = !0;
+        return;
+      }
+      e.value = new IntersectionObserver(v, {
+        root: null,
+        //if the root is null, then we will check if the target is visible in the doc root!
+        threshold: o.threshold
+      });
+    }), V(() => {
+      f();
+    }), (s, n) => t(r).isVisible ? l(s.$slots, "observer", {
+      key: 1,
+      observer: e.value,
+      isVisible: t(r).isVisible
+    }) : (B(), k("div", {
+      key: 0,
+      ref: "root",
+      class: O(s.$attrs["root-classes"])
+    }, [
+      l(s.$slots, "observer", {
+        observer: e.value,
+        isVisible: t(r).isVisible
+      })
+    ], 2));
+  }
+});
+export {
+  _
+};

package/dist/chunks/LineChart.vue_vue_type_script_setup_true_lang.CXNsFiyD.js

@@ -0,0 +1,42 @@
+import { defineComponent as m, onBeforeMount as u, useTemplateRef as f, computed as d, createBlock as h, createCommentVNode as C, unref as t, openBlock as g } from "vue";
+import { Line as L } from "vue-chartjs";
+import { Chart as _, LineController as k, LineElement as x, Filler as y, PointElement as B, CategoryScale as E, LinearScale as v } from "chart.js";
+import { useChartJsModules as M } from "../useChartjsModules.js";
+const A = /* @__PURE__ */ m({
+  __name: "LineChart",
+  props: {
+    options: {},
+    data: {}
+  },
+  setup(o, { expose: r }) {
+    _.register(
+      k,
+      x,
+      y,
+      B,
+      E,
+      v
+    );
+    const n = o, {
+      registerPlugins: a,
+      registerTimeCartesianAxis: s,
+      executeRegistration: i,
+      resolved: c
+    } = M(n.options);
+    u(async () => {
+      await i(a, s);
+    });
+    const p = f("chart"), l = d(
+      () => p.value?.chart
+    );
+    return r({ chartInstance: l }), (e, P) => t(c) ? (g(), h(t(L), {
+      key: 0,
+      ref: "chart",
+      options: e.options,
+      data: e.data
+    }, null, 8, ["options", "data"])) : C("", !0);
+  }
+});
+export {
+  A as _
+};

package/dist/chunks/ObjectUtils.DwkJjVq1.js

@@ -0,0 +1,10 @@
+function c(n, o) {
+  if (n)
+    for (const t in n)
+      o[t] = n[t];
+}
+const f = (n) => !n || !Object.keys(n).length;
+export {
+  c as l,
+  f as u
+};

package/dist/chunks/PharmacyIcon.DEQ8mOEJ.js

@@ -0,0 +1,11 @@
+import { h as o } from "vue";
+const r = () => ({
+  width: 20,
+  height: 20,
+  "stroke-color": "#222",
+  "aria-hidden": !0
+});
+o("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 17 17" });
+export {
+  r as e
+};

package/dist/chunks/RadioButton.vue_vue_type_script_setup_true_lang.CxVJji0G.js

@@ -0,0 +1,58 @@
+import { defineComponent as k, useId as m, computed as c, createElementBlock as p, openBlock as b, withModifiers as l, createElementVNode as n, normalizeClass as u, createTextVNode as f, toDisplayString as h } from "vue";
+const C = ["id", "name", "checked"], V = ["for"], y = /* @__PURE__ */ k({
+  __name: "RadioButton",
+  props: {
+    id: {},
+    name: {},
+    label: {},
+    modelValue: { type: Boolean, default: !1 },
+    inputClasses: {},
+    labelClasses: {}
+  },
+  emits: ["change", "update:modelValue"],
+  setup(i, { emit: d }) {
+    const o = d, a = m(), s = c(() => `${i.id ?? a}`), r = () => {
+      if (i.modelValue) return;
+      const e = {
+        id: i.id ?? a,
+        label: i.label,
+        name: i.name
+      };
+      o("change", e), o("update:modelValue", !i.modelValue);
+    };
+    return (e, t) => (b(), p("div", {
+      class: "uikit:inline-block",
+      onClick: l(r, ["stop"])
+    }, [
+      n("input", {
+        id: s.value,
+        ref: "checkbox",
+        type: "radio",
+        class: "uikit:pointer-events-none uikit:hidden",
+        name: e.name,
+        checked: e.modelValue,
+        onChange: t[0] || (t[0] = l(() => {
+        }, ["prevent"])),
+        onClick: t[1] || (t[1] = l(() => {
+        }, ["prevent"]))
+      }, null, 40, C),
+      n("label", {
+        class: u([e.labelClasses, "uikit:flex uikit:cursor-pointer uikit:items-center uikit:text-sm"]),
+        for: s.value
+      }, [
+        n("span", {
+          class: u(["uikit:flex-no-shrink uikit:mr-2 uikit:inline-block uikit:h-4 uikit:w-4 uikit:transform uikit:rounded-full uikit:border uikit:border-solid uikit:border-w-secondary uikit:transition-colors uikit:duration-200", [
+            {
+              "checked uikit:border-w-primary uikit:bg-w-primary uikit:shadow-[0_0_0_2px_white_inset]": e.modelValue
+            },
+            e.inputClasses
+          ]])
+        }, null, 2),
+        f(" " + h(e.label), 1)
+      ], 10, V)
+    ]));
+  }
+});
+export {
+  y as _
+};

package/dist/chunks/RadioGroup.vue_vue_type_script_setup_true_lang.BNKSEicl.js

@@ -0,0 +1,62 @@
+import { defineComponent as p, mergeModels as d, useModel as C, ref as h, watch as $, renderSlot as u, createElementVNode as V, normalizeClass as c, createElementBlock as k, openBlock as m, Fragment as R, renderList as g, createBlock as y } from "vue";
+import { _ } from "./RadioButton.vue_vue_type_script_setup_true_lang.CxVJji0G.js";
+const b = ["data-cy"], w = /* @__PURE__ */ p({
+  inheritAttrs: !1,
+  __name: "RadioGroup",
+  props: /* @__PURE__ */ d({
+    radioValues: { default: () => [] },
+    dataCy: {},
+    radioContainerClasses: {}
+  }, {
+    resetRadio: {
+      default: !1
+    },
+    resetRadioModifiers: {}
+  }),
+  emits: /* @__PURE__ */ d(["update:modelValue"], ["update:resetRadio"]),
+  setup(o, { emit: f }) {
+    const i = f, n = C(o, "resetRadio"), a = h(null), l = (e) => {
+      a.value = e, i("update:modelValue", e);
+    }, t = () => {
+      a.value = null, n.value = !1, i("update:modelValue", null);
+    }, r = (e) => a.value ? `${a.value.id}` == `${e.id}` : !1;
+    return (() => {
+      for (const e of o.radioValues)
+        if (e.active) {
+          l(e);
+          return;
+        }
+    })(), $(n, (e) => {
+      e && t();
+    }), (e, M) => u(e.$slots, "default", {
+      handleClick: l,
+      activeValue: a.value,
+      reset: t,
+      isActive: r
+    }, () => [
+      V("div", {
+        class: c(["radio-group-container", e.$attrs.class]),
+        "data-cy": e.dataCy
+      }, [
+        u(e.$slots, "radio_elements", {
+          handleClick: l,
+          activeValue: a.value,
+          reset: t,
+          isActive: r
+        }, () => [
+          (m(!0), k(R, null, g(e.radioValues, (s, v) => (m(), y(_, {
+            id: s.id,
+            key: v,
+            class: c(e.radioContainerClasses),
+            label: `${s.label}`,
+            "model-value": `${s.id}` == `${a.value?.id}`,
+            onChange: l
+          }, null, 8, ["id", "class", "label", "model-value"]))), 128))
+        ])
+      ], 10, b)
+    ]);
+  }
+});
+export {
+  w as _
+};

package/dist/chunks/SelectItem.vue_vue_type_script_setup_true_lang.jB3LVM3c.js

@@ -0,0 +1,41 @@
+import { defineComponent as r, useTemplateRef as u, watch as d, nextTick as m, createElementBlock as c, openBlock as f, normalizeClass as p, renderSlot as k, createElementVNode as v } from "vue";
+const b = ["tabindex"], x = ["innerHTML"], $ = /* @__PURE__ */ r({
+  __name: "SelectItem",
+  props: {
+    label: { default: "" },
+    active: { type: Boolean, default: !1 },
+    idx: { default: -1 }
+  },
+  emits: ["click", "mouseover"],
+  setup(o, { emit: s }) {
+    const l = s, t = o, n = u("liItem");
+    return d(
+      () => t.active,
+      (e) => {
+        e && m(() => {
+          n.value && n.value.focus();
+        });
+      },
+      { immediate: !0 }
+    ), (e, i) => (f(), c("li", {
+      ref: "liItem",
+      class: p(["uikit:list-none uikit:text-w-black", [
+        { "active uikit:bg-w-cultured": e.active },
+        "uikit:outline-hidden",
+        e.$attrs.class
+      ]]),
+      tabindex: e.$attrs.tabindex ?? -1,
+      onClick: i[0] || (i[0] = (a) => l("click", t.idx)),
+      onMouseover: i[1] || (i[1] = (a) => l("mouseover", t.idx))
+    }, [
+      k(e.$slots, "default", { itemIdx: e.idx }, () => [
+        v("span", {
+          innerHTML: t.label
+        }, null, 8, x)
+      ])
+    ], 42, b));
+  }
+});
+export {
+  $ as _
+};

package/dist/chunks/ShimmerMultiLine.vue_vue_type_script_setup_true_lang.CPUobRgG.js

@@ -0,0 +1,29 @@
+import { defineComponent as t, createElementBlock as n, openBlock as r, Fragment as s, renderList as l, createBlock as m, normalizeStyle as a, normalizeClass as o } from "vue";
+import h from "../BaseShimmerLoader.js";
+const c = /* @__PURE__ */ t({
+  __name: "ShimmerMultiLine",
+  props: {
+    lines: { default: 1 },
+    randomLength: { type: Boolean, default: !1 },
+    shimmerClasses: {},
+    inheritHeight: { type: Boolean, default: !1 }
+  },
+  setup(u) {
+    return (e, d) => (r(!0), n(s, null, l(e.lines, (i) => (r(), m(h, {
+      ref_for: !0,
+      ref: "shimmerLines",
+      class: o(["shimmer-line", [
+        e.shimmerClasses,
+        e.inheritHeight ? "uikit:h-[1em]" : "uikit:h-8",
+        "uikit:mb-2 uikit:rounded-xs"
+      ]]),
+      key: `sml-${i}`,
+      style: a({
+        marginRight: e.randomLength ? `${Math.round(Math.random() * 5) * 10}%` : 0
+      })
+    }, null, 8, ["class", "style"]))), 128));
+  }
+});
+export {
+  c as _
+};