bitboss-ui 2.0.165 → 2.0.167

package/dist/index102.js

@@ -0,0 +1,100 @@
+import { defineComponent as f, ref as g, computed as v, createBlock as y, openBlock as B, withCtx as s, createVNode as w, mergeProps as k, renderSlot as a, normalizeProps as r, guardReactiveProps as i } from "vue";
+import P from "./index27.js";
+/* empty css        */
+import V from "./index35.js";
+/* empty css        */
+const I = /* @__PURE__ */ f({
+  __name: "BbRating",
+  props: {
+    autofocus: {},
+    color: {},
+    compact: { type: Boolean },
+    disabled: { type: Boolean },
+    errors: {},
+    hasErrors: { type: Boolean },
+    hideLegend: { type: Boolean },
+    hint: {},
+    id: {},
+    inputPosition: { default: "left" },
+    legend: {},
+    legendPosition: {},
+    modelValue: {},
+    name: {},
+    persistentHint: { type: Boolean },
+    readonly: { type: Boolean },
+    reverse: { type: Boolean },
+    stars: {},
+    size: {}
+  },
+  emits: ["blur", "change", "click", "focus", "inactive", "input", "keydown", "mousedown", "mouseup", "update:modelValue"],
+  setup(d, { emit: p }) {
+    const u = d, o = p, l = g(!1), m = v(() => u.persistentHint || l.value), c = {
+      onBlur: (e) => o("blur", e),
+      onChange: (e) => o("change", e),
+      onClick: (e) => o("click", e),
+      onFocus: (e) => {
+        l.value = !0, o("focus", e);
+      },
+      onInactive: () => {
+        l.value = !1, o("inactive");
+      },
+      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)
+    };
+    return (e, $) => (B(), y(P, {
+      id: e.id,
+      class: "bb-rating",
+      compact: e.compact,
+      direction: "vertical",
+      errors: e.errors,
+      "has-errors": e.hasErrors,
+      "hide-label": e.hideLegend,
+      hint: e.hint,
+      "input-position": e.inputPosition,
+      label: e.legend,
+      "label-position": e.legendPosition,
+      "label-tag": "legend",
+      name: e.name,
+      reverse: e.reverse,
+      "show-hint": m.value,
+      tag: "fieldset"
+    }, {
+      label: s((t) => [
+        a(e.$slots, "legend", r(i(t)))
+      ]),
+      input: s(({ id: t, hasErrors: h, ariaDescribedby: b }) => [
+        w(V, k({
+          id: t,
+          "aria-describedby": b,
+          autofocus: e.autofocus,
+          color: e.color,
+          disabled: e.disabled,
+          "has-errors": h,
+          "model-value": e.modelValue,
+          name: e.name,
+          readonly: e.readonly,
+          size: e.size,
+          stars: e.stars
+        }, c), {
+          prepend: s((n) => [
+            a(e.$slots, "prepend", r(i(n)))
+          ]),
+          append: s((n) => [
+            a(e.$slots, "append", r(i(n)))
+          ]),
+          icon: s((n) => [
+            a(e.$slots, "icon", r(i(n)))
+          ]),
+          _: 2
+        }, 1040, ["id", "aria-describedby", "autofocus", "color", "disabled", "has-errors", "model-value", "name", "readonly", "size", "stars"])
+      ]),
+      _: 3
+    }, 8, ["id", "compact", "errors", "has-errors", "hide-label", "hint", "input-position", "label", "label-position", "name", "reverse", "show-hint"]));
+  }
+});
+export {
+  I as default
+};

package/dist/index104.js

@@ -0,0 +1,24 @@
+import { defineComponent as t, createBlock as o, openBlock as a, resolveDynamicComponent as r, normalizeStyle as l, withCtx as n, renderSlot as s } from "vue";
+const d = /* @__PURE__ */ t({
+  __name: "BbRatio",
+  props: {
+    ratio: { default: 1 },
+    tag: { default: "div" }
+  },
+  setup(i) {
+    return (e, p) => (a(), o(r(e.tag), {
+      class: "bb-ratio",
+      style: l({
+        aspectRatio: e.ratio
+      })
+    }, {
+      default: n(() => [
+        s(e.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["style"]));
+  }
+});
+export {
+  d as default
+};

package/dist/index106.js

@@ -0,0 +1,144 @@
+import { defineComponent as D, computed as V, toRef as r, ref as E, reactive as L, watch as m, createElementBlock as b, openBlock as B, Fragment as g, renderSlot as i, createCommentVNode as P, unref as R, renderList as j } from "vue";
+import { useItemValue as G } from "./index277.js";
+import { isNil as k } from "./index263.js";
+import { indexBy as U } from "./index278.js";
+import { hash as p } from "./index227.js";
+import { useItemsGetter as W } from "./index241.js";
+import { usePrefill as q } from "./index246.js";
+import { useIndexById as z } from "./index242.js";
+import { useBaseOptions as J } from "./index243.js";
+import { useHashedWatcher as K } from "./index245.js";
+const oe = /* @__PURE__ */ D({
+  __name: "BbRows",
+  props: {
+    columns: { default: () => [] },
+    dependencies: { default: () => [] },
+    depsDebounceTime: { default: 0 },
+    disabled: { type: Boolean },
+    items: { type: [Array, Function], default: () => [] },
+    itemValue: {},
+    loading: { type: Boolean },
+    max: { default: 1 / 0 },
+    modelValue: { default: () => [] },
+    multiple: { type: Boolean, default: !0 },
+    selectable: { type: [Boolean, Function] },
+    selectAll: { type: Boolean },
+    unselectedItems: { default: () => [] }
+  },
+  emits: ["update:modelValue", "update:unselectedItems"],
+  setup(H, { emit: x }) {
+    const t = H, u = x, { getItemValue: A } = G(), f = V(() => !!(t.loading || w.value)), {
+      getter: v,
+      items: y,
+      loading: w
+    } = W({
+      items: r(t, "items")
+    }), { hasPrefilled: O } = q({
+      onStart: !0,
+      currentValue: t.modelValue,
+      multiple: t.multiple,
+      fn: async ({ prefill: e }) => {
+        await v(e, t.modelValue);
+      }
+    }), { data: h } = z({
+      items: r(t, "modelValue")
+    }), { options: S } = J({
+      disabled: r(t, "disabled"),
+      items: y,
+      itemText: void 0,
+      itemValue: t.itemValue,
+      max: t.max,
+      selectable: !0,
+      selectedIndexedByHash: h
+    }), F = async (e) => {
+      t.multiple ? u("update:modelValue", t.modelValue.concat(e.value)) : u("update:modelValue", e.value);
+    }, N = async (e) => {
+      if (t.multiple) {
+        const l = { ...h.value };
+        delete l[e.valueHash], u("update:modelValue", Object.values(l));
+      } else
+        u("update:modelValue", null);
+    };
+    K(
+      () => [t.dependencies, t.items],
+      async () => {
+        O.value && await v(!1, t.modelValue);
+      },
+      {
+        debounce: t.depsDebounceTime
+      }
+    );
+    const I = V(() => S.value.map((e) => {
+      let l = !t.selectable;
+      typeof t.selectable == "function" && (l = !t.selectable(e.item)), l = l || !!e.disabled;
+      const a = U(
+        t.columns.map((s) => {
+          const { label: $, key: C } = s;
+          let n = A(e.item, s.key);
+          return s.formatter && // By default the formatter runs anyway
+          (!k(n) || s.formatOnNull !== !1) && (n = s.formatter(n, s.key, e.item)), s.placeholder && k(n) && (n = s.placeholder), {
+            value: n,
+            key: C,
+            label: $
+          };
+        }),
+        (s) => s.key
+      ), c = !!(e.selected || d.value) && !o.has(e.valueHash);
+      return {
+        columns: a,
+        item: e.item,
+        text: e.text,
+        valueHash: e.valueHash,
+        value: e.value,
+        selected: c,
+        disabled: l
+      };
+    })), T = (e) => {
+      d.value || F(e), o.delete(e.valueHash), u(
+        "update:unselectedItems",
+        t.unselectedItems.filter((l) => p(l) !== p(e.value))
+      );
+    }, _ = (e) => {
+      o.add(e.valueHash), u("update:unselectedItems", [...t.unselectedItems, e.value]), N(e);
+    }, o = L(/* @__PURE__ */ new Set());
+    m(
+      () => t.unselectedItems,
+      () => {
+        o.clear(), t.unselectedItems.forEach((e) => {
+          o.add(p(e));
+        });
+      }
+    );
+    const d = E(t.selectAll);
+    return m(
+      () => t.selectAll,
+      () => {
+        d.value = t.selectAll;
+      }
+    ), m(d, () => {
+      o.clear(), u("update:unselectedItems", []), u("update:modelValue", []);
+    }), (e, l) => (B(), b(g, null, [
+      f.value ? i(e.$slots, "loading", {
+        key: 0,
+        items: R(y)
+      }) : P("", !0),
+      I.value.length ? (B(!0), b(g, { key: 2 }, j(I.value, (a, c) => i(e.$slots, "default", {
+        key: a.valueHash + d.value,
+        checked: a.selected,
+        columns: a.columns,
+        disabled: a.disabled,
+        index: c,
+        item: a.item,
+        select: () => T(a),
+        unselect: () => _(a),
+        value: a.value
+      })), 128)) : i(e.$slots, "no-data", {
+        key: 1,
+        loading: f.value
+      })
+    ], 64));
+  }
+});
+export {
+  oe as default
+};

package/dist/index107.js

@@ -1,131 +1,178 @@
-import { defineComponent as f, ref as v, computed as g, openBlock as y, createBlock as B, withCtx as a, renderSlot as i, normalizeProps as l, guardReactiveProps as r, createVNode as w, mergeProps as $ } from "vue";
+import { defineComponent as f, ref as y, computed as v, createBlock as g, openBlock as B, withCtx as a, createVNode as $, mergeProps as w, renderSlot as n, normalizeProps as l, guardReactiveProps as t } from "vue";
 import T from "./index27.js";
 /* empty css        */
-import V from "./index43.js";
+import V from "./index37.js";
 /* empty css        */
-const E = /* @__PURE__ */ f({
-  __name: "BbSwitchGroup",
+const k = /* @__PURE__ */ f({
+  __name: "BbSelect",
   props: {
+    allowWriting: { type: [Boolean, String], default: !0 },
+    "append:icon": {},
+    autocomplete: {},
     autofocus: {},
-    color: {},
+    clearable: { type: Boolean },
+    comma: { type: Boolean },
     compact: { type: Boolean },
     dependencies: {},
     depsDebounceTime: {},
+    direction: {},
     disabled: { type: Boolean },
     enforceCoherence: { type: Boolean },
     errors: {},
+    filterBy: { type: [String, Array, Boolean, Function, null], default: () => [] },
     hasErrors: { type: Boolean },
     hideLabel: { type: Boolean },
-    hideLegend: { type: Boolean },
     hint: {},
     id: {},
-    inputDirection: {},
-    items: { type: [Array, Function] },
+    items: {},
     itemText: {},
     itemValue: {},
-    legend: {},
+    label: {},
+    labelPosition: {},
+    loading: { type: Boolean },
     loadingText: {},
     max: {},
+    maxSelectedLabels: {},
     modelValue: {},
     modelValueDebounceTime: {},
+    multiple: { type: Boolean },
     name: {},
     noDataText: {},
     persistentHint: { type: Boolean },
+    placeholder: {},
+    prefill: { type: [Boolean, String], default: "focus" },
+    "prepend:icon": {},
+    required: { type: Boolean },
+    queryDebounceTime: {},
     readonly: { type: Boolean },
-    reverse: { type: Boolean }
+    reverse: { type: Boolean },
+    selectedLabelsFn: {},
+    showChevron: { type: Boolean, default: !0 },
+    stash: { type: Boolean },
+    teleportTarget: {},
+    transitionDuration: {},
+    updateOnAnimationFrame: { type: Boolean }
   },
-  emits: ["blur", "change", "click", "focus", "inactive", "input", "keydown", "mousedown", "mouseup", "update:modelValue"],
-  setup(d, { emit: p }) {
-    const m = d, n = p, t = v(!1), u = g(() => m.persistentHint || t.value), c = {
-      onBlur: (e) => n("blur", e),
-      onChange: (e) => n("change", e),
-      onClick: (e) => n("click", e),
+  emits: ["blur", "change", "click", "focus", "inactive", "input", "update:modelValue", "option:add"],
+  setup(d, { emit: m }) {
+    const r = d, i = m, s = y(!1), u = v(() => r.persistentHint || s.value), c = {
+      onBlur: (e) => i("blur", e),
+      onChange: (e) => i("change", e),
+      onClick: (e) => i("click", e),
+      "onOption:add": (e) => i("option:add", e),
       onFocus: (e) => {
-        t.value = !0, n("focus", e);
+        s.value = !0, i("focus", e);
       },
       onInactive: () => {
-        t.value = !1, n("inactive");
+        s.value = !1, i("inactive");
       },
-      onInput: (e) => n("input", e),
-      onKeydown: (e) => n("keydown", e),
-      onMousedown: (e) => n("mousedown", e),
-      onMouseup: (e) => n("mouseup", e),
-      "onUpdate:modelValue": (e) => n("update:modelValue", e)
+      onInput: (e) => i("input", e),
+      "onUpdate:modelValue": (e) => i("update:modelValue", e)
     };
-    return (e, D) => (y(), B(T, {
+    return (e, D) => (B(), g(T, {
       id: e.id,
-      class: "bb-switch-group",
+      class: "bb-select",
       compact: e.compact,
-      direction: "vertical",
+      direction: e.direction,
       errors: e.errors,
       "has-errors": e.hasErrors,
-      "hide-label": e.hideLegend,
+      "hide-label": e.hideLabel,
       hint: e.hint,
-      label: e.legend,
-      "label-tag": "legend",
+      label: e.label,
+      "label-position": e.labelPosition,
+      "model-value": e.modelValue,
       name: e.name,
       reverse: e.reverse,
-      "show-hint": u.value,
-      tag: "fieldset"
+      "show-hint": u.value
     }, {
-      label: a((s) => [
-        i(e.$slots, "legend", l(r(s)))
+      label: a((p) => [
+        n(e.$slots, "label", l(t(p)))
       ]),
-      input: a(({ id: s, hasErrors: h, ariaDescribedby: b }) => [
-        w(V, $({
-          id: s,
-          "aria-describedby": b,
+      input: a(({ id: p, hasErrors: b, ariaDescribedby: h }) => [
+        $(V, w({
+          id: p,
+          "allow-writing": e.allowWriting,
+          "append:icon": r["append:icon"],
+          "aria-describedby": h,
+          autocomplete: e.autocomplete,
           autofocus: e.autofocus,
-          color: e.color,
+          clearable: e.clearable,
+          comma: e.comma,
+          compact: e.compact,
           dependencies: e.dependencies,
           "deps-debounce-time": e.depsDebounceTime,
-          direction: e.inputDirection,
           disabled: e.disabled,
           "enforce-coherence": e.enforceCoherence,
-          "has-errors": h,
-          "hide-label": e.hideLabel,
+          "filter-by": e.filterBy,
+          "has-errors": b,
           "item-text": e.itemText,
           "item-value": e.itemValue,
           items: e.items,
+          loading: e.loading,
           "loading-text": e.loadingText,
           max: e.max,
+          "max-selected-labels": e.maxSelectedLabels,
           "model-value": e.modelValue,
           "model-value-debounce-time": e.modelValueDebounceTime,
+          multiple: e.multiple,
           name: e.name,
           "no-data-text": e.noDataText,
-          readonly: e.readonly
+          placeholder: e.placeholder,
+          prefill: e.prefill,
+          "prepend:icon": r["prepend:icon"],
+          "query-debounce-time": e.queryDebounceTime,
+          readonly: e.readonly,
+          required: e.required,
+          "selected-labels-fn": e.selectedLabelsFn,
+          "show-chevron": e.showChevron,
+          stash: e.stash,
+          "teleport-target": e.teleportTarget,
+          "transition-duration": e.transitionDuration,
+          "update-on-animation-frame": e.updateOnAnimationFrame
         }, c), {
-          prepend: a((o) => [
-            i(e.$slots, "prepend", l(r(o)))
+          "append-outer": a((o) => [
+            n(e.$slots, "append-outer", l(t(o)))
+          ]),
+          append: a((o) => [
+            n(e.$slots, "append", l(t(o)))
+          ]),
+          prefix: a((o) => [
+            n(e.$slots, "prefix", l(t(o)))
+          ]),
+          chevron: a((o) => [
+            n(e.$slots, "chevron", l(t(o)))
           ]),
           loading: a((o) => [
-            i(e.$slots, "loading", l(r(o)))
+            n(e.$slots, "loading", l(t(o)))
           ]),
           "no-data": a((o) => [
-            i(e.$slots, "no-data", l(r(o)))
+            n(e.$slots, "no-data", l(t(o)))
           ]),
-          "option:prepend": a((o) => [
-            i(e.$slots, "option:prepend", l(r(o)))
+          option: a((o) => [
+            n(e.$slots, "option", l(t(o)))
           ]),
-          icon: a((o) => [
-            i(e.$slots, "icon", l(r(o)))
+          "options:append": a((o) => [
+            n(e.$slots, "options:append", l(t(o)))
           ]),
-          label: a((o) => [
-            i(e.$slots, "label", l(r(o)))
+          "options:prepend": a((o) => [
+            n(e.$slots, "options:prepend", l(t(o)))
           ]),
-          "option:append": a((o) => [
-            i(e.$slots, "option:append", l(r(o)))
+          "prepend-outer": a((o) => [
+            n(e.$slots, "prepend-outer", l(t(o)))
           ]),
-          append: a((o) => [
-            i(e.$slots, "append", l(r(o)))
+          prepend: a((o) => [
+            n(e.$slots, "prepend", l(t(o)))
+          ]),
+          suffix: a((o) => [
+            n(e.$slots, "suffix", l(t(o)))
           ]),
           _: 2
-        }, 1040, ["id", "aria-describedby", "autofocus", "color", "dependencies", "deps-debounce-time", "direction", "disabled", "enforce-coherence", "has-errors", "hide-label", "item-text", "item-value", "items", "loading-text", "max", "model-value", "model-value-debounce-time", "name", "no-data-text", "readonly"])
+        }, 1040, ["id", "allow-writing", "append:icon", "aria-describedby", "autocomplete", "autofocus", "clearable", "comma", "compact", "dependencies", "deps-debounce-time", "disabled", "enforce-coherence", "filter-by", "has-errors", "item-text", "item-value", "items", "loading", "loading-text", "max", "max-selected-labels", "model-value", "model-value-debounce-time", "multiple", "name", "no-data-text", "placeholder", "prefill", "prepend:icon", "query-debounce-time", "readonly", "required", "selected-labels-fn", "show-chevron", "stash", "teleport-target", "transition-duration", "update-on-animation-frame"])
       ]),
       _: 3
-    }, 8, ["id", "compact", "errors", "has-errors", "hide-label", "hint", "label", "name", "reverse", "show-hint"]));
+    }, 8, ["id", "compact", "direction", "errors", "has-errors", "hide-label", "hint", "label", "label-position", "model-value", "name", "reverse", "show-hint"]));
   }
 });
 export {
-  E as default
+  k as default
 };