@pgcorp/ui-kit 0.14.0 → 0.15.0

package/dist/src/internal/flatTree.d.ts

@@ -0,0 +1,8 @@
+/** Native flat-tree parent, including explicit assigned slots and exposed shadow roots. */
+export declare function flatTreeParent(node: Node): Node | null;
+/** Rendered element children; shadow content replaces light DOM and slots expose actual assignments. */
+export declare function flatTreeChildren(element: Element, exposedShadow?: ShadowRoot): readonly Element[];
+/** Checks actual native ancestry without giving unassigned light DOM a shadow-surface membership. */
+export declare function flatTreeContains(scope: ParentNode, target: Node): boolean;
+/** Enumerates rendered native descendants in flat-tree order for Tab navigation. */
+export declare function flatTreeElements(root: ParentNode): HTMLElement[];

package/dist/src/internal/flatTree.js

@@ -0,0 +1,23 @@
+//#region src/internal/flatTree.ts
+function e(e) {
+	return e instanceof Element && e.assignedSlot ? e.assignedSlot : e instanceof ShadowRoot ? e.host : e.parentNode;
+}
+function t(e, t) {
+	if (e instanceof HTMLSlotElement) return e.assignedNodes({ flatten: !0 }).length > 0 ? e.assignedElements({ flatten: !0 }) : [...e.children];
+	let n = t ?? e.shadowRoot;
+	return [...n ? n.children : e.children];
+}
+function n(t, n) {
+	for (let r = n; r; r = e(r)) if (r === t) return !0;
+	return !1;
+}
+function r(e) {
+	let n = [], r = (e) => {
+		e instanceof HTMLElement && n.push(e);
+		for (let n of t(e)) r(n);
+	}, i = e instanceof Element ? t(e) : [...e.children];
+	for (let e of i) r(e);
+	return n;
+}
+//#endregion
+export { t as flatTreeChildren, n as flatTreeContains, r as flatTreeElements, e as flatTreeParent };

package/dist/src/internal/focusNavigation.d.ts

@@ -1,7 +1,10 @@
+export { nativeFocusChain, nativeFocusedElement } from './nativeFocus';
 /** Проверяет native focus capability независимо от временной видимости ancestor scope. */
 export declare const hasFocusableSemantics: (element: HTMLElement) => boolean;
 /** Проверяет programmatic/browser focus owner без layout-эвристик. / Checks a programmatic/browser focus owner without layout heuristics. */
 export declare const isFocusableElement: (element: HTMLElement) => boolean;
+/** Restored focus also admits explicitly programmatic dialog roots without adding a Tab stop. */
+export declare const isProgrammaticallyFocusableElement: (element: HTMLElement) => boolean;
 /**
  * Поднимает произвольный event target до ближайшего canonical focus owner внутри optional boundary.
  * Lifts an arbitrary event target to the nearest canonical focus owner inside an optional boundary.

package/dist/src/internal/focusNavigation.js

@@ -1,5 +1,8 @@
+import { flatTreeElements as e, flatTreeParent as t } from "./flatTree.js";
+import { nativeFocusedElement as n } from "./nativeFocus.js";
+import { isActualNativeModal as r, isNativeModalBackground as i } from "./viewportModality.js";
 //#region src/internal/focusNavigation.ts
-var e = [
+var a = [
 	"a[href]",
 	"button:not([disabled])",
 	"textarea:not([disabled])",
@@ -7,20 +10,30 @@ var e = [
 	"select:not([disabled])",
 	"[contenteditable=\"true\"]",
 	"[tabindex]:not([tabindex=\"-1\"])"
-].join(", "), t = (e) => {
-	if (e.hidden || e.closest("[inert]") || e.closest("[aria-hidden=\"true\"]")) return !1;
-	let t = window.getComputedStyle(e);
-	return t.display !== "none" && t.visibility !== "hidden";
-}, n = (t) => t.matches(e), r = (e) => n(e) && t(e), i = (t, n) => {
-	let i = (t instanceof Element ? t : t instanceof Node ? t.parentElement : null)?.closest(e) ?? null;
-	return !i || !r(i) || n instanceof Node && !n.contains(i) ? null : i;
-}, a = (t, n = {}) => [...t.querySelectorAll(e)].filter((e) => r(e) ? !n.requireLayout || e.offsetParent !== null || e.getClientRects().length > 0 : !1), o = (e, t, n, r) => {
-	let i = a(t).filter((e) => !n?.contains(e));
+].join(", "), o = (e) => {
+	if (i(e)) return !1;
+	let n = window.getComputedStyle(e);
+	if (n.visibility === "hidden" || n.visibility === "collapse") return !1;
+	for (let n = e; n;) {
+		if (n.matches("[hidden], [aria-hidden=\"true\"]") || n.hasAttribute("inert") || window.getComputedStyle(n).display === "none") return !1;
+		if (r(n)) {
+			for (let e = t(n); e; e = t(e)) if (e instanceof Element && (e.matches("[hidden], [aria-hidden=\"true\"]") || window.getComputedStyle(e).display === "none")) return !1;
+			return !0;
+		}
+		let e = t(n);
+		n = e instanceof Element ? e : e instanceof ShadowRoot ? e.host : null;
+	}
+	return !0;
+}, s = (e) => e.matches(a), c = (e) => !e.matches(":disabled") && s(e) && o(e), l = (e) => !e.matches(":disabled") && (s(e) || e.matches("[tabindex=\"-1\"]") || r(e)) && o(e), u = (e, t) => {
+	let n = (e instanceof Element ? e : e instanceof Node ? e.parentElement : null)?.closest(a) ?? null;
+	return !n || !c(n) || t instanceof Node && !t.contains(n) ? null : n;
+}, d = (t, n = {}) => e(t).filter((e) => c(e) ? !n.requireLayout || e.offsetParent !== null || e.getClientRects().length > 0 : !1), f = (e, t, n, r) => {
+	let i = d(t).filter((e) => !n?.contains(e));
 	if (i.length === 0) return null;
-	let o = i.indexOf(e);
-	if (o >= 0) return i[(o + (r ? -1 : 1) + i.length) % i.length] ?? null;
-	let s = r ? [...i].reverse() : i, c = r ? Node.DOCUMENT_POSITION_PRECEDING : Node.DOCUMENT_POSITION_FOLLOWING;
-	return s.find((t) => !!(e.compareDocumentPosition(t) & c)) ?? s[0] ?? null;
+	let a = i.indexOf(e);
+	if (a >= 0) return i[(a + (r ? -1 : 1) + i.length) % i.length] ?? null;
+	let o = r ? [...i].reverse() : i, s = r ? Node.DOCUMENT_POSITION_PRECEDING : Node.DOCUMENT_POSITION_FOLLOWING;
+	return o.find((t) => !!(e.compareDocumentPosition(t) & s)) ?? o[0] ?? null;
 };
 //#endregion
-export { i as findFocusableOwner, o as findRelativeTabTarget, a as getFocusableElements, n as hasFocusableSemantics, r as isFocusableElement };
+export { u as findFocusableOwner, f as findRelativeTabTarget, d as getFocusableElements, s as hasFocusableSemantics, c as isFocusableElement, l as isProgrammaticallyFocusableElement, n as nativeFocusedElement };

package/dist/src/internal/inertLease.d.ts

@@ -0,0 +1,8 @@
+/** Exact native inert ownership; overlapping owners restore the literal attribute after their last release. */
+export interface InertLease {
+    readonly boundary: Element;
+    readonly isCurrent: () => boolean;
+    readonly release: () => void;
+}
+/** Acquires one exact native boundary without changing aria-hidden or another owner's lifetime. */
+export declare function acquireInertLease(boundary: Element): InertLease;

package/dist/src/internal/inertLease.js

@@ -0,0 +1,33 @@
+//#region src/internal/inertLease.ts
+var e = /* @__PURE__ */ new WeakMap(), t = (e, t, n) => {
+	let r = !1;
+	for (let e of n) e.attributeName === "inert" && (t.ownedWrites > 0 ? --t.ownedWrites : r = !0);
+	r && (t.previous = e.getAttribute("inert")), t.owners.size > 0 && !e.hasAttribute("inert") && (t.ownedWrites += 1, e.setAttribute("inert", ""));
+};
+function n(n) {
+	let r = Symbol("inert-owner"), i = e.get(n);
+	if (i) t(n, i, i.observer.takeRecords());
+	else {
+		let r = new MutationObserver((e) => t(n, a, e)), a = {
+			previous: n.getAttribute("inert"),
+			owners: /* @__PURE__ */ new Set(),
+			observer: r,
+			ownedWrites: 0
+		};
+		r.observe(n, {
+			attributes: !0,
+			attributeFilter: ["inert"]
+		}), i = a, e.set(n, i);
+	}
+	i.owners.add(r), n.hasAttribute("inert") || (i.ownedWrites += 1, n.setAttribute("inert", ""));
+	let a = i;
+	return {
+		boundary: n,
+		isCurrent: () => a.owners.has(r) && e.get(n) === a && n.hasAttribute("inert"),
+		release: () => {
+			a.owners.has(r) && (t(n, a, a.observer.takeRecords()), !(!a.owners.delete(r) || a.owners.size > 0) && (e.delete(n), a.observer.disconnect(), a.previous === null ? n.removeAttribute("inert") : n.setAttribute("inert", a.previous)));
+		}
+	};
+}
+//#endregion
+export { n as acquireInertLease };

package/dist/src/internal/layerStack.d.ts

@@ -1,16 +1,37 @@
 export type LayerKind = 'dialog' | 'listbox' | 'menu' | 'popover' | 'tooltip';
 export type LayerDismissReason = 'escape' | 'outside-contextmenu' | 'outside-pointer';
+/** One-cycle native focus authority. Cancellation is idempotent; no consumer-shaped token is accepted. */
+export interface LayerFocusAdmission {
+    readonly restoreTarget: HTMLElement | null;
+    /** Executes this cycle's exact host acquisition; only that command may authorize source inertness loss. */
+    acquireHost: (acquire: () => () => void) => () => void;
+    cancel: () => void;
+}
+export interface LayerFocusAdmissionOptions {
+    /** Exact connected host content whose acquisition can make the captured native source inert. */
+    releaseBoundary?: HTMLElement | null;
+}
 export interface LayerRegistrationOptions {
     kind: LayerKind;
     root: () => HTMLElement | null;
     anchor?: () => HTMLElement | null;
     branches?: () => readonly HTMLElement[];
+    /** Exact additional modal/portal surfaces; anchors and dismissal branches are not modality roots. */
+    /** Actual native viewport owner and its exact direct portal; no div modality substitute. */
+    nativeDialog?: {
+        readonly subject: HTMLDialogElement;
+        readonly portal: () => HTMLElement | null;
+    };
+    /** Visual inside-pointer surfaces are distinct from a full-viewport semantic root. */
+    dismissalRoots?: () => readonly HTMLElement[];
     /** Explicit composition owner; null keeps independent root dialogs outside focus-derived ancestry. */
     parent?: LayerRegistration | null;
     modal?: boolean;
     /** Native event scope for a contained layer; global modal children do not inherit it. */
     eventBoundary?: () => HTMLElement | null;
     restoreTarget?: HTMLElement | null;
+    /** Captured before a transient source retires; belongs to this registration only. */
+    focusAdmission?: LayerFocusAdmission | null;
     dismissOnEscape?: () => boolean;
     dismissOnOutsidePointer?: () => boolean;
     blocksParentFocusTrap?: boolean;
@@ -19,12 +40,25 @@ export interface LayerRegistrationOptions {
     /** Releases owner UI/subscriptions when its ancestor retires, without a synthetic dismiss event. */
     onRetire?: () => void;
 }
+/** Native focus-loss authority from the last genuine owner; BODY never creates it. */
+export interface LayerOwnedFocusLoss {
+    /** True only while the exact owner/revisions survive and its observed source is unavailable. */
+    readonly isCurrentUnavailable: () => boolean;
+}
 export interface LayerRegistration {
     readonly id: symbol;
     readonly zIndex: string;
     readonly focusScope: () => ParentNode;
     /** Whether this registration still owns the global topmost focus request. */
     readonly isTopmost: () => boolean;
+    /** Reconciles an exact native surface ref mount/replacement before its focus or interaction path. */
+    readonly refreshModality: () => void;
+    /** Native focus membership includes registered logical descendants, not unrelated layers. */
+    readonly containsFocusTarget: (target: Node) => boolean;
+    /** Captures only this registration's exact previously observed native focus target. */
+    readonly captureOwnedFocusLoss: (target: Element) => LayerOwnedFocusLoss | null;
+    /** Claims initial native focus once. External focus and unrelated lifecycle changes deny the claim. */
+    readonly claimFocus: (target: HTMLElement) => boolean;
     /** Requests one Tab target, committed by this registration's normal close only. */
     readonly handoffFocus: (target: HTMLElement) => () => void;
     unregister: (options?: {
@@ -33,6 +67,12 @@ export interface LayerRegistration {
         commitFocusHandoff?: boolean;
     }) => void;
 }
+/**
+ * Captures current native intent, including an exact still-pending owned menu return.
+ * It does not grant authority from an arbitrary historical BODY state. The snapshot
+ * owns observers until claim/cancel; callers must cancel on every abandoned cycle.
+ */
+export declare function captureLayerFocusAdmission(options?: LayerFocusAdmissionOptions): LayerFocusAdmission | null;
 /**
  * Регистрирует одну открытую overlay-поверхность в общем dismiss/focus/body-lock стеке.
  * Registers one open overlay surface in the shared dismiss/focus/body-lock stack.