keystra 0.0.0-stage → 0.1.1

package/dist/focus.cjs

@@ -0,0 +1,374 @@
+'use strict';
+
+// src/utils/dom.ts
+var DISABLED_SELECTOR_DEFAULT = "[disabled],[aria-disabled='true']";
+function isDisabled(element, selector = DISABLED_SELECTOR_DEFAULT) {
+  if (!selector) return false;
+  const html = element;
+  if (html.disabled === true) return true;
+  if (element.getAttribute("aria-disabled") === "true") return true;
+  if (selector === DISABLED_SELECTOR_DEFAULT) return element.hasAttribute("disabled");
+  try {
+    return element.matches(selector);
+  } catch {
+    return false;
+  }
+}
+function isHidden(element) {
+  const html = element;
+  const probe = html;
+  if (typeof probe.checkVisibility === "function") {
+    try {
+      return !probe.checkVisibility.call(html, { checkOpacity: false, checkVisibilityCSS: true });
+    } catch {
+    }
+  }
+  let node = html;
+  while (node && node.nodeType === 1) {
+    if (node.hidden === true) return true;
+    if (node.style && node.style.display === "none") return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+function focusElement(element, preventScroll = true) {
+  if (typeof element.focus !== "function") return false;
+  try {
+    element.focus({ preventScroll });
+  } catch {
+    try {
+      element.focus();
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function contains(parent, child) {
+  if (!parent || !child) return false;
+  if (parent === child) return true;
+  if (typeof parent.contains === "function") return parent.contains(child);
+  let node = child;
+  while (node) {
+    if (node === parent) return true;
+    node = node.parentNode;
+  }
+  return false;
+}
+var idCounter = 0;
+function ensureId(element, prefix) {
+  const existing = element.id;
+  if (existing) return existing;
+  idCounter += 1;
+  const generated = `${prefix}-${idCounter}`;
+  element.id = generated;
+  return generated;
+}
+
+// src/focus/roving-focus.ts
+var RovingTabindex = class {
+  constructor(options = {}) {
+    this.current = /* @__PURE__ */ new WeakMap();
+    this.originals = /* @__PURE__ */ new Map();
+    this.active = null;
+    this.respectNegative = options.respectNegative !== false;
+    this.disabled = options.disabled === true;
+  }
+  get activeElement() {
+    return this.active;
+  }
+  sync(element, others) {
+    if (this.disabled) return;
+    const desired = element ? this.desiredFor(element) : null;
+    for (let i = 0; i < others.length; i++) {
+      const item = others[i];
+      if (item === element) continue;
+      this.write(item, "-1");
+    }
+    this.active = element;
+    if (element && desired !== null) this.write(element, desired);
+    this.forgetDetached(others.length);
+  }
+  move(element) {
+    if (this.disabled) return;
+    const desired = this.desiredFor(element);
+    if (this.active && this.active !== element) this.write(this.active, "-1");
+    this.active = element;
+    this.write(element, desired);
+  }
+  forgetDetached(live) {
+    if (this.originals.size <= live) return;
+    for (const element of this.originals.keys()) {
+      if (!element.isConnected) this.originals.delete(element);
+    }
+  }
+  authoredTabStop(items) {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const authored = this.originals.has(item) ? this.originals.get(item) : item.getAttribute("tabindex");
+      if (authored === "0") return item;
+    }
+    return null;
+  }
+  apply(element) {
+    if (this.disabled) return;
+    this.active = element;
+    if (element) this.write(element, this.desiredFor(element));
+  }
+  desiredFor(element) {
+    if (this.respectNegative) {
+      const authored = this.originals.has(element) ? this.originals.get(element) : element.getAttribute("tabindex");
+      if (authored === "-1") return "-1";
+    }
+    return "0";
+  }
+  write(element, value) {
+    if (this.current.get(element) === value) return;
+    if (!this.originals.has(element)) this.originals.set(element, element.getAttribute("tabindex"));
+    element.setAttribute("tabindex", value);
+    this.current.set(element, value);
+  }
+  restore() {
+    for (const [element, value] of this.originals) {
+      if (value === null) element.removeAttribute("tabindex");
+      else element.setAttribute("tabindex", value);
+      this.current.delete(element);
+    }
+    this.originals.clear();
+    this.active = null;
+  }
+  get touched() {
+    return this.originals.size;
+  }
+};
+
+// src/focus/focus-manager.ts
+var FocusManager = class {
+  constructor(options = {}) {
+    this.items = [];
+    this.activeElement = null;
+    this.activeIndex = -1;
+    this.outsideElement = null;
+    this.lastInsideElement = null;
+    this.lastKnownIndex = 0;
+    this.cleared = false;
+    this.started = false;
+    this.container = null;
+    this.markedOption = null;
+    this.options = options;
+    this.virtual = options.virtual === true;
+    const roving = options.roving;
+    this.rovingEnabled = roving !== false && (typeof roving !== "object" || roving.enabled !== false);
+    this.roving = new RovingTabindex({
+      disabled: !this.rovingEnabled,
+      respectNegative: typeof roving === "object" ? roving.force !== true : true
+    });
+  }
+  get element() {
+    return this.activeElement;
+  }
+  get index() {
+    return this.activeIndex;
+  }
+  get focusedIndex() {
+    if (this.activeIndex < 0) return -1;
+    if (this.virtual) return this.activeIndex;
+    if (typeof document === "undefined") return this.activeIndex;
+    const active = document.activeElement;
+    const current = this.activeElement;
+    if (!current) return -1;
+    if (active === current) return this.activeIndex;
+    if (active && contains(current, active)) return this.activeIndex;
+    return -1;
+  }
+  get previousElement() {
+    return this.outsideElement;
+  }
+  get lastFocused() {
+    return this.lastInsideElement;
+  }
+  sync(items, container) {
+    const previous = this.activeElement;
+    if (this.activeIndex >= 0) this.lastKnownIndex = this.activeIndex;
+    this.items = items;
+    if (container !== void 0) this.container = container;
+    if (previous) {
+      const index = items.indexOf(previous);
+      if (index !== -1 && this.isUsable(previous)) {
+        this.activeIndex = index;
+        this.promote(previous, items);
+        return index;
+      }
+    }
+    const fromDocument = previous || !this.cleared ? this.readActiveFromDocument(container) : -1;
+    if (fromDocument >= 0) {
+      const element = items[fromDocument];
+      this.activeElement = element;
+      this.activeIndex = fromDocument;
+      this.lastInsideElement = element;
+      this.lastKnownIndex = fromDocument;
+      this.promote(element, items);
+      return fromDocument;
+    }
+    this.activeElement = null;
+    this.activeIndex = -1;
+    let candidate = null;
+    if (previous && items.length > 0) {
+      const previousIndex = this.lastKnownIndex;
+      candidate = items[Math.min(previousIndex, items.length - 1)] ?? items[0] ?? null;
+    } else if (!this.started && items.length > 0) {
+      candidate = this.roving.authoredTabStop(items) ?? items[0] ?? null;
+      const index = candidate ? items.indexOf(candidate) : -1;
+      if (index > 0 && candidate && this.isUsable(candidate)) {
+        this.activeElement = candidate;
+        this.activeIndex = index;
+        this.lastInsideElement = candidate;
+        this.lastKnownIndex = index;
+      }
+    } else {
+      candidate = items[0] ?? null;
+    }
+    this.started = true;
+    this.promote(candidate, items);
+    return this.activeIndex;
+  }
+  promote(element, items) {
+    this.roving.sync(this.virtual ? null : element, items);
+    this.writeActiveDescendant(this.virtual ? element : null);
+  }
+  writeActiveDescendant(element) {
+    if (!this.virtual) return;
+    this.markOption(element);
+    const owner = this.options.descendantOwner?.() ?? null;
+    if (!owner) return;
+    if (!element) {
+      if (owner.hasAttribute("aria-activedescendant")) owner.removeAttribute("aria-activedescendant");
+      return;
+    }
+    const id = ensureId(element, "keystra-item");
+    if (owner.getAttribute("aria-activedescendant") !== id) {
+      owner.setAttribute("aria-activedescendant", id);
+    }
+  }
+  markOption(element) {
+    if (this.markedOption === element) return;
+    if (this.markedOption) this.markedOption.setAttribute("aria-selected", "false");
+    this.markedOption = element?.getAttribute("role") === "option" ? element : null;
+    if (this.markedOption) this.markedOption.setAttribute("aria-selected", "true");
+  }
+  observe(element, container) {
+    if (!element) return;
+    if (container && !contains(container, element)) return;
+    const index = this.items.indexOf(element);
+    if (index === -1) return;
+    const item = this.items[index];
+    this.activeElement = item;
+    this.activeIndex = index;
+    this.lastInsideElement = item;
+    this.lastKnownIndex = index;
+    if (!this.virtual) this.roving.apply(item);
+    this.writeActiveDescendant(item);
+  }
+  focusIndex(index, action = null, preventScroll, moveFocus = true) {
+    const items = this.items;
+    if (index < 0 || index >= items.length) return null;
+    const element = items[index];
+    if (!this.isUsable(element)) return null;
+    const previous = this.activeElement;
+    if (previous && previous !== element) {
+      const previousIndex = items.indexOf(previous);
+      if (previousIndex !== -1) this.options.onBlur?.(previous, previousIndex);
+    }
+    this.captureOutside(previous);
+    this.activeElement = element;
+    this.activeIndex = index;
+    this.cleared = false;
+    this.lastInsideElement = element;
+    this.lastKnownIndex = index;
+    if (this.virtual) this.writeActiveDescendant(element);
+    else this.roving.move(element);
+    if (moveFocus && !this.virtual) {
+      focusElement(element, preventScroll ?? this.options.preventScroll !== false);
+    }
+    this.options.onFocus?.(element, index, action);
+    return element;
+  }
+  setActiveIndex(index) {
+    const element = index >= 0 ? this.items[index] ?? null : null;
+    this.activeElement = element;
+    this.activeIndex = element ? index : -1;
+    if (element) {
+      this.cleared = false;
+      this.lastInsideElement = element;
+      this.lastKnownIndex = index;
+    } else {
+      this.cleared = index < 0;
+    }
+    this.promote(element ?? this.items[0] ?? null, this.items);
+  }
+  focusElement(element, action = null) {
+    if (!element) return false;
+    const index = this.items.indexOf(element);
+    if (index === -1) return false;
+    return this.focusIndex(index, action) !== null;
+  }
+  restore() {
+    const target = this.outsideElement;
+    if (target && typeof target.focus === "function" && !isHidden(target) && !isDisabled(target)) {
+      focusElement(target, this.options.preventScroll !== false);
+      return true;
+    }
+    if (this.virtual) return false;
+    if (this.lastInsideElement && this.items.indexOf(this.lastInsideElement) !== -1) {
+      return this.focusElement(this.lastInsideElement);
+    }
+    return this.focusIndex(this.activeIndex) !== null;
+  }
+  remember(element) {
+    if (element) this.outsideElement = element;
+  }
+  clear() {
+    this.activeElement = null;
+    this.activeIndex = -1;
+    this.items = [];
+    this.lastInsideElement = null;
+    this.lastKnownIndex = 0;
+  }
+  dispose() {
+    this.writeActiveDescendant(null);
+    this.roving.restore();
+    this.clear();
+    this.outsideElement = null;
+  }
+  isUsable(element) {
+    if (!element) return false;
+    if (isDisabled(element, this.options.disabledSelector ?? null)) return false;
+    if (this.options.skipHidden !== false && isHidden(element)) return false;
+    return true;
+  }
+  captureOutside(current) {
+    if (typeof document === "undefined") return;
+    const active = document.activeElement;
+    if (!active || active === document.body || active === document.documentElement) return;
+    if (current && active === current) return;
+    if (this.items.indexOf(active) !== -1) return;
+    if (this.container && contains(this.container, active)) return;
+    this.outsideElement = active;
+  }
+  readActiveFromDocument(container) {
+    if (typeof document === "undefined") return -1;
+    const active = document.activeElement;
+    if (!active || active === document.body) return -1;
+    const index = this.items.indexOf(active);
+    if (index !== -1) return index;
+    if (container) {
+      for (let i = 0; i < this.items.length; i++) {
+        if (contains(this.items[i], active)) return i;
+      }
+    }
+    return -1;
+  }
+};
+
+exports.FocusManager = FocusManager;
+exports.RovingTabindex = RovingTabindex;

package/dist/focus.d.cts

@@ -0,0 +1,74 @@
+import { z as RovingOptions, K as KeyAction } from './index-IZkcWAXP.cjs';
+
+interface RovingTabindexOptions {
+    readonly respectNegative?: boolean;
+    readonly disabled?: boolean;
+}
+declare class RovingTabindex<T extends Element = HTMLElement> {
+    private readonly current;
+    private readonly originals;
+    private active;
+    private readonly respectNegative;
+    private readonly disabled;
+    constructor(options?: RovingTabindexOptions);
+    get activeElement(): T | null;
+    sync(element: T | null, others: readonly T[]): void;
+    move(element: T): void;
+    private forgetDetached;
+    authoredTabStop(items: readonly T[]): T | null;
+    apply(element: T | null): void;
+    private desiredFor;
+    private write;
+    restore(): void;
+    get touched(): number;
+}
+
+interface FocusManagerOptions<T extends Element = HTMLElement> {
+    readonly roving?: boolean | RovingOptions;
+    readonly preventScroll?: boolean;
+    readonly disabledSelector?: string | null;
+    readonly skipHidden?: boolean;
+    readonly onFocus?: (element: T, index: number, action: KeyAction | null) => void;
+    readonly onBlur?: (element: T, index: number) => void;
+    readonly virtual?: boolean;
+    readonly descendantOwner?: (() => Element | null) | null;
+}
+declare class FocusManager<T extends Element = HTMLElement> {
+    readonly roving: RovingTabindex<T>;
+    private items;
+    private activeElement;
+    private activeIndex;
+    private outsideElement;
+    private lastInsideElement;
+    private lastKnownIndex;
+    private cleared;
+    private started;
+    private readonly rovingEnabled;
+    private readonly options;
+    private readonly virtual;
+    private container;
+    private markedOption;
+    constructor(options?: FocusManagerOptions<T>);
+    get element(): T | null;
+    get index(): number;
+    get focusedIndex(): number;
+    get previousElement(): HTMLElement | null;
+    get lastFocused(): T | null;
+    sync(items: readonly T[], container?: Element | null): number;
+    private promote;
+    private writeActiveDescendant;
+    private markOption;
+    observe(element: Element | null, container: Element | null): void;
+    focusIndex(index: number, action?: KeyAction | null, preventScroll?: boolean, moveFocus?: boolean): T | null;
+    setActiveIndex(index: number): void;
+    focusElement(element: T | null, action?: KeyAction | null): boolean;
+    restore(): boolean;
+    remember(element: HTMLElement | null): void;
+    clear(): void;
+    dispose(): void;
+    private isUsable;
+    private captureOutside;
+    private readActiveFromDocument;
+}
+
+export { FocusManager, type FocusManagerOptions, RovingTabindex, type RovingTabindexOptions };

package/dist/focus.d.ts

@@ -0,0 +1,74 @@
+import { z as RovingOptions, K as KeyAction } from './index-IZkcWAXP.js';
+
+interface RovingTabindexOptions {
+    readonly respectNegative?: boolean;
+    readonly disabled?: boolean;
+}
+declare class RovingTabindex<T extends Element = HTMLElement> {
+    private readonly current;
+    private readonly originals;
+    private active;
+    private readonly respectNegative;
+    private readonly disabled;
+    constructor(options?: RovingTabindexOptions);
+    get activeElement(): T | null;
+    sync(element: T | null, others: readonly T[]): void;
+    move(element: T): void;
+    private forgetDetached;
+    authoredTabStop(items: readonly T[]): T | null;
+    apply(element: T | null): void;
+    private desiredFor;
+    private write;
+    restore(): void;
+    get touched(): number;
+}
+
+interface FocusManagerOptions<T extends Element = HTMLElement> {
+    readonly roving?: boolean | RovingOptions;
+    readonly preventScroll?: boolean;
+    readonly disabledSelector?: string | null;
+    readonly skipHidden?: boolean;
+    readonly onFocus?: (element: T, index: number, action: KeyAction | null) => void;
+    readonly onBlur?: (element: T, index: number) => void;
+    readonly virtual?: boolean;
+    readonly descendantOwner?: (() => Element | null) | null;
+}
+declare class FocusManager<T extends Element = HTMLElement> {
+    readonly roving: RovingTabindex<T>;
+    private items;
+    private activeElement;
+    private activeIndex;
+    private outsideElement;
+    private lastInsideElement;
+    private lastKnownIndex;
+    private cleared;
+    private started;
+    private readonly rovingEnabled;
+    private readonly options;
+    private readonly virtual;
+    private container;
+    private markedOption;
+    constructor(options?: FocusManagerOptions<T>);
+    get element(): T | null;
+    get index(): number;
+    get focusedIndex(): number;
+    get previousElement(): HTMLElement | null;
+    get lastFocused(): T | null;
+    sync(items: readonly T[], container?: Element | null): number;
+    private promote;
+    private writeActiveDescendant;
+    private markOption;
+    observe(element: Element | null, container: Element | null): void;
+    focusIndex(index: number, action?: KeyAction | null, preventScroll?: boolean, moveFocus?: boolean): T | null;
+    setActiveIndex(index: number): void;
+    focusElement(element: T | null, action?: KeyAction | null): boolean;
+    restore(): boolean;
+    remember(element: HTMLElement | null): void;
+    clear(): void;
+    dispose(): void;
+    private isUsable;
+    private captureOutside;
+    private readActiveFromDocument;
+}
+
+export { FocusManager, type FocusManagerOptions, RovingTabindex, type RovingTabindexOptions };

package/dist/focus.js

@@ -0,0 +1,2 @@
+export { FocusManager, RovingTabindex } from './chunk-ZOJRXXQN.js';
+import './chunk-77GGU3AX.js';