keystra 0.0.0-stage → 0.1.1

package/dist/chunk-77GGU3AX.js

@@ -0,0 +1,135 @@
+// src/utils/dom.ts
+function hasDom() {
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function resolveElement(target, root = null) {
+  if (target == null) return null;
+  if (typeof target === "function") {
+    return resolveElement(target(), root);
+  }
+  if (typeof target === "string") {
+    const scope = root ?? (hasDom() ? document : null);
+    if (!scope) return null;
+    try {
+      return scope.querySelector(target);
+    } catch {
+      return null;
+    }
+  }
+  return target;
+}
+function queryItems(container, selector) {
+  if (!container) return [];
+  if (typeof selector === "function") {
+    const result = selector(container);
+    return Array.from(result);
+  }
+  if (!selector) return [];
+  try {
+    return Array.from(container.querySelectorAll(selector));
+  } catch {
+    return [];
+  }
+}
+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 isFocusable(element) {
+  const html = element;
+  if (typeof html.focus !== "function") return false;
+  if (isDisabled(element)) return false;
+  return !isHidden(element);
+}
+var EDITABLE_SELECTOR_DEFAULT = "input:not([type='hidden']):not([readonly]),textarea:not([readonly]),select,[contenteditable=''],[contenteditable='true'],[iscontenteditable]";
+function isEditableTarget(target, extraSelector) {
+  if (!target || typeof target.matches !== "function") return false;
+  const element = target;
+  const selector = extraSelector ? `${EDITABLE_SELECTOR_DEFAULT},${extraSelector}` : EDITABLE_SELECTOR_DEFAULT;
+  try {
+    if (element.matches(selector)) return true;
+  } catch {
+  }
+  const html = element;
+  return html.isContentEditable === true;
+}
+function getText(element) {
+  const label = element.getAttribute("aria-label") ?? element.textContent ?? "";
+  return label.replace(/\s+/g, " ").trim();
+}
+function setAttribute(element, name, value) {
+  if (value === null) element.removeAttribute(name);
+  else if (element.getAttribute(name) !== value) element.setAttribute(name, value);
+}
+function toggleClass(element, name, on) {
+  if (!name) return;
+  const html = element;
+  if (typeof html.classList?.toggle === "function") html.classList.toggle(name, on);
+}
+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;
+}
+function resolveEventTarget(target) {
+  if (target == null) return null;
+  if (typeof target === "string") return resolveElement(target);
+  if (typeof target === "function") return resolveEventTarget(target());
+  return target;
+}
+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;
+}
+
+export { contains, ensureId, focusElement, getText, hasDom, isDisabled, isEditableTarget, isFocusable, isHidden, queryItems, resolveElement, resolveEventTarget, setAttribute, toggleClass };

package/dist/chunk-KDOJARJD.js

@@ -0,0 +1,29 @@
+// src/navigation/custom.ts
+function createCustomStrategy(hooks) {
+  const resolved = typeof hooks === "function" ? { onNavigate: hooks } : hooks;
+  return (context) => {
+    if (context.direction || isMovementAction(context.action)) {
+      const result2 = resolved.onNavigate?.(context);
+      if (typeof result2 === "number") return result2;
+      return resolved.fallback ? resolved.fallback(context) : null;
+    }
+    const result = resolved.onAction?.(context);
+    if (typeof result === "number") return result;
+    return resolved.onNavigate?.(context) ?? null;
+  };
+}
+function composeStrategies(...strategies) {
+  const list = strategies.filter(Boolean);
+  return (context) => {
+    for (let i = 0; i < list.length; i++) {
+      const result = list[i](context);
+      if (typeof result === "number" && result >= 0) return result;
+    }
+    return null;
+  };
+}
+function isMovementAction(action) {
+  return action === "next" || action === "previous" || action === "first" || action === "last" || action === "pageUp" || action === "pageDown";
+}
+
+export { composeStrategies, createCustomStrategy };

package/dist/chunk-LYYUOTBP.js

@@ -0,0 +1,125 @@
+import { KeyMatcher, EventManager, normalizeKeyEvent, createKeystra } from './chunk-U7YK6PPT.js';
+import { resolveElement, resolveEventTarget, isEditableTarget } from './chunk-77GGU3AX.js';
+
+// src/core/hooks.ts
+function resolveContainer(target) {
+  return resolveElement(target, typeof document !== "undefined" ? document : null);
+}
+function useKeystra(options = {}) {
+  let stored = { ...options };
+  let instance = null;
+  let container = resolveContainer(stored.container);
+  let detached = false;
+  let resumeOnAttach = false;
+  let destroyed = false;
+  const handle = {
+    get instance() {
+      return instance;
+    },
+    get container() {
+      return container;
+    },
+    attach(target) {
+      if (destroyed) return null;
+      const element = resolveContainer(target);
+      if (!element) return instance;
+      if (!instance) {
+        container = element;
+        instance = createKeystra({ ...stored, container: element });
+        return instance;
+      }
+      if (element !== container) {
+        container = element;
+        instance.update({ container: element });
+      }
+      if (detached) {
+        detached = false;
+        if (resumeOnAttach) instance.enable();
+        resumeOnAttach = false;
+      }
+      return instance;
+    },
+    detach() {
+      if (!instance || detached) return;
+      resumeOnAttach = instance.enabled;
+      detached = true;
+      instance.disable();
+      container = null;
+    },
+    destroy() {
+      destroyed = true;
+      instance?.destroy();
+      instance = null;
+      container = null;
+      detached = false;
+      resumeOnAttach = false;
+    }
+  };
+  if (container) handle.attach(container);
+  return handle;
+}
+var SHORTCUT_ACTION = "shortcut";
+function isChord(match) {
+  const binding = match.binding;
+  return binding.ctrl === true || binding.alt === true || binding.meta === true;
+}
+function createKeyBinding(binding, handler, options = {}) {
+  const matcher = new KeyMatcher({ [SHORTCUT_ACTION]: binding }, options.sequences ?? []);
+  const events = new EventManager();
+  const capture = options.capture === true;
+  const shouldPrevent = options.preventDefault !== false;
+  const shouldStop = options.stopPropagation === true;
+  const allowInEditable = options.allowInEditable === true;
+  const editableSelector = options.editableSelector ?? null;
+  let disposer = null;
+  let destroyed = false;
+  function target() {
+    const explicit = resolveEventTarget(options.target);
+    if (explicit) return explicit;
+    return typeof document !== "undefined" ? document : null;
+  }
+  function onKeyDown(rawEvent) {
+    if (destroyed) return;
+    if (options.when && !options.when()) return;
+    const event = rawEvent;
+    const match = matcher.match(normalizeKeyEvent(event), handle);
+    const editable = !allowInEditable && isEditableTarget(event.target, editableSelector);
+    if (!match) return;
+    if (!match.complete) {
+      if (match.preventDefault && shouldPrevent && !(editable && !isChord(match))) event.preventDefault();
+      return;
+    }
+    if (editable && !isChord(match)) return;
+    if (shouldPrevent && match.preventDefault !== false) event.preventDefault();
+    if (shouldStop) event.stopPropagation();
+    handler(event, { action: match.actions[0] ?? SHORTCUT_ACTION, fromSequence: match.fromSequence });
+  }
+  const handle = {
+    enable() {
+      if (destroyed || disposer) return;
+      const listenOn = target();
+      if (!listenOn) return;
+      disposer = events.add(listenOn, "keydown", onKeyDown, { capture, passive: false });
+    },
+    disable() {
+      if (!disposer) return;
+      disposer();
+      disposer = null;
+      matcher.resetSequence();
+    },
+    destroy() {
+      destroyed = true;
+      handle.disable();
+      matcher.dispose();
+      events.dispose();
+    },
+    matches(event) {
+      const match = matcher.match(normalizeKeyEvent(event), handle);
+      return match !== null && match.complete;
+    }
+  };
+  if (options.enabled !== false) handle.enable();
+  return handle;
+}
+
+export { createKeyBinding, useKeystra };

package/dist/chunk-S5YVXIMA.js

@@ -0,0 +1,61 @@
+// src/utils/emitter.ts
+var Emitter = class {
+  constructor() {
+    this.handlers = null;
+  }
+  on(event, handler) {
+    if (!this.handlers) this.handlers = /* @__PURE__ */ new Map();
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      this.off(event, handler);
+    };
+  }
+  off(event, handler) {
+    const set = this.handlers?.get(event);
+    if (!set) return;
+    if (handler) set.delete(handler);
+    else set.clear();
+    if (set.size === 0) this.handlers?.delete(event);
+  }
+  emit(event, payload) {
+    const set = this.handlers?.get(event);
+    if (!set || set.size === 0) return;
+    for (const handler of Array.from(set)) {
+      handler(payload);
+    }
+  }
+  clear() {
+    this.handlers?.clear();
+    this.handlers = null;
+  }
+  get size() {
+    if (!this.handlers) return 0;
+    let total = 0;
+    for (const set of this.handlers.values()) total += set.size;
+    return total;
+  }
+};
+
+// src/utils/layout.ts
+var LayoutCache = class {
+  constructor() {
+    this.rects = /* @__PURE__ */ new WeakMap();
+  }
+  rect(element, version) {
+    const cached = this.rects.get(element);
+    if (cached && cached.version === version) return cached.rect;
+    const rect = element.getBoundingClientRect();
+    this.rects.set(element, { version, rect });
+    return rect;
+  }
+};
+
+export { Emitter, LayoutCache };

package/dist/chunk-SSIKGDD4.js

@@ -0,0 +1,255 @@
+import { setAttribute, toggleClass } from './chunk-77GGU3AX.js';
+
+// src/selection/selection-manager.ts
+var SelectionManager = class {
+  constructor(options = {}) {
+    this.selectedItems = [];
+    this.itemsValue = [];
+    this.provider = null;
+    this.anchorElement = null;
+    this.touched = /* @__PURE__ */ new Set();
+    this.onDiff = null;
+    this.needsInitial = true;
+    this.options = options;
+    this.modeValue = options.mode ?? "single";
+    this.attribute = options.attribute ?? null;
+    this.selectedClass = options.selectedClass;
+    this.aria = options.aria === true;
+  }
+  get mode() {
+    return this.modeValue;
+  }
+  get selected() {
+    return this.selectedItems;
+  }
+  get items() {
+    return this.provider ? this.provider() : this.itemsValue;
+  }
+  get selectedIndexes() {
+    const result = [];
+    for (let i = 0; i < this.selectedItems.length; i++) {
+      const index = this.items.indexOf(this.selectedItems[i]);
+      if (index !== -1) result.push(index);
+    }
+    return result.sort((a, b) => a - b);
+  }
+  get anchor() {
+    return this.anchorElement;
+  }
+  get size() {
+    return this.selectedItems.length;
+  }
+  bindItems(provider) {
+    this.provider = provider;
+  }
+  setDiffHandler(handler) {
+    this.onDiff = handler;
+  }
+  sync(items) {
+    if (this.itemsValue === items && !this.needsInitial) return;
+    this.itemsValue = items;
+    const current = this.items;
+    if (this.needsInitial) {
+      this.needsInitial = false;
+      this.applyInitial(this.options.initial);
+    }
+    if (this.aria || this.attribute || this.selectedClass) {
+      for (let i = 0; i < current.length; i++) {
+        const element = current[i];
+        this.paint(element, this.selectedItems.indexOf(element) !== -1);
+      }
+    }
+    if (this.touched.size > current.length) {
+      for (const element of this.touched) {
+        if (!element.isConnected && this.selectedItems.indexOf(element) === -1) this.touched.delete(element);
+      }
+    }
+    if (this.selectedItems.length === 0 && this.anchorElement === null) return;
+    let changed = false;
+    const kept = [];
+    for (const element of this.selectedItems) {
+      if (current.indexOf(element) !== -1) kept.push(element);
+      else {
+        this.paint(element, false);
+        changed = true;
+      }
+    }
+    if (this.anchorElement && current.indexOf(this.anchorElement) === -1) {
+      this.anchorElement = kept[0] ?? null;
+      changed = true;
+    }
+    if (changed) {
+      const previous = this.selectedItems;
+      this.selectedItems = kept;
+      this.options.onChange?.(this.selectedItems);
+      this.onDiff?.(this.selectedItems, [], previous.filter((element) => kept.indexOf(element) === -1));
+    }
+  }
+  applyInitial(initial) {
+    if (initial == null) return;
+    const current = this.items;
+    if (typeof initial === "number") {
+      const element = current[initial];
+      if (element) this.select(element);
+      return;
+    }
+    const list = Array.isArray(initial) ? initial : [initial];
+    for (const element of list) if (element) this.select(element, this.modeValue !== "single");
+  }
+  select(elementOrIndex, extend = false) {
+    if (this.modeValue === "none") return;
+    const element = this.resolve(elementOrIndex);
+    if (!element) return;
+    if (this.modeValue === "single" || !extend && this.modeValue !== "multiple") {
+      if (this.selectedItems.length === 1 && this.selectedItems[0] === element) {
+        this.anchorElement = element;
+        return;
+      }
+      const removed = this.selectedItems.slice();
+      this.selectedItems = [element];
+      this.anchorElement = element;
+      for (const item of removed) this.paint(item, false);
+      this.paint(element, true);
+      this.emit(removed);
+      return;
+    }
+    if (this.modeValue === "range" && extend && this.anchorElement) {
+      this.selectRange(this.anchorElement, element);
+      return;
+    }
+    if (this.selectedItems.indexOf(element) === -1) {
+      const previous = this.selectedItems.slice();
+      this.selectedItems.push(element);
+      this.paint(element, true);
+      this.emit(previous);
+    }
+    if (!this.anchorElement) this.anchorElement = element;
+  }
+  toggle(elementOrIndex) {
+    if (this.modeValue === "none") return;
+    const element = this.resolve(elementOrIndex);
+    if (!element) return;
+    if (this.modeValue === "single") {
+      if (this.selectedItems[0] === element) this.clear();
+      else this.select(element);
+      return;
+    }
+    const previous = this.selectedItems.slice();
+    const index = previous.indexOf(element);
+    if (index === -1) {
+      this.selectedItems.push(element);
+      this.paint(element, true);
+    } else {
+      this.selectedItems.splice(index, 1);
+      this.paint(element, false);
+      if (this.anchorElement === element) this.anchorElement = this.selectedItems[0] ?? null;
+    }
+    this.emit(previous);
+    if (!this.anchorElement && index === -1) this.anchorElement = element;
+  }
+  deselect(elementOrIndex) {
+    const element = this.resolve(elementOrIndex);
+    if (!element) return;
+    const index = this.selectedItems.indexOf(element);
+    if (index === -1) return;
+    const previous = this.selectedItems.slice();
+    this.selectedItems.splice(index, 1);
+    this.paint(element, false);
+    if (this.anchorElement === element) this.anchorElement = this.selectedItems[0] ?? null;
+    this.emit(previous);
+  }
+  selectRange(from, to) {
+    if (this.modeValue === "none") return;
+    const start = this.resolve(from);
+    const end = this.resolve(to);
+    if (!start || !end) return;
+    let a = this.items.indexOf(start);
+    let b = this.items.indexOf(end);
+    if (a === -1 || b === -1) return;
+    if (a > b) {
+      const swap = a;
+      a = b;
+      b = swap;
+    }
+    const previous = this.selectedItems.slice();
+    const next = [];
+    for (let i = a; i <= b; i++) {
+      const element = this.items[i];
+      if (element) next.push(element);
+    }
+    this.selectedItems = next;
+    this.anchorElement = start;
+    for (const element of previous) if (next.indexOf(element) === -1) this.paint(element, false);
+    for (const element of next) this.paint(element, true);
+    this.emit(previous);
+  }
+  selectAll() {
+    if (this.modeValue === "none" || this.modeValue === "single") {
+      if (this.modeValue === "single" && this.items[0]) this.select(this.items[0]);
+      return;
+    }
+    const previous = this.selectedItems.slice();
+    this.selectedItems = this.items.slice();
+    for (const element of this.selectedItems) this.paint(element, true);
+    this.anchorElement = this.items[0] ?? null;
+    this.emit(previous);
+  }
+  clear() {
+    if (this.selectedItems.length === 0 && !this.anchorElement) return;
+    const previous = this.selectedItems.slice();
+    this.selectedItems = [];
+    this.anchorElement = null;
+    for (const element of previous) this.paint(element, false);
+    this.emit(previous);
+  }
+  isSelected(elementOrIndex) {
+    const element = this.resolve(elementOrIndex);
+    return element !== null && this.selectedItems.indexOf(element) !== -1;
+  }
+  indexOfSelected(element) {
+    return this.selectedItems.indexOf(element);
+  }
+  setMode(mode) {
+    if (mode === this.modeValue) return;
+    this.modeValue = mode;
+    if (mode === "single" && this.selectedItems.length > 1) {
+      const previous = this.selectedItems.slice();
+      this.selectedItems = previous.slice(0, 1);
+      for (const element of previous) if (this.selectedItems.indexOf(element) === -1) this.paint(element, false);
+      this.emit(previous);
+    }
+    if (mode === "none") this.clear();
+  }
+  dispose() {
+    this.provider = null;
+    for (const element of this.touched) {
+      if (this.aria) setAttribute(element, "aria-selected", null);
+      if (this.attribute) element.removeAttribute(this.attribute);
+      toggleClass(element, this.selectedClass, false);
+    }
+    this.touched.clear();
+    this.selectedItems = [];
+    this.anchorElement = null;
+    this.itemsValue = [];
+  }
+  resolve(elementOrIndex) {
+    if (elementOrIndex === void 0 || elementOrIndex === null) return null;
+    if (typeof elementOrIndex === "number") return this.items[elementOrIndex] ?? null;
+    return elementOrIndex;
+  }
+  paint(element, on) {
+    this.touched.add(element);
+    if (this.aria) setAttribute(element, "aria-selected", on ? "true" : "false");
+    if (this.attribute) setAttribute(element, this.attribute, on ? "true" : null);
+    toggleClass(element, this.selectedClass, on);
+  }
+  emit(previous) {
+    const added = this.selectedItems.filter((element) => previous.indexOf(element) === -1);
+    const removed = previous.filter((element) => this.selectedItems.indexOf(element) === -1);
+    if (added.length === 0 && removed.length === 0) return;
+    this.options.onChange?.(this.selectedItems);
+    this.onDiff?.(this.selectedItems, added, removed);
+  }
+};
+
+export { SelectionManager };