bitboss-ui 2.1.119 → 2.1.121

package/dist/index20.js

@@ -1,196 +1,9 @@
-import { defineComponent as z, ref as B, toRef as p, computed as R, createBlock as W, openBlock as K, unref as T, withCtx as n, renderSlot as l, normalizeProps as f, guardReactiveProps as h, createVNode as N, mergeProps as C } from "vue";
-import U from "./index18.js";
-/* empty css        */
-import q from "./index282.js";
-/* empty css         */
-import { useItemsGetter as J } from "./index247.js";
-import { useIndexById as $ } from "./index246.js";
-import { useBaseOptions as Q } from "./index243.js";
-import { useCoherence as X } from "./index244.js";
-import { hash as Y } from "./index238.js";
-import { useHashedWatcher as w } from "./index245.js";
-import { usePrefill as Z } from "./index248.js";
-import { useLogger as _ } from "./index267.js";
-const fe = /* @__PURE__ */ z({
-  __name: "BaseCheckboxGroup",
-  props: {
-    ariaDescribedby: {},
-    autofocus: {},
-    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: {},
-    max: { default: 1 / 0 },
-    modelValue: {},
-    multiple: { type: Boolean, default: !0 },
-    modelValueDebounceTime: { default: 0 },
-    name: {},
-    noDataText: {},
-    readonly: { type: Boolean }
-  },
-  emits: ["blur", "change", "click", "focus", "inactive", "input", "keydown", "mousedown", "mouseup", "update:modelValue"],
-  setup(I, { emit: D }) {
-    const o = I, t = D, L = _();
-    o.multiple && !Array.isArray(o.modelValue) && L.throw(
-      'BaseCheckboxGroup: multiple is set to "true" but modelValue is not an array.'
-    );
-    const r = B(), u = B(!1), {
-      getter: d,
-      items: E,
-      loading: H
-    } = J({
-      items: p(o, "items"),
-      debounce: 0
-    }), c = () => {
-      o.enforceCoherence && !v.value && t("update:modelValue", O.value);
-    }, { hasPrefilled: x } = Z({
-      trigger: !0,
-      currentValue: o.modelValue,
-      multiple: o.multiple,
-      fn: async (e) => {
-        await d(e, o.modelValue), c();
-      }
-    }), { data: b } = $({
-      items: R(() => [].concat(o.modelValue))
-    }), { options: y } = Q({
-      disabled: p(o, "disabled"),
-      items: E,
-      itemText: o.itemText,
-      itemValue: o.itemValue,
-      max: o.max,
-      selectable: !0,
-      selectedIndexedByHash: b
-    }), P = async (e) => {
-      if (o.multiple) {
-        t("update:modelValue", [].concat(o.modelValue).concat(e.value));
-        return;
-      }
-      t("update:modelValue", e.value);
-    }, F = async (e) => {
-      if (!o.multiple) {
-        t("update:modelValue", null);
-        return;
-      }
-      const s = { ...b.value };
-      delete s[e.valueHash], t("update:modelValue", Object.values(s));
-    }, { data: M } = $({
-      items: y,
-      key: "valueHash"
-    }), { coherent: v, coherentValue: O } = X({
-      modelValue: p(o, "modelValue"),
-      multiple: o.multiple,
-      iteratee: (e) => !!M.value[Y(e)]
-    });
-    let i = 0;
-    w(
-      () => o.modelValue,
-      async () => {
-        i++, v.value || (await d(!1, o.modelValue), c()), i--;
-      },
-      {
-        debounce: o.modelValueDebounceTime
-      }
-    ), w(
-      () => [o.dependencies, o.items],
-      async () => {
-        x.value && (i++, await d(!1, o.modelValue), i === 1 && c(), i--);
-      },
-      {
-        debounce: o.depsDebounceTime
-      }
-    );
-    const A = (e) => {
-      if (o.id)
-        return [o.id, e.valueHash].filter(Boolean).join("-");
-    }, G = (e, s) => {
-      t("change", e), s.selected ? F(s) : P(s);
-    }, S = {
-      onBlur: (e) => t("blur", e),
-      onClick: (e) => t("click", e),
-      onFocus: (e) => {
-        t("focus", e), u.value || (document.addEventListener("focusin", V, { passive: !0 }), document.addEventListener("click", k, { passive: !0 }), u.value = !0);
-      },
-      onInput: (e) => t("input", e),
-      onKeydown: (e) => t("keydown", e),
-      onMousedown: (e) => t("mousedown", e),
-      onMouseup: (e) => t("mouseup", e)
-    }, g = () => {
-      t("inactive"), u.value = !1, document.removeEventListener("focusin", V), document.removeEventListener("click", k);
-    }, V = (e) => {
-      e.target instanceof HTMLElement && (r.value?.$el.contains(e.target) || g());
-    }, k = (e) => {
-      e.target instanceof HTMLElement && (r.value?.$el.contains(e.target) || g());
-    };
-    return (e, s) => (K(), W(q, {
-      ref_key: "container",
-      ref: r,
-      class: "bb-base-checkbox-group",
-      direction: e.direction,
-      "has-errors": e.hasErrors,
-      "hide-label": e.hideLabel,
-      loading: !!T(H),
-      "loading-text": e.loadingText,
-      "no-data-text": e.noDataText,
-      options: T(y)
-    }, {
-      prepend: n(() => [
-        l(e.$slots, "prepend")
-      ]),
-      loading: n(() => [
-        l(e.$slots, "loading")
-      ]),
-      "no-data": n(() => [
-        l(e.$slots, "no-data")
-      ]),
-      label: n((a) => [
-        l(e.$slots, "label", f(h(a)))
-      ]),
-      "option:prepend": n((a) => [
-        l(e.$slots, "option:prepend", f(h(a)))
-      ]),
-      input: n(({ option: a, index: j }) => [
-        N(U, C({
-          id: A(a),
-          "aria-describedby": e.ariaDescribedby,
-          autofocus: e.autofocus && !j,
-          checked: a.selected,
-          color: e.color,
-          disabled: a.disabled,
-          "has-errors": e.hasErrors,
-          name: e.name,
-          readonly: e.readonly,
-          "true-value": a.value
-        }, S, {
-          onChange: (m) => G(m, a)
-        }), {
-          icon: n((m) => [
-            l(e.$slots, "icon", C({
-              item: a.item,
-              text: a.text
-            }, m))
-          ]),
-          _: 2
-        }, 1040, ["id", "aria-describedby", "autofocus", "checked", "color", "disabled", "has-errors", "name", "readonly", "true-value", "onChange"])
-      ]),
-      "option:append": n((a) => [
-        l(e.$slots, "option:append", f(h(a)))
-      ]),
-      append: n(() => [
-        l(e.$slots, "append")
-      ]),
-      _: 3
-    }, 8, ["direction", "has-errors", "hide-label", "loading", "loading-text", "no-data-text", "options"]));
-  }
-});
-export {
-  fe as default
+import { urlAlphabet as e } from "./index19.js";
+//#region node_modules/nanoid/index.browser.js
+var t = (t = 21) => {
+	let n = "", r = crypto.getRandomValues(new Uint8Array(t |= 0));
+	for (; t--;) n += e[r[t] & 63];
+	return n;
 };
+//#endregion
+export { t as nanoid };

package/dist/index200.js

@@ -1,5 +1,6 @@
-import o from "./index103.js";
+import e from "./index198.js";
 /* empty css         */
-export {
-  o as default
-};
+//#region src/components/BaseSwitchGroup/BaseSwitchGroup.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/index201.js

@@ -1,5 +1,224 @@
-import o from "./index105.js";
-/* empty css         */
-export {
-  o as default
-};
+import e from "./index71.js";
+import t from "./index74.js";
+import { useIndexById as n } from "./index90.js";
+import { useBaseOptions as r } from "./index93.js";
+import { last as i } from "./index105.js";
+import { isEmpty as a } from "./index132.js";
+import o from "./index163.js";
+import ee from "./index171.js";
+import s from "./index174.js";
+import { Fragment as c, computed as l, createBlock as u, createCommentVNode as d, createElementBlock as f, createElementVNode as p, createVNode as m, defineComponent as h, mergeProps as g, nextTick as _, normalizeClass as v, openBlock as y, ref as b, renderSlot as x, toRef as S, unref as C, vModelText as w, watch as T, withCtx as E, withDirectives as D, withKeys as O, withModifiers as k } from "vue";
+//#region src/components/BaseTag/BaseTag.vue?vue&type=script&setup=true&lang.ts
+var te = { class: "bb-base-tag__input-container" }, A = [
+	"id",
+	"aria-describedby",
+	"autocomplete",
+	"autofocus",
+	"disabled",
+	"placeholder",
+	"readonly",
+	"required",
+	"onKeydown"
+], j = /* @__PURE__ */ h({
+	__name: "BaseTag",
+	props: {
+		"append:icon": {},
+		ariaDescribedby: {},
+		autocomplete: { default: "off" },
+		autofocus: {},
+		comma: { type: Boolean },
+		clearable: { type: Boolean },
+		compact: { type: Boolean },
+		disabled: { type: Boolean },
+		divider: { default: "Enter" },
+		hasErrors: { type: Boolean },
+		id: {},
+		loading: { type: Boolean },
+		max: {},
+		modelValue: {},
+		multiple: {
+			type: Boolean,
+			default: !0
+		},
+		name: {},
+		placeholder: {},
+		"prepend:icon": {},
+		readonly: { type: Boolean },
+		required: { type: Boolean }
+	},
+	emits: [
+		"blur",
+		"change",
+		"click",
+		"duplicate",
+		"focus",
+		"inactive",
+		"input",
+		"keydown",
+		"keyup",
+		"update:modelValue"
+	],
+	setup(h, { emit: j }) {
+		let M = h, N = j;
+		if (M.multiple && !Array.isArray(M.modelValue)) throw Error("Multiple is set to \"true\" but modelValue is not an array.");
+		let P = b(null), F = b(null), I = b(null), L = b(null), R = l(() => M.comma ? I.value : L.value), z = b(null), B = () => {
+			z.value instanceof HTMLInputElement && z.value.focus();
+		}, V = b(""), H = l(() => G.value.filter((e) => e.selected)), { data: U, get: W } = n({ items: S(M, "modelValue") }), { options: G } = r({
+			disabled: S(M, "disabled"),
+			items: l(() => [].concat(M.modelValue)),
+			itemText: void 0,
+			itemValue: void 0,
+			max: M.max,
+			selectable: !0,
+			selectedIndexedByHash: U
+		}), K = () => {
+			if (M.multiple) {
+				V.value = "";
+				return;
+			}
+			let e;
+			H.value && (e = i(H.value)), V.value = e?.text || "";
+		}, q = async (e) => {
+			if (M.multiple) {
+				let t = { ...U.value };
+				delete t[e.valueHash], N("update:modelValue", Object.values(t));
+			} else N("update:modelValue", null);
+			B();
+		};
+		T(() => M.modelValue, async () => {
+			K();
+		});
+		let J = b(!1), Y = () => {
+			J.value = !0;
+		}, X = () => {
+			J.value = !1, N("inactive");
+		}, Z = l(() => !(M.readonly || M.disabled || !R.value && M.multiple)), ne = (e) => {
+			Z.value && (!M.multiple || V.value || (e.preventDefault(), H.value.length && R.value?.focusPrevious()));
+		}, re = (e) => {
+			Z.value && (!M.multiple || V.value || (e.preventDefault(), H.value.length && R.value?.focusNext()));
+		}, ie = async () => {
+			!Z.value || V.value || !H.value.length || (R.value?.getHighlighted() && R.value.confirmOption(), await _(), R.value?.focusPrevious());
+		}, ae = () => {
+			R.value?.blur();
+		}, oe = async (e) => {
+			if (N("keydown", e), M.readonly || M.disabled) {
+				e.preventDefault();
+				return;
+			}
+			if (/^[A-Za-z0-9]$/.test(e.key) && R.value?.blur(), e.key === M.divider || e.key === "Unidentified" && V.value.includes(M.divider)) {
+				if (M.divider.length === 1 && V.value.includes(M.divider)) {
+					let e = V.value.split(M.divider)[0];
+					if (e) V.value = e;
+					else {
+						V.value = "";
+						return;
+					}
+				}
+				if (!V.value) {
+					N("keydown", e);
+					return;
+				}
+				if (e.preventDefault(), W(V.value)) N("duplicate", V.value), V.value = "";
+				else if (M.max && H.value.length >= M.max) return;
+				else M.multiple ? N("update:modelValue", M.modelValue.concat(V.value)) : N("update:modelValue", V.value);
+			}
+		}, se = (e) => {
+			N("focus", e), Y(), document.addEventListener("click", $), document.addEventListener("focusin", $);
+		}, Q = (e) => {
+			N("click", e), !(M.disabled || M.readonly) && z.value instanceof HTMLElement && z.value.focus();
+		}, $ = async (e) => {
+			if (e.target instanceof Node && P.value && !P.value.$el.contains(e.target)) {
+				X(), document.removeEventListener("click", $), document.removeEventListener("focusin", $), K();
+				return;
+			}
+		}, ce = {
+			onBlur: (e) => N("blur", e),
+			onChange: (e) => N("change", e),
+			onKeyup: (e) => N("keyup", e),
+			onInput: (e) => N("input", e)
+		}, le = () => {
+			let e = null;
+			M.multiple && (e = []), N("update:modelValue", e);
+		};
+		return (n, r) => (y(), u(t, {
+			ref_key: "outerContainer",
+			ref: P,
+			class: v({
+				"bb-base-tag": !0,
+				"bb-base-tag--active": J.value,
+				"bb-base-tag--disabled": n.disabled,
+				"bb-base-tag--loading": n.loading,
+				"bb-base-tag--errors": n.hasErrors,
+				"bb-base-tag--readonly": n.readonly,
+				"bb-base-tag--compact": n.compact
+			}),
+			onClick: Q
+		}, {
+			"prepend-outer": E(() => [x(n.$slots, "prepend-outer")]),
+			"append-outer": E(() => [x(n.$slots, "append-outer")]),
+			default: E(() => [m(e, {
+				ref_key: "innerContainer",
+				ref: F,
+				"append:icon": M["append:icon"],
+				clearable: n.clearable && !C(a)(n.modelValue),
+				"prepend:icon": M["prepend:icon"],
+				"prevent-focus": !0,
+				"onClick:clear": le
+			}, {
+				prepend: E(() => [x(n.$slots, "prepend")]),
+				prefix: E(() => [x(n.$slots, "prefix")]),
+				append: E(() => [x(n.$slots, "append")]),
+				suffix: E(() => [x(n.$slots, "suffix")]),
+				default: E(() => [m(o, { tag: "span" }, {
+					default: E(() => [p("span", te, [n.multiple ? (y(), f(c, { key: 0 }, [n.comma ? (y(), u(s, {
+						key: 0,
+						ref_key: "commaBox",
+						ref: I,
+						options: H.value
+					}, null, 8, ["options"])) : (y(), u(ee, {
+						key: 1,
+						ref_key: "chipsBox",
+						ref: L,
+						options: H.value,
+						"onOption:unselected": q
+					}, null, 8, ["options"]))], 64)) : d("", !0), D(p("input", g({
+						id: n.id,
+						ref_key: "input",
+						ref: z
+					}, ce, {
+						"onUpdate:modelValue": r[0] ||= (e) => V.value = e,
+						"aria-describedby": n.ariaDescribedby,
+						autocomplete: n.autocomplete,
+						autofocus: n.autofocus,
+						class: "bb-base-tag__text-input",
+						disabled: n.disabled,
+						enterkeyhint: "done",
+						placeholder: n.placeholder,
+						readonly: n.readonly,
+						required: n.required && (!n.multiple || !n.modelValue.length),
+						size: "1",
+						style: { "--characters": V.value.length },
+						type: "text",
+						onFocus: k(se, ["stop"]),
+						onKeydown: [
+							k(oe, ["stop"]),
+							O(k(ie, ["stop"]), ["delete"]),
+							O(k(ne, ["stop"]), ["left"]),
+							O(k(ae, ["stop", "prevent"]), ["esc"]),
+							O(k(re, ["stop"]), ["right"])
+						]
+					}), null, 16, A), [[w, V.value]])])]),
+					_: 1
+				})]),
+				_: 3
+			}, 8, [
+				"append:icon",
+				"clearable",
+				"prepend:icon"
+			])]),
+			_: 3
+		}, 8, ["class"]));
+	}
+});
+//#endregion
+export { j as default };

package/dist/index203.js

@@ -1,4 +1,6 @@
-import f from "./index109.js";
-export {
-  f as default
-};
+import e from "./index201.js";
+/* empty css         */
+//#region src/components/BaseTag/BaseTag.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/index204.js

@@ -1,5 +1,135 @@
-import o from "./index110.js";
-/* empty css         */
-export {
-  o as default
-};
+import { isNotNil as e } from "./index26.js";
+import t from "./index71.js";
+import n from "./index74.js";
+import r from "./index163.js";
+import { computed as i, createBlock as a, createElementVNode as o, createVNode as s, defineComponent as c, mergeProps as l, nextTick as u, normalizeClass as d, onMounted as f, openBlock as p, ref as m, renderSlot as h, unref as g, watch as _, withCtx as v } from "vue";
+//#region src/components/BaseTextarea/BaseTextarea.vue?vue&type=script&setup=true&lang.ts
+var y = [
+	"id",
+	"aria-describedby",
+	"autocomplete",
+	"autofocus",
+	"disabled",
+	"name",
+	"placeholder",
+	"readonly",
+	"required",
+	"rows",
+	"value"
+], b = /* @__PURE__ */ c({
+	__name: "BaseTextarea",
+	props: {
+		"append:icon": {},
+		ariaDescribedby: {},
+		autocomplete: {},
+		autoGrow: { type: Boolean },
+		autofocus: {},
+		clearable: { type: Boolean },
+		compact: { type: Boolean },
+		disabled: { type: Boolean },
+		hasErrors: { type: Boolean },
+		id: {},
+		loading: { type: Boolean },
+		modelValue: {},
+		name: {},
+		placeholder: {},
+		"prepend:icon": {},
+		readonly: { type: Boolean },
+		required: { type: Boolean },
+		rows: {}
+	},
+	emits: [
+		"blur",
+		"change",
+		"click",
+		"focus",
+		"input",
+		"keydown",
+		"mousedown",
+		"mouseup",
+		"update:modelValue"
+	],
+	setup(c, { emit: b }) {
+		let x = c, S = b;
+		if (x.rows && x.autoGrow) throw Error("Textarea: You cannot set rows and auto-grow attributes together. You either use rows and let the user resize or define a minimum height in CSS with auto-grow.");
+		let C = m(null), w = i(() => ({
+			"bb-base-textarea": !0,
+			"bb-base-textarea--auto-grow": x.autoGrow,
+			"bb-base-textarea--disabled": x.disabled,
+			"bb-base-textarea--errors": x.hasErrors,
+			"bb-base-textarea--loading": x.loading,
+			"bb-base-textarea--readonly": x.readonly,
+			"bb-base-textarea--compact": x.compact
+		})), T = i(() => x.modelValue ? x.modelValue : "");
+		f(() => {
+			x.autoGrow && x.modelValue && k();
+		}), _(() => x.modelValue, () => {
+			x.autoGrow && u(k);
+		});
+		function E(e) {
+			if (e.stopPropagation(), e.target instanceof HTMLTextAreaElement) {
+				let t = e.target.value;
+				S("input", e), S("update:modelValue", t || null);
+			}
+		}
+		function D(e) {
+			e.stopPropagation(), e.target instanceof HTMLTextAreaElement && S("keydown", e);
+		}
+		let O = {
+			onBlur: (e) => S("blur", e),
+			onChange: (e) => S("change", e),
+			onClick: (e) => S("click", e),
+			onFocus: (e) => S("focus", e),
+			onMousedown: (e) => S("mousedown", e),
+			onMouseup: (e) => S("mouseup", e)
+		};
+		function k() {
+			C.value && (C.value.style.height = "0px", C.value.style.height = `${C.value.scrollHeight}px`);
+		}
+		return (i, c) => (p(), a(n, { class: d(w.value) }, {
+			"prepend-outer": v(() => [h(i.$slots, "prepend-outer")]),
+			"append-outer": v(() => [h(i.$slots, "append-outer")]),
+			default: v(() => [s(t, {
+				"append:icon": x["append:icon"],
+				clearable: i.clearable && g(e)(i.modelValue),
+				"prepend:icon": x["prepend:icon"],
+				"onClick:clear": c[0] ||= (e) => i.$emit("update:modelValue", null)
+			}, {
+				prepend: v(() => [h(i.$slots, "prepend")]),
+				prefix: v(() => [h(i.$slots, "prefix")]),
+				append: v(() => [h(i.$slots, "append")]),
+				suffix: v(() => [h(i.$slots, "suffix")]),
+				default: v(() => [s(r, { tag: "span" }, {
+					default: v(() => [o("textarea", l({
+						id: i.id,
+						ref_key: "textarea",
+						ref: C,
+						"aria-describedby": i.ariaDescribedby,
+						autocomplete: i.autocomplete,
+						autofocus: i.autofocus,
+						class: "bb-base-textarea__input scrollbar-border",
+						disabled: i.disabled,
+						name: i.name,
+						placeholder: i.placeholder,
+						readonly: i.readonly,
+						required: i.required,
+						rows: i.rows,
+						value: T.value
+					}, O, {
+						onInput: E,
+						onKeydown: D
+					}), null, 16, y)]),
+					_: 1
+				})]),
+				_: 3
+			}, 8, [
+				"append:icon",
+				"clearable",
+				"prepend:icon"
+			])]),
+			_: 3
+		}, 8, ["class"]));
+	}
+});
+//#endregion
+export { b as default };

package/dist/index206.js

@@ -1,5 +1,6 @@
-import o from "./index114.js";
+import e from "./index204.js";
 /* empty css         */
-export {
-  o as default
-};
+//#region src/components/BaseTextarea/BaseTextarea.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/index207.js

@@ -1,5 +1,5 @@
-import o from "./index116.js";
-/* empty css         */
-export {
-  o as default
-};
+import { isEmpty as e } from "./index132.js";
+//#region src/utilities/functions/isNotEmpty.ts
+var t = (t) => !e(t);
+//#endregion
+export { t as isNotEmpty };