@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/controls/SSelect.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,241 @@
+import { findRelativeTabTarget as e } from "../../../internal/focusNavigation.js";
+import { registerLayer as t } from "../../../internal/layerStack.js";
+import { useFloatingPosition as n } from "../../../composables/useFloatingPosition.js";
+import { useUiKitLocale as r } from "../../../composables/useUiKitLocale.js";
+import { mergeIdReferences as i, useOwnedAttrs as a } from "../../../internal/ownedAttrs.js";
+import { validateBoolean as o, validateDomId as ee, validateExactString as s, validateNonEmptyString as c } from "../../../internal/runtimeContract.js";
+import l from "./SField.vue.js";
+import { isSelectionModelList as u, resolveSelectionInventory as te, validateOptionalSelectionString as d, validateSelectionMarker as f, validateSelectionModel as p } from "../_internal/selectionContract.js";
+import m from "./SComboboxTrigger.vue.js";
+import h from "./SListbox.vue.js";
+import { Teleport as g, computed as _, createBlock as v, createCommentVNode as ne, createElementBlock as re, createElementVNode as y, createVNode as b, defineComponent as x, mergeProps as S, nextTick as C, normalizeStyle as ie, onBeforeUnmount as w, openBlock as T, ref as E, unref as D, useId as ae, withCtx as oe } from "vue";
+//#region src/components/shared/controls/SSelect.vue?vue&type=script&setup=true&lang.ts
+var O = /*@__PURE__*/ x({
+	inheritAttrs: !1,
+	__name: "SSelect",
+	props: {
+		options: {},
+		label: { default: void 0 },
+		placeholder: { default: void 0 },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		errorMessage: { default: void 0 },
+		helpText: { default: void 0 },
+		emptyOptionLabel: { default: void 0 },
+		id: { default: void 0 },
+		size: { default: "md" },
+		appearance: { default: "field" },
+		align: { default: "left" },
+		triggerMarker: { default: void 0 },
+		title: { default: void 0 },
+		selectionMode: { default: void 0 },
+		modelValue: {}
+	},
+	emits: ["update:modelValue"],
+	setup(x, { emit: O }) {
+		let k = x, { t: A } = r(), j = O, M = a({
+			component: "SSelect",
+			owner: "combobox trigger"
+		}), N = _(() => M.bindings()), P = ae(), F = _(() => {
+			let e = s("SSelect", "selectionMode", k.selectionMode ?? "single", ["single", "multiple"]), t;
+			if (k.emptyOptionLabel !== void 0) {
+				if (e === "multiple") throw Error("SSelect: emptyOptionLabel is available only in single selection mode");
+				t = c("SSelect", "emptyOptionLabel", k.emptyOptionLabel);
+			}
+			return {
+				inputId: k.id === void 0 ? `s-select-${P}` : ee("SSelect", "id", k.id),
+				label: k.label === void 0 ? void 0 : c("SSelect", "label", k.label),
+				placeholder: c("SSelect", "placeholder", k.placeholder ?? A("forms.selectPlaceholder")),
+				disabled: o("SSelect", "disabled", k.disabled),
+				readonly: o("SSelect", "readonly", k.readonly),
+				required: o("SSelect", "required", k.required),
+				invalid: o("SSelect", "invalid", k.invalid),
+				errorMessage: d("SSelect", "errorMessage", k.errorMessage),
+				helpText: d("SSelect", "helpText", k.helpText),
+				size: s("SSelect", "size", k.size, [
+					"xs",
+					"sm",
+					"md"
+				]),
+				appearance: s("SSelect", "appearance", k.appearance, ["field", "swatch"]),
+				align: s("SSelect", "align", k.align, [
+					"left",
+					"right",
+					"center"
+				]),
+				triggerMarker: f("SSelect", "triggerMarker", k.triggerMarker),
+				title: d("SSelect", "title", k.title),
+				selectionMode: e,
+				emptyOptionLabel: t
+			};
+		}), I = _(() => `${F.value.inputId}-listbox`), L = _(() => F.value.selectionMode), R = _(() => te("SSelect", k.options)), z = _(() => p("SSelect", F.value.selectionMode, k.modelValue, R.value)), B = _(() => {
+			let e = N.value["aria-label"];
+			return e === void 0 ? F.value.label ?? F.value.placeholder : c("SSelect", "aria-label", e);
+		}), V = _(() => R.value.options.find((e) => z.value.has(e.token))?.option ?? null), H = _(() => R.value.options.filter((e) => z.value.has(e.token)).map((e) => e.option.label).join(", ")), U = _(() => F.value.emptyOptionLabel), W = _(() => {
+			let e = F.value.appearance === "swatch" ? "color" : "select", t = {
+				id: I.value,
+				label: B.value,
+				options: k.options,
+				variant: e,
+				invalid: F.value.invalid
+			};
+			if (F.value.selectionMode === "multiple") {
+				if (!u(k.modelValue)) throw TypeError("SSelect: multiple selection requires modelValue to be an array");
+				return {
+					...t,
+					selectionMode: "multiple",
+					modelValue: k.modelValue
+				};
+			}
+			if (u(k.modelValue)) throw TypeError("SSelect: single selection requires modelValue to be a selection key or null");
+			return {
+				...t,
+				selectionMode: "single",
+				modelValue: k.modelValue,
+				clearOptionLabel: F.value.emptyOptionLabel
+			};
+		}), G = E(!1), K = E("var(--s-layer-root-floating)"), q = null, J = E(null), Y = E(null), se = _(() => `bottom-${F.value.align === "left" ? "start" : F.value.align === "right" ? "end" : "center"}`), { anchorRef: X, panelRef: Z, floatingStyle: ce } = n({
+			active: G,
+			placement: () => se.value,
+			widthMatch: () => F.value.appearance === "field" ? "exact" : "none",
+			zIndex: () => K.value
+		});
+		function Q(e = "trigger") {
+			G.value && (G.value = !1, q?.unregister({ restoreFocus: e === "trigger" || e === "selection" || e === "escape" }), q = null, K.value = "var(--s-layer-root-floating)");
+		}
+		function $() {
+			let e = J.value;
+			if (!e) throw Error("SSelect: combobox trigger API is unavailable");
+			return e.getElement();
+		}
+		function le(t) {
+			let n = $(), r = q?.focusScope() ?? document, i = e(n, r, Z.value, t.shiftKey);
+			t.preventDefault(), Q("tab"), i && C(() => i.focus());
+		}
+		async function ue() {
+			if (z.value, U.value, F.value.disabled || F.value.readonly || G.value) return;
+			let e = $();
+			G.value = !0, q = t({
+				kind: "listbox",
+				root: () => Z.value,
+				anchor: () => X.value,
+				restoreTarget: e,
+				requestDismiss: (e) => Q(e === "escape" ? "escape" : "outside")
+			}), K.value = q.zIndex, await C(), G.value && Y.value?.focusSelectedOrFirst();
+		}
+		function de() {
+			G.value ? Q("trigger") : ue();
+		}
+		function fe(e) {
+			if (L.value === "multiple") {
+				if (!u(e)) throw TypeError("SSelect: multiple selection update must be an array");
+				p("SSelect update", "multiple", e, R.value), j("update:modelValue", e);
+				return;
+			}
+			if (u(e)) throw TypeError("SSelect: single selection update must be a selection key or null");
+			p("SSelect update", "single", e, R.value), j("update:modelValue", e), Q("selection");
+		}
+		return w(() => {
+			q?.unregister({ restoreFocus: !1 }), q = null;
+		}), (e, t) => (T(), v(l, {
+			"control-id": F.value.inputId,
+			label: F.value.label,
+			required: F.value.required,
+			"help-text": F.value.helpText,
+			"error-message": F.value.errorMessage,
+			invalid: F.value.invalid,
+			disabled: F.value.disabled,
+			readonly: F.value.readonly
+		}, {
+			default: oe((e) => [y("div", {
+				ref_key: "anchorRef",
+				ref: X,
+				class: "s-select-anchor"
+			}, [b(m, {
+				ref_key: "triggerRef",
+				ref: J,
+				id: e.controlId,
+				title: F.value.title,
+				"accessible-label": B.value,
+				expanded: G.value,
+				controls: I.value,
+				"display-value": H.value,
+				placeholder: F.value.placeholder,
+				marker: F.value.triggerMarker ?? V.value?.marker,
+				size: F.value.size,
+				disabled: e.disabled,
+				invalid: e.invalid,
+				"described-by": D(i)(N.value["aria-describedby"], e.describedBy),
+				required: e.required,
+				readonly: e.readonly,
+				"test-id": N.value["data-testid"],
+				test: N.value["data-test"],
+				"task-mapping-internal-value": N.value["data-task-mapping-internal-value"],
+				"task-mapping-kind": N.value["data-task-mapping-kind"],
+				appearance: F.value.appearance,
+				width: F.value.appearance === "swatch" ? "auto" : "full",
+				onToggle: de
+			}, null, 8, [
+				"id",
+				"title",
+				"accessible-label",
+				"expanded",
+				"controls",
+				"display-value",
+				"placeholder",
+				"marker",
+				"size",
+				"disabled",
+				"invalid",
+				"described-by",
+				"required",
+				"readonly",
+				"test-id",
+				"test",
+				"task-mapping-internal-value",
+				"task-mapping-kind",
+				"appearance",
+				"width"
+			])], 512), (T(), v(g, { to: "body" }, [G.value ? (T(), re("div", {
+				key: 0,
+				ref_key: "panelRef",
+				ref: Z,
+				style: ie(D(ce)),
+				class: "s-select-layer"
+			}, [b(h, S({
+				ref_key: "listboxRef",
+				ref: Y
+			}, W.value, {
+				"onUpdate:modelValue": fe,
+				onEscape: t[0] ||= (e) => Q("escape"),
+				onTab: le
+			}), null, 16)], 4)) : ne("", !0)]))]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid",
+			"disabled",
+			"readonly"
+		]));
+	}
+});
+//#endregion
+export { O as default };

package/dist/src/components/shared/controls/SSwitch.vue.d.ts

@@ -0,0 +1,29 @@
+export interface Props {
+    modelValue: boolean;
+    label?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    helpText?: string;
+    errorMessage?: string;
+    id?: string;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    required: boolean;
+    label: string;
+    id: string;
+    invalid: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    helpText: string;
+    errorMessage: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/shared/controls/SSwitch.vue.js

@@ -0,0 +1,8 @@
+import "../../../../assets/src/components/shared/controls/SSwitch.css_vue_type_style_index_0_src_7b4d74b5_scoped_7b4d74b5_lang.css";
+import e from "../../../../_virtual/_plugin-vue_export-helper.js";
+import t from "./SSwitch.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                                     */
+//#region src/components/shared/controls/SSwitch.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-7b4d74b5"]]);
+//#endregion
+export { n as default };

package/dist/src/components/shared/controls/SSwitch.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,99 @@
+import { mergeIdReferences as e, useOwnedAttrs as t } from "../../../internal/ownedAttrs.js";
+import { useInteractiveLeafRegistration as n } from "../../../internal/passiveContentContract.js";
+import { useBinaryInput as r } from "../../../internal/useBinaryInput.js";
+import i from "./SField.vue.js";
+import { createBlock as a, createElementVNode as o, defineComponent as s, mergeProps as c, openBlock as l, unref as u, withCtx as d, withModifiers as f } from "vue";
+//#region src/components/shared/controls/SSwitch.vue?vue&type=script&setup=true&lang.ts
+var p = { class: "s-switch-control" }, m = [
+	"id",
+	"checked",
+	"disabled",
+	"required",
+	"aria-checked",
+	"aria-invalid",
+	"aria-readonly",
+	"aria-describedby"
+], h = /*@__PURE__*/ s({
+	inheritAttrs: !1,
+	__name: "SSwitch",
+	props: {
+		modelValue: { type: Boolean },
+		label: { default: void 0 },
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		readonly: {
+			type: Boolean,
+			default: !1
+		},
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		invalid: {
+			type: Boolean,
+			default: !1
+		},
+		helpText: { default: void 0 },
+		errorMessage: { default: void 0 },
+		id: { default: void 0 }
+	},
+	emits: ["update:modelValue", "click"],
+	setup(s, { emit: h }) {
+		let g = s, _ = h, v = t({
+			component: "SSwitch",
+			owner: "native switch input"
+		});
+		n({ owner: "SSwitch" });
+		let { checkedValue: y, inputId: b, onChange: x, onClick: S, setInputElement: C } = r({
+			owner: "SSwitch",
+			inputName: "switch",
+			props: g,
+			emitUpdate: (e) => _("update:modelValue", e),
+			emitClick: (e) => _("click", e)
+		});
+		return (t, n) => (l(), a(i, {
+			"control-id": u(b),
+			label: s.label,
+			required: s.required,
+			"help-text": s.helpText,
+			"error-message": s.errorMessage,
+			invalid: s.invalid,
+			disabled: s.disabled,
+			readonly: s.readonly,
+			layout: "inline"
+		}, {
+			default: d((t) => [o("span", p, [o("input", c({ ref: u(C) }, u(v).bindings(), {
+				id: t.controlId,
+				type: "checkbox",
+				role: "switch",
+				class: "s-switch-input",
+				checked: u(y),
+				disabled: t.disabled,
+				required: t.required,
+				"aria-checked": u(y),
+				"aria-invalid": t.invalid || void 0,
+				"aria-readonly": t.readonly || void 0,
+				"aria-describedby": u(e)(u(v).string("aria-describedby"), t.describedBy),
+				onClick: n[0] ||= f((...e) => u(S) && u(S)(...e), ["stop"]),
+				onChange: n[1] ||= (...e) => u(x) && u(x)(...e)
+			}), null, 16, m), n[2] ||= o("span", {
+				class: "s-switch-track",
+				"aria-hidden": "true"
+			}, [o("span", { class: "s-switch-thumb" })], -1)])]),
+			_: 1
+		}, 8, [
+			"control-id",
+			"label",
+			"required",
+			"help-text",
+			"error-message",
+			"invalid",
+			"disabled",
+			"readonly"
+		]));
+	}
+});
+//#endregion
+export { h as default };

package/dist/src/components/shared/controls/STextarea.d.ts

@@ -0,0 +1 @@
+export type { Props as STextareaProps, STextareaApi, STextareaAppearance, STextareaAutocomplete, STextareaSuggestionPopupRole, STextareaSuggestions, STextareaReplaceOptions, STextareaResizeContract, STextareaSelection, STextareaSelectionDirection, STextareaSize, STextareaState, } from './STextarea.vue';

package/dist/src/components/shared/controls/STextarea.vue.d.ts

@@ -0,0 +1,121 @@
+/** Визуальная интеграция native textarea с SField. / Native textarea visual integration with SField. */
+export type STextareaAppearance = 'default' | 'ghost';
+export type STextareaSize = 'sm' | 'md' | 'lg';
+export type STextareaSelectionDirection = 'forward' | 'backward' | 'none';
+export type STextareaAutocomplete = 'list' | 'both' | 'inline' | 'none';
+export type STextareaSuggestionPopupRole = 'listbox' | 'grid' | 'tree' | 'dialog';
+/** Полный native selection contract без сведения диапазона к одному cursor. */
+export interface STextareaSelection {
+    start: number;
+    end: number;
+    direction: STextareaSelectionDirection;
+}
+/** Связь multiline textbox с consumer-owned suggestion popup без недопустимого role="combobox" на textarea. */
+export interface STextareaSuggestions {
+    controls: string;
+    activeDescendant?: string;
+    autocomplete?: STextareaAutocomplete;
+    popupRole?: STextareaSuggestionPopupRole;
+}
+export interface STextareaState {
+    text: string;
+    cursor: number;
+    selection: STextareaSelection;
+    composing: boolean;
+}
+export interface STextareaReplaceOptions {
+    selection?: STextareaSelection;
+    selectionMode?: SelectionMode;
+    focus?: boolean;
+}
+/** Typed imperative surface for focus, selection, resizing, and controlled edits. */
+export interface STextareaApi {
+    focus(): void;
+    getSelection(): STextareaSelection;
+    getSelectionOffset(): number;
+    insertSoftLineBreak(): void;
+    replaceSelection(text: string, options?: STextareaReplaceOptions): STextareaState;
+    resize(): void;
+    setSelection(selection: STextareaSelection, focusOwner?: boolean): void;
+    setSelectionOffset(offset: number): void;
+}
+/**
+ * Дискриминированный resize contract: fixed не имеет maxRows, content может быть bounded или unbounded.
+ * Discriminated resize contract: fixed has no maxRows; content can be bounded or unbounded.
+ */
+export type STextareaResizeContract = {
+    mode: 'fixed';
+    autoResize: false;
+} | {
+    mode: 'content';
+    autoResize: true;
+    maxRows?: number;
+    minHeight?: number;
+    maxHeight?: number;
+};
+export interface Props {
+    modelValue: string | null;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    errorMessage?: string;
+    helpText?: string;
+    id?: string;
+    rows?: number;
+    size?: STextareaSize;
+    autoResize?: boolean;
+    maxRows?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    suggestions?: STextareaSuggestions;
+    appearance?: STextareaAppearance;
+    monospace?: boolean;
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, STextareaApi, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (mouseEvent: MouseEvent) => any;
+    compositionend: (compositionEvent: CompositionEvent) => any;
+    compositionstart: (compositionEvent: CompositionEvent) => any;
+    compositionupdate: (compositionEvent: CompositionEvent) => any;
+    keydown: (keyboardEvent: KeyboardEvent) => any;
+    keyup: (keyboardEvent: KeyboardEvent) => any;
+    paste: (clipboardEvent: ClipboardEvent) => any;
+    "update:modelValue": (value: string) => any;
+    "selection-change": (selection: STextareaSelection) => any;
+    "state-change": (state: STextareaState) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((mouseEvent: MouseEvent) => any) | undefined;
+    onCompositionend?: ((compositionEvent: CompositionEvent) => any) | undefined;
+    onCompositionstart?: ((compositionEvent: CompositionEvent) => any) | undefined;
+    onCompositionupdate?: ((compositionEvent: CompositionEvent) => any) | undefined;
+    onKeydown?: ((keyboardEvent: KeyboardEvent) => any) | undefined;
+    onKeyup?: ((keyboardEvent: KeyboardEvent) => any) | undefined;
+    onPaste?: ((clipboardEvent: ClipboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onSelection-change"?: ((selection: STextareaSelection) => any) | undefined;
+    "onState-change"?: ((state: STextareaState) => any) | undefined;
+}>, {
+    required: boolean;
+    label: string;
+    id: string;
+    invalid: boolean;
+    size: STextareaSize;
+    maxHeight: number;
+    placeholder: string;
+    disabled: boolean;
+    readonly: boolean;
+    rows: number;
+    helpText: string;
+    errorMessage: string;
+    modelValue: string | null;
+    appearance: STextareaAppearance;
+    autoResize: boolean;
+    maxRows: number;
+    minHeight: number;
+    suggestions: STextareaSuggestions;
+    monospace: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/components/shared/controls/STextarea.vue.js

@@ -0,0 +1,7 @@
+import "../../../../assets/src/components/shared/controls/STextarea.css_vue_type_style_index_0_src_true_lang.css";
+import e from "./STextarea.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                   */
+//#region src/components/shared/controls/STextarea.vue
+var t = e;
+//#endregion
+export { t as default };