@enigmax/primitives 0.22.0 → 0.23.0

package/dist/chunk-3BQVOOAM.js

@@ -0,0 +1,388 @@
+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();
+    }
+  };
+}
+
+export { CONTEXT_MENU_SEARCH_KEYS, createContextMenu, isAction };

package/dist/{chunk-QQFNAKMY.js → chunk-45UHLZYT.js}

@@ -1,4 +1,4 @@
-import { createSearch } from './chunk-D5A2ZMAG.js';
+import { createSearch } from './chunk-4ZPMP47J.js';
 import { useRef, useState, useMemo, useEffect } from 'react';
 
 function useSearch(options = {}) {

package/dist/chunk-4VUHQFAT.js

@@ -0,0 +1,130 @@
+// src/core/keys.ts
+var MODIFIERS = /* @__PURE__ */ new Set(["mod", "ctrl", "control", "meta", "cmd", "command", "super", "win", "shift", "alt", "option", "opt"]);
+var NAMED = {
+  esc: "escape",
+  escape: "escape",
+  del: "delete",
+  delete: "delete",
+  back: "backspace",
+  backspace: "backspace",
+  enter: "enter",
+  return: "enter",
+  space: " ",
+  spacebar: " ",
+  tab: "tab",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright",
+  arrowup: "arrowup",
+  arrowdown: "arrowdown",
+  arrowleft: "arrowleft",
+  arrowright: "arrowright",
+  home: "home",
+  end: "end",
+  pageup: "pageup",
+  pagedown: "pagedown",
+  plus: "+"
+};
+function isApplePlatform() {
+  if (typeof navigator === "undefined") return false;
+  const source = navigator.platform || navigator.userAgent || "";
+  return /mac|iphone|ipad|ipod/i.test(source);
+}
+function parseShortcut(spec) {
+  if (typeof spec !== "string") return { ...spec, key: normalizeKey(spec.key) };
+  const shortcut = { key: "" };
+  const parts = spec.split(/[+-](?!$)/).map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) return { key: normalizeKey(spec.trim()) };
+  parts.forEach((part, index) => {
+    const word = part.toLowerCase();
+    const last = index === parts.length - 1;
+    if (!last && MODIFIERS.has(word)) {
+      applyModifier(shortcut, word);
+      return;
+    }
+    if (last && MODIFIERS.has(word) && parts.length > 1) {
+      applyModifier(shortcut, word);
+      return;
+    }
+    shortcut.key = normalizeKey(part);
+  });
+  if (!shortcut.key) shortcut.key = normalizeKey(parts[parts.length - 1]);
+  return shortcut;
+}
+function applyModifier(shortcut, word) {
+  if (word === "mod") shortcut.mod = true;
+  else if (word === "ctrl" || word === "control") shortcut.ctrl = true;
+  else if (word === "meta" || word === "cmd" || word === "command" || word === "super" || word === "win") shortcut.meta = true;
+  else if (word === "shift") shortcut.shift = true;
+  else shortcut.alt = true;
+}
+function normalizeKey(key) {
+  const lower = key.toLowerCase();
+  return NAMED[lower] ?? lower;
+}
+function shortcutList(spec) {
+  if (spec === false || spec == null) return [];
+  const entries = Array.isArray(spec) ? spec : [spec];
+  return entries.map(parseShortcut);
+}
+function matchesShortcut(event, spec, apple = isApplePlatform()) {
+  return shortcutList(spec).some((shortcut) => matchesOne(event, shortcut, apple));
+}
+function matchesOne(event, shortcut, apple) {
+  const key = normalizeKey(event.key);
+  const wantCtrl = Boolean(shortcut.ctrl || shortcut.mod && !apple);
+  const wantMeta = Boolean(shortcut.meta || shortcut.mod && apple);
+  return key === shortcut.key && Boolean(event.ctrlKey) === wantCtrl && Boolean(event.metaKey) === wantMeta && Boolean(event.shiftKey) === Boolean(shortcut.shift) && Boolean(event.altKey) === Boolean(shortcut.alt);
+}
+function shortcutTokens(spec, apple = isApplePlatform()) {
+  const shortcut = parseShortcut(spec);
+  const tokens = [];
+  if (shortcut.ctrl || shortcut.mod && !apple) tokens.push(apple ? "\u2303" : "Ctrl");
+  if (shortcut.alt) tokens.push(apple ? "\u2325" : "Alt");
+  if (shortcut.shift) tokens.push(apple ? "\u21E7" : "Shift");
+  if (shortcut.meta || shortcut.mod && apple) tokens.push(apple ? "\u2318" : "Win");
+  tokens.push(keyLabel(shortcut.key, apple));
+  return tokens;
+}
+function shortcutText(spec, apple = isApplePlatform()) {
+  return shortcutTokens(spec, apple).join(apple ? "" : "+");
+}
+var KEY_LABELS = {
+  " ": "Space",
+  escape: "Esc",
+  enter: "Enter",
+  backspace: "Backspace",
+  delete: "Del",
+  arrowup: "\u2191",
+  arrowdown: "\u2193",
+  arrowleft: "\u2190",
+  arrowright: "\u2192",
+  pageup: "PgUp",
+  pagedown: "PgDn"
+};
+var APPLE_KEY_LABELS = {
+  delete: "\u2326",
+  backspace: "\u232B",
+  enter: "\u21A9",
+  escape: "esc"
+};
+function keyLabel(key, apple) {
+  if (apple && APPLE_KEY_LABELS[key]) return APPLE_KEY_LABELS[key];
+  const named = KEY_LABELS[key];
+  if (named) return named;
+  return key.length === 1 ? key.toUpperCase() : key.charAt(0).toUpperCase() + key.slice(1);
+}
+var TYPEAHEAD_MS = 600;
+function typeaheadStep(state, character, now = Date.now(), windowMs = TYPEAHEAD_MS) {
+  const typed = now - state.at > windowMs ? character : state.typed + character;
+  const repeated = typed.length > 1 && [...typed].every((letter) => letter === typed[0]);
+  return {
+    typed,
+    at: now,
+    needle: repeated ? typed[0] : typed,
+    cycle: typed.length === 1 || repeated
+  };
+}
+
+export { TYPEAHEAD_MS, isApplePlatform, matchesShortcut, parseShortcut, shortcutList, shortcutText, shortcutTokens, typeaheadStep };

package/dist/{chunk-D5A2ZMAG.js → chunk-4ZPMP47J.js}

@@ -61,6 +61,11 @@ function subsequenceScore(query, text) {
   }
   return score;
 }
+function shortenQuery(query, max = 32) {
+  const trimmed = query.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max - 1).trimEnd()}\u2026`;
+}
 function createSearch(options = {}) {
   let opts = { ...options };
   let items = opts.items ?? [];
@@ -175,4 +180,4 @@ function createSearch(options = {}) {
   };
 }
 
-export { createSearch, subsequenceMatcher };
+export { createSearch, shortenQuery, subsequenceMatcher };