@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/_internal/selectionContract.js

@@ -0,0 +1,138 @@
+import { validateBoolean as e, validateNonEmptyString as t } from "../../../internal/runtimeContract.js";
+import { selectionKeyToken as n, validateSelectionIdentities as r } from "./useSelectionRoving.js";
+import { createCustomMarker as i } from "./markerContract.js";
+//#region src/components/shared/_internal/selectionContract.ts
+var a = /* @__PURE__ */ new Set([
+	"value",
+	"label",
+	"title",
+	"marker",
+	"disabled"
+]), o = /* @__PURE__ */ new Set([
+	"groupId",
+	"label",
+	"options"
+]), s = [
+	"surface",
+	"primary",
+	"success",
+	"blue",
+	"sky",
+	"indigo",
+	"emerald",
+	"green",
+	"teal",
+	"amber",
+	"orange",
+	"rose",
+	"pink",
+	"fuchsia",
+	"cyan",
+	"lime",
+	"custom"
+];
+function c(e, t, n) {
+	if (typeof n != "object" || !n || Array.isArray(n)) throw TypeError(`${e}: ${t} must be an option object or an option group`);
+}
+function l(e, t, n, r) {
+	let i = Object.keys(n).find((e) => !r.has(e));
+	if (i !== void 0) throw TypeError(`${e}: ${t}.${i} is not part of the selection contract`);
+}
+function u(e, t, n) {
+	if (n !== void 0) {
+		if (typeof n != "string") throw TypeError(`${e}: ${t} must be a string when provided`);
+		return n;
+	}
+}
+function d(e, n, r) {
+	if (r === void 0) return;
+	c(e, n, r);
+	let a = r.tone;
+	if (typeof a != "string" || !s.some((e) => e === a)) throw TypeError(`${e}: ${n}.tone is not a supported marker tone`);
+	return l(e, n, r, a === "custom" ? /* @__PURE__ */ new Set(["tone", "color"]) : /* @__PURE__ */ new Set(["tone"])), a === "custom" && i(t(e, `${n}.color`, r.color)), r;
+}
+function f(r, i, o) {
+	c(r, o, i), l(r, o, i, a);
+	let s = i.value, f = n(r, s, `${o}.value`), p = t(r, `${o}.label`, i.label), m = u(r, `${o}.title`, i.title);
+	i.disabled !== void 0 && e(r, `${o}.disabled`, i.disabled);
+	let h = d(r, `${o}.marker`, i.marker);
+	return {
+		option: {
+			value: s,
+			label: p,
+			...m === void 0 ? {} : { title: m },
+			...h === void 0 ? {} : { marker: h },
+			...i.disabled === void 0 ? {} : { disabled: i.disabled }
+		},
+		token: f,
+		coordinate: o
+	};
+}
+function p(e, i) {
+	if (!Array.isArray(i)) throw TypeError(`${e}: options must be an array`);
+	let a = i, s = [], u = [], d = [], p = [];
+	for (let [r, i] of a.entries()) {
+		let a = `options[${r}]`;
+		if (c(e, a, i), "groupId" in i) {
+			l(e, a, i, o);
+			let r = t(e, `${a}.groupId`, i.groupId), c = t(e, `${a}.label`, i.label);
+			if (!Array.isArray(i.options)) throw TypeError(`${e}: ${a}.options must be an array`);
+			if (i.options.length === 0) throw Error(`${e}: ${a}.options must contain at least one option`);
+			p.push({
+				key: r,
+				coordinate: `${a}.groupId`
+			});
+			let m = i.options.map((t, n) => {
+				let r = `${a}.options[${n}]`, i = f(e, t, r);
+				return d.push({
+					key: i.option.value,
+					coordinate: `${r}.value`
+				}), u.push(i), i;
+			});
+			s.push({
+				kind: "group",
+				groupId: r,
+				label: c,
+				records: m,
+				token: `group:${n(e, r, `${a}.groupId`)}`
+			});
+			continue;
+		}
+		let m = f(e, i, a);
+		d.push({
+			key: m.option.value,
+			coordinate: `${a}.value`
+		}), u.push(m), s.push({
+			kind: "option",
+			record: m,
+			token: `option:${m.token}`
+		});
+	}
+	return r(`${e} groups`, p), r(e, d), {
+		entries: s,
+		options: u,
+		optionsByToken: new Map(u.map((e) => [e.token, e]))
+	};
+}
+function m(e, t, i, a) {
+	if (i === void 0) throw TypeError(`${e}: modelValue is required and cannot be undefined`);
+	if (t === "multiple") {
+		if (!Array.isArray(i)) throw TypeError(`${e}: multiple selection requires modelValue to be an array`);
+		let t = r(`${e} modelValue`, i.map((e, t) => ({
+			key: e,
+			coordinate: `modelValue[${t}]`
+		})));
+		for (let n of t.keys()) if (!a.optionsByToken.has(n)) throw Error(`${e}: modelValue does not match every option`);
+		return new Set(t.keys());
+	}
+	if (h(i)) throw TypeError(`${e}: single selection requires modelValue to be a selection key or null`);
+	if (i === null) return /* @__PURE__ */ new Set();
+	let o = n(e, i, "modelValue");
+	if (!a.optionsByToken.has(o)) throw Error(`${e}: modelValue does not match any option`);
+	return /* @__PURE__ */ new Set([o]);
+}
+function h(e) {
+	return Array.isArray(e);
+}
+//#endregion
+export { h as isSelectionModelList, p as resolveSelectionInventory, u as validateOptionalSelectionString, d as validateSelectionMarker, m as validateSelectionModel };

package/dist/src/components/shared/_internal/sidebarGroupContext.d.ts

@@ -0,0 +1,27 @@
+import { ComputedRef, InjectionKey, Ref } from 'vue';
+import { SectionState, SidebarSectionsState } from '../containers/sidebar';
+/** Stable mounted descriptor registered by one SSidebarSection. */
+export interface SidebarSectionRegistration {
+    readonly key: string;
+    readonly element: HTMLElement;
+}
+/** DOM-ordered registered section with its exact controlled state. */
+export interface RegisteredSidebarSection {
+    readonly key: string;
+    readonly element: HTMLElement;
+    readonly state: Readonly<SectionState>;
+}
+export type SidebarSectionStyle = Readonly<Record<string, string | number>>;
+export interface SidebarGroupContext {
+    readonly sectionsState: ComputedRef<SidebarSectionsState>;
+    readonly orderedSections: ComputedRef<readonly RegisteredSidebarSection[]>;
+    readonly geometryRevision: Readonly<Ref<number>>;
+    registerSection(registration: SidebarSectionRegistration): () => void;
+    toggleSection(key: string): void;
+    getSectionStyle(key: string): SidebarSectionStyle;
+    getSectionSize(key: string): number;
+    beginResize(topKey: string, bottomKey: string): void;
+    resizeSections(topKey: string, bottomKey: string, requestedTopSize: number): void;
+    finishResize(topKey: string, bottomKey: string): void;
+}
+export declare const sidebarGroupContextKey: InjectionKey<SidebarGroupContext>;

package/dist/src/components/shared/_internal/sidebarGroupContext.js

@@ -0,0 +1,4 @@
+//#region src/components/shared/_internal/sidebarGroupContext.ts
+var e = Symbol("SidebarGroupContext");
+//#endregion
+export { e as sidebarGroupContextKey };

package/dist/src/components/shared/_internal/tabsContext.d.ts

@@ -0,0 +1,51 @@
+import { ComputedRef, InjectionKey } from 'vue';
+export type STabsActivationMode = 'automatic' | 'manual';
+export type STabRegistrationKey = string;
+export type STabPanelRegistrationKey = string;
+export type STabListRegistrationKey = symbol;
+export type STabPanelsRegistrationKey = symbol;
+export interface STabRegistration {
+    readonly tabKey: string;
+    readonly disabled: () => boolean;
+    readonly element: () => HTMLElement | null;
+}
+export interface STabPanelRegistration {
+    readonly tabKey: string;
+    readonly element: () => HTMLElement | null;
+}
+export interface STabState {
+    readonly active: boolean;
+    readonly disabled: boolean;
+    readonly tabIndex: 0 | -1;
+    readonly tabId: string;
+    readonly panelId: string | undefined;
+}
+export interface STabPanelState {
+    readonly active: boolean;
+    readonly panelId: string;
+    readonly tabId: string | undefined;
+}
+export interface STabsContext {
+    readonly activeKey: ComputedRef<string | null>;
+    readonly activationMode: ComputedRef<STabsActivationMode>;
+    readonly closeButtonMode: ComputedRef<'reserve' | 'overlay'>;
+    readonly closeButtonVisibility: ComputedRef<'always' | 'active-hover' | 'hover'>;
+    readonly tabDensity: ComputedRef<'compact' | 'default' | 'comfortable'>;
+    readonly registerTab: (registration: STabRegistration) => STabRegistrationKey;
+    readonly unregisterTab: (key: STabRegistrationKey) => void;
+    readonly notifyTabOrderChanged: () => void;
+    readonly getTabState: (key: STabRegistrationKey) => STabState;
+    readonly getActiveTabElement: () => HTMLElement | null;
+    readonly activateTab: (key: STabRegistrationKey) => void;
+    readonly focusTab: (key: STabRegistrationKey) => void;
+    readonly registerPanel: (registration: STabPanelRegistration) => STabPanelRegistrationKey;
+    readonly unregisterPanel: (key: STabPanelRegistrationKey) => void;
+    readonly notifyPanelOrderChanged: () => void;
+    readonly getPanelState: (key: STabPanelRegistrationKey) => STabPanelState;
+    readonly handleTabKeydown: (key: STabRegistrationKey, event: KeyboardEvent) => void;
+    readonly registerTabList: (scrollActiveIntoCenter: () => void) => STabListRegistrationKey;
+    readonly unregisterTabList: (key: STabListRegistrationKey) => void;
+    readonly registerPanels: () => STabPanelsRegistrationKey;
+    readonly unregisterPanels: (key: STabPanelsRegistrationKey) => void;
+}
+export declare const tabsContextKey: InjectionKey<STabsContext>;

package/dist/src/components/shared/_internal/tabsContext.js

@@ -0,0 +1,4 @@
+//#region src/components/shared/_internal/tabsContext.ts
+var e = Symbol("STabsContext");
+//#endregion
+export { e as tabsContextKey };

package/dist/src/components/shared/_internal/treeRuntime.d.ts

@@ -0,0 +1,68 @@
+import { ComputedRef, InjectionKey, Ref } from 'vue';
+import { STreeNodeContentScope, TreeActionsLayout, TreeActivationOrigin, TreeDensity, TreeExpandControl, SelectionKey, TreeModel, TreeRowVariant, TreeSelection, TreeSelectionRail } from '../complex/types';
+export declare const TREE_RUNTIME_KEY = "s-tree-runtime";
+export declare const TREE_ACTION_CONTEXT_KEY: InjectionKey<TreeActionContext>;
+export interface RegisteredTreeItem<T extends object, K extends SelectionKey> {
+    key: K;
+    parentKey?: K;
+    node: T;
+    element: HTMLElement;
+    activate(origin: TreeActivationOrigin): void;
+    select(): void;
+    toggle(): void;
+    expanded(): boolean;
+    hasChildren(): boolean;
+    disabled(): boolean;
+}
+export type TreeActionKey = symbol;
+export interface RegisteredTreeAction {
+    readonly key: TreeActionKey;
+    readonly element: HTMLElement;
+    focus(options?: FocusOptions): void;
+    disabled(): boolean;
+}
+export interface TreeActionContext {
+    register(action: RegisteredTreeAction): void;
+    unregister(action: RegisteredTreeAction): void;
+}
+export declare class TreeItemRegistrationStore<T extends object, K extends SelectionKey> {
+    #private;
+    constructor(root: () => HTMLElement | null);
+    register(item: RegisteredTreeItem<T, K>): void;
+    unregister(key: K): void;
+    get(key: K): RegisteredTreeItem<T, K> | undefined;
+    ordered(): RegisteredTreeItem<T, K>[];
+}
+export declare class TreeActionRegistrationStore implements TreeActionContext {
+    #private;
+    constructor(root: () => HTMLElement | null);
+    register(action: RegisteredTreeAction): void;
+    unregister(action: RegisteredTreeAction): void;
+    orderedEnabled(): RegisteredTreeAction[];
+    actionForTarget(target: EventTarget | null): RegisteredTreeAction | undefined;
+}
+export declare function useTreeActionRegistration(options: Readonly<{
+    owner: string;
+    element: Readonly<Ref<HTMLElement | null>>;
+    disabled: () => boolean;
+}>): boolean;
+export interface TreeRuntime<T extends object, K extends SelectionKey> {
+    model: TreeModel<T, K>;
+    selection: ComputedRef<TreeSelection<K>>;
+    expanded: ComputedRef<ReadonlySet<K>>;
+    density: ComputedRef<TreeDensity>;
+    actionsLayout: ComputedRef<TreeActionsLayout>;
+    expandControl: ComputedRef<TreeExpandControl>;
+    selectionRail: ComputedRef<TreeSelectionRail>;
+    rowVariant: ComputedRef<TreeRowVariant>;
+    activeKey: Ref<K | undefined>;
+    activateNode(node: T, origin: TreeActivationOrigin): void;
+    selectNode(node: T): void;
+    toggleNode(node: T): void;
+    checkNode(node: T): void;
+    multipleKeys(node: T): readonly K[];
+    register(item: RegisteredTreeItem<T, K>): void;
+    unregister(key: K): void;
+    handleItemKeydown(item: RegisteredTreeItem<T, K>, event: KeyboardEvent): void;
+}
+export type TreeNodeScope<T extends object, K extends SelectionKey> = STreeNodeContentScope<T, K>;

package/dist/src/components/shared/_internal/treeRuntime.js

@@ -0,0 +1,81 @@
+import { inject as e, onBeforeUnmount as t, onMounted as n } from "vue";
+//#region src/components/shared/_internal/treeRuntime.ts
+var r = "s-tree-runtime", i = Symbol("s-tree-action-context");
+function a(e, t, n) {
+	if (t.element === n.element) return 0;
+	let r = t.element.compareDocumentPosition(n.element), i = t.element.ownerDocument.defaultView?.Node;
+	if (!i) throw Error(`${e}: registered elements require an active DOM document`);
+	if ((r & i.DOCUMENT_POSITION_DISCONNECTED) !== 0) throw Error(`${e}: registered elements must belong to the same DOM tree`);
+	if ((r & i.DOCUMENT_POSITION_FOLLOWING) !== 0) return -1;
+	if ((r & i.DOCUMENT_POSITION_PRECEDING) !== 0) return 1;
+	throw Error(`${e}: registered elements have no deterministic DOM order`);
+}
+function o(e, t, n) {
+	return t ? [...n].filter((e) => e.element.isConnected && t.contains(e.element)).sort((t, n) => a(e, t, n)) : [];
+}
+var s = class {
+	#e = /* @__PURE__ */ new Map();
+	#t;
+	constructor(e) {
+		this.#t = e;
+	}
+	register(e) {
+		let t = this.#e.get(e.key);
+		if (t && t.element !== e.element) throw Error(`STree: runtime registration collision for ${typeof e.key}:${String(e.key)}`);
+		this.#e.set(e.key, e);
+	}
+	unregister(e) {
+		this.#e.delete(e);
+	}
+	get(e) {
+		return this.#e.get(e);
+	}
+	ordered() {
+		return o("STree item registry", this.#t(), this.#e.values());
+	}
+}, c = class {
+	#e = /* @__PURE__ */ new Map();
+	#t;
+	constructor(e) {
+		this.#t = e;
+	}
+	register(e) {
+		let t = this.#e.get(e.key);
+		if (t && t !== e) throw Error(`STree: action registration collision for ${String(e.key)}`);
+		let n = [...this.#e.values()].find((t) => t.key !== e.key && t.element === e.element);
+		if (n) throw Error(`STree: action element is already registered by ${String(n.key)}`);
+		this.#e.set(e.key, e);
+	}
+	unregister(e) {
+		let t = this.#e.get(e.key);
+		if (t) {
+			if (t !== e) throw Error(`STree: stale action unregistration for ${String(e.key)}`);
+			this.#e.delete(e.key);
+		}
+	}
+	orderedEnabled() {
+		return o("STree action registry", this.#t(), this.#e.values()).filter((e) => !e.disabled());
+	}
+	actionForTarget(e) {
+		if (e instanceof Node) return this.orderedEnabled().find((t) => t.element === e || t.element.contains(e));
+	}
+};
+function l(r) {
+	let a = e(i, null);
+	if (!a) return !1;
+	let o = Symbol(r.owner), s;
+	return n(() => {
+		let e = r.element.value;
+		if (!e) throw Error(`STree: ${r.owner} action registration requires a mounted element`);
+		s = {
+			key: o,
+			element: e,
+			focus: (t) => e.focus(t),
+			disabled: r.disabled
+		}, a.register(s);
+	}), t(() => {
+		s && a.unregister(s);
+	}), !0;
+}
+//#endregion
+export { i as TREE_ACTION_CONTEXT_KEY, r as TREE_RUNTIME_KEY, c as TreeActionRegistrationStore, s as TreeItemRegistrationStore, l as useTreeActionRegistration };

package/dist/src/components/shared/_internal/useRadioGroup.d.ts

@@ -0,0 +1,32 @@
+import { ComponentPublicInstance, ComputedRef, Ref } from 'vue';
+import { SelectionKey, SelectionRovingOption } from './useSelectionRoving';
+/** Опция общего radio-group runtime. / An option accepted by the shared radio-group runtime. */
+export type RadioGroupOption<T extends SelectionKey> = SelectionRovingOption<T>;
+/** ARIA-контракт контейнера radio-group. / ARIA contract for a radio-group container. */
+export interface RadioGroupAriaContract {
+    labelledBy: string;
+    describedBy?: string;
+    required?: boolean;
+    invalid?: boolean;
+}
+/** Общий runtime-контракт radio-group без визуального представления. / Shared radio-group runtime without presentation ownership. */
+export interface RadioGroupRuntime<T extends SelectionKey> {
+    focusableValue: ComputedRef<T | undefined>;
+    groupBindings: (contract: RadioGroupAriaContract) => Record<string, unknown>;
+    optionBindings: (option: RadioGroupOption<T>) => Record<string, unknown>;
+    optionRef: (value: T) => (element: Element | ComponentPublicInstance | null) => void;
+    optionToken: (value: T) => string;
+}
+/**
+ * Централизует identity, ARIA, readonly/disabled и roving-focus radio-group.
+ * Centralizes identity, ARIA, readonly/disabled, and roving focus for a radio group.
+ */
+export declare function useRadioGroup<T extends SelectionKey>(config: {
+    component: string;
+    options: ComputedRef<readonly RadioGroupOption<T>[]>;
+    selectedValue: Ref<T | null | undefined>;
+    disabled: ComputedRef<boolean>;
+    readonly: ComputedRef<boolean>;
+    update: (value: T) => void;
+    orientation?: 'horizontal' | 'vertical' | 'both';
+}): RadioGroupRuntime<T>;

package/dist/src/components/shared/_internal/useRadioGroup.js

@@ -0,0 +1,48 @@
+import { selectionKeyToken as e, useSelectionRoving as t } from "./useSelectionRoving.js";
+import { computed as n } from "vue";
+//#region src/components/shared/_internal/useRadioGroup.ts
+function r(e) {
+	return e instanceof HTMLElement ? e : null;
+}
+function i(i) {
+	let a = n(() => i.disabled.value ? i.options.value.map((e) => ({
+		...e,
+		disabled: !0
+	})) : i.options.value), o = (e) => {
+		let t = i.options.value.find((t) => t.value === e);
+		i.disabled.value || i.readonly.value || t?.disabled || i.update(e);
+	}, s = t({
+		options: a,
+		selectedValue: i.selectedValue,
+		orientation: i.orientation,
+		select: o,
+		component: i.component
+	});
+	return {
+		focusableValue: s.focusableValue,
+		groupBindings: (e) => ({
+			role: "radiogroup",
+			"aria-labelledby": e.labelledBy,
+			"aria-describedby": e.describedBy,
+			"aria-required": e.required || void 0,
+			"aria-invalid": e.invalid || void 0,
+			"aria-disabled": i.disabled.value || void 0,
+			"aria-readonly": i.readonly.value || void 0
+		}),
+		optionBindings: (e) => ({
+			type: "button",
+			role: "radio",
+			disabled: i.disabled.value || e.disabled,
+			"aria-checked": e.value === i.selectedValue.value,
+			tabindex: e.value === s.focusableValue.value ? 0 : -1,
+			onClick: () => o(e.value),
+			onKeydown: (t) => s.handleKeydown(t, e.value)
+		}),
+		optionRef: (e) => (t) => {
+			s.register(e, r(t));
+		},
+		optionToken: (t) => e(i.component, t, "option.value")
+	};
+}
+//#endregion
+export { i as useRadioGroup };

package/dist/src/components/shared/_internal/useSelectionRoving.d.ts

@@ -0,0 +1,36 @@
+import { ComputedRef, Ref } from 'vue';
+/** Стабильный ключ, принимаемый владельцами выбора. / Stable key accepted by selection owners. */
+export type SelectionKey = string | number;
+/** Ключ и точная координата его объявления для диагностики. / A key and its exact declaration coordinate for diagnostics. */
+export interface SelectionIdentity<T extends SelectionKey = SelectionKey> {
+    key: T;
+    coordinate: string;
+}
+/** Опция общего roving-focus с состоянием доступности. / A shared roving-focus option with availability state. */
+export interface SelectionRovingOption<T extends SelectionKey> {
+    value: T;
+    disabled?: boolean;
+}
+/** Публичный keyboard/focus-контракт владельца выбора. / Public keyboard/focus contract for a selection owner. */
+export interface SelectionRovingApi<T extends SelectionKey> {
+    focusableValue: ComputedRef<T | undefined>;
+    register: (value: T, element: Element | null) => void;
+    handleKeydown: (event: KeyboardEvent, value: T) => void;
+}
+/** Проверяет runtime-контракт identity в точной координате вызова. / Asserts the runtime identity contract at the exact caller coordinate. */
+export declare function assertSelectionKey(component: string, key: unknown, coordinate: string): asserts key is SelectionKey;
+/** Возвращает type-aware token для DOM id, Vue key и lookup map. / Returns a type-aware token for DOM ids, Vue keys, and lookup maps. */
+export declare function selectionKeyToken(component: string, key: SelectionKey, coordinate: string): string;
+/** Проверяет полный inventory identity и возвращает канонический индекс. / Validates a complete identity inventory and returns its canonical index. */
+export declare function validateSelectionIdentities<T extends SelectionKey>(component: string, identities: readonly SelectionIdentity<T>[]): ReadonlyMap<string, T>;
+/**
+ * Управляет общим roving-focus без потери доменного типа ключа.
+ * Manages shared roving focus without losing the domain key type.
+ */
+export declare function useSelectionRoving<T extends SelectionKey>(config: {
+    options: ComputedRef<readonly SelectionRovingOption<T>[]>;
+    selectedValue: Ref<T | null | undefined>;
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    select: (value: T) => void;
+    component?: string;
+}): SelectionRovingApi<T>;

package/dist/src/components/shared/_internal/useSelectionRoving.js

@@ -0,0 +1,58 @@
+import { computed as e } from "vue";
+//#region src/components/shared/_internal/useSelectionRoving.ts
+function t(e, t) {
+	return `${e}: ${t} must be a non-empty string or a finite number`;
+}
+function n(e, n, r) {
+	if (typeof n == "string") {
+		if (n.trim().length === 0) throw TypeError(t(e, r));
+		return;
+	}
+	if (!(typeof n == "number" && Number.isFinite(n))) throw TypeError(t(e, r));
+}
+function r(e, t, r) {
+	return n(e, t, r), typeof t == "string" ? `string:${encodeURIComponent(t)}` : `number:${Object.is(t, -0) ? "0" : String(t)}`;
+}
+function i(e, t) {
+	let n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+	for (let a of t) {
+		let t = r(e, a.key, a.coordinate), o = i.get(t);
+		if (o !== void 0) throw Error(`${e}: duplicate selection key at ${a.coordinate}; first declared at ${o}`);
+		i.set(t, a.coordinate), n.set(t, a.key);
+	}
+	return n;
+}
+function a(e, t) {
+	return i(e, t.map((e, t) => ({
+		key: e.value,
+		coordinate: `options[${t}].value`
+	})));
+}
+function o(e, t, n) {
+	if (t == null) return;
+	let i = r(e, t, "selectedValue");
+	if (!n.has(i)) throw Error(`${e}: selectedValue does not match any option`);
+}
+function s(t) {
+	let n = /* @__PURE__ */ new Map(), i = t.orientation ?? "both", s = t.component ?? "useSelectionRoving", c = e(() => {
+		let e = t.options.value, n = a(s, e);
+		return o(s, t.selectedValue.value, n), e;
+	}), l = e(() => c.value.filter((e) => !e.disabled));
+	return {
+		focusableValue: e(() => {
+			let e = t.selectedValue.value;
+			return l.value.find((t) => t.value === e)?.value ?? l.value[0]?.value;
+		}),
+		register: (e, t) => {
+			r(s, e, "registered value"), t instanceof HTMLElement ? n.set(e, t) : n.delete(e);
+		},
+		handleKeydown: (e, r) => {
+			let a = i !== "vertical" && e.key === "ArrowLeft" ? -1 : i !== "vertical" && e.key === "ArrowRight" ? 1 : i !== "horizontal" && e.key === "ArrowUp" ? -1 : i !== "horizontal" && e.key === "ArrowDown" ? 1 : null, o = l.value;
+			if (o.length === 0) return;
+			let s = o.findIndex((e) => e.value === r), c = e.key === "Home" ? o[0] : e.key === "End" ? o[o.length - 1] : a === null ? void 0 : o[(Math.max(s, 0) + a + o.length) % o.length];
+			c && (e.preventDefault(), t.select(c.value), n.get(c.value)?.focus());
+		}
+	};
+}
+//#endregion
+export { n as assertSelectionKey, r as selectionKeyToken, s as useSelectionRoving, i as validateSelectionIdentities };

package/dist/src/components/shared/codeLanguages.d.ts

@@ -0,0 +1,5 @@
+import { Extension } from '@codemirror/state';
+import { CodeEditorLanguageContract } from '../../internal/codeEditorContract';
+export { resolveCodeLanguageKey } from '../../internal/codeLanguageIdentity';
+export declare function getCodeMirrorLanguageExtension(input: CodeEditorLanguageContract): Extension | null;
+export declare function resolveHighlightLanguageKey(input: CodeEditorLanguageContract): string;

package/dist/src/components/shared/codeLanguages.js

@@ -0,0 +1,42 @@
+import { resolveCodeLanguageKey as e } from "../../internal/codeLanguageIdentity.js";
+import { StreamLanguage as t } from "@codemirror/language";
+import { langNames as n, loadLanguage as r } from "@uiw/codemirror-extensions-langs";
+import { makefile as i } from "codemirror-lang-makefile";
+import { dockerFile as a } from "@codemirror/legacy-modes/mode/dockerfile";
+import { nginx as o } from "@codemirror/legacy-modes/mode/nginx";
+import { shell as s } from "@codemirror/legacy-modes/mode/shell";
+//#region src/components/shared/codeLanguages.ts
+var c = {
+	dockerfile: t.define(a),
+	makefile: i(),
+	nginx: t.define(o),
+	shell: t.define(s)
+}, l = {
+	javascript: "js",
+	powershell: "ps1",
+	python: "py",
+	ruby: "rb",
+	rust: "rs",
+	shell: "bash",
+	typescript: "ts"
+}, u = {
+	shell: "bash",
+	text: "plaintext"
+}, d = new Set(n);
+function f(e) {
+	return d.has(e);
+}
+function p(t) {
+	let n = e(t), i = l[n] ?? n;
+	if (f(i)) {
+		let e = r(i);
+		if (e) return e;
+	}
+	return c[i] ?? c[n] ?? null;
+}
+function m(t) {
+	let n = e(t);
+	return u[n] ?? n;
+}
+//#endregion
+export { p as getCodeMirrorLanguageExtension, e as resolveCodeLanguageKey, m as resolveHighlightLanguageKey };

package/dist/src/components/shared/complex/SKanbanCard.vue.d.ts

@@ -0,0 +1,42 @@
+import { InteractiveSurfaceContract, InteractiveSurfaceDensity, InteractiveSurfacePadding, InteractiveSurfaceRadius, InteractiveSurfaceTone } from '../controls/SInteractiveSurface.vue';
+export interface Props {
+    title: string;
+    subtitle?: string;
+    surface?: InteractiveSurfaceContract;
+    selected?: boolean;
+    tone?: InteractiveSurfaceTone;
+    density?: InteractiveSurfaceDensity;
+    padding?: InteractiveSurfacePadding;
+    radius?: InteractiveSurfaceRadius;
+    fill?: boolean;
+}
+declare var __VLS_10: {}, __VLS_12: {}, __VLS_15: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    meta?: (props: typeof __VLS_12) => any;
+} & {
+    actions?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    activate: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onActivate?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+    fill: boolean;
+    radius: InteractiveSurfaceRadius;
+    tone: InteractiveSurfaceTone;
+    density: InteractiveSurfaceDensity;
+    surface: InteractiveSurfaceContract;
+    padding: InteractiveSurfacePadding;
+    subtitle: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/shared/complex/SKanbanCard.vue.js

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