bitboss-ui 2.1.134 → 2.1.136

package/dist/index83.js

@@ -1,141 +0,0 @@
-import { isCssColor as e } from "./index78.js";
-import { booleanishToBoolean as t } from "./index79.js";
-import { isEqual as n } from "./index82.js";
-import { computed as r, createCommentVNode as i, createElementBlock as a, createElementVNode as o, defineComponent as s, guardReactiveProps as c, mergeProps as l, normalizeProps as u, openBlock as d, ref as f, renderSlot as p, watch as m } from "vue";
-//#region src/components/BaseCheckbox/BaseCheckbox.vue?vue&type=script&setup=true&lang.ts
-var h = {
-	"aria-hidden": "true",
-	class: "bb-base-checkbox-container"
-}, g = {
-	class: "bb-base-checkbox-container__icon",
-	viewBox: "276.411 158.834 114.971 114.97"
-}, _ = {
-	key: 0,
-	d: "M 310 216 L 358 216",
-	fill: "none",
-	"stroke-linecap": "round",
-	"stroke-width": "14px"
-}, v = {
-	key: 1,
-	d: "M 297.574 224.786 L 318.309 243.134 L 371.568 189.232",
-	fill: "none",
-	"stroke-linecap": "round",
-	"stroke-width": "14px"
-}, y = /* @__PURE__ */ s({
-	__name: "BaseCheckbox",
-	props: {
-		ariaDescribedby: {},
-		autofocus: {},
-		checked: { type: [Boolean, String] },
-		color: {},
-		disabled: { type: Boolean },
-		falseValue: { default: !1 },
-		hasErrors: { type: Boolean },
-		id: {},
-		indeterminate: {},
-		modelValue: {},
-		name: {},
-		readonly: { type: Boolean },
-		required: { type: Boolean },
-		submitWhenFalse: { type: Boolean },
-		trueValue: { default: !0 }
-	},
-	emits: [
-		"blur",
-		"change",
-		"click",
-		"focus",
-		"input",
-		"keydown",
-		"mousedown",
-		"mouseup",
-		"update:modelValue"
-	],
-	setup(s, { emit: y }) {
-		let b = s, x = y, S = f(null), C = r(() => b.checked ? t(b.checked) : n(b.trueValue, b.modelValue)), w = r(() => {
-			let e = b.indeterminate;
-			return e === "" ? !0 : e === !0 || e === "true";
-		}), T = f(!1), E = f(!1), D = (e) => {
-			T.value = !1, E.value = !1, x("blur", e);
-		}, O = (e) => {
-			if (e.target instanceof HTMLInputElement) {
-				let t = e.target.checked ? b.trueValue : b.falseValue;
-				x("change", e), x("update:modelValue", t);
-			}
-		}, k = (e) => {
-			T.value = !0, e.target instanceof HTMLInputElement && (E.value = e.target.matches(":focus-visible")), x("focus", e);
-		}, A = r(() => {
-			let t = { class: {
-				"bb-base-checkbox": !0,
-				"bb-base-checkbox--disabled": b.disabled,
-				"bb-base-checkbox--errors": b.hasErrors,
-				"bb-base-checkbox--indeterminate": w.value,
-				"bb-base-checkbox--readonly": b.readonly,
-				[`bb-base-checkbox--${b.color}`]: b.color && !e(b.color)
-			} };
-			return b.color && e(b.color) && (t.style = `--color: ${b.color}`), t;
-		}), j = (e) => typeof e == "string" ? e : JSON.stringify(e), M = r(() => {
-			let e = j(b.falseValue);
-			return {
-				disabled: b.disabled,
-				name: b.name,
-				type: "hidden",
-				value: e
-			};
-		}), N = {
-			onBlur: D,
-			onChange: O,
-			onFocus: k,
-			onClick: (e) => x("click", e),
-			onInput: (e) => x("input", e),
-			onKeydown: (e) => x("keydown", e),
-			onMousedown: (e) => x("mousedown", e),
-			onMouseup: (e) => x("mouseup", e)
-		}, P = r(() => {
-			let e = j(b.trueValue);
-			return {
-				"aria-describedby": b.ariaDescribedby,
-				autofocus: b.autofocus,
-				checked: C.value,
-				disabled: b.disabled || b.readonly,
-				id: b.id,
-				indeterminate: w.value,
-				name: b.name,
-				required: b.required,
-				tabindex: b.disabled ? -1 : void 0,
-				type: "checkbox",
-				value: e,
-				...N
-			};
-		}), F = r(() => ({
-			checked: C.value,
-			disabled: !!b.disabled,
-			falseValue: b.falseValue,
-			focused: T.value,
-			focusVisible: E.value,
-			hasErrors: !!b.hasErrors,
-			id: b.id,
-			name: b.name,
-			parsedValue: P.value.value,
-			readonly: !!b.readonly,
-			trueValue: b.trueValue,
-			value: C.value ? b.trueValue : b.falseValue
-		}));
-		return m(() => [
-			b.modelValue,
-			b.checked,
-			b.indeterminate
-		], () => {
-			S.value && (S.value.indeterminate = w.value);
-		}), (e, t) => (d(), a("span", u(c(A.value)), [
-			!C.value && e.submitWhenFalse ? (d(), a("input", u(l({ key: 0 }, M.value)), null, 16)) : i("", !0),
-			o("input", l(P.value, {
-				ref_key: "checkboxInput",
-				ref: S
-			}), null, 16),
-			o("span", h, [p(e.$slots, "icon", u(c(F.value)), () => [(d(), a("svg", g, [w.value ? (d(), a("path", _)) : (d(), a("path", v))]))])])
-		], 16));
-	}
-});
-//#endregion
-export { y as default };

package/dist/index85.js

@@ -1,6 +0,0 @@
-import e from "./index83.js";
-/* empty css        */
-//#region src/components/BaseCheckbox/BaseCheckbox.vue
-var t = e;
-//#endregion
-export { t as default };

package/dist/index89.js

@@ -1,30 +0,0 @@
-import { useDebounceFn as e } from "./index13.js";
-import { computed as t, ref as n, unref as r } from "vue";
-//#region src/composables/useItemsGetter.ts
-var i = (i) => {
-	let a = t(() => r(i.items)), o = n([]), s = n(0), c = 0, l = async (...e) => {
-		if (Array.isArray(a.value)) {
-			o.value = a.value;
-			return;
-		}
-		if (typeof a.value != "function") return;
-		let t = ++c;
-		s.value++;
-		try {
-			let n = await a.value(...e);
-			t === c && (o.value = n);
-		} catch (e) {
-			console.error(e);
-		} finally {
-			s.value--;
-		}
-	};
-	return {
-		getter: l,
-		debouncedGetter: e(l, i.debounce || 0),
-		items: o,
-		loading: t(() => s.value > 0)
-	};
-};
-//#endregion
-export { i as useItemsGetter };

package/dist/index92.js

@@ -1,9 +0,0 @@
-import { get as e } from "./index41.js";
-//#region src/composables/useItemValue.ts
-var t = () => ({ getItemValue(t, n) {
-	if (n === void 0) return t;
-	if (typeof n == "function") return n(t);
-	if (typeof n == "string") return e(t, n);
-} });
-//#endregion
-export { t as useItemValue };

package/dist/index94.js

@@ -1,4 +0,0 @@
-//#region src/utilities/functions/isNil.ts
-var e = (e) => e == null;
-//#endregion
-export { e as isNil };

package/dist/index96.js

@@ -1,10 +0,0 @@
-import { watchDebounced as e } from "./index13.js";
-import { hash as t } from "./index81.js";
-//#region src/composables/useHashedWatcher.ts
-var n = (n, r, i) => {
-	e(n, (e, n) => {
-		t(e) !== t(n) && r(e, n);
-	}, i);
-};
-//#endregion
-export { n as useHashedWatcher };

package/dist/index98.js

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