bitboss-ui 2.0.38 → 2.0.39

package/dist/index31.js

@@ -1,130 +1,100 @@
-import { defineComponent as L, ref as m, toRef as l, openBlock as E, createBlock as $, unref as p, withCtx as t, renderSlot as i, normalizeProps as f, guardReactiveProps as b, createVNode as B, mergeProps as v, createSlots as C } from "vue";
-import { useOptions as w } from "./index205.js";
-import q from "./index29.js";
-/* empty css        */
-import z from "./index206.js";
-/* empty css         */
-const N = /* @__PURE__ */ L({
-  __name: "BaseRadioGroup",
+import { defineComponent as g, computed as s, ref as _, openBlock as B, createElementBlock as w, normalizeProps as t, guardReactiveProps as l, createElementVNode as u, mergeProps as V, renderSlot as C } from "vue";
+import { isCssColor as i } from "./index212.js";
+import { when as E } from "./index213.js";
+const q = {
+  "aria-hidden": "true",
+  class: "bb-base-radio-container"
+}, O = /* @__PURE__ */ g({
+  __name: "BaseRadio",
   props: {
     ariaDescribedby: {},
     autofocus: {},
+    checked: {},
     color: {},
-    dependencies: {},
-    depsDebounceTime: { default: 0 },
-    direction: { default: "horizontal" },
     disabled: { type: Boolean },
-    enforceCoherence: { type: Boolean },
     hasErrors: { type: Boolean },
-    hideLabel: { type: Boolean },
     id: {},
-    items: { type: [Array, Function], default: () => [] },
-    itemText: {},
-    itemValue: {},
-    loadingText: { default: "Caricamento..." },
     modelValue: {},
-    modelValueDebounceTime: { default: 0 },
     name: {},
-    noDataText: { default: "Nessun elemento da visualizzare" },
     readonly: {},
-    required: { type: Boolean }
+    required: { type: Boolean },
+    value: {}
   },
-  emits: ["blur", "change", "click", "focus", "inactive", "input", "keydown", "mousedown", "mouseup", "update:modelValue"],
-  setup(h, { emit: y }) {
-    const n = h, o = y, c = m(), r = m(!1), { innerLoading: g, options: T } = w({
-      dependencies: l(n, "dependencies"),
-      depsDebounceTime: n.depsDebounceTime,
-      disabled: l(n, "disabled"),
-      emit: o,
-      enforceCoherence: n.enforceCoherence,
-      items: l(n, "items"),
-      itemText: n.itemText,
-      itemValue: n.itemValue,
-      modelValue: l(n, "modelValue"),
-      modelValueDebounceTime: n.modelValueDebounceTime,
-      multiple: !1,
-      prefill: !0,
-      queryDebounceTime: 0,
-      resetQueryOnOptionSelected: !1,
-      stash: !1
-    }), k = {
-      onBlur: (e) => o("blur", e),
-      onChange: (e) => o("change", e),
-      onClick: (e) => o("click", e),
-      onFocus: (e) => {
-        o("focus", e), r.value || (document.addEventListener("focusin", d, { passive: !0 }), document.addEventListener("click", u, { passive: !0 }), r.value = !0);
-      },
-      onInput: (e) => o("input", e),
-      onKeydown: (e) => o("keydown", e),
-      onMousedown: (e) => o("mousedown", e),
-      onMouseup: (e) => o("mouseup", e),
-      "onUpdate:modelValue": (e) => o("update:modelValue", e)
-    }, d = (e) => {
-      var s;
-      e.target instanceof HTMLElement && ((s = c.value) != null && s.contains(e.target) || (o("inactive"), r.value = !1, document.removeEventListener("focusin", d), document.removeEventListener("click", u)));
-    }, u = (e) => {
-      var s;
-      e.target instanceof HTMLElement && ((s = c.value) != null && s.contains(e.target) || (o("inactive"), r.value = !1, document.removeEventListener("focusin", d), document.removeEventListener("click", u)));
-    };
-    return (e, s) => (E(), $(z, {
-      class: "bb-base-radio-group",
-      direction: e.direction,
-      "has-errors": e.hasErrors,
-      "hide-label": e.hideLabel,
-      loading: !!p(g),
-      "loading-text": e.loadingText,
-      "no-data-text": e.noDataText,
-      options: p(T)
-    }, {
-      prepend: t(() => [
-        i(e.$slots, "prepend")
-      ]),
-      loading: t(() => [
-        i(e.$slots, "loading")
-      ]),
-      "no-data": t(() => [
-        i(e.$slots, "no-data")
-      ]),
-      "option:prepend": t((a) => [
-        i(e.$slots, "option:prepend", f(b(a)))
-      ]),
-      input: t(({ option: a, index: V }) => [
-        B(q, v({
-          id: a.valueHash,
-          "aria-describedby": e.ariaDescribedby,
-          autofocus: e.autofocus && !V,
-          checked: a.selected,
-          color: e.color,
-          disabled: a.disabled,
-          "has-errors": e.hasErrors,
-          "model-value": n.modelValue,
-          name: e.name,
-          readonly: e.readonly,
-          required: e.required,
-          value: a.value
-        }, k), C({ _: 2 }, [
-          e.$slots.icon ? {
-            name: "icon",
-            fn: t((D) => [
-              i(e.$slots, "icon", v({
-                item: a.item,
-                text: a.text
-              }, D))
-            ]),
-            key: "0"
-          } : void 0
-        ]), 1040, ["id", "aria-describedby", "autofocus", "checked", "color", "disabled", "has-errors", "model-value", "name", "readonly", "required", "value"])
-      ]),
-      "option:append": t((a) => [
-        i(e.$slots, "option:prepend", f(b(a)))
-      ]),
-      append: t(() => [
-        i(e.$slots, "prepend")
-      ]),
-      _: 3
-    }, 8, ["direction", "has-errors", "hide-label", "loading", "loading-text", "no-data-text", "options"]));
+  emits: ["blur", "change", "click", "focus", "input", "keydown", "mousedown", "mouseup", "update:modelValue"],
+  setup(b, { emit: p }) {
+    const e = b, a = p, c = s(() => e.checked ? !0 : JSON.stringify(e.modelValue) === JSON.stringify(e.value)), n = _(!1), m = s(() => {
+      const r = {
+        class: {
+          "bb-base-radio": !0,
+          "bb-base-radio--disabled": e.disabled,
+          "bb-base-radio--errors": e.hasErrors,
+          "bb-base-radio--readonly": e.readonly,
+          [`bb-base-radio--${e.color}`]: e.color && !i(e.color)
+        }
+      };
+      return e.color && i(e.color) && (r.style = `--color: ${e.color}`), r;
+    }), y = E(
+      (r) => typeof r != "string",
+      JSON.stringify
+    ), d = s(() => {
+      const r = y(e.value), k = {
+        onBlur: (o) => {
+          n.value = !1, a("blur", o);
+        },
+        onChange: (o) => {
+          a("change", o), a("update:modelValue", e.value);
+        },
+        onClick: (o) => a("click", o),
+        onFocus: (o) => {
+          n.value = !0, a("focus", o);
+        },
+        onInput: (o) => a("input", o),
+        onKeydown: (o) => a("keydown", o),
+        onMousedown: (o) => a("mousedown", o),
+        onMouseup: (o) => a("mouseup", o)
+      };
+      return {
+        "aria-describedby": e.ariaDescribedby,
+        autofocus: e.autofocus,
+        checked: c.value,
+        // There is no such thing as readonly radio so we disable and style it with css
+        disabled: e.disabled || e.readonly,
+        id: e.id,
+        name: e.name,
+        required: e.required,
+        tabindex: e.disabled ? -1 : void 0,
+        type: "radio",
+        value: r,
+        ...k
+      };
+    }), f = s(() => ({
+      checked: c.value,
+      disabled: e.disabled,
+      focused: n.value,
+      hasErrors: e.hasErrors,
+      id: e.id,
+      name: e.name,
+      parsedValue: d.value.value,
+      readonly: e.readonly,
+      required: e.required,
+      value: e.value
+    })), v = s(() => {
+      let r = {};
+      return e.color && i(e.color) && (r.color = e.color), {
+        class: "bb-base-radio-container__icon",
+        style: r
+      };
+    });
+    return (r, h) => (B(), w("span", t(l(m.value)), [
+      u("input", V(d.value, { class: "sr-only" }), null, 16),
+      u("span", q, [
+        C(r.$slots, "icon", t(l(f.value)), () => [
+          u("span", t(l(v.value)), null, 16)
+        ])
+      ])
+    ], 16));
   }
 });
 export {
-  N as default
+  O as default
 };

package/dist/index310.js

@@ -0,0 +1,49 @@
+import { observeElementRect as f, observeElementOffset as s, elementScroll as d, Virtualizer as p } from "./index314.js";
+import { defaultKeyExtractor as S, defaultRangeExtractor as V, measureElement as b } from "./index314.js";
+import { computed as g, unref as l, shallowRef as E, watch as o, triggerRef as i, onScopeDispose as v } from "vue";
+function w(e) {
+  const t = new p(l(e)), a = E(t), u = t._didMount();
+  return o(
+    () => l(e).getScrollElement(),
+    (r) => {
+      r && t._willUpdate();
+    },
+    {
+      immediate: !0
+    }
+  ), o(
+    () => l(e),
+    (r) => {
+      t.setOptions({
+        ...r,
+        onChange: (c, m) => {
+          var n;
+          i(a), (n = r.onChange) == null || n.call(r, c, m);
+        }
+      }), t._willUpdate(), i(a);
+    },
+    {
+      immediate: !0
+    }
+  ), v(u), a;
+}
+function z(e) {
+  return w(
+    g(() => ({
+      observeElementRect: f,
+      observeElementOffset: s,
+      scrollToFn: d,
+      ...l(e)
+    }))
+  );
+}
+export {
+  p as Virtualizer,
+  S as defaultKeyExtractor,
+  V as defaultRangeExtractor,
+  d as elementScroll,
+  b as measureElement,
+  s as observeElementOffset,
+  f as observeElementRect,
+  z as useVirtualizer
+};

package/dist/index311.js

@@ -0,0 +1,4 @@
+import f from "./index295.js";
+export {
+  f as default
+};