@pibbl/core 0.0.1

package/dist/lib/focus/focus-manager.js

@@ -0,0 +1,1131 @@
+import { GLOBAL_STATE } from "../global-state.js";
+import { Teardowns } from "../teardowns.js";
+import { resolveTargetRootBounds } from "./geometry.js";
+import {
+  mountDOMFocusHost
+} from "./dom-focus-host.js";
+import {
+  applyDirectionalNavigationDefault,
+  applyKeyboardActivationDefault,
+  applyTabDefault
+} from "./keyboard-defaults.js";
+import { transitionLogicalFocus } from "./focus-events.js";
+import {
+  isHtmlFocusCandidate
+} from "./types.js";
+import { getManagedTabStops } from "./dom-tab-stops.js";
+const UNFOCUSED_SNAPSHOT = Object.freeze({
+  isFocused: false,
+  isFocusVisible: false
+});
+const retainedDirectionalBoundaries = /* @__PURE__ */ new WeakMap();
+const coordinators = /* @__PURE__ */ new WeakMap();
+const managerOwners = /* @__PURE__ */ new WeakMap();
+const COMPATIBILITY_PRESS_WINDOW_MS = 1500;
+class DirectionalBoundary {
+  constructor(owner) {
+    this.owner = owner;
+  }
+  owner;
+  committedCandidates = Object.freeze([]);
+  get candidates() {
+    return this.committedCandidates;
+  }
+  commit(candidates) {
+    this.committedCandidates = candidates;
+  }
+}
+class FocusManagerCoordinator {
+  constructor(eventRoot) {
+    this.eventRoot = eventRoot;
+    eventRoot.rootInstance?.mainTeardowns.add(() => this.dispose());
+  }
+  eventRoot;
+  managers = /* @__PURE__ */ new Set();
+  transactions = /* @__PURE__ */ new WeakMap();
+  active;
+  domFocusHost;
+  domFocusHostTeardowns;
+  disposed = false;
+  add(manager) {
+    if (this.disposed) {
+      throw new Error("Pibbl focus manager root is disposed.");
+    }
+    this.ensureDOMFocusHost();
+    this.managers.add(manager);
+    const transaction = this.eventRoot.renderTransaction;
+    if (transaction) {
+      const state = this.stateFor(transaction);
+      state.prepared = manager;
+      this.eventRoot.focusPolicy = manager;
+    }
+  }
+  claim(manager) {
+    const transaction = this.eventRoot.renderTransaction;
+    if (!transaction) {
+      if (this.active && this.active !== manager) {
+        throw duplicateManagerError();
+      }
+      this.setActive(manager);
+      return;
+    }
+    const state = this.stateFor(transaction);
+    if (state.claimed && state.claimed !== manager) {
+      throw duplicateManagerError();
+    }
+    state.claimed = manager;
+    this.eventRoot.focusPolicy = manager;
+  }
+  beforeNativeDispatch(type, event) {
+    const manager = this.active;
+    const routeLogicalEvent = this.domFocusHost?.beforeNativeDispatch(type, event) ?? true;
+    return routeLogicalEvent && manager && !manager.isDestroyed ? manager : void 0;
+  }
+  syncDOMFocusHost(manager) {
+    if (this.active === manager) {
+      this.domFocusHost?.syncCandidateAvailability(manager.hasFocusCandidates);
+      this.domFocusHost?.syncHtmlRegions(manager.htmlFocusRegions);
+    }
+  }
+  focusCanvasFromPress(manager) {
+    if (this.active === manager) this.domFocusHost?.focusFromPress();
+  }
+  claimRetainedManagers(instance) {
+    const retained = Array.from(this.managers).filter((manager) => {
+      const owner = managerOwners.get(manager);
+      return !manager.isDestroyed && !manager.ownerWasReleased && owner !== void 0 && isInstanceWithin(owner, instance);
+    });
+    const transaction = this.eventRoot.renderTransaction;
+    if (!transaction) {
+      for (const manager of retained) this.claim(manager);
+      return retained;
+    }
+    const state = this.stateFor(transaction);
+    for (const manager of retained) {
+      if (state.replayedManagers.has(manager)) continue;
+      state.replayedManagers.add(manager);
+      this.claim(manager);
+    }
+    return retained;
+  }
+  release(manager) {
+    if (manager.isDestroyed) return;
+    manager.markOwnerReleased();
+    const transaction = this.eventRoot.renderTransaction;
+    if (transaction) {
+      const state = this.stateFor(transaction);
+      if (!state.finished) return;
+    }
+    if (this.active === manager) {
+      this.setActive(void 0);
+    }
+    this.destroy(manager);
+  }
+  stateFor(transaction) {
+    const existing = this.transactions.get(transaction);
+    if (existing) return existing;
+    const state = {
+      prior: this.active,
+      replayedManagers: /* @__PURE__ */ new Set(),
+      prepared: void 0,
+      claimed: void 0,
+      finished: false,
+      restored: void 0
+    };
+    this.transactions.set(transaction, state);
+    transaction.onFinish((success) => this.finishTransaction(state, success));
+    return state;
+  }
+  finishTransaction(state, success) {
+    if (state.finished) return;
+    state.finished = true;
+    if (success) {
+      if (state.claimed) {
+        this.active = state.claimed;
+      } else if (this.active?.ownerWasReleased) {
+        this.active = void 0;
+      }
+      this.eventRoot.focusPolicy = this.active;
+      for (const manager of Array.from(this.managers)) {
+        if (manager !== this.active && manager.ownerWasReleased) {
+          this.destroy(manager);
+        }
+      }
+      this.domFocusHost?.setManager(this.active);
+      return;
+    }
+    const attemptedReplacement = state.claimed && state.claimed !== state.prior || state.prepared && state.prepared !== state.prior;
+    const restored = state.prior && attemptedReplacement && !state.prior.isDestroyed ? state.prior : void 0;
+    state.restored = restored;
+    this.active = restored;
+    this.eventRoot.focusPolicy = restored;
+    for (const manager of Array.from(this.managers)) {
+      if (manager !== restored) this.destroy(manager);
+    }
+    this.domFocusHost?.setManager(restored);
+  }
+  destroy(manager) {
+    this.managers.delete(manager);
+    manager.destroyFromCoordinator();
+    if (this.managers.size === 0) this.disposeDOMFocusHost();
+  }
+  ensureDOMFocusHost() {
+    if (this.domFocusHost) return;
+    const canvas = this.eventRoot.canvas;
+    if (!canvas) {
+      throw new Error(
+        "FocusManagement requires an HTMLCanvasElement root; an OffscreenCanvas has no DOM focus host."
+      );
+    }
+    const teardowns = new Teardowns();
+    try {
+      this.domFocusHost = mountDOMFocusHost(canvas, this.eventRoot, teardowns);
+      this.domFocusHostTeardowns = teardowns;
+    } catch (error) {
+      teardowns.execute();
+      throw error;
+    }
+  }
+  disposeDOMFocusHost() {
+    this.domFocusHost = void 0;
+    this.domFocusHostTeardowns?.execute();
+    this.domFocusHostTeardowns = void 0;
+  }
+  setActive(manager) {
+    this.active = manager;
+    this.eventRoot.focusPolicy = manager;
+    this.domFocusHost?.setManager(manager);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.active = void 0;
+    this.eventRoot.focusPolicy = void 0;
+    for (const manager of Array.from(this.managers)) this.destroy(manager);
+    this.disposeDOMFocusHost();
+  }
+}
+class PibblFocusManager {
+  constructor(eventRoot, owner) {
+    this.eventRoot = eventRoot;
+    const canvas = eventRoot.canvas;
+    if (!canvas) {
+      throw new Error(
+        "FocusManagement requires an HTMLCanvasElement root; an OffscreenCanvas has no DOM focus host."
+      );
+    }
+    managerOwners.set(this, owner);
+    this.coordinator = getCoordinator(eventRoot);
+    try {
+      this.coordinator.add(this);
+    } catch (error) {
+      managerOwners.delete(this);
+      throw error;
+    }
+  }
+  eventRoot;
+  committedCandidates = Object.freeze([]);
+  committedHtmlCandidates = Object.freeze([]);
+  committedNavigationCandidates = Object.freeze([]);
+  committedBoundaries = /* @__PURE__ */ new Set();
+  pending;
+  transactionalPending;
+  directionalStack = [];
+  focusedTarget;
+  focusedHtmlRegion;
+  pendingHtmlFocusModality;
+  focusVisible = false;
+  pendingSpaceTarget;
+  pendingPressFocus;
+  representedPointerPresses = /* @__PURE__ */ new Map();
+  representedTouchContacts = /* @__PURE__ */ new Map();
+  activeTouchIdentifiers = /* @__PURE__ */ new Set();
+  primaryTouchIdentifier;
+  touchSequenceActive = false;
+  touchMouseCompatibility;
+  focusRenderRevision = 0;
+  layerFocusRenderRevisions = /* @__PURE__ */ new WeakMap();
+  destroyed = false;
+  ownerReleased = false;
+  coordinator;
+  get candidates() {
+    return this.committedCandidates;
+  }
+  /** @internal Full source-order list including native HtmlBox regions. */
+  get navigationCandidates() {
+    return this.committedNavigationCandidates;
+  }
+  get htmlFocusRegions() {
+    return this.committedHtmlCandidates.map((candidate) => candidate.region);
+  }
+  get focusedNavigationCandidate() {
+    if (this.focusedHtmlRegion) {
+      return this.committedHtmlCandidates.find(
+        (candidate) => candidate.region === this.focusedHtmlRegion
+      );
+    }
+    return this.focusedTarget ? this.committedCandidates.find(
+      (candidate) => candidate.target === this.focusedTarget
+    ) : void 0;
+  }
+  /** @internal Resolves dynamic native eligibility at each navigation boundary. */
+  isNavigationCandidateFocusable(candidate) {
+    return isHtmlFocusCandidate(candidate) ? Boolean(
+      candidate.region.active && candidate.region.content && getManagedTabStops(candidate.region.content).length
+    ) : Boolean(this.liveFocusCandidate(candidate.target));
+  }
+  /** Includes a successful render's collected candidates before commit callbacks settle. */
+  get hasFocusCandidates() {
+    return this.committedNavigationCandidates.length > 0 || (this.transactionalPending?.frame.targets.length ?? 0) + (this.transactionalPending?.frame.htmlRegions.length ?? 0) > 0;
+  }
+  get isDestroyed() {
+    return this.destroyed;
+  }
+  get ownerWasReleased() {
+    return this.ownerReleased;
+  }
+  get canvas() {
+    const canvas = this.eventRoot.canvas;
+    if (!canvas) throw new Error("Pibbl focus manager has no DOM Canvas host.");
+    return canvas;
+  }
+  get logicalFocusTarget() {
+    return this.focusedTarget;
+  }
+  get logicalFocusVisible() {
+    return this.focusVisible;
+  }
+  beginCollection() {
+    this.assertLive();
+    if (this.pending) {
+      throw new Error("FocusManagement cannot enter twice on one Pibbl root.");
+    }
+    this.coordinator.claim(this);
+    this.pending = {
+      entries: [],
+      targets: [],
+      htmlRegions: [],
+      observedTargets: /* @__PURE__ */ new Set(),
+      observedHtmlRegions: /* @__PURE__ */ new Set(),
+      ineligibleTargets: /* @__PURE__ */ new Set(),
+      boundaries: new Set(this.directionalStack)
+    };
+  }
+  finishCollection(success) {
+    const pending = this.pending;
+    this.pending = void 0;
+    if (!pending || !success || this.destroyed) return;
+    const transaction = this.eventRoot.renderTransaction;
+    if (transaction) {
+      this.transactionalPending = { transaction, frame: pending };
+      transaction.onFinish((transactionSucceeded) => {
+        if (this.transactionalPending?.transaction === transaction) {
+          this.transactionalPending = void 0;
+        }
+        if (transactionSucceeded && !this.destroyed) {
+          this.commitCollection(pending);
+        }
+      });
+      return;
+    }
+    this.commitCollection(pending);
+  }
+  commitCollection(pending) {
+    const collected = [];
+    for (const [sourceIndex, observed] of pending.entries.entries()) {
+      if ("target" in observed) {
+        const target = observed.target;
+        collected.push(
+          Object.freeze({
+            target,
+            sourceIndex,
+            directionalBoundary: observed.directionalBoundary,
+            rootBounds: resolveTargetRootBounds(target)
+          })
+        );
+        continue;
+      }
+      const region = observed.region;
+      if (region.active && region.content)
+        collected.push(
+          Object.freeze({
+            region,
+            sourceIndex,
+            directionalBoundary: observed.directionalBoundary,
+            rootBounds: region.rootBounds
+          })
+        );
+    }
+    const navigation = Object.freeze(collected);
+    this.commitNavigationCandidates(navigation, pending.boundaries);
+    const candidates = navigation.filter(
+      (candidate) => !isHtmlFocusCandidate(candidate)
+    );
+    for (const candidate of candidates) {
+      if (candidate.directionalBoundary) {
+        retainedDirectionalBoundaries.set(
+          candidate.target,
+          asDirectionalBoundary(candidate.directionalBoundary)
+        );
+      } else {
+        retainedDirectionalBoundaries.delete(candidate.target);
+      }
+    }
+  }
+  observeTarget(target) {
+    const pending = this.pending;
+    if (!pending) return;
+    if (this.pendingSpaceTarget === target && !target.handlers.click) {
+      this.cancelSpaceActivation();
+    }
+    if (!isKeyboardFocusable(target)) {
+      this.markPendingIneligible(target);
+      return;
+    }
+    pending.ineligibleTargets.delete(target);
+    this.recordPendingTarget(target, this.currentDirectionalBoundary());
+  }
+  /** @internal Collects one published HtmlBox in source order. */
+  observeHtmlRegion(region) {
+    const pending = this.pending;
+    if (!pending || pending.observedHtmlRegions.has(region)) return;
+    pending.observedHtmlRegions.add(region);
+    const observed = {
+      region,
+      directionalBoundary: this.currentDirectionalBoundary()
+    };
+    pending.htmlRegions.push(observed);
+    pending.entries.push(observed);
+  }
+  /** @internal Removes an unmounted HtmlBox without manufacturing a Canvas target. */
+  removeHtmlFocusRegion(region) {
+    if (this.pending?.observedHtmlRegions.delete(region)) {
+      this.pending.htmlRegions.splice(
+        this.pending.htmlRegions.findIndex((entry) => entry.region === region),
+        1
+      );
+      const index = this.pending.entries.findIndex(
+        (entry) => "region" in entry && entry.region === region
+      );
+      if (index >= 0) this.pending.entries.splice(index, 1);
+      return;
+    }
+    if (!this.committedHtmlCandidates.some(
+      (candidate) => candidate.region === region
+    ))
+      return;
+    const wasFocused = this.focusedHtmlRegion === region;
+    const canvas = this.eventRoot.canvas;
+    const shouldReturnNativeFocus = Boolean(
+      wasFocused && canvas && !this.eventRoot.rootInstance?.mainTeardowns.closed && region.content?.contains(canvas.ownerDocument.activeElement)
+    );
+    this.commitNavigationCandidates(
+      this.committedNavigationCandidates.filter(
+        (candidate) => !isHtmlFocusCandidate(candidate) || candidate.region !== region
+      ),
+      this.committedBoundaries
+    );
+    if (shouldReturnNativeFocus && canvas) {
+      this.coordinator.focusCanvasFromPress(this);
+      this.clearFocusState();
+    }
+    if (wasFocused) this.clearHtmlFocus(region);
+  }
+  /** @internal Deactivates retained DOM hosts while the root has no display area. */
+  suspendHtmlRegions() {
+    if (this.committedHtmlCandidates.length === 0) return;
+    const focused = this.focusedHtmlRegion;
+    const canvas = this.eventRoot.canvas;
+    const shouldReturnNativeFocus = Boolean(
+      focused && canvas && !this.eventRoot.rootInstance?.mainTeardowns.closed && focused.content?.contains(canvas.ownerDocument.activeElement)
+    );
+    this.commitNavigationCandidates(
+      this.committedNavigationCandidates.filter(
+        (candidate) => !isHtmlFocusCandidate(candidate)
+      ),
+      this.committedBoundaries
+    );
+    if (shouldReturnNativeFocus && canvas) {
+      this.coordinator.focusCanvasFromPress(this);
+      this.clearFocusState();
+    }
+    if (focused) this.clearHtmlFocus(focused);
+  }
+  observeTransactionalTarget(target) {
+    const transactional = this.transactionalPending;
+    if (!transactional || transactional.transaction !== this.eventRoot.renderTransaction)
+      return;
+    const pending = transactional.frame;
+    if (this.pendingSpaceTarget === target && !target.handlers.click) {
+      this.cancelSpaceActivation();
+    }
+    if (!isKeyboardFocusable(target)) {
+      pending.ineligibleTargets.add(target);
+      const index = pending.targets.findIndex(
+        (candidate) => candidate.target === target
+      );
+      if (index !== -1) pending.targets.splice(index, 1);
+      const entryIndex = pending.entries.findIndex(
+        (entry) => "target" in entry && entry.target === target
+      );
+      if (entryIndex !== -1) pending.entries.splice(entryIndex, 1);
+      pending.observedTargets.delete(target);
+      return;
+    }
+    pending.ineligibleTargets.delete(target);
+    if (pending.observedTargets.has(target)) return;
+    pending.observedTargets.add(target);
+    const observed = {
+      target,
+      directionalBoundary: this.currentDirectionalBoundary()
+    };
+    pending.targets.push(observed);
+    pending.entries.push(observed);
+  }
+  removeTarget(target) {
+    if (this.pendingSpaceTarget === target) this.cancelSpaceActivation();
+    if (this.pending) {
+      this.markPendingIneligible(target);
+      return;
+    }
+    if (!this.committedCandidates.some((candidate) => candidate.target === target)) {
+      if (this.focusedTarget === target) this.clearFocusState();
+      return;
+    }
+    this.commitRemovedTarget(target);
+  }
+  snapshot(target) {
+    if (this.ownerReleased || this.pending?.ineligibleTargets.has(target) || target !== this.focusedTarget) {
+      return UNFOCUSED_SNAPSHOT;
+    }
+    return Object.freeze({
+      isFocused: true,
+      isFocusVisible: this.focusVisible
+    });
+  }
+  resolveKeyboardTarget() {
+    const target = this.focusedTarget;
+    if (target && this.pending?.ineligibleTargets.has(target)) return void 0;
+    return target && this.committedCandidates.some((candidate) => candidate.target === target) ? target : void 0;
+  }
+  afterDispatch(event) {
+    if (event.type === "keydown") {
+      applyTabDefault(this, event);
+    }
+    if (event.type === "keydown" || event.type === "keyup") {
+      applyKeyboardActivationDefault(this, event);
+    }
+    if (event.type === "keydown") {
+      applyDirectionalNavigationDefault(this, event);
+    }
+  }
+  afterPressDispatch(input) {
+    if (this.destroyed) return;
+    this.purgeExpiredPresses(input.originalEvent.timeStamp);
+    switch (input.source) {
+      case "pointer":
+        this.recordPointerPress(input);
+        if (!pressWasPrevented(input)) this.applyPressFocus(input.target);
+        return;
+      case "mouse":
+        if (this.consumeRepresentedMousePress(input)) return;
+        if (!pressWasPrevented(input)) this.applyPressFocus(input.target);
+        return;
+      case "touch":
+        if (this.consumeRepresentedTouchPress(input)) return;
+        this.recordTouchFallback(input);
+        if (!pressWasPrevented(input)) this.applyPressFocus(input.target);
+        return;
+    }
+  }
+  afterTouchDispatch(input) {
+    if (this.destroyed) return;
+    this.purgeExpiredPresses(input.originalEvent.timeStamp);
+    this.reconcileTouchContacts(input);
+    if (input.type === "touchstart") {
+      const primary = this.recordTouchStarts(input);
+      if (!primary) return;
+      this.afterPressDispatch({
+        source: "touch",
+        target: primary.target,
+        event: void 0,
+        originalEvent: input.originalEvent,
+        x: primary.x,
+        y: primary.y,
+        touchIdentifier: primary.identifier
+      });
+      return;
+    }
+    if (input.type === "touchend" || input.type === "touchcancel") {
+      this.recordTouchTerminals(input);
+    }
+  }
+  beforeNativeDispatch(type, event) {
+    return this.coordinator.beforeNativeDispatch(type, event);
+  }
+  enterDOMFocus(backwards) {
+    if (this.destroyed) return;
+    const pendingPress = this.pendingPressFocus;
+    if (pendingPress) {
+      this.pendingPressFocus = void 0;
+      transitionLogicalFocus(
+        this,
+        this.liveFocusCandidate(pendingPress.target),
+        "pointer"
+      );
+      return;
+    }
+    const candidates = backwards ? [...this.committedNavigationCandidates].reverse() : this.committedNavigationCandidates;
+    for (const candidate of candidates) {
+      if (this.focusNavigationCandidate(candidate, "keyboard", backwards))
+        return;
+    }
+  }
+  leaveDOMFocus() {
+    if (this.destroyed) return;
+    this.pendingPressFocus = void 0;
+    transitionLogicalFocus(this, void 0, "keyboard");
+  }
+  activateDOMHost() {
+    if (!this.destroyed) this.coordinator.syncDOMFocusHost(this);
+  }
+  focusNavigationCandidate(candidate, modality, backwards = false) {
+    if (!candidate) return false;
+    if (!isHtmlFocusCandidate(candidate)) {
+      this.focusedHtmlRegion && this.clearHtmlFocus(this.focusedHtmlRegion);
+      transitionLogicalFocus(
+        this,
+        this.liveFocusCandidate(candidate.target),
+        modality
+      );
+      return true;
+    }
+    const region = candidate.region;
+    const content = region.active ? region.content : void 0;
+    const stops = content ? getManagedTabStops(content) : [];
+    const destination = backwards ? stops.at(-1) : stops[0];
+    if (!destination) return false;
+    if (this.focusedTarget) transitionLogicalFocus(this, void 0, modality);
+    this.adoptHtmlFocus(region, modality);
+    this.pendingHtmlFocusModality = modality;
+    destination.focus({ preventScroll: true });
+    this.pendingHtmlFocusModality = void 0;
+    return true;
+  }
+  /** @internal Called by the native region listeners after the browser focuses a descendant. */
+  adoptNativeHtmlFocus(region, modality) {
+    if (!this.committedHtmlCandidates.some(
+      (candidate) => candidate.region === region
+    ))
+      return;
+    const carriedModality = modality ?? (this.focusVisible ? "keyboard" : "pointer");
+    if (this.focusedTarget)
+      transitionLogicalFocus(this, void 0, carriedModality);
+    this.adoptHtmlFocus(
+      region,
+      this.pendingHtmlFocusModality ?? carriedModality
+    );
+  }
+  /** @internal Native blur settled outside a registered host. */
+  clearNativeHtmlFocus(region) {
+    if (this.focusedHtmlRegion === region) this.clearHtmlFocus(region);
+  }
+  /** @internal Reconciles a committed host list with the browser focus owner. */
+  reconcileNativeHtmlFocus(region) {
+    if (region) {
+      this.adoptNativeHtmlFocus(region, void 0);
+    } else if (this.focusedHtmlRegion) {
+      this.clearHtmlFocus(this.focusedHtmlRegion);
+    }
+  }
+  replayRetainedSubtree(instance) {
+    const retainedManagers = this.coordinator.claimRetainedManagers(instance);
+    const replayManager = retainedManagers.length === 1 ? retainedManagers[0] : this;
+    replayManager.replayRetainedTargets(instance);
+  }
+  layerFocusRenderRevision(instance) {
+    return this.ownerReleased ? void 0 : this.layerFocusRenderRevisions.get(instance);
+  }
+  replayRetainedTargets(instance) {
+    const retained = this.committedNavigationCandidates.filter(
+      (candidate) => isHtmlFocusCandidate(candidate) ? isInstanceWithin(candidate.region.owner, instance) : isInstanceWithin(candidate.target.owner, instance)
+    );
+    if (!retained.some(isHtmlFocusCandidate)) {
+      this.replayCanvasOnlyTargets(instance);
+      return;
+    }
+    if (this.pending) {
+      for (const candidate of retained) {
+        const retainedBoundary = isHtmlFocusCandidate(candidate) ? candidate.directionalBoundary instanceof DirectionalBoundary && isInstanceWithin(candidate.directionalBoundary.owner, instance) ? candidate.directionalBoundary : void 0 : retainedDirectionalBoundaries.get(candidate.target);
+        const directionalBoundary = retainedBoundary && isInstanceWithin(retainedBoundary.owner, instance) ? retainedBoundary : this.currentDirectionalBoundary();
+        if (directionalBoundary) {
+          this.pending.boundaries.add(directionalBoundary);
+        }
+        if (isHtmlFocusCandidate(candidate)) {
+          const region = candidate.region;
+          if (!region.active || !region.content) continue;
+          if (!this.pending.observedHtmlRegions.has(region)) {
+            this.pending.observedHtmlRegions.add(region);
+            const observed = { region, directionalBoundary };
+            this.pending.htmlRegions.push(observed);
+            this.pending.entries.push(observed);
+          }
+        } else if (isKeyboardFocusable(candidate.target)) {
+          this.recordPendingTarget(candidate.target, directionalBoundary);
+        } else {
+          this.markPendingIneligible(candidate.target);
+        }
+      }
+      return;
+    }
+    if (retained.length === 0) return;
+    const replayed = new Set(retained);
+    const candidates = Object.freeze(
+      this.committedNavigationCandidates.map((candidate) => {
+        if (!replayed.has(candidate)) return candidate;
+        return isHtmlFocusCandidate(candidate) ? Object.freeze({
+          ...candidate,
+          rootBounds: candidate.region.rootBounds
+        }) : Object.freeze({
+          ...candidate,
+          rootBounds: resolveTargetRootBounds(candidate.target)
+        });
+      })
+    );
+    this.commitNavigationCandidates(candidates, this.committedBoundaries);
+  }
+  replayCanvasOnlyTargets(instance) {
+    const targets = [];
+    collectRetainedTargets(instance, targets);
+    if (this.pending) {
+      for (const target of targets) {
+        if (!isKeyboardFocusable(target)) {
+          this.markPendingIneligible(target);
+          continue;
+        }
+        const retainedBoundary = retainedDirectionalBoundaries.get(target);
+        const directionalBoundary = retainedBoundary && isInstanceWithin(retainedBoundary.owner, instance) ? retainedBoundary : this.currentDirectionalBoundary();
+        if (directionalBoundary)
+          this.pending.boundaries.add(directionalBoundary);
+        this.recordPendingTarget(target, directionalBoundary);
+      }
+      return;
+    }
+    const replayed = new Set(targets);
+    if (!this.committedCandidates.some(
+      (candidate) => replayed.has(candidate.target)
+    ))
+      return;
+    const candidates = Object.freeze(
+      this.committedCandidates.map(
+        (candidate) => replayed.has(candidate.target) ? Object.freeze({
+          ...candidate,
+          rootBounds: resolveTargetRootBounds(candidate.target)
+        }) : candidate
+      )
+    );
+    this.commitCandidates(candidates, this.committedBoundaries);
+  }
+  setFocusState(target, focusVisible) {
+    if (target && !this.committedCandidates.some((candidate) => candidate.target === target)) {
+      throw new Error(
+        "Pibbl logical focus target is not a live focus candidate."
+      );
+    }
+    this.commitLogicalFocus(target, focusVisible);
+  }
+  liveFocusCandidate(target) {
+    return target?.live && target.owner.eventRoot === this.eventRoot && this.committedCandidates.some((candidate) => candidate.target === target) ? target : void 0;
+  }
+  commitLogicalFocus(target, focusVisible) {
+    const nextFocusVisible = Boolean(target && focusVisible);
+    if (target === this.focusedTarget && nextFocusVisible === this.focusVisible) {
+      return;
+    }
+    const previous = this.focusedTarget;
+    if (this.focusedTarget !== target) this.cancelSpaceActivation();
+    this.focusedTarget = target;
+    this.focusVisible = nextFocusVisible;
+    const revision = ++this.focusRenderRevision;
+    this.markFocusRenderLayers(previous, revision);
+    this.markFocusRenderLayers(target, revision);
+  }
+  enterDirectionalBoundary(boundary) {
+    const value = asDirectionalBoundary(boundary);
+    this.directionalStack.push(value);
+    this.pending?.boundaries.add(value);
+  }
+  exitDirectionalBoundary(boundary) {
+    const value = asDirectionalBoundary(boundary);
+    if (this.directionalStack.at(-1) !== value) {
+      throw new Error("Pibbl directional boundary scope exited out of order.");
+    }
+    this.directionalStack.pop();
+  }
+  currentDirectionalBoundary() {
+    return this.directionalStack.at(-1);
+  }
+  markFocusRenderLayers(target, revision) {
+    let instance = target?.owner;
+    while (instance && instance !== this.eventRoot.rootInstance) {
+      this.layerFocusRenderRevisions.set(instance, revision);
+      instance = instance.parent ? GLOBAL_STATE.pibblInstances.get(instance.parent) : void 0;
+    }
+  }
+  dispose() {
+    if (this.ownerReleased || this.destroyed) return;
+    this.coordinator.release(this);
+  }
+  markOwnerReleased() {
+    this.ownerReleased = true;
+  }
+  destroyFromCoordinator() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    managerOwners.delete(this);
+    this.pending = void 0;
+    this.directionalStack = [];
+    this.pendingPressFocus = void 0;
+    this.cancelSpaceActivation();
+    this.representedPointerPresses.clear();
+    this.representedTouchContacts.clear();
+    this.activeTouchIdentifiers.clear();
+    this.primaryTouchIdentifier = void 0;
+    this.touchSequenceActive = false;
+    this.touchMouseCompatibility = void 0;
+    for (const boundary of this.committedBoundaries) {
+      boundary.commit(Object.freeze([]));
+    }
+    this.committedBoundaries.clear();
+    this.committedCandidates = Object.freeze([]);
+    this.clearFocusState();
+  }
+  recordPendingTarget(target, directionalBoundary) {
+    const pending = this.pending;
+    if (!pending || pending.observedTargets.has(target)) return;
+    pending.observedTargets.add(target);
+    const observed = { target, directionalBoundary };
+    pending.targets.push(observed);
+    pending.entries.push(observed);
+  }
+  markPendingIneligible(target) {
+    const pending = this.pending;
+    if (!pending) return;
+    pending.ineligibleTargets.add(target);
+    if (!pending.observedTargets.delete(target)) return;
+    for (let index = pending.targets.length - 1; index >= 0; index--) {
+      if (pending.targets[index].target === target) {
+        pending.targets.splice(index, 1);
+      }
+    }
+    for (let index = pending.entries.length - 1; index >= 0; index--) {
+      const entry = pending.entries[index];
+      if ("target" in entry && entry.target === target)
+        pending.entries.splice(index, 1);
+    }
+  }
+  commitCandidates(candidates, boundaries) {
+    const canvasByTarget = new Map(
+      candidates.map((candidate) => [candidate.target, candidate])
+    );
+    const navigation = this.committedNavigationCandidates.map(
+      (candidate) => isHtmlFocusCandidate(candidate) ? candidate : canvasByTarget.get(candidate.target) ?? candidate
+    ).filter(
+      (candidate) => isHtmlFocusCandidate(candidate) || candidates.some((canvas) => canvas.target === candidate.target)
+    );
+    if (navigation.length === 0 && candidates.length > 0)
+      navigation.push(...candidates);
+    this.commitNavigationCandidates(Object.freeze(navigation), boundaries);
+  }
+  commitNavigationCandidates(candidates, boundaries) {
+    const pendingByBoundary = /* @__PURE__ */ new Map();
+    for (const boundary of boundaries) pendingByBoundary.set(boundary, []);
+    for (const candidate of candidates) {
+      if (candidate.directionalBoundary instanceof DirectionalBoundary) {
+        pendingByBoundary.get(candidate.directionalBoundary)?.push(candidate);
+      }
+    }
+    const committedByBoundary = /* @__PURE__ */ new Map();
+    for (const [boundary, directCandidates] of pendingByBoundary) {
+      committedByBoundary.set(boundary, Object.freeze(directCandidates));
+    }
+    for (const boundary of this.committedBoundaries) {
+      if (!committedByBoundary.has(boundary)) {
+        boundary.commit(Object.freeze([]));
+      }
+    }
+    for (const [boundary, directCandidates] of committedByBoundary) {
+      boundary.commit(directCandidates);
+    }
+    this.committedBoundaries = new Set(committedByBoundary.keys());
+    this.committedNavigationCandidates = candidates;
+    this.committedCandidates = Object.freeze(
+      candidates.filter(
+        (candidate) => !isHtmlFocusCandidate(candidate)
+      )
+    );
+    this.committedHtmlCandidates = Object.freeze(
+      candidates.filter(
+        (candidate) => isHtmlFocusCandidate(candidate)
+      )
+    );
+    if (this.focusedTarget && !candidates.some(
+      (candidate) => !isHtmlFocusCandidate(candidate) && candidate.target === this.focusedTarget
+    )) {
+      this.clearFocusState();
+    }
+    if (this.focusedHtmlRegion && !this.committedHtmlCandidates.some(
+      (candidate) => candidate.region === this.focusedHtmlRegion
+    ))
+      this.clearHtmlFocus(this.focusedHtmlRegion);
+    this.activateDOMHost();
+  }
+  commitRemovedTarget(target) {
+    const retained = this.committedCandidates.filter(
+      (candidate) => candidate.target !== target
+    );
+    const candidates = Object.freeze(
+      retained.map(
+        (candidate, sourceIndex) => Object.freeze({ ...candidate, sourceIndex })
+      )
+    );
+    this.commitCandidates(candidates, this.committedBoundaries);
+  }
+  clearFocusState() {
+    this.cancelSpaceActivation();
+    this.focusedTarget = void 0;
+    this.focusVisible = false;
+  }
+  adoptHtmlFocus(region, modality) {
+    const visible = modality === "keyboard";
+    if (this.focusedHtmlRegion === region && this.focusVisible === visible)
+      return;
+    const previous = this.focusedHtmlRegion;
+    this.focusedHtmlRegion = region;
+    this.focusVisible = visible;
+    if (previous && previous !== region)
+      this.notifyHtmlFocus(previous, false, false);
+    this.notifyHtmlFocus(region, true, visible);
+  }
+  clearHtmlFocus(region) {
+    if (this.focusedHtmlRegion !== region) return;
+    this.focusedHtmlRegion = void 0;
+    this.focusVisible = false;
+    this.notifyHtmlFocus(region, false, false);
+  }
+  notifyHtmlFocus(region, isFocusWithin, isFocusVisible) {
+    region.onFocusSnapshot?.(Object.freeze({ isFocusWithin, isFocusVisible }));
+  }
+  applyPressFocus(requestedTarget) {
+    const target = this.liveFocusCandidate(requestedTarget);
+    const pending = { target };
+    this.pendingPressFocus = pending;
+    try {
+      this.coordinator.focusCanvasFromPress(this);
+      if (this.pendingPressFocus !== pending || this.destroyed || this.canvas.ownerDocument.activeElement !== this.canvas) {
+        return;
+      }
+      this.pendingPressFocus = void 0;
+      transitionLogicalFocus(this, this.liveFocusCandidate(target), "pointer");
+    } finally {
+      if (this.pendingPressFocus === pending)
+        this.pendingPressFocus = void 0;
+    }
+  }
+  beginSpaceActivation(target) {
+    this.pendingSpaceTarget = target;
+  }
+  hasPendingSpaceActivation(target) {
+    return Boolean(target && this.pendingSpaceTarget === target);
+  }
+  consumeSpaceActivation() {
+    const target = this.pendingSpaceTarget;
+    this.pendingSpaceTarget = void 0;
+    return target;
+  }
+  cancelSpaceActivation() {
+    this.pendingSpaceTarget = void 0;
+  }
+  recordPointerPress(input) {
+    if (input.pointerId === void 0) return;
+    this.representedPointerPresses.set(input.pointerId, {
+      x: input.x,
+      y: input.y,
+      timeStamp: input.originalEvent.timeStamp,
+      suppressMouse: true,
+      suppressTouch: input.pointerType === "touch"
+    });
+  }
+  consumeRepresentedMousePress(input) {
+    for (const [pointerId, press] of this.representedPointerPresses) {
+      if (!press.suppressMouse || !samePress(press, input)) continue;
+      press.suppressMouse = false;
+      if (!press.suppressTouch)
+        this.representedPointerPresses.delete(pointerId);
+      return true;
+    }
+    if (this.touchMouseCompatibility && samePress(this.touchMouseCompatibility, input)) {
+      this.touchMouseCompatibility = void 0;
+      return true;
+    }
+    return false;
+  }
+  consumeRepresentedTouchPress(input) {
+    const identifier = input.touchIdentifier;
+    if (identifier === void 0) return false;
+    const existing = this.representedTouchContacts.get(identifier);
+    if (existing && samePress(existing, input)) return true;
+    this.representedTouchContacts.set(identifier, pressRecord(input));
+    for (const [pointerId, press] of this.representedPointerPresses) {
+      if (!press.suppressTouch || !samePress(press, input)) continue;
+      press.suppressTouch = false;
+      if (!press.suppressMouse)
+        this.representedPointerPresses.delete(pointerId);
+      return true;
+    }
+    return false;
+  }
+  recordTouchFallback(input) {
+    this.touchMouseCompatibility = pressRecord(input);
+  }
+  recordTouchStarts(input) {
+    let primary;
+    for (const contact of input.changedContacts) {
+      if (this.activeTouchIdentifiers.has(contact.identifier)) continue;
+      if (!this.touchSequenceActive) {
+        this.touchSequenceActive = true;
+        this.primaryTouchIdentifier = contact.identifier;
+      }
+      if (contact.identifier === this.primaryTouchIdentifier) primary = contact;
+      this.activeTouchIdentifiers.add(contact.identifier);
+    }
+    return primary;
+  }
+  reconcileTouchContacts(input) {
+    const activeIdentifiers = new Set(input.activeIdentifiers);
+    for (const identifier of this.activeTouchIdentifiers) {
+      if (activeIdentifiers.has(identifier)) continue;
+      this.activeTouchIdentifiers.delete(identifier);
+      this.representedTouchContacts.delete(identifier);
+    }
+    const startingIdentifiers = input.type === "touchstart" ? new Set(input.changedContacts.map((contact) => contact.identifier)) : void 0;
+    for (const identifier of activeIdentifiers) {
+      if (!startingIdentifiers?.has(identifier)) {
+        this.activeTouchIdentifiers.add(identifier);
+      }
+    }
+    if (this.activeTouchIdentifiers.size > 0) {
+      this.touchSequenceActive = true;
+      return;
+    }
+    this.touchSequenceActive = false;
+    this.primaryTouchIdentifier = void 0;
+    this.representedTouchContacts.clear();
+  }
+  recordTouchTerminals(input) {
+    for (const contact of input.changedContacts) {
+      this.activeTouchIdentifiers.delete(contact.identifier);
+      this.representedTouchContacts.delete(contact.identifier);
+    }
+    if (this.activeTouchIdentifiers.size > 0) return;
+    this.touchSequenceActive = false;
+    this.primaryTouchIdentifier = void 0;
+    this.representedTouchContacts.clear();
+  }
+  purgeExpiredPresses(timeStamp) {
+    for (const [pointerId, press] of this.representedPointerPresses) {
+      if (!recentPress(press, timeStamp)) {
+        this.representedPointerPresses.delete(pointerId);
+      }
+    }
+    for (const [identifier, press] of this.representedTouchContacts) {
+      if (!recentPress(press, timeStamp)) {
+        this.representedTouchContacts.delete(identifier);
+      }
+    }
+    if (this.touchMouseCompatibility && !recentPress(this.touchMouseCompatibility, timeStamp)) {
+      this.touchMouseCompatibility = void 0;
+    }
+  }
+  assertLive() {
+    if (this.destroyed) throw new Error("Pibbl focus manager is disposed.");
+  }
+}
+function pressWasPrevented(input) {
+  return input.event?.defaultPrevented ?? input.originalEvent.defaultPrevented;
+}
+function pressRecord(input) {
+  return {
+    x: input.x,
+    y: input.y,
+    timeStamp: input.originalEvent.timeStamp
+  };
+}
+function samePress(press, input) {
+  return recentPress(press, input.originalEvent.timeStamp) && Math.abs(press.x - input.x) <= 1 && Math.abs(press.y - input.y) <= 1;
+}
+function recentPress(press, timeStamp) {
+  const elapsed = timeStamp - press.timeStamp;
+  return elapsed >= 0 && elapsed <= COMPATIBILITY_PRESS_WINDOW_MS;
+}
+function createFocusManager(eventRoot, owner) {
+  return new PibblFocusManager(eventRoot, owner);
+}
+function requireFocusManager(eventRoot) {
+  const manager = eventRoot.focusPolicy;
+  if (!(manager instanceof PibblFocusManager)) {
+    throw new Error(
+      "KeyboardNavigation requires an active FocusManagement focus manager."
+    );
+  }
+  return manager;
+}
+function createDirectionalBoundary(owner) {
+  return new DirectionalBoundary(owner);
+}
+function getCoordinator(eventRoot) {
+  let coordinator = coordinators.get(eventRoot);
+  if (!coordinator) {
+    coordinator = new FocusManagerCoordinator(eventRoot);
+    coordinators.set(eventRoot, coordinator);
+  }
+  return coordinator;
+}
+function duplicateManagerError() {
+  return new Error(
+    "FocusManagement allows only one focus manager per Pibbl root."
+  );
+}
+function asDirectionalBoundary(boundary) {
+  if (!(boundary instanceof DirectionalBoundary)) {
+    throw new Error("Unknown Pibbl directional boundary.");
+  }
+  return boundary;
+}
+function isKeyboardFocusable(target) {
+  return target.keyboardFocusable ?? Boolean(
+    target.handlers.click || target.handlers.keydown || target.handlers.keyup
+  );
+}
+function collectRetainedTargets(instance, targets) {
+  if (instance.mainTeardowns.closed) return;
+  for (const target of instance.eventRoot.targets) {
+    if (target.live && target.owner.eventRoot === instance.eventRoot && !target.owner.mainTeardowns.closed && isInstanceWithin(target.owner, instance))
+      targets.push(target);
+  }
+}
+function isInstanceWithin(instance, ancestor) {
+  let current = instance;
+  while (current) {
+    if (current === ancestor) return true;
+    current = current.parent ? GLOBAL_STATE.pibblInstances.get(current.parent) : void 0;
+  }
+  return false;
+}
+export {
+  PibblFocusManager,
+  createDirectionalBoundary,
+  createFocusManager,
+  requireFocusManager
+};
+//# sourceMappingURL=focus-manager.js.map