@shtabapp/ui-kit 1.85.0 → 1.85.1

package/dist/components/SInlineInput/utils/useInlineInput.js

@@ -0,0 +1,309 @@
+import { CONSECUTIVE_WHITESPACE_PATTERN, LINE_BREAK_SEQUENCE_PATTERN, ZERO_WIDTH_SPACE_GLOBAL_PATTERN } from "./inlineInputTextPatterns.js";
+import { useStringHistory } from "./useStringHistory.js";
+import { useCursorManagement } from "./useCursorManagement.js";
+import { computed, nextTick, onMounted, ref, toValue, watch } from "vue";
+import { useEventListener } from "@vueuse/core";
+//#region src/components/SInlineInput/utils/useInlineInput.ts
+/**
+* Composable для управления contenteditable элементом с поддержкой v-model.
+*
+* Решает проблемы:
+* 1. Исчезновение высоты элемента при пустом тексте (через ZWS).
+* 2. Синхронизация позиции каретки при внешних обновлениях.
+* 3. Очистка "мусорных" тегов (br, div), которые добавляют браузеры.
+*/
+var useInlineInput = (modelValue, options = {}) => {
+	const multiline = computed(() => toValue(options).multiline ?? false);
+	const maxLength = computed(() => {
+		const limit = toValue(options).maxLength;
+		if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) return;
+		return limit;
+	});
+	const editableRef = ref(null);
+	const isPlaceholderVisible = ref(true);
+	/**
+	* Флаг, указывающий, что изменение произошло внутри компонента (ввод пользователя).
+	* Нужен для предотвращения лишних обновлений DOM из watcher-а.
+	*/
+	const isLocalUpdate = ref(false);
+	const isHistoryNavigation = ref(false);
+	const { setCursorToEnd, getCursorOffset, setCursorOffset, scrollCaretIntoView } = useCursorManagement(editableRef);
+	const { undo, redo, commit, commitDebounced } = useStringHistory(modelValue, { autoCommit: false });
+	let selectAllScrollLeft = null;
+	let isOutsidePointerDown = false;
+	const isPointerInsideRoot = (target) => {
+		const element = editableRef.value;
+		if (!element) return false;
+		const root = element.closest(".s-ui-inline-input");
+		return root instanceof Element && target instanceof Node && root.contains(target);
+	};
+	const rejectFocusAfterOutsidePointer = () => {
+		if (!isOutsidePointerDown) return false;
+		isOutsidePointerDown = false;
+		editableRef.value?.blur();
+		return true;
+	};
+	useEventListener(document, "mousedown", (event) => {
+		const element = editableRef.value;
+		if (!element) return;
+		isOutsidePointerDown = !isPointerInsideRoot(event.target);
+		if (isOutsidePointerDown && document.activeElement === element) element.blur();
+	}, { capture: true });
+	const scrollCaretIfSingleLine = () => {
+		if (multiline.value) return;
+		scrollCaretIntoView();
+	};
+	useEventListener(document, "selectionchange", () => {
+		if (multiline.value || !editableRef.value) return;
+		if (document.activeElement !== editableRef.value) return;
+		if (selectAllScrollLeft !== null) {
+			editableRef.value.scrollLeft = selectAllScrollLeft;
+			selectAllScrollLeft = null;
+			return;
+		}
+		scrollCaretIntoView();
+	});
+	/**
+	* Очищает сырой текст из DOM для сохранения в модель.
+	* Удаляет ZWS и нормализует переносы строк.
+	*/
+	const cleanValue = (value) => {
+		let cleaned = value.replace(ZERO_WIDTH_SPACE_GLOBAL_PATTERN, "");
+		if (!multiline.value) cleaned = cleaned.replace(LINE_BREAK_SEQUENCE_PATTERN, " ");
+		return cleaned;
+	};
+	/**
+	* Проверяет, является ли значение пустым (с учётом zero-space)
+	*/
+	const isEmpty = (value) => {
+		return cleanValue(value).length === 0;
+	};
+	/** Обрезает строку до maxlength (после cleanValue). */
+	const clampToMaxLength = (value) => {
+		if (maxLength.value === void 0 || value.length <= maxLength.value) return value;
+		return value.slice(0, maxLength.value);
+	};
+	/** Длина выделенного внутри поля текста после cleanValue (для замены при вставке). */
+	const getSelectedCleanedLength = () => {
+		const element = editableRef.value;
+		const selection = window.getSelection();
+		if (!element || !selection?.rangeCount || !selection.anchorNode) return 0;
+		if (!element.contains(selection.anchorNode)) return 0;
+		return cleanValue(selection.toString()).length;
+	};
+	/** Сколько символов ещё можно вставить с учётом лимита и текущего выделения. */
+	const getAvailableLengthForInsert = () => {
+		if (maxLength.value === void 0 || !editableRef.value) return Number.POSITIVE_INFINITY;
+		const currentLength = cleanValue(editableRef.value.textContent || "").length;
+		const selectedLength = getSelectedCleanedLength();
+		return Math.max(0, maxLength.value - currentLength + selectedLength);
+	};
+	/** true, если печатный символ превысит maxlength без замены выделения. */
+	const wouldExceedMaxLengthOnKeydown = (event) => {
+		if (maxLength.value === void 0) return false;
+		if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey) return false;
+		return getAvailableLengthForInsert() <= 0;
+	};
+	/** Синхронизирует DOM с v-model: ZWS, cleanValue, maxlength, placeholder, позиция каретки. */
+	const syncModel = () => {
+		if (!editableRef.value) return {
+			changed: false,
+			content: "",
+			cursor: 0
+		};
+		if ((editableRef.value.textContent || "") === "") {
+			editableRef.value.textContent = "​";
+			setCursorToEnd();
+		}
+		const currentText = editableRef.value.textContent || "";
+		const cleanedText = cleanValue(currentText);
+		const clampedText = clampToMaxLength(cleanedText);
+		const wasTruncated = cleanedText !== clampedText;
+		if (wasTruncated) editableRef.value.textContent = clampedText.length > 0 ? clampedText : "​";
+		isPlaceholderVisible.value = clampedText.length === 0;
+		const hasChanged = modelValue.value !== clampedText;
+		if (hasChanged) modelValue.value = clampedText;
+		let currentCursor = getCursorOffset();
+		if (currentText.startsWith("​") && currentCursor > 0) currentCursor -= 1;
+		if (wasTruncated) {
+			currentCursor = Math.min(currentCursor, clampedText.length);
+			setCursorOffset(currentCursor);
+		}
+		return {
+			changed: hasChanged || wasTruncated,
+			content: clampedText,
+			cursor: currentCursor
+		};
+	};
+	/**
+	* Основной обработчик ввода.
+	* Гарантирует наличие ZWS, если поле опустело.
+	*/
+	const handleInput = () => {
+		isLocalUpdate.value = true;
+		const { changed, content, cursor } = syncModel();
+		if (changed) commitDebounced(content, cursor, { type: "input" });
+		nextTick(() => {
+			scrollCaretIfSingleLine();
+			isLocalUpdate.value = false;
+		});
+	};
+	/**
+	* При фокусе гарантируем, что ZWS на месте и каретка стоит правильно.
+	*/
+	const handleFocus = () => {
+		if (rejectFocusAfterOutsidePointer()) return;
+		if (!editableRef.value) return;
+		if (!cleanValue(editableRef.value.textContent || "")) {
+			if (editableRef.value.textContent !== "​") editableRef.value.textContent = "​";
+			setCursorToEnd();
+		}
+	};
+	/**
+	* При потере фокуса просто обновляем видимость плейсхолдера.
+	*/
+	const handleBlur = () => {
+		if (!editableRef.value) return;
+		isPlaceholderVisible.value = isEmpty(editableRef.value.textContent || "");
+	};
+	/**
+	* Обработка вставки из буфера обмена (Paste).
+	* Очищает форматирование и соблюдает лимиты.
+	*/
+	const handlePaste = async (event) => {
+		event.preventDefault();
+		let pastedText = event.clipboardData?.getData("text/plain") || "";
+		const availableLength = getAvailableLengthForInsert();
+		if (availableLength <= 0) return;
+		if (pastedText.length > availableLength) pastedText = pastedText.slice(0, availableLength);
+		if (!multiline.value) pastedText = pastedText.replace(LINE_BREAK_SEQUENCE_PATTERN, " ");
+		const cleanedText = pastedText.trim().replace(CONSECUTIVE_WHITESPACE_PATTERN, " ");
+		if (!cleanedText) return;
+		const selection = window.getSelection();
+		if (!selection || !selection.rangeCount) return;
+		isLocalUpdate.value = true;
+		const range = selection.getRangeAt(0);
+		range.deleteContents();
+		const textNode = document.createTextNode(cleanedText);
+		range.insertNode(textNode);
+		range.setStartAfter(textNode);
+		range.setEndAfter(textNode);
+		selection.removeAllRanges();
+		selection.addRange(range);
+		const { changed, content, cursor } = syncModel();
+		if (changed) commit(content, cursor, { type: "paste" });
+		if (!multiline.value) await setCursorOffset(cursor);
+		await nextTick();
+		scrollCaretIfSingleLine();
+		isLocalUpdate.value = false;
+	};
+	/**
+	* Обработка клавиш: блок maxlength, Enter в однострочном режиме, Undo/Redo.
+	*/
+	const handleKeydown = (event) => {
+		const isCtrlPressed = event.ctrlKey || event.metaKey;
+		const isShiftPressed = event.shiftKey;
+		if (wouldExceedMaxLengthOnKeydown(event)) {
+			event.preventDefault();
+			return;
+		}
+		if (!multiline.value && (event.key === "Enter" || event.key === "NumpadEnter")) {
+			event.preventDefault();
+			return;
+		}
+		if (!multiline.value && isCtrlPressed && event.code === "KeyA" && editableRef.value) {
+			selectAllScrollLeft = editableRef.value.scrollLeft;
+			return;
+		}
+		if (isCtrlPressed && event.code === "KeyZ") {
+			event.preventDefault();
+			isHistoryNavigation.value = true;
+			const result = isShiftPressed ? redo() : undo();
+			if (result) nextTick(() => {
+				setCursorOffset(result.cursorPosition ?? result.content.length);
+				nextTick(scrollCaretIfSingleLine);
+				isHistoryNavigation.value = false;
+			});
+			else isHistoryNavigation.value = false;
+		}
+	};
+	/** Фокусирует contenteditable при клике по обёртке. */
+	const handleWrapperClick = () => {
+		if (editableRef.value && document.activeElement !== editableRef.value) editableRef.value.focus();
+	};
+	/** Убирает переносы из DOM и модели при переходе в однострочный режим. */
+	const flattenToSingleLine = () => {
+		if (!editableRef.value || multiline.value) return;
+		isLocalUpdate.value = true;
+		const cleaned = clampToMaxLength(cleanValue(editableRef.value.innerText || editableRef.value.textContent || ""));
+		modelValue.value = cleaned;
+		editableRef.value.textContent = cleaned.length > 0 ? cleaned : "​";
+		isPlaceholderVisible.value = cleaned.length === 0;
+		nextTick(() => {
+			isLocalUpdate.value = false;
+		});
+	};
+	/** При выключении multiline схлопывает уже введённые переносы строк. */
+	watch(multiline, (isMultiline, wasMultiline) => {
+		if (isMultiline || !wasMultiline) return;
+		flattenToSingleLine();
+	});
+	/** Обрезает текст при уменьшении maxlength. */
+	const enforceMaxLength = () => {
+		if (!editableRef.value || modelValue.value === void 0) return;
+		isLocalUpdate.value = true;
+		syncModel();
+		nextTick(() => {
+			isLocalUpdate.value = false;
+		});
+	};
+	/** При уменьшении maxlength обрезает уже введённый текст. */
+	watch(maxLength, (limit, previousLimit) => {
+		if (limit === void 0 || previousLimit !== void 0 && limit >= previousLimit) return;
+		enforceMaxLength();
+	});
+	const applyModelValueToDom = async (newValue) => {
+		if (isLocalUpdate.value) return;
+		if (!editableRef.value) return;
+		const clampedValue = clampToMaxLength(newValue);
+		const currentContent = editableRef.value.textContent || "";
+		if (cleanValue(currentContent) !== clampedValue || clampedValue === "" && currentContent !== "​") {
+			editableRef.value.textContent = clampedValue === "" ? "​" : clampedValue;
+			isPlaceholderVisible.value = clampedValue === "";
+			if (clampedValue !== newValue) {
+				isLocalUpdate.value = true;
+				modelValue.value = clampedValue;
+				nextTick(() => {
+					isLocalUpdate.value = false;
+				});
+			}
+			if (document.activeElement === editableRef.value && !isHistoryNavigation.value) {
+				await nextTick();
+				setCursorToEnd();
+			}
+		}
+	};
+	onMounted(async () => {
+		await nextTick();
+		applyModelValueToDom(modelValue.value);
+	});
+	watch(editableRef, (element) => {
+		if (!element) return;
+		applyModelValueToDom(modelValue.value);
+	});
+	watch(modelValue, (newValue) => {
+		applyModelValueToDom(newValue);
+	});
+	return {
+		editableRef,
+		isPlaceholderVisible,
+		handleInput,
+		handleFocus,
+		handleBlur,
+		handlePaste,
+		handleKeydown,
+		handleWrapperClick
+	};
+};
+//#endregion
+export { useInlineInput };

package/dist/components/SInlineInput/utils/useStringHistory.cjs

@@ -0,0 +1,115 @@
+const require_debounce = require("../../../vendor/lodash-es/debounce.cjs");
+let vue = require("vue");
+//#region src/components/SInlineInput/utils/useStringHistory.ts
+var useStringHistory = (contentRef, options = {}) => {
+	const history = (0, vue.ref)([]);
+	const redoStack = (0, vue.ref)([]);
+	const isPaused = (0, vue.ref)(false);
+	const { capacity = 20, debounceDelay = 500, autoCommit = true } = options;
+	const cleanRedoStack = () => {
+		redoStack.value = [];
+	};
+	const checkForDuplicate = (newContent) => {
+		return history.value[history.value.length - 1]?.content === newContent;
+	};
+	const cutHistory = () => {
+		if (history.value.length > capacity) history.value = history.value.slice(-capacity);
+	};
+	const skipNextWatch = (0, vue.ref)(false);
+	const commit = (newContent, cursorPosition, meta) => {
+		if (isPaused.value) return;
+		if (checkForDuplicate(newContent)) return;
+		cleanRedoStack();
+		history.value.push({
+			content: newContent,
+			timestamp: Date.now(),
+			cursorPosition,
+			meta
+		});
+		cutHistory();
+	};
+	const commitDebounced = require_debounce.default((newContent, cursorPosition, meta) => {
+		commit(newContent, cursorPosition, meta);
+	}, debounceDelay);
+	const initializeHistory = () => {
+		commit(contentRef.value || "", 0, { type: "init" });
+	};
+	if (contentRef.value !== void 0) initializeHistory();
+	let watchStopper = null;
+	const setupAutoCommit = () => {
+		if (!autoCommit) return;
+		watchStopper = (0, vue.watch)(contentRef, (newValue, oldValue) => {
+			if (isPaused.value || newValue === oldValue) return;
+			if (skipNextWatch.value) {
+				skipNextWatch.value = false;
+				return;
+			}
+			commitDebounced(newValue, newValue.length, { type: "auto" });
+		}, { flush: "post" });
+	};
+	setupAutoCommit();
+	(0, vue.onBeforeUnmount)(() => {
+		commitDebounced.cancel();
+		if (watchStopper) {
+			watchStopper();
+			watchStopper = null;
+		}
+	});
+	const undo = () => {
+		if (history.value.length < 2) return;
+		commitDebounced.cancel();
+		skipNextWatch.value = true;
+		const current = history.value.pop();
+		if (!current) return;
+		redoStack.value.unshift(current);
+		const previous = history.value[history.value.length - 1];
+		if (previous) {
+			contentRef.value = previous.content;
+			return {
+				content: previous.content,
+				cursorPosition: previous.cursorPosition
+			};
+		}
+	};
+	const redo = () => {
+		if (redoStack.value.length === 0) return;
+		commitDebounced.cancel();
+		skipNextWatch.value = true;
+		const next = redoStack.value.shift();
+		if (!next) return;
+		history.value.push(next);
+		contentRef.value = next.content;
+		return {
+			content: next.content,
+			cursorPosition: next.cursorPosition
+		};
+	};
+	const clear = () => {
+		commitDebounced.cancel();
+		history.value = [];
+		redoStack.value = [];
+	};
+	const pause = () => {
+		commitDebounced.cancel();
+		isPaused.value = true;
+	};
+	const resume = () => {
+		isPaused.value = false;
+		initializeHistory();
+	};
+	return {
+		history,
+		redoStack,
+		canUndo: (0, vue.computed)(() => history.value.length > 1),
+		canRedo: (0, vue.computed)(() => redoStack.value.length > 0),
+		undo,
+		redo,
+		commit,
+		commitDebounced,
+		clear,
+		pause,
+		resume
+	};
+};
+//#endregion
+exports.useStringHistory = useStringHistory;

package/dist/components/SInlineInput/utils/useStringHistory.js

@@ -0,0 +1,115 @@
+import debounce from "../../../vendor/lodash-es/debounce.js";
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+//#region src/components/SInlineInput/utils/useStringHistory.ts
+var useStringHistory = (contentRef, options = {}) => {
+	const history = ref([]);
+	const redoStack = ref([]);
+	const isPaused = ref(false);
+	const { capacity = 20, debounceDelay = 500, autoCommit = true } = options;
+	const cleanRedoStack = () => {
+		redoStack.value = [];
+	};
+	const checkForDuplicate = (newContent) => {
+		return history.value[history.value.length - 1]?.content === newContent;
+	};
+	const cutHistory = () => {
+		if (history.value.length > capacity) history.value = history.value.slice(-capacity);
+	};
+	const skipNextWatch = ref(false);
+	const commit = (newContent, cursorPosition, meta) => {
+		if (isPaused.value) return;
+		if (checkForDuplicate(newContent)) return;
+		cleanRedoStack();
+		history.value.push({
+			content: newContent,
+			timestamp: Date.now(),
+			cursorPosition,
+			meta
+		});
+		cutHistory();
+	};
+	const commitDebounced = debounce((newContent, cursorPosition, meta) => {
+		commit(newContent, cursorPosition, meta);
+	}, debounceDelay);
+	const initializeHistory = () => {
+		commit(contentRef.value || "", 0, { type: "init" });
+	};
+	if (contentRef.value !== void 0) initializeHistory();
+	let watchStopper = null;
+	const setupAutoCommit = () => {
+		if (!autoCommit) return;
+		watchStopper = watch(contentRef, (newValue, oldValue) => {
+			if (isPaused.value || newValue === oldValue) return;
+			if (skipNextWatch.value) {
+				skipNextWatch.value = false;
+				return;
+			}
+			commitDebounced(newValue, newValue.length, { type: "auto" });
+		}, { flush: "post" });
+	};
+	setupAutoCommit();
+	onBeforeUnmount(() => {
+		commitDebounced.cancel();
+		if (watchStopper) {
+			watchStopper();
+			watchStopper = null;
+		}
+	});
+	const undo = () => {
+		if (history.value.length < 2) return;
+		commitDebounced.cancel();
+		skipNextWatch.value = true;
+		const current = history.value.pop();
+		if (!current) return;
+		redoStack.value.unshift(current);
+		const previous = history.value[history.value.length - 1];
+		if (previous) {
+			contentRef.value = previous.content;
+			return {
+				content: previous.content,
+				cursorPosition: previous.cursorPosition
+			};
+		}
+	};
+	const redo = () => {
+		if (redoStack.value.length === 0) return;
+		commitDebounced.cancel();
+		skipNextWatch.value = true;
+		const next = redoStack.value.shift();
+		if (!next) return;
+		history.value.push(next);
+		contentRef.value = next.content;
+		return {
+			content: next.content,
+			cursorPosition: next.cursorPosition
+		};
+	};
+	const clear = () => {
+		commitDebounced.cancel();
+		history.value = [];
+		redoStack.value = [];
+	};
+	const pause = () => {
+		commitDebounced.cancel();
+		isPaused.value = true;
+	};
+	const resume = () => {
+		isPaused.value = false;
+		initializeHistory();
+	};
+	return {
+		history,
+		redoStack,
+		canUndo: computed(() => history.value.length > 1),
+		canRedo: computed(() => redoStack.value.length > 0),
+		undo,
+		redo,
+		commit,
+		commitDebounced,
+		clear,
+		pause,
+		resume
+	};
+};
+//#endregion
+export { useStringHistory };

package/dist/components/SInlineMessage/SInlineMessage.types.cjs

@@ -0,0 +1,8 @@
+//#region src/components/SInlineMessage/SInlineMessage.types.ts
+var ESInlineMessageValidationStatus = /* @__PURE__ */ function(ESInlineMessageValidationStatus) {
+	ESInlineMessageValidationStatus["DEFAULT"] = "default";
+	ESInlineMessageValidationStatus["ERROR"] = "error";
+	return ESInlineMessageValidationStatus;
+}({});
+//#endregion
+exports.ESInlineMessageValidationStatus = ESInlineMessageValidationStatus;

package/dist/components/SInlineMessage/SInlineMessage.types.js

@@ -0,0 +1,8 @@
+//#region src/components/SInlineMessage/SInlineMessage.types.ts
+var ESInlineMessageValidationStatus = /* @__PURE__ */ function(ESInlineMessageValidationStatus) {
+	ESInlineMessageValidationStatus["DEFAULT"] = "default";
+	ESInlineMessageValidationStatus["ERROR"] = "error";
+	return ESInlineMessageValidationStatus;
+}({});
+//#endregion
+export { ESInlineMessageValidationStatus };

package/dist/components/SInlineMessage/SInlineMessage.vue.cjs

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

package/dist/components/SInlineMessage/SInlineMessage.vue.js

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

package/dist/components/SInlineMessage/SInlineMessage.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1,20 @@
+const require_SInlineMessage_types = require("./SInlineMessage.types.cjs");
+let vue = require("vue");
+//#region src/components/SInlineMessage/SInlineMessage.vue?vue&type=script&setup=true&lang.ts
+var SInlineMessage_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ (0, vue.defineComponent)({
+	__name: "SInlineMessage",
+	props: {
+		message: {},
+		validationStatus: { default: () => require_SInlineMessage_types.ESInlineMessageValidationStatus.DEFAULT }
+	},
+	setup(__props) {
+		const inlineMessageClasses = (0, vue.computed)(() => {
+			return { "s-ui-inline-message--error": __props.validationStatus === require_SInlineMessage_types.ESInlineMessageValidationStatus.ERROR };
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("span", { class: (0, vue.normalizeClass)(["s-ui-inline-message s-ui-typography-label-12-medium", inlineMessageClasses.value]) }, (0, vue.toDisplayString)(__props.message), 3);
+		};
+	}
+});
+//#endregion
+exports.default = SInlineMessage_vue_vue_type_script_setup_true_lang_default;

package/dist/components/SInlineMessage/SInlineMessage.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,20 @@
+import { ESInlineMessageValidationStatus } from "./SInlineMessage.types.js";
+import { computed, createElementBlock, defineComponent, normalizeClass, openBlock, toDisplayString } from "vue";
+//#region src/components/SInlineMessage/SInlineMessage.vue?vue&type=script&setup=true&lang.ts
+var SInlineMessage_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "SInlineMessage",
+	props: {
+		message: {},
+		validationStatus: { default: () => ESInlineMessageValidationStatus.DEFAULT }
+	},
+	setup(__props) {
+		const inlineMessageClasses = computed(() => {
+			return { "s-ui-inline-message--error": __props.validationStatus === ESInlineMessageValidationStatus.ERROR };
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", { class: normalizeClass(["s-ui-inline-message s-ui-typography-label-12-medium", inlineMessageClasses.value]) }, toDisplayString(__props.message), 3);
+		};
+	}
+});
+//#endregion
+export { SInlineMessage_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/SInput/SInput.types.cjs

@@ -0,0 +1,9 @@
+//#region src/components/SInput/SInput.types.ts
+var ESInputCustomize = /* @__PURE__ */ function(ESInputCustomize) {
+	ESInputCustomize["NONE"] = "none";
+	ESInputCustomize["HORIZONTAL"] = "horizontal";
+	ESInputCustomize["VERTICAL"] = "vertical";
+	return ESInputCustomize;
+}({});
+//#endregion
+exports.ESInputCustomize = ESInputCustomize;

package/dist/components/SInput/SInput.types.js

@@ -0,0 +1,9 @@
+//#region src/components/SInput/SInput.types.ts
+var ESInputCustomize = /* @__PURE__ */ function(ESInputCustomize) {
+	ESInputCustomize["NONE"] = "none";
+	ESInputCustomize["HORIZONTAL"] = "horizontal";
+	ESInputCustomize["VERTICAL"] = "vertical";
+	return ESInputCustomize;
+}({});
+//#endregion
+export { ESInputCustomize };

package/dist/components/SInput/SInput.vue.cjs

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

package/dist/components/SInput/SInput.vue.js

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