@pibbl/core 0.0.1

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

@@ -0,0 +1,78 @@
+import { dispatchToLogicalTarget } from "../events/dispatch.js";
+import { update } from "../update.js";
+const activeTransitions = /* @__PURE__ */ new WeakMap();
+function transitionLogicalFocus(manager, requestedNext, modality) {
+  if (manager.isDestroyed) return;
+  const active = activeTransitions.get(manager);
+  if (active) {
+    active.queued = { target: requestedNext, modality };
+    return;
+  }
+  const transaction = { queued: void 0 };
+  activeTransitions.set(manager, transaction);
+  let request = {
+    target: requestedNext,
+    modality
+  };
+  let changed = false;
+  try {
+    while (request && !manager.isDestroyed) {
+      transaction.queued = void 0;
+      changed = performLogicalFocusTransition(
+        manager,
+        request.target,
+        request.modality
+      ) || changed;
+      request = transaction.queued;
+    }
+  } finally {
+    activeTransitions.delete(manager);
+    if (changed) schedule(manager);
+  }
+}
+function performLogicalFocusTransition(manager, requestedNext, modality) {
+  const previous = manager.logicalFocusTarget;
+  const initialNext = manager.liveFocusCandidate(requestedNext);
+  const nextVisible = Boolean(initialNext && modality === "keyboard");
+  if (previous === initialNext) {
+    if (manager.logicalFocusVisible === nextVisible) return false;
+    manager.commitLogicalFocus(initialNext, nextVisible);
+    return true;
+  }
+  const outgoing = manager.liveFocusCandidate(previous);
+  if (outgoing) {
+    dispatchFocusEvent("focusout", outgoing, manager.liveFocusCandidate(initialNext));
+    if (manager.liveFocusCandidate(outgoing)) {
+      dispatchFocusEvent("blur", outgoing, manager.liveFocusCandidate(initialNext));
+    }
+  }
+  if (manager.isDestroyed) return false;
+  const next = manager.liveFocusCandidate(initialNext);
+  manager.commitLogicalFocus(next, Boolean(next && modality === "keyboard"));
+  if (next) {
+    const related = manager.liveFocusCandidate(previous);
+    dispatchFocusEvent("focusin", next, related);
+    if (manager.logicalFocusTarget === next && manager.liveFocusCandidate(next)) {
+      dispatchFocusEvent("focus", next, manager.liveFocusCandidate(previous));
+    }
+  }
+  return true;
+}
+function dispatchFocusEvent(type, target, relatedTarget) {
+  dispatchToLogicalTarget(
+    type,
+    target,
+    new FocusEvent(type, {
+      bubbles: type === "focusin" || type === "focusout",
+      cancelable: false
+    }),
+    relatedTarget ?? null
+  );
+}
+function schedule(manager) {
+  if (!manager.isDestroyed) update(manager.canvas);
+}
+export {
+  transitionLogicalFocus
+};
+//# sourceMappingURL=focus-events.js.map

package/dist/lib/focus/focus-events.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/focus/focus-events.ts"],
+  "sourcesContent": ["import { dispatchToLogicalTarget } from '../events/dispatch.js';\nimport type { PibblEventType } from '../events/types.js';\nimport { update } from '../update.js';\nimport type { PibblFocusManager } from './focus-manager.js';\nimport type { PibblFocusModality } from './types.js';\nimport type { PibblEventTargetRegistration } from '../events/registrations.js';\n\ninterface FocusTransitionRequest {\n  readonly target: PibblEventTargetRegistration | undefined;\n  readonly modality: PibblFocusModality;\n}\n\ninterface ActiveFocusTransition {\n  queued: FocusTransitionRequest | undefined;\n}\n\nconst activeTransitions = new WeakMap<PibblFocusManager, ActiveFocusTransition>();\n\nexport function transitionLogicalFocus(\n  manager: PibblFocusManager,\n  requestedNext: PibblEventTargetRegistration | undefined,\n  modality: PibblFocusModality,\n): void {\n  if (manager.isDestroyed) return;\n  const active = activeTransitions.get(manager);\n  if (active) {\n    active.queued = { target: requestedNext, modality };\n    return;\n  }\n\n  const transaction: ActiveFocusTransition = { queued: undefined };\n  activeTransitions.set(manager, transaction);\n  let request: FocusTransitionRequest | undefined = {\n    target: requestedNext,\n    modality,\n  };\n  let changed = false;\n  try {\n    while (request && !manager.isDestroyed) {\n      transaction.queued = undefined;\n      changed = performLogicalFocusTransition(\n        manager,\n        request.target,\n        request.modality,\n      ) || changed;\n      request = transaction.queued;\n    }\n  } finally {\n    activeTransitions.delete(manager);\n    if (changed) schedule(manager);\n  }\n}\n\nfunction performLogicalFocusTransition(\n  manager: PibblFocusManager,\n  requestedNext: PibblEventTargetRegistration | undefined,\n  modality: PibblFocusModality,\n): boolean {\n  const previous = manager.logicalFocusTarget;\n  const initialNext = manager.liveFocusCandidate(requestedNext);\n  const nextVisible = Boolean(initialNext && modality === 'keyboard');\n\n  if (previous === initialNext) {\n    if (manager.logicalFocusVisible === nextVisible) return false;\n    manager.commitLogicalFocus(initialNext, nextVisible);\n    return true;\n  }\n\n  const outgoing = manager.liveFocusCandidate(previous);\n  if (outgoing) {\n    dispatchFocusEvent('focusout', outgoing, manager.liveFocusCandidate(initialNext));\n    if (manager.liveFocusCandidate(outgoing)) {\n      dispatchFocusEvent('blur', outgoing, manager.liveFocusCandidate(initialNext));\n    }\n  }\n\n  if (manager.isDestroyed) return false;\n  const next = manager.liveFocusCandidate(initialNext);\n  manager.commitLogicalFocus(next, Boolean(next && modality === 'keyboard'));\n\n  if (next) {\n    const related = manager.liveFocusCandidate(previous);\n    dispatchFocusEvent('focusin', next, related);\n    if (\n      manager.logicalFocusTarget === next &&\n      manager.liveFocusCandidate(next)\n    ) {\n      dispatchFocusEvent('focus', next, manager.liveFocusCandidate(previous));\n    }\n  }\n  return true;\n}\n\nfunction dispatchFocusEvent(\n  type: Extract<PibblEventType, 'blur' | 'focus' | 'focusin' | 'focusout'>,\n  target: PibblEventTargetRegistration,\n  relatedTarget: PibblEventTargetRegistration | undefined,\n): void {\n  dispatchToLogicalTarget(\n    type,\n    target,\n    new FocusEvent(type, {\n      bubbles: type === 'focusin' || type === 'focusout',\n      cancelable: false,\n    }),\n    relatedTarget ?? null,\n  );\n}\n\nfunction schedule(manager: PibblFocusManager): void {\n  if (!manager.isDestroyed) update(manager.canvas);\n}\n"],
+  "mappings": "AAAA,SAAS,+BAA+B;AAExC,SAAS,cAAc;AAcvB,MAAM,oBAAoB,oBAAI,QAAkD;AAEzE,SAAS,uBACd,SACA,eACA,UACM;AACN,MAAI,QAAQ,YAAa;AACzB,QAAM,SAAS,kBAAkB,IAAI,OAAO;AAC5C,MAAI,QAAQ;AACV,WAAO,SAAS,EAAE,QAAQ,eAAe,SAAS;AAClD;AAAA,EACF;AAEA,QAAM,cAAqC,EAAE,QAAQ,OAAU;AAC/D,oBAAkB,IAAI,SAAS,WAAW;AAC1C,MAAI,UAA8C;AAAA,IAChD,QAAQ;AAAA,IACR;AAAA,EACF;AACA,MAAI,UAAU;AACd,MAAI;AACF,WAAO,WAAW,CAAC,QAAQ,aAAa;AACtC,kBAAY,SAAS;AACrB,gBAAU;AAAA,QACR;AAAA,QACA,QAAQ;AAAA,QACR,QAAQ;AAAA,MACV,KAAK;AACL,gBAAU,YAAY;AAAA,IACxB;AAAA,EACF,UAAE;AACA,sBAAkB,OAAO,OAAO;AAChC,QAAI,QAAS,UAAS,OAAO;AAAA,EAC/B;AACF;AAEA,SAAS,8BACP,SACA,eACA,UACS;AACT,QAAM,WAAW,QAAQ;AACzB,QAAM,cAAc,QAAQ,mBAAmB,aAAa;AAC5D,QAAM,cAAc,QAAQ,eAAe,aAAa,UAAU;AAElE,MAAI,aAAa,aAAa;AAC5B,QAAI,QAAQ,wBAAwB,YAAa,QAAO;AACxD,YAAQ,mBAAmB,aAAa,WAAW;AACnD,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,QAAQ,mBAAmB,QAAQ;AACpD,MAAI,UAAU;AACZ,uBAAmB,YAAY,UAAU,QAAQ,mBAAmB,WAAW,CAAC;AAChF,QAAI,QAAQ,mBAAmB,QAAQ,GAAG;AACxC,yBAAmB,QAAQ,UAAU,QAAQ,mBAAmB,WAAW,CAAC;AAAA,IAC9E;AAAA,EACF;AAEA,MAAI,QAAQ,YAAa,QAAO;AAChC,QAAM,OAAO,QAAQ,mBAAmB,WAAW;AACnD,UAAQ,mBAAmB,MAAM,QAAQ,QAAQ,aAAa,UAAU,CAAC;AAEzE,MAAI,MAAM;AACR,UAAM,UAAU,QAAQ,mBAAmB,QAAQ;AACnD,uBAAmB,WAAW,MAAM,OAAO;AAC3C,QACE,QAAQ,uBAAuB,QAC/B,QAAQ,mBAAmB,IAAI,GAC/B;AACA,yBAAmB,SAAS,MAAM,QAAQ,mBAAmB,QAAQ,CAAC;AAAA,IACxE;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,mBACP,MACA,QACA,eACM;AACN;AAAA,IACE;AAAA,IACA;AAAA,IACA,IAAI,WAAW,MAAM;AAAA,MACnB,SAAS,SAAS,aAAa,SAAS;AAAA,MACxC,YAAY;AAAA,IACd,CAAC;AAAA,IACD,iBAAiB;AAAA,EACnB;AACF;AAEA,SAAS,SAAS,SAAkC;AAClD,MAAI,CAAC,QAAQ,YAAa,QAAO,QAAQ,MAAM;AACjD;",
+  "names": []
+}

package/dist/lib/focus/focus-manager.d.ts

@@ -0,0 +1,121 @@
+import type { PibblEventTargetRegistration } from "../events/registrations.js";
+import type { PibblEvent, PibblEventType } from "../events/types.js";
+import type { PibblEventRoot, PibblFocusPressDefaultInput, PibblFocusTouchDefaultInput, PibblFocusPolicyBridge, PibblInstance } from "../types.js";
+import type { HtmlFocusRegion } from "./html-focus-region.js";
+import { type PibblDirectionalBoundary, type PibblFocusCandidate, type PibblNavigationCandidate } from "./types.js";
+export declare class PibblFocusManager implements PibblFocusPolicyBridge {
+    private readonly eventRoot;
+    private committedCandidates;
+    private committedHtmlCandidates;
+    private committedNavigationCandidates;
+    private committedBoundaries;
+    private pending;
+    private transactionalPending;
+    private directionalStack;
+    private focusedTarget;
+    private focusedHtmlRegion;
+    private pendingHtmlFocusModality;
+    private focusVisible;
+    private pendingSpaceTarget;
+    private pendingPressFocus;
+    private readonly representedPointerPresses;
+    private readonly representedTouchContacts;
+    private activeTouchIdentifiers;
+    private primaryTouchIdentifier;
+    private touchSequenceActive;
+    private touchMouseCompatibility;
+    private focusRenderRevision;
+    private readonly layerFocusRenderRevisions;
+    private destroyed;
+    private ownerReleased;
+    private readonly coordinator;
+    constructor(eventRoot: PibblEventRoot, owner: PibblInstance);
+    get candidates(): readonly PibblFocusCandidate[];
+    /** @internal Full source-order list including native HtmlBox regions. */
+    get navigationCandidates(): readonly PibblNavigationCandidate[];
+    get htmlFocusRegions(): readonly HtmlFocusRegion[];
+    get focusedNavigationCandidate(): PibblNavigationCandidate | undefined;
+    /** @internal Resolves dynamic native eligibility at each navigation boundary. */
+    isNavigationCandidateFocusable(candidate: PibblNavigationCandidate): boolean;
+    /** Includes a successful render's collected candidates before commit callbacks settle. */
+    get hasFocusCandidates(): boolean;
+    get isDestroyed(): boolean;
+    get ownerWasReleased(): boolean;
+    get canvas(): HTMLCanvasElement;
+    get logicalFocusTarget(): PibblEventTargetRegistration | undefined;
+    get logicalFocusVisible(): boolean;
+    beginCollection(): void;
+    finishCollection(success: boolean): void;
+    private commitCollection;
+    observeTarget(target: PibblEventTargetRegistration): void;
+    /** @internal Collects one published HtmlBox in source order. */
+    observeHtmlRegion(region: HtmlFocusRegion): void;
+    /** @internal Removes an unmounted HtmlBox without manufacturing a Canvas target. */
+    removeHtmlFocusRegion(region: HtmlFocusRegion): void;
+    /** @internal Deactivates retained DOM hosts while the root has no display area. */
+    suspendHtmlRegions(): void;
+    observeTransactionalTarget(target: PibblEventTargetRegistration): void;
+    removeTarget(target: PibblEventTargetRegistration): void;
+    snapshot(target: PibblEventTargetRegistration): Readonly<{
+        isFocused: false;
+        isFocusVisible: false;
+    }> | Readonly<{
+        isFocused: true;
+        isFocusVisible: boolean;
+    }>;
+    resolveKeyboardTarget(): PibblEventTargetRegistration | undefined;
+    afterDispatch(event: PibblEvent): void;
+    afterPressDispatch(input: PibblFocusPressDefaultInput): void;
+    afterTouchDispatch(input: PibblFocusTouchDefaultInput): void;
+    beforeNativeDispatch(type: PibblEventType, event: Event): PibblFocusManager | undefined;
+    enterDOMFocus(backwards: boolean): void;
+    leaveDOMFocus(): void;
+    activateDOMHost(): void;
+    focusNavigationCandidate(candidate: PibblNavigationCandidate | undefined, modality: "keyboard" | "pointer", backwards?: boolean): boolean;
+    /** @internal Called by the native region listeners after the browser focuses a descendant. */
+    adoptNativeHtmlFocus(region: HtmlFocusRegion, modality: "keyboard" | "pointer" | undefined): void;
+    /** @internal Native blur settled outside a registered host. */
+    clearNativeHtmlFocus(region: HtmlFocusRegion): void;
+    /** @internal Reconciles a committed host list with the browser focus owner. */
+    reconcileNativeHtmlFocus(region: HtmlFocusRegion | undefined): void;
+    replayRetainedSubtree(instance: PibblInstance): void;
+    layerFocusRenderRevision(instance: PibblInstance): number | undefined;
+    private replayRetainedTargets;
+    private replayCanvasOnlyTargets;
+    setFocusState(target: PibblEventTargetRegistration | undefined, focusVisible: boolean): void;
+    liveFocusCandidate(target: PibblEventTargetRegistration | undefined): PibblEventTargetRegistration | undefined;
+    commitLogicalFocus(target: PibblEventTargetRegistration | undefined, focusVisible: boolean): void;
+    enterDirectionalBoundary(boundary: PibblDirectionalBoundary): void;
+    exitDirectionalBoundary(boundary: PibblDirectionalBoundary): void;
+    private currentDirectionalBoundary;
+    private markFocusRenderLayers;
+    dispose(): void;
+    markOwnerReleased(): void;
+    destroyFromCoordinator(): void;
+    private recordPendingTarget;
+    private markPendingIneligible;
+    private commitCandidates;
+    private commitNavigationCandidates;
+    private commitRemovedTarget;
+    private clearFocusState;
+    private adoptHtmlFocus;
+    private clearHtmlFocus;
+    private notifyHtmlFocus;
+    private applyPressFocus;
+    beginSpaceActivation(target: PibblEventTargetRegistration): void;
+    hasPendingSpaceActivation(target: PibblEventTargetRegistration | undefined): boolean;
+    consumeSpaceActivation(): PibblEventTargetRegistration | undefined;
+    cancelSpaceActivation(): void;
+    private recordPointerPress;
+    private consumeRepresentedMousePress;
+    private consumeRepresentedTouchPress;
+    private recordTouchFallback;
+    private recordTouchStarts;
+    private reconcileTouchContacts;
+    private recordTouchTerminals;
+    private purgeExpiredPresses;
+    private assertLive;
+}
+export declare function createFocusManager(eventRoot: PibblEventRoot, owner: PibblInstance): PibblFocusManager;
+export declare function requireFocusManager(eventRoot: PibblEventRoot): PibblFocusManager;
+export declare function createDirectionalBoundary(owner: PibblInstance): PibblDirectionalBoundary;