keystra 0.0.0-stage → 0.1.1

package/dist/chunk-XFNYIPOW.js

@@ -0,0 +1,253 @@
+// src/navigation/directional.ts
+function actionToDirection(action) {
+  switch (action) {
+    case "up":
+      return "up";
+    case "down":
+      return "down";
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    default:
+      return null;
+  }
+}
+function createDirectionalStrategy(options = {}) {
+  const crossWeight = options.crossAxisWeight ?? 2;
+  return (context) => {
+    const direction = context.direction ?? actionToDirection(context.action);
+    if (!direction) return null;
+    const items = context.items;
+    const total = items.length;
+    if (total === 0) return -1;
+    const from = context.index;
+    if (from < 0 || from >= total) {
+      return direction === "down" || direction === "right" ? 0 : total - 1;
+    }
+    const current = items[from];
+    if (!current) return null;
+    const origin = context.rectOf(current);
+    const ox = origin.left + origin.width / 2;
+    const oy = origin.top + origin.height / 2;
+    const horizontal = direction === "left" || direction === "right";
+    const sign = direction === "right" || direction === "down" ? 1 : -1;
+    let bestIndex = -1;
+    let bestScore = Infinity;
+    let nearestIndex = -1;
+    let nearestDistance = Infinity;
+    for (let i = 0; i < total; i++) {
+      if (i === from) continue;
+      const element = items[i];
+      const rect = context.rectOf(element);
+      if (rect.width === 0 && rect.height === 0) continue;
+      const dx = rect.left + rect.width / 2 - ox;
+      const dy = rect.top + rect.height / 2 - oy;
+      const distance = Math.hypot(dx, dy);
+      if (distance < nearestDistance) {
+        nearestDistance = distance;
+        nearestIndex = i;
+      }
+      const primary = (horizontal ? dx : dy) * sign;
+      if (primary <= 0) continue;
+      const cross = Math.abs(horizontal ? dy : dx);
+      if (cross > primary) continue;
+      const score = primary + cross * crossWeight;
+      if (score < bestScore) {
+        bestScore = score;
+        bestIndex = i;
+      }
+    }
+    if (bestIndex !== -1) return bestIndex;
+    const allowFallback = options.wrapFallback ?? context.loop;
+    return allowFallback ? nearestIndex : null;
+  };
+}
+
+// src/navigation/grid.ts
+function computeGridInfo(context) {
+  const items = context.items;
+  const total = items.length;
+  if (total === 0) return { starts: [0], columns: 1 };
+  const starts = [0];
+  let rowTop = context.rectOf(items[0]).top;
+  let currentColumns = 1;
+  let maxColumns = 1;
+  for (let i = 1; i < total; i++) {
+    const rect = context.rectOf(items[i]);
+    if (Math.abs(rect.top - rowTop) < 2) {
+      currentColumns++;
+      continue;
+    }
+    maxColumns = Math.max(maxColumns, currentColumns);
+    currentColumns = 1;
+    rowTop = rect.top;
+    starts.push(i);
+  }
+  return { starts, columns: Math.max(maxColumns, currentColumns) };
+}
+function declaredInfo(total, columns) {
+  const starts = [];
+  for (let start = 0; start < total; start += columns) starts.push(start);
+  if (starts.length === 0) starts.push(0);
+  return { starts, columns };
+}
+function rowOf(info, index) {
+  const starts = info.starts;
+  let row = 0;
+  for (let i = 0; i < starts.length; i++) {
+    if (starts[i] <= index) row = i;
+    else break;
+  }
+  return row;
+}
+function rowStart(info, row) {
+  return info.starts[row] ?? 0;
+}
+function rowEnd(info, row, total) {
+  return row + 1 < info.starts.length ? info.starts[row + 1] - 1 : total - 1;
+}
+function createGridStrategy(options = {}) {
+  const maintainColumn = options.maintainColumn !== false;
+  const rowHomeEnd = options.rowHomeEnd === true;
+  const declared = options.columns && options.columns > 0 ? options.columns : 0;
+  let cachedVersion = -1;
+  let cachedItems = null;
+  let cached = { starts: [0], columns: 1 };
+  return (context) => {
+    const items = context.items;
+    const total = items.length;
+    if (total === 0) return -1;
+    const columns = declared || context.columns;
+    const index = context.index;
+    const direction = context.direction ?? directionFromAction(context.action);
+    if (!direction) {
+      if (context.action === "first") {
+        if (!rowHomeEnd || index < 0) return 0;
+        const info2 = infoFor(context, columns, total);
+        return rowStart(info2, rowOf(info2, index));
+      }
+      if (context.action === "last") {
+        if (!rowHomeEnd || index < 0) return total - 1;
+        const info2 = infoFor(context, columns, total);
+        return rowEnd(info2, rowOf(info2, index), total);
+      }
+      return null;
+    }
+    if (index < 0 || index >= total) {
+      return direction === "down" || direction === "right" ? 0 : total - 1;
+    }
+    const info = infoFor(context, columns, total);
+    const row = rowOf(info, index);
+    const start = rowStart(info, row);
+    const end = rowEnd(info, row, total);
+    if (direction === "left" || direction === "right") {
+      const next = index + (direction === "right" ? 1 : -1);
+      if (next >= start && next <= end) return next;
+      if (!context.loop) return index;
+      return direction === "right" ? start : end;
+    }
+    const rowDelta = direction === "down" ? 1 : -1;
+    let targetRow = row + rowDelta;
+    if (targetRow < 0 || targetRow >= info.starts.length) {
+      if (!context.loop) return index;
+      targetRow = targetRow < 0 ? info.starts.length - 1 : 0;
+    }
+    const targetStart = rowStart(info, targetRow);
+    const targetEnd = rowEnd(info, targetRow, total);
+    if (columns > 0 && !maintainColumn) return targetStart;
+    if (columns > 0) {
+      const column = index - start;
+      const candidate = targetStart + column;
+      return candidate <= targetEnd ? candidate : targetEnd;
+    }
+    const current = context.rectOf(items[index]);
+    return nearestInRow(context, targetStart, targetEnd, current.left + current.width / 2);
+    function infoFor(ctx, cols, count) {
+      if (cols > 0) return declaredInfo(count, cols);
+      if (cachedVersion === ctx.version && cachedItems === ctx.items) return cached;
+      cached = computeGridInfo(ctx);
+      cachedVersion = ctx.version;
+      cachedItems = ctx.items;
+      return cached;
+    }
+  };
+}
+function nearestInRow(context, start, end, targetX) {
+  let best = start;
+  let bestDistance = Infinity;
+  for (let i = start; i <= end; i++) {
+    const element = context.items[i];
+    if (!element) continue;
+    const rect = context.rectOf(element);
+    const distance = Math.abs(rect.left + rect.width / 2 - targetX);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = i;
+    }
+  }
+  return best;
+}
+function directionFromAction(action) {
+  switch (action) {
+    case "up":
+    case "previous":
+      return "up";
+    case "down":
+    case "next":
+      return "down";
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    default:
+      return null;
+  }
+}
+
+// src/navigation/sequential.ts
+function findNextIndex(total, from, step, loop, clamp = true) {
+  if (total === 0 || step === 0) return -1;
+  if (from < 0 || from >= total) {
+    return step > 0 ? 0 : total - 1;
+  }
+  const next = from + step;
+  if (loop) return (next % total + total) % total;
+  if (next < 0) return clamp ? 0 : -1;
+  if (next >= total) return clamp ? total - 1 : -1;
+  return next;
+}
+function actionDelta(action, direction) {
+  if (direction) {
+    if (direction === "down" || direction === "right") return 1;
+    if (direction === "up" || direction === "left") return -1;
+    return 0;
+  }
+  switch (action) {
+    case "next":
+    case "down":
+    case "right":
+      return 1;
+    case "previous":
+    case "up":
+    case "left":
+      return -1;
+    default:
+      return 0;
+  }
+}
+function createSequentialStrategy(axis = "both") {
+  return (context) => {
+    const { action, direction, index, items, loop } = context;
+    const delta = actionDelta(action, direction);
+    if (delta === 0) return null;
+    const isVerticalAction = direction !== null ? direction === "up" || direction === "down" : action === "up" || action === "down";
+    if (axis === "vertical" && !isVerticalAction && direction !== null) return null;
+    if (axis === "horizontal" && isVerticalAction) return null;
+    return findNextIndex(items.length, index, delta, loop);
+  };
+}
+var verticalStrategy = /* @__PURE__ */ createSequentialStrategy("vertical");
+var horizontalStrategy = /* @__PURE__ */ createSequentialStrategy("horizontal");
+
+export { actionDelta, actionToDirection, createDirectionalStrategy, createGridStrategy, createSequentialStrategy, directionFromAction, findNextIndex, horizontalStrategy, verticalStrategy };

package/dist/chunk-ZOJRXXQN.js

@@ -0,0 +1,308 @@
+import { contains, ensureId, focusElement, isHidden, isDisabled } from './chunk-77GGU3AX.js';
+
+// 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;
+  }
+};
+
+export { FocusManager, RovingTabindex };