@shtabapp/ui-kit 1.85.0 → 1.85.2

package/dist/components/SSelect/utils/buildSelectListItemProps.cjs

@@ -0,0 +1,18 @@
+const require_resolveListItemFields = require("../../SList/utils/resolveListItemFields.cjs");
+//#region src/components/SSelect/utils/buildSelectListItemProps.ts
+var buildSelectListItemProps = ({ listItemScope, itemTitle, itemSubtitle, itemDisabled, itemIconLeft, listActiveKey, isOptionSelected }) => {
+	const optionItem = listItemScope.item;
+	return {
+		rowKey: listItemScope.key,
+		title: require_resolveListItemFields.resolveListItemStringField(optionItem, itemTitle),
+		subtitle: require_resolveListItemFields.resolveListItemStringField(optionItem, itemSubtitle),
+		disabled: require_resolveListItemFields.resolveListItemBooleanField(optionItem, itemDisabled),
+		iconLeft: require_resolveListItemFields.resolveListItemIconField(optionItem, itemIconLeft),
+		selected: isOptionSelected,
+		active: listActiveKey === listItemScope.key,
+		revealRight: listItemScope.revealRight,
+		tiny: true
+	};
+};
+//#endregion
+exports.buildSelectListItemProps = buildSelectListItemProps;

package/dist/components/SSelect/utils/buildSelectListItemProps.js

@@ -0,0 +1,18 @@
+import { resolveListItemBooleanField, resolveListItemIconField, resolveListItemStringField } from "../../SList/utils/resolveListItemFields.js";
+//#region src/components/SSelect/utils/buildSelectListItemProps.ts
+var buildSelectListItemProps = ({ listItemScope, itemTitle, itemSubtitle, itemDisabled, itemIconLeft, listActiveKey, isOptionSelected }) => {
+	const optionItem = listItemScope.item;
+	return {
+		rowKey: listItemScope.key,
+		title: resolveListItemStringField(optionItem, itemTitle),
+		subtitle: resolveListItemStringField(optionItem, itemSubtitle),
+		disabled: resolveListItemBooleanField(optionItem, itemDisabled),
+		iconLeft: resolveListItemIconField(optionItem, itemIconLeft),
+		selected: isOptionSelected,
+		active: listActiveKey === listItemScope.key,
+		revealRight: listItemScope.revealRight,
+		tiny: true
+	};
+};
+//#endregion
+export { buildSelectListItemProps };

package/dist/components/SSelect/utils/resolveSelectItemValue.cjs

@@ -0,0 +1,35 @@
+//#region src/components/SSelect/utils/resolveSelectItemValue.ts
+var isSelectableFieldValue = (value) => {
+	return typeof value === "string" || typeof value === "number";
+};
+var resolveSelectItemValue = (item, fieldKey) => {
+	const fieldValue = item[fieldKey];
+	if (isSelectableFieldValue(fieldValue)) return fieldValue;
+};
+var formatSelectListKey = (value) => {
+	if (typeof value === "string") return value;
+	return String(value);
+};
+var isPresentSelectValue = (value) => {
+	if (value === void 0 || value === null) return false;
+	if (typeof value === "string") return value.length > 0;
+	return true;
+};
+var findSelectItemByListKey = (listKey, optionItems, itemValueKey) => {
+	return optionItems.find((optionItem) => formatSelectListKey(resolveSelectItemValue(optionItem, itemValueKey) ?? "") === listKey);
+};
+var isSelectItemRecord = (value) => {
+	return typeof value === "object" && value !== null;
+};
+var resolveValueFromListKey = (listKey, optionItems, itemValueKey) => {
+	const matchedOption = findSelectItemByListKey(listKey, optionItems, itemValueKey);
+	if (!matchedOption) return;
+	return resolveSelectItemValue(matchedOption, itemValueKey);
+};
+//#endregion
+exports.findSelectItemByListKey = findSelectItemByListKey;
+exports.formatSelectListKey = formatSelectListKey;
+exports.isPresentSelectValue = isPresentSelectValue;
+exports.isSelectItemRecord = isSelectItemRecord;
+exports.resolveSelectItemValue = resolveSelectItemValue;
+exports.resolveValueFromListKey = resolveValueFromListKey;

package/dist/components/SSelect/utils/resolveSelectItemValue.js

@@ -0,0 +1,30 @@
+//#region src/components/SSelect/utils/resolveSelectItemValue.ts
+var isSelectableFieldValue = (value) => {
+	return typeof value === "string" || typeof value === "number";
+};
+var resolveSelectItemValue = (item, fieldKey) => {
+	const fieldValue = item[fieldKey];
+	if (isSelectableFieldValue(fieldValue)) return fieldValue;
+};
+var formatSelectListKey = (value) => {
+	if (typeof value === "string") return value;
+	return String(value);
+};
+var isPresentSelectValue = (value) => {
+	if (value === void 0 || value === null) return false;
+	if (typeof value === "string") return value.length > 0;
+	return true;
+};
+var findSelectItemByListKey = (listKey, optionItems, itemValueKey) => {
+	return optionItems.find((optionItem) => formatSelectListKey(resolveSelectItemValue(optionItem, itemValueKey) ?? "") === listKey);
+};
+var isSelectItemRecord = (value) => {
+	return typeof value === "object" && value !== null;
+};
+var resolveValueFromListKey = (listKey, optionItems, itemValueKey) => {
+	const matchedOption = findSelectItemByListKey(listKey, optionItems, itemValueKey);
+	if (!matchedOption) return;
+	return resolveSelectItemValue(matchedOption, itemValueKey);
+};
+//#endregion
+export { findSelectItemByListKey, formatSelectListKey, isPresentSelectValue, isSelectItemRecord, resolveSelectItemValue, resolveValueFromListKey };

package/dist/components/SSelect/utils/useSelectState.cjs

@@ -0,0 +1,192 @@
+const require_useSelectionGroup = require("../../../composables/useSelectionGroup.cjs");
+const require_resolveListItemFields = require("../../SList/utils/resolveListItemFields.cjs");
+const require_resolveSelectItemValue = require("./resolveSelectItemValue.cjs");
+const require_SSelect_types = require("../SSelect.types.cjs");
+let vue = require("vue");
+//#region src/components/SSelect/utils/useSelectState.ts
+var defaultFilterSelectItem = (query, item, itemFields) => {
+	if (!query) return true;
+	const normalizedQuery = query.toLocaleLowerCase();
+	const normalizedTitle = require_resolveListItemFields.resolveListItemStringField(item, itemFields.itemTitle)?.toLocaleLowerCase() ?? "";
+	const normalizedValue = require_resolveSelectItemValue.formatSelectListKey(require_resolveSelectItemValue.resolveSelectItemValue(item, itemFields.itemValue) ?? "").toLocaleLowerCase();
+	return normalizedTitle.includes(normalizedQuery) || normalizedValue.includes(normalizedQuery);
+};
+var filterSelectItems = (optionItems, query, itemFields, filterOption) => {
+	const resolveFilter = filterOption ?? ((activeQuery, item) => defaultFilterSelectItem(activeQuery, item, itemFields));
+	if (!query) return [...optionItems];
+	return optionItems.filter((optionItem) => resolveFilter(query, optionItem));
+};
+var isModelStringValue = (value) => {
+	return typeof value === "string" && require_resolveSelectItemValue.isPresentSelectValue(value);
+};
+var isModelNumberValue = (value) => {
+	return typeof value === "number" && require_resolveSelectItemValue.isPresentSelectValue(value);
+};
+var resolvePrimitiveFromModelEntry = (entry, returnObject, itemValueKey) => {
+	if (returnObject) {
+		if (!require_resolveSelectItemValue.isSelectItemRecord(entry)) return;
+		const itemValue = require_resolveSelectItemValue.resolveSelectItemValue(entry, itemValueKey);
+		if (isModelStringValue(itemValue)) return itemValue;
+		if (isModelNumberValue(itemValue)) return itemValue;
+		return;
+	}
+	const primitiveEntry = typeof entry === "string" || typeof entry === "number" ? entry : void 0;
+	if (isModelStringValue(primitiveEntry)) return primitiveEntry;
+	if (isModelNumberValue(primitiveEntry)) return primitiveEntry;
+};
+var normalizeModelToValues = (modelValue, returnObject, itemValueKey) => {
+	if (!modelValue) return [];
+	return (Array.isArray(modelValue) ? modelValue : [modelValue]).flatMap((entry) => {
+		const primitiveValue = resolvePrimitiveFromModelEntry(entry, returnObject, itemValueKey);
+		return require_resolveSelectItemValue.isPresentSelectValue(primitiveValue) ? [primitiveValue] : [];
+	});
+};
+var commitSingleSelectModelValue = (model, resolved) => {
+	if (isModelStringValue(resolved)) {
+		model.value = resolved;
+		return;
+	}
+	if (isModelNumberValue(resolved)) {
+		model.value = resolved;
+		return;
+	}
+	model.value = void 0;
+};
+var findSelectItemsByValues = (optionItems, valueItems, itemValueKey) => {
+	return valueItems.flatMap((valueItem) => {
+		const targetKey = require_resolveSelectItemValue.formatSelectListKey(valueItem);
+		const matchedOption = optionItems.find((optionItem) => require_resolveSelectItemValue.formatSelectListKey(require_resolveSelectItemValue.resolveSelectItemValue(optionItem, itemValueKey) ?? "") === targetKey);
+		return matchedOption ? [matchedOption] : [];
+	});
+};
+var useSelectState = ({ modelValue, options, itemFields, multiple, returnObject, searchable, filterOption, isDropdownOpen, searchQuery }) => {
+	const isMultipleMode = (0, vue.computed)(() => (0, vue.toValue)(multiple));
+	const isReturnObjectMode = (0, vue.computed)(() => (0, vue.toValue)(returnObject));
+	const isSearchableInputMode = (0, vue.computed)(() => (0, vue.toValue)(searchable) === require_SSelect_types.ESSelectSearchable.INPUT);
+	const isSearchableContentMode = (0, vue.computed)(() => (0, vue.toValue)(searchable) === require_SSelect_types.ESSelectSearchable.CONTENT);
+	const isSearchableMode = (0, vue.computed)(() => Boolean((0, vue.toValue)(searchable)));
+	const selectedValues = (0, vue.computed)(() => {
+		const activeItemFields = (0, vue.toValue)(itemFields);
+		return normalizeModelToValues(modelValue.value, isReturnObjectMode.value, activeItemFields.itemValue);
+	});
+	const filteredOptions = (0, vue.computed)(() => {
+		const optionItems = (0, vue.toValue)(options);
+		const activeItemFields = (0, vue.toValue)(itemFields);
+		return filterSelectItems(optionItems, isSearchableMode.value ? searchQuery.value : "", activeItemFields, (0, vue.toValue)(filterOption));
+	});
+	const listSelectionMode = (0, vue.computed)(() => {
+		if (isMultipleMode.value) return require_useSelectionGroup.ESelectionMode.MULTIPLE;
+		return require_useSelectionGroup.ESelectionMode.SINGLE;
+	});
+	const commitMultipleSelection = (valueItems, optionItems, itemValueKey) => {
+		if (isReturnObjectMode.value) {
+			modelValue.value = findSelectItemsByValues(optionItems, valueItems, itemValueKey);
+			return;
+		}
+		modelValue.value = valueItems;
+	};
+	const commitSingleSelection = (listKey, optionItems, itemValueKey) => {
+		if (!listKey) {
+			modelValue.value = void 0;
+			return;
+		}
+		if (isReturnObjectMode.value) {
+			modelValue.value = require_resolveSelectItemValue.findSelectItemByListKey(listKey, optionItems, itemValueKey) ?? void 0;
+			return;
+		}
+		commitSingleSelectModelValue(modelValue, require_resolveSelectItemValue.resolveValueFromListKey(listKey, optionItems, itemValueKey));
+	};
+	const listSelectedModel = (0, vue.computed)({
+		get: () => {
+			if (isMultipleMode.value) return selectedValues.value.map((valueItem) => require_resolveSelectItemValue.formatSelectListKey(valueItem));
+			const firstValue = selectedValues.value[0];
+			if (!require_resolveSelectItemValue.isPresentSelectValue(firstValue)) return;
+			return require_resolveSelectItemValue.formatSelectListKey(firstValue);
+		},
+		set: (nextSelection) => {
+			const optionItems = (0, vue.toValue)(options);
+			const activeItemFields = (0, vue.toValue)(itemFields);
+			if (isMultipleMode.value) {
+				commitMultipleSelection((Array.isArray(nextSelection) ? nextSelection : []).map((listKey) => require_resolveSelectItemValue.resolveValueFromListKey(listKey, optionItems, activeItemFields.itemValue)).filter((valueItem) => require_resolveSelectItemValue.isPresentSelectValue(valueItem)), optionItems, activeItemFields.itemValue);
+				return;
+			}
+			commitSingleSelection(typeof nextSelection === "string" ? nextSelection : void 0, optionItems, activeItemFields.itemValue);
+		}
+	});
+	const hasSelectedValues = (0, vue.computed)(() => selectedValues.value.length > 0);
+	const findSelectItemByValue = (optionItems, value, itemValueKey) => {
+		const targetKey = require_resolveSelectItemValue.formatSelectListKey(value);
+		return optionItems.find((optionItem) => require_resolveSelectItemValue.formatSelectListKey(require_resolveSelectItemValue.resolveSelectItemValue(optionItem, itemValueKey) ?? "") === targetKey);
+	};
+	const singleDisplayLabel = (0, vue.computed)(() => {
+		const firstValue = selectedValues.value[0];
+		if (!require_resolveSelectItemValue.isPresentSelectValue(firstValue)) return "";
+		const activeItemFields = (0, vue.toValue)(itemFields);
+		const matchedOption = findSelectItemByValue((0, vue.toValue)(options), firstValue, activeItemFields.itemValue);
+		if (!matchedOption) return require_resolveSelectItemValue.formatSelectListKey(firstValue);
+		return require_resolveListItemFields.resolveListItemStringField(matchedOption, activeItemFields.itemTitle) ?? "";
+	});
+	const multipleDisplayLabels = (0, vue.computed)(() => {
+		const optionItems = (0, vue.toValue)(options);
+		const activeItemFields = (0, vue.toValue)(itemFields);
+		return selectedValues.value.map((valueItem) => {
+			const matchedOption = findSelectItemByValue(optionItems, valueItem, activeItemFields.itemValue);
+			if (!matchedOption) return require_resolveSelectItemValue.formatSelectListKey(valueItem);
+			return require_resolveListItemFields.resolveListItemStringField(matchedOption, activeItemFields.itemTitle) ?? "";
+		});
+	});
+	const multipleDisplayText = (0, vue.computed)(() => {
+		return multipleDisplayLabels.value.join(", ");
+	});
+	const showPlaceholder = (0, vue.computed)(() => {
+		if (isMultipleMode.value) return selectedValues.value.length === 0;
+		return !singleDisplayLabel.value;
+	});
+	const showInputSearchField = (0, vue.computed)(() => {
+		return isSearchableInputMode.value && (isDropdownOpen.value || isMultipleMode.value);
+	});
+	const resetSearchQuery = () => {
+		searchQuery.value = "";
+	};
+	const clearSelection = () => {
+		modelValue.value = void 0;
+		resetSearchQuery();
+	};
+	const removeSelectedValue = (valueToRemove) => {
+		const targetKey = require_resolveSelectItemValue.formatSelectListKey(valueToRemove);
+		commitMultipleSelection(selectedValues.value.filter((valueItem) => require_resolveSelectItemValue.formatSelectListKey(valueItem) !== targetKey), (0, vue.toValue)(options), (0, vue.toValue)(itemFields).itemValue);
+	};
+	(0, vue.watch)(isDropdownOpen, (isOpen) => {
+		if (!isOpen) resetSearchQuery();
+	});
+	(0, vue.watch)(() => (0, vue.toValue)(searchable), () => {
+		resetSearchQuery();
+	});
+	return {
+		searchQuery,
+		selectedValues,
+		filteredOptions,
+		listSelectionMode,
+		listSelectedModel,
+		hasSelectedValues,
+		singleDisplayLabel,
+		multipleDisplayLabels,
+		multipleDisplayText,
+		showPlaceholder,
+		showInputSearchField,
+		isSearchableMode,
+		isSearchableInputMode,
+		isSearchableContentMode,
+		isMultipleMode,
+		isReturnObjectMode,
+		clearSelection,
+		removeSelectedValue,
+		resetSearchQuery,
+		formatSelectListKey: require_resolveSelectItemValue.formatSelectListKey,
+		resolveValueFromListKey: (listKey) => {
+			return require_resolveSelectItemValue.resolveValueFromListKey(listKey, (0, vue.toValue)(options), (0, vue.toValue)(itemFields).itemValue);
+		}
+	};
+};
+//#endregion
+exports.useSelectState = useSelectState;

package/dist/components/SSelect/utils/useSelectState.js

@@ -0,0 +1,192 @@
+import { ESelectionMode } from "../../../composables/useSelectionGroup.js";
+import { resolveListItemStringField } from "../../SList/utils/resolveListItemFields.js";
+import { findSelectItemByListKey, formatSelectListKey, isPresentSelectValue, isSelectItemRecord, resolveSelectItemValue, resolveValueFromListKey } from "./resolveSelectItemValue.js";
+import { ESSelectSearchable } from "../SSelect.types.js";
+import { computed, toValue, watch } from "vue";
+//#region src/components/SSelect/utils/useSelectState.ts
+var defaultFilterSelectItem = (query, item, itemFields) => {
+	if (!query) return true;
+	const normalizedQuery = query.toLocaleLowerCase();
+	const normalizedTitle = resolveListItemStringField(item, itemFields.itemTitle)?.toLocaleLowerCase() ?? "";
+	const normalizedValue = formatSelectListKey(resolveSelectItemValue(item, itemFields.itemValue) ?? "").toLocaleLowerCase();
+	return normalizedTitle.includes(normalizedQuery) || normalizedValue.includes(normalizedQuery);
+};
+var filterSelectItems = (optionItems, query, itemFields, filterOption) => {
+	const resolveFilter = filterOption ?? ((activeQuery, item) => defaultFilterSelectItem(activeQuery, item, itemFields));
+	if (!query) return [...optionItems];
+	return optionItems.filter((optionItem) => resolveFilter(query, optionItem));
+};
+var isModelStringValue = (value) => {
+	return typeof value === "string" && isPresentSelectValue(value);
+};
+var isModelNumberValue = (value) => {
+	return typeof value === "number" && isPresentSelectValue(value);
+};
+var resolvePrimitiveFromModelEntry = (entry, returnObject, itemValueKey) => {
+	if (returnObject) {
+		if (!isSelectItemRecord(entry)) return;
+		const itemValue = resolveSelectItemValue(entry, itemValueKey);
+		if (isModelStringValue(itemValue)) return itemValue;
+		if (isModelNumberValue(itemValue)) return itemValue;
+		return;
+	}
+	const primitiveEntry = typeof entry === "string" || typeof entry === "number" ? entry : void 0;
+	if (isModelStringValue(primitiveEntry)) return primitiveEntry;
+	if (isModelNumberValue(primitiveEntry)) return primitiveEntry;
+};
+var normalizeModelToValues = (modelValue, returnObject, itemValueKey) => {
+	if (!modelValue) return [];
+	return (Array.isArray(modelValue) ? modelValue : [modelValue]).flatMap((entry) => {
+		const primitiveValue = resolvePrimitiveFromModelEntry(entry, returnObject, itemValueKey);
+		return isPresentSelectValue(primitiveValue) ? [primitiveValue] : [];
+	});
+};
+var commitSingleSelectModelValue = (model, resolved) => {
+	if (isModelStringValue(resolved)) {
+		model.value = resolved;
+		return;
+	}
+	if (isModelNumberValue(resolved)) {
+		model.value = resolved;
+		return;
+	}
+	model.value = void 0;
+};
+var findSelectItemsByValues = (optionItems, valueItems, itemValueKey) => {
+	return valueItems.flatMap((valueItem) => {
+		const targetKey = formatSelectListKey(valueItem);
+		const matchedOption = optionItems.find((optionItem) => formatSelectListKey(resolveSelectItemValue(optionItem, itemValueKey) ?? "") === targetKey);
+		return matchedOption ? [matchedOption] : [];
+	});
+};
+var useSelectState = ({ modelValue, options, itemFields, multiple, returnObject, searchable, filterOption, isDropdownOpen, searchQuery }) => {
+	const isMultipleMode = computed(() => toValue(multiple));
+	const isReturnObjectMode = computed(() => toValue(returnObject));
+	const isSearchableInputMode = computed(() => toValue(searchable) === ESSelectSearchable.INPUT);
+	const isSearchableContentMode = computed(() => toValue(searchable) === ESSelectSearchable.CONTENT);
+	const isSearchableMode = computed(() => Boolean(toValue(searchable)));
+	const selectedValues = computed(() => {
+		const activeItemFields = toValue(itemFields);
+		return normalizeModelToValues(modelValue.value, isReturnObjectMode.value, activeItemFields.itemValue);
+	});
+	const filteredOptions = computed(() => {
+		const optionItems = toValue(options);
+		const activeItemFields = toValue(itemFields);
+		return filterSelectItems(optionItems, isSearchableMode.value ? searchQuery.value : "", activeItemFields, toValue(filterOption));
+	});
+	const listSelectionMode = computed(() => {
+		if (isMultipleMode.value) return ESelectionMode.MULTIPLE;
+		return ESelectionMode.SINGLE;
+	});
+	const commitMultipleSelection = (valueItems, optionItems, itemValueKey) => {
+		if (isReturnObjectMode.value) {
+			modelValue.value = findSelectItemsByValues(optionItems, valueItems, itemValueKey);
+			return;
+		}
+		modelValue.value = valueItems;
+	};
+	const commitSingleSelection = (listKey, optionItems, itemValueKey) => {
+		if (!listKey) {
+			modelValue.value = void 0;
+			return;
+		}
+		if (isReturnObjectMode.value) {
+			modelValue.value = findSelectItemByListKey(listKey, optionItems, itemValueKey) ?? void 0;
+			return;
+		}
+		commitSingleSelectModelValue(modelValue, resolveValueFromListKey(listKey, optionItems, itemValueKey));
+	};
+	const listSelectedModel = computed({
+		get: () => {
+			if (isMultipleMode.value) return selectedValues.value.map((valueItem) => formatSelectListKey(valueItem));
+			const firstValue = selectedValues.value[0];
+			if (!isPresentSelectValue(firstValue)) return;
+			return formatSelectListKey(firstValue);
+		},
+		set: (nextSelection) => {
+			const optionItems = toValue(options);
+			const activeItemFields = toValue(itemFields);
+			if (isMultipleMode.value) {
+				commitMultipleSelection((Array.isArray(nextSelection) ? nextSelection : []).map((listKey) => resolveValueFromListKey(listKey, optionItems, activeItemFields.itemValue)).filter((valueItem) => isPresentSelectValue(valueItem)), optionItems, activeItemFields.itemValue);
+				return;
+			}
+			commitSingleSelection(typeof nextSelection === "string" ? nextSelection : void 0, optionItems, activeItemFields.itemValue);
+		}
+	});
+	const hasSelectedValues = computed(() => selectedValues.value.length > 0);
+	const findSelectItemByValue = (optionItems, value, itemValueKey) => {
+		const targetKey = formatSelectListKey(value);
+		return optionItems.find((optionItem) => formatSelectListKey(resolveSelectItemValue(optionItem, itemValueKey) ?? "") === targetKey);
+	};
+	const singleDisplayLabel = computed(() => {
+		const firstValue = selectedValues.value[0];
+		if (!isPresentSelectValue(firstValue)) return "";
+		const activeItemFields = toValue(itemFields);
+		const matchedOption = findSelectItemByValue(toValue(options), firstValue, activeItemFields.itemValue);
+		if (!matchedOption) return formatSelectListKey(firstValue);
+		return resolveListItemStringField(matchedOption, activeItemFields.itemTitle) ?? "";
+	});
+	const multipleDisplayLabels = computed(() => {
+		const optionItems = toValue(options);
+		const activeItemFields = toValue(itemFields);
+		return selectedValues.value.map((valueItem) => {
+			const matchedOption = findSelectItemByValue(optionItems, valueItem, activeItemFields.itemValue);
+			if (!matchedOption) return formatSelectListKey(valueItem);
+			return resolveListItemStringField(matchedOption, activeItemFields.itemTitle) ?? "";
+		});
+	});
+	const multipleDisplayText = computed(() => {
+		return multipleDisplayLabels.value.join(", ");
+	});
+	const showPlaceholder = computed(() => {
+		if (isMultipleMode.value) return selectedValues.value.length === 0;
+		return !singleDisplayLabel.value;
+	});
+	const showInputSearchField = computed(() => {
+		return isSearchableInputMode.value && (isDropdownOpen.value || isMultipleMode.value);
+	});
+	const resetSearchQuery = () => {
+		searchQuery.value = "";
+	};
+	const clearSelection = () => {
+		modelValue.value = void 0;
+		resetSearchQuery();
+	};
+	const removeSelectedValue = (valueToRemove) => {
+		const targetKey = formatSelectListKey(valueToRemove);
+		commitMultipleSelection(selectedValues.value.filter((valueItem) => formatSelectListKey(valueItem) !== targetKey), toValue(options), toValue(itemFields).itemValue);
+	};
+	watch(isDropdownOpen, (isOpen) => {
+		if (!isOpen) resetSearchQuery();
+	});
+	watch(() => toValue(searchable), () => {
+		resetSearchQuery();
+	});
+	return {
+		searchQuery,
+		selectedValues,
+		filteredOptions,
+		listSelectionMode,
+		listSelectedModel,
+		hasSelectedValues,
+		singleDisplayLabel,
+		multipleDisplayLabels,
+		multipleDisplayText,
+		showPlaceholder,
+		showInputSearchField,
+		isSearchableMode,
+		isSearchableInputMode,
+		isSearchableContentMode,
+		isMultipleMode,
+		isReturnObjectMode,
+		clearSelection,
+		removeSelectedValue,
+		resetSearchQuery,
+		formatSelectListKey,
+		resolveValueFromListKey: (listKey) => {
+			return resolveValueFromListKey(listKey, toValue(options), toValue(itemFields).itemValue);
+		}
+	};
+};
+//#endregion
+export { useSelectState };

package/dist/components/STab/STab.types.cjs

@@ -0,0 +1,14 @@
+//#region src/components/STab/STab.types.ts
+var ESTabAppearance = /* @__PURE__ */ function(ESTabAppearance) {
+	ESTabAppearance["PRIMARY"] = "primary";
+	ESTabAppearance["SECONDARY"] = "secondary";
+	return ESTabAppearance;
+}({});
+var ESTabSize = /* @__PURE__ */ function(ESTabSize) {
+	ESTabSize["SMALL"] = "small";
+	ESTabSize["LARGE"] = "large";
+	return ESTabSize;
+}({});
+//#endregion
+exports.ESTabAppearance = ESTabAppearance;
+exports.ESTabSize = ESTabSize;

package/dist/components/STab/STab.types.js

@@ -0,0 +1,13 @@
+//#region src/components/STab/STab.types.ts
+var ESTabAppearance = /* @__PURE__ */ function(ESTabAppearance) {
+	ESTabAppearance["PRIMARY"] = "primary";
+	ESTabAppearance["SECONDARY"] = "secondary";
+	return ESTabAppearance;
+}({});
+var ESTabSize = /* @__PURE__ */ function(ESTabSize) {
+	ESTabSize["SMALL"] = "small";
+	ESTabSize["LARGE"] = "large";
+	return ESTabSize;
+}({});
+//#endregion
+export { ESTabAppearance, ESTabSize };

package/dist/components/STab/STab.vue.cjs

@@ -0,0 +1,6 @@
+const require_STab_vue_vue_type_script_setup_true_lang = require("./STab.vue_vue_type_script_setup_true_lang.cjs");
+;/* empty css                                                          */
+//#region src/components/STab/STab.vue
+var STab_default = require_STab_vue_vue_type_script_setup_true_lang.default;
+//#endregion
+exports.default = STab_default;

package/dist/components/STab/STab.vue.js

@@ -0,0 +1,6 @@
+import STab_vue_vue_type_script_setup_true_lang_default from "./STab.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                        */
+//#region src/components/STab/STab.vue
+var STab_default = STab_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { STab_default as default };