@enigmax/primitives 0.22.0 → 0.24.0

package/dist/chunk-Z3VDE7OA.js

@@ -0,0 +1,532 @@
+import { typeaheadStep } from './chunk-4VUHQFAT.js';
+import { createSearch } from './chunk-4ZPMP47J.js';
+
+// src/core/context-menu.ts
+function isAction(entry) {
+  return (entry.type ?? "item") === "item";
+}
+var CONTEXT_MENU_SEARCH_KEYS = ["label", "description", "group", "keywords"];
+var SEARCHABLE_FROM = 8;
+var PAGE = 5;
+var DEFAULT_CACHE_MS = 5 * 60 * 1e3;
+function fold(value) {
+  return value.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLowerCase();
+}
+function createContextMenu(options = {}) {
+  let opts = { ...options };
+  let root = opts.items ?? [];
+  let open = false;
+  let point = null;
+  let levels = [];
+  let typed = "";
+  let typedAt = 0;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const cache = /* @__PURE__ */ new Map();
+  const wantsFocus = /* @__PURE__ */ new Set();
+  const engines = /* @__PURE__ */ new Map();
+  function cacheMs() {
+    return opts.cacheMs ?? DEFAULT_CACHE_MS;
+  }
+  function keyOf(path) {
+    return path.join("\0");
+  }
+  function searchableFor(item, entries) {
+    const asked = item?.searchable ?? "auto";
+    if (asked !== "auto") return asked;
+    return entries.filter(isAction).length >= SEARCHABLE_FROM;
+  }
+  function filtered(level) {
+    if (!level.searchable || !level.query.trim()) return [...level.entries];
+    const actions = level.entries.filter(isAction);
+    const matched = new Set(engineFor(level, actions).searchNow(level.query).map((match) => match.item));
+    return trimFurniture(level.entries.filter((entry) => !isAction(entry) || matched.has(entry)));
+  }
+  function engineFor(level, actions) {
+    const id = keyOf(level.path);
+    const held = engines.get(id);
+    if (held && held.items.length === actions.length && held.items.every((item, index) => item === actions[index])) return held.engine;
+    held?.engine.destroy();
+    const engine = createSearch({
+      items: actions,
+      keys: opts.searchKeys ?? CONTEXT_MENU_SEARCH_KEYS,
+      fuse: opts.fuse,
+      fuseOptions: opts.fuseOptions,
+      matcher: opts.matcher,
+      // A menu filters as you type: the rows are in memory, and a delay is felt as the
+      // panel lagging behind the field.
+      debounce: 0,
+      empty: "all"
+    });
+    engines.set(id, { items: actions, engine });
+    return engine;
+  }
+  function trimFurniture(entries) {
+    const result = [];
+    let separator = null;
+    let caption = null;
+    for (const entry of entries) {
+      if (!isAction(entry)) {
+        if (entry.type === "separator") separator = entry;
+        else caption = entry;
+        continue;
+      }
+      if (separator && result.length > 0) result.push(separator);
+      if (caption) result.push(caption);
+      separator = null;
+      caption = null;
+      result.push(entry);
+    }
+    return result;
+  }
+  function wrap(index, length) {
+    return (index % length + length) % length;
+  }
+  function enabledIndex(level, from, step) {
+    const length = level.visible.length;
+    if (length === 0) return -1;
+    for (let attempt = 0; attempt < length; attempt++) {
+      const index = wrap(from + step * attempt, length);
+      const entry = level.visible[index];
+      if (entry && isAction(entry) && !entry.disabled) return index;
+    }
+    return -1;
+  }
+  function makeLevel(path, item, entries, loading = false, error = null) {
+    const level = {
+      path,
+      title: (item ? item.title : opts.title) ?? null,
+      entries: [...entries],
+      visible: [],
+      active: -1,
+      query: "",
+      searchable: searchableFor(item, entries),
+      loading,
+      error
+    };
+    level.visible = filtered(level);
+    return level;
+  }
+  function snapshot() {
+    return {
+      open,
+      point,
+      // Copied one level deep: a subscriber that keeps a snapshot must not see the next
+      // state mutate the one it is holding.
+      levels: levels.map((level) => ({ ...level, path: [...level.path], entries: [...level.entries], visible: [...level.visible] }))
+    };
+  }
+  function emit() {
+    const state = snapshot();
+    opts.onChange?.(state);
+    for (const listener of listeners) listener(state);
+  }
+  function deepest() {
+    return levels[levels.length - 1];
+  }
+  function actionAt(level, index) {
+    const entry = level?.visible[index];
+    return entry && isAction(entry) ? entry : null;
+  }
+  function hasSubmenu(item) {
+    return Boolean(item.loadItems || item.items && item.items.some(isAction));
+  }
+  function hasActions(entries) {
+    return entries.some(isAction);
+  }
+  function pushSubmenu(parent, index, focus) {
+    const level = levels[parent];
+    const item = actionAt(level, index);
+    if (!item || item.disabled || !hasSubmenu(item)) return;
+    const path = [...level.path, item.id];
+    const id = keyOf(path);
+    const shown = levels[parent + 1];
+    if (shown && keyOf(shown.path) === id) {
+      level.active = index;
+      if (focus) {
+        wantsFocus.add(id);
+        if (shown.active < 0) focusFirst(parent + 1);
+      }
+      emit();
+      return;
+    }
+    levels = levels.slice(0, parent + 1);
+    level.active = index;
+    if (focus) wantsFocus.add(id);
+    else wantsFocus.delete(id);
+    if (item.items) {
+      levels.push(makeLevel(path, item, item.items));
+      if (focus) focusFirst(levels.length - 1);
+      emit();
+      return;
+    }
+    const entry = cache.get(id);
+    const fresh = entry?.entries && (cacheMs() <= 0 ? false : Date.now() - entry.at < cacheMs());
+    if (fresh && entry?.entries) {
+      levels.push(makeLevel(path, item, entry.entries));
+      if (focus) focusFirst(levels.length - 1);
+      emit();
+      return;
+    }
+    levels.push(makeLevel(path, item, [], true));
+    emit();
+    const request = entry?.pending ?? Promise.resolve().then(() => item.loadItems());
+    cache.set(id, { at: entry?.at ?? Date.now(), entries: entry?.entries, pending: request });
+    request.then(
+      (entries) => {
+        cache.set(id, { at: Date.now(), entries });
+        settle(id, path, item, entries, null);
+      },
+      (reason) => {
+        cache.delete(id);
+        settle(id, path, item, [], reason instanceof Error ? reason : new Error(String(reason)));
+      }
+    );
+  }
+  function settle(id, path, item, entries, error) {
+    if (destroyed) return;
+    const index = levels.findIndex((level) => keyOf(level.path) === id);
+    if (index === -1) return;
+    levels = levels.slice(0, index);
+    levels.push(makeLevel(path, item, entries, false, error));
+    if (wantsFocus.has(id)) focusFirst(index);
+    emit();
+  }
+  function focusFirst(index) {
+    const level = levels[index];
+    if (!level) return;
+    level.active = enabledIndex(level, 0, 1);
+  }
+  function refilter(level) {
+    const current = level.active >= 0 ? level.visible[level.active] : void 0;
+    level.visible = filtered(level);
+    const kept = current ? level.visible.indexOf(current) : -1;
+    const entry = kept >= 0 ? level.visible[kept] : void 0;
+    level.active = entry && isAction(entry) && !entry.disabled ? kept : enabledIndex(level, 0, 1);
+  }
+  return {
+    get state() {
+      return snapshot();
+    },
+    open(next) {
+      if (destroyed) return false;
+      if (!hasActions(root)) return false;
+      const wasOpen = open;
+      open = true;
+      point = { x: next.x, y: next.y };
+      levels = [makeLevel([], null, root)];
+      typed = "";
+      wantsFocus.clear();
+      if (!wasOpen) opts.onOpenChange?.(true);
+      emit();
+      return true;
+    },
+    close() {
+      if (destroyed || !open) return;
+      open = false;
+      point = null;
+      levels = [];
+      typed = "";
+      wantsFocus.clear();
+      opts.onOpenChange?.(false);
+      emit();
+    },
+    move(key) {
+      if (destroyed) return;
+      const level = deepest();
+      if (!level || level.visible.length === 0) return;
+      const from = level.active < 0 ? -1 : level.active;
+      switch (key) {
+        // Wrapping, because a menu is a short list and the row after the last one is
+        // the first: clamping leaves the arrow key doing nothing, which reads as a
+        // frozen panel.
+        case "ArrowDown":
+          level.active = enabledIndex(level, from + 1, 1);
+          break;
+        // From the LAST row when nothing is highlighted, which is how a menu opened at
+        // the pointer starts: `from - 1` there is the row before the last one.
+        case "ArrowUp":
+          level.active = enabledIndex(level, from < 0 ? level.visible.length - 1 : from - 1 + level.visible.length, -1);
+          break;
+        case "Home":
+          level.active = enabledIndex(level, 0, 1);
+          break;
+        case "End":
+          level.active = enabledIndex(level, level.visible.length - 1, -1);
+          break;
+        case "PageDown":
+          level.active = enabledIndex(level, Math.min(level.visible.length - 1, from + PAGE), 1);
+          break;
+        case "PageUp":
+          level.active = enabledIndex(level, Math.max(0, from - PAGE), -1);
+          break;
+      }
+      emit();
+    },
+    setActive(levelIndex, index) {
+      const level = levels[levelIndex];
+      if (destroyed || !level || level.active === index) return;
+      if (index < 0 || index >= level.visible.length) return;
+      const item = actionAt(level, index);
+      if (!item || item.disabled) return;
+      level.active = index;
+      emit();
+    },
+    setQuery(levelIndex, query) {
+      const level = levels[levelIndex];
+      if (destroyed || !level) return;
+      level.query = query;
+      levels = levels.slice(0, levelIndex + 1);
+      refilter(level);
+      emit();
+    },
+    openSubmenu(levelIndex, index, focus = false) {
+      if (destroyed) return;
+      pushSubmenu(levelIndex, index, focus);
+    },
+    closeBelow(levelIndex) {
+      if (destroyed || levels.length <= levelIndex + 1) return;
+      levels = levels.slice(0, levelIndex + 1);
+      emit();
+    },
+    select(levelIndex, index) {
+      if (destroyed) return;
+      const level = levels[levelIndex];
+      const item = actionAt(level, index);
+      if (!item || item.disabled) return;
+      if (hasSubmenu(item)) {
+        pushSubmenu(levelIndex, index, true);
+        return;
+      }
+      const path = [...level?.path ?? [], item.id];
+      open = false;
+      point = null;
+      levels = [];
+      typed = "";
+      wantsFocus.clear();
+      opts.onOpenChange?.(false);
+      emit();
+      opts.onSelect?.(item, path);
+    },
+    selectActive() {
+      const index = levels.length - 1;
+      const level = levels[index];
+      if (level && level.active >= 0) this.select(index, level.active);
+    },
+    enterSubmenu() {
+      const index = levels.length - 1;
+      const level = levels[index];
+      if (!level || level.active < 0) return;
+      const item = actionAt(level, level.active);
+      if (item && hasSubmenu(item)) pushSubmenu(index, level.active, true);
+    },
+    leaveSubmenu() {
+      if (destroyed || levels.length <= 1) return;
+      levels = levels.slice(0, levels.length - 1);
+      emit();
+    },
+    typeahead(character) {
+      if (destroyed || character.length !== 1) return;
+      const level = deepest();
+      if (!level || level.visible.length === 0) return;
+      const step = typeaheadStep({ typed, at: typedAt }, character);
+      typed = step.typed;
+      typedAt = step.at;
+      const needle = fold(step.needle);
+      const from = step.cycle && level.active >= 0 ? 1 : 0;
+      for (let step2 = from; step2 < level.visible.length + from; step2++) {
+        const index = wrap(Math.max(level.active, 0) + step2, level.visible.length);
+        const entry = level.visible[index];
+        if (!entry || !isAction(entry) || entry.disabled) continue;
+        if (fold(entry.label).startsWith(needle)) {
+          level.active = index;
+          emit();
+          return;
+        }
+      }
+    },
+    invalidate(path) {
+      if (!path) {
+        cache.clear();
+        return;
+      }
+      cache.delete(keyOf(path));
+    },
+    update(next) {
+      if (destroyed) return;
+      const hadItems = next.items !== void 0;
+      opts = { ...opts, ...next };
+      if (hadItems) {
+        root = next.items ?? [];
+        const level = levels[0];
+        if (level) {
+          level.entries = [...root];
+          level.title = opts.title ?? null;
+          level.searchable = searchableFor(null, root);
+          refilter(level);
+          emit();
+        }
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      destroyed = true;
+      listeners.clear();
+      cache.clear();
+      wantsFocus.clear();
+      for (const held of engines.values()) held.engine.destroy();
+      engines.clear();
+    }
+  };
+}
+
+// src/core/clipboard-menu.ts
+var CLIPBOARD_PREFIX = "enigma:clipboard:";
+var SELECTABLE_TYPES = /* @__PURE__ */ new Set(["text", "search", "url", "tel", "password"]);
+var EMPTY = { editable: null, writable: false, selection: "", copyable: true, range: null };
+function isEditableElement(node) {
+  return Boolean(node && node.isContentEditable);
+}
+function documentSelection(element) {
+  const selection = typeof window === "undefined" ? null : window.getSelection();
+  if (!selection || selection.isCollapsed || selection.rangeCount === 0) return "";
+  const range = selection.getRangeAt(0);
+  if (element && !range.intersectsNode(element)) return "";
+  return selection.toString();
+}
+function inspectClipboardTarget(node) {
+  if (typeof document === "undefined") return EMPTY;
+  const element = node instanceof Element ? node : null;
+  const field = element?.closest?.("input, textarea");
+  if (field) {
+    const password = field instanceof HTMLInputElement && field.type === "password";
+    const selectable = field instanceof HTMLTextAreaElement || SELECTABLE_TYPES.has(field.type);
+    const start = selectable ? field.selectionStart ?? 0 : 0;
+    const end = selectable ? field.selectionEnd ?? 0 : 0;
+    return {
+      editable: field,
+      writable: !field.disabled && !field.readOnly,
+      selection: selectable ? field.value.slice(start, end) : "",
+      copyable: !password,
+      range: selectable ? { start, end } : null
+    };
+  }
+  const editable = isEditableElement(element) ? element.closest("[contenteditable]") ?? element : null;
+  return {
+    editable,
+    writable: Boolean(editable),
+    selection: documentSelection(element),
+    copyable: true,
+    // A contenteditable's selection is a live DOM Range the browser keeps for us; there is
+    // no pair of offsets to restore, and re-focusing the element puts the caret back.
+    range: null
+  };
+}
+async function clipboardHasText() {
+  if (typeof navigator === "undefined" || !navigator.clipboard?.readText) return null;
+  try {
+    const status = await navigator.permissions?.query({ name: "clipboard-read" });
+    if (status?.state !== "granted") return null;
+    return (await navigator.clipboard.readText()).length > 0;
+  } catch {
+    return null;
+  }
+}
+function clipboardEntries(target, options = {}) {
+  const { copy = true, cut = true, paste = true, labels = {}, icons = {}, clipboardEmpty = false } = options;
+  const entries = [];
+  const selected = target.selection.length > 0 && target.copyable;
+  const canPaste = typeof navigator !== "undefined" && Boolean(navigator.clipboard?.readText);
+  if (copy && selected) {
+    entries.push({ id: `${CLIPBOARD_PREFIX}copy`, label: labels.copy ?? "Copy", shortcut: "Mod+C", icon: icons.copy });
+  }
+  if (cut && selected && target.writable) {
+    entries.push({ id: `${CLIPBOARD_PREFIX}cut`, label: labels.cut ?? "Cut", shortcut: "Mod+X", icon: icons.cut });
+  }
+  if (paste && target.writable && canPaste) {
+    entries.push({
+      id: `${CLIPBOARD_PREFIX}paste`,
+      label: labels.paste ?? "Paste",
+      shortcut: "Mod+V",
+      icon: icons.paste,
+      // Listed and greyed rather than dropped: a row that disappears between two opens
+      // is read as the menu being unreliable, and every desktop menu greys this one.
+      disabled: clipboardEmpty
+    });
+  }
+  return entries;
+}
+function clipboardAction(id) {
+  if (!id.startsWith(CLIPBOARD_PREFIX)) return null;
+  const action = id.slice(CLIPBOARD_PREFIX.length);
+  return action === "copy" || action === "cut" || action === "paste" ? action : null;
+}
+function restore(target) {
+  const element = target.editable;
+  if (!element) return;
+  element.focus({ preventScroll: true });
+  if (!target.range) return;
+  const field = element;
+  try {
+    field.setSelectionRange(target.range.start, target.range.end);
+  } catch {
+  }
+}
+function writeFieldValue(field, next) {
+  const prototype = field instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+  const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+  if (setter) setter.call(field, next);
+  else field.value = next;
+  field.dispatchEvent(new Event("input", { bubbles: true }));
+}
+function replaceSelection(target, text) {
+  const element = target.editable;
+  if (!element) return;
+  try {
+    if (document.execCommand("insertText", false, text)) return;
+  } catch {
+  }
+  const field = element;
+  if (typeof field.setSelectionRange !== "function" || target.range === null) return;
+  const start = field.selectionStart ?? target.range.start;
+  const end = field.selectionEnd ?? target.range.end;
+  writeFieldValue(field, field.value.slice(0, start) + text + field.value.slice(end));
+  const caret = start + text.length;
+  try {
+    field.setSelectionRange(caret, caret);
+  } catch {
+  }
+}
+async function performClipboardAction(action, target) {
+  restore(target);
+  if (action === "copy" || action === "cut") {
+    if (!target.selection || !target.copyable) return false;
+    try {
+      await navigator.clipboard.writeText(target.selection);
+    } catch {
+      try {
+        if (!document.execCommand("copy")) return false;
+      } catch {
+        return false;
+      }
+    }
+    if (action === "cut" && target.writable) replaceSelection(target, "");
+    return true;
+  }
+  if (!target.writable) return false;
+  try {
+    const text = await navigator.clipboard.readText();
+    if (!text) return false;
+    replaceSelection(target, text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { CLIPBOARD_PREFIX, CONTEXT_MENU_SEARCH_KEYS, clipboardAction, clipboardEntries, clipboardHasText, createContextMenu, inspectClipboardTarget, isAction, performClipboardAction };