@enigmax/primitives 0.22.0 → 0.24.0

package/dist/chunk-WSQC3PCC.js

@@ -0,0 +1,466 @@
+import { shortcutList, matchesShortcut } from './chunk-4VUHQFAT.js';
+
+// src/core/selection.ts
+var DEFAULT_SELECTION_SHORTCUTS = {
+  selectAll: "Mod+A",
+  clear: "Escape",
+  invert: false,
+  moveUp: "ArrowUp",
+  moveDown: "ArrowDown",
+  moveLeft: "ArrowLeft",
+  moveRight: "ArrowRight",
+  moveHome: "Home",
+  moveEnd: "End",
+  movePageUp: "PageUp",
+  movePageDown: "PageDown",
+  extendUp: "Shift+ArrowUp",
+  extendDown: "Shift+ArrowDown",
+  extendLeft: "Shift+ArrowLeft",
+  extendRight: "Shift+ArrowRight",
+  extendHome: "Shift+Home",
+  extendEnd: "Shift+End",
+  extendPageUp: "Shift+PageUp",
+  extendPageDown: "Shift+PageDown",
+  // The cursor moving WITHOUT the selection following, which is how a file manager lets you
+  // reach a distant row and add it with Ctrl+Space rather than starting again.
+  cursorUp: "Mod+ArrowUp",
+  cursorDown: "Mod+ArrowDown",
+  toggleCursor: "Mod+Space",
+  open: "Enter",
+  rename: "F2",
+  delete: "Delete",
+  deletePermanent: "Shift+Delete",
+  copy: "Mod+C",
+  cut: "Mod+X",
+  paste: "Mod+V"
+};
+var OWNED = /* @__PURE__ */ new Set([
+  "selectAll",
+  "clear",
+  "invert",
+  "moveUp",
+  "moveDown",
+  "moveLeft",
+  "moveRight",
+  "moveHome",
+  "moveEnd",
+  "movePageUp",
+  "movePageDown",
+  "extendUp",
+  "extendDown",
+  "extendLeft",
+  "extendRight",
+  "extendHome",
+  "extendEnd",
+  "extendPageUp",
+  "extendPageDown",
+  "cursorUp",
+  "cursorDown",
+  "toggleCursor"
+]);
+function createSelection(options = {}) {
+  let opts = { ...options };
+  let items = opts.items ?? [];
+  let selected = /* @__PURE__ */ new Set();
+  let cursor = -1;
+  let anchor = -1;
+  let rangeBase = null;
+  let marqueeBase = null;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  function idOf(index) {
+    const item = items[index];
+    if (item === void 0) return null;
+    return opts.getId ? opts.getId(item, index) : String(index);
+  }
+  function selectable(index) {
+    const item = items[index];
+    if (item === void 0) return false;
+    return !opts.disabled?.(item, index);
+  }
+  function multiple() {
+    return opts.multiple ?? true;
+  }
+  function columns() {
+    return Math.max(1, opts.columns ?? 1);
+  }
+  function orderedIds() {
+    const ids = [];
+    for (let index = 0; index < items.length; index++) {
+      const id = idOf(index);
+      if (id !== null && selected.has(id)) ids.push(id);
+    }
+    return ids;
+  }
+  function selectedItems() {
+    const chosen = [];
+    for (let index = 0; index < items.length; index++) {
+      const id = idOf(index);
+      if (id !== null && selected.has(id)) chosen.push(items[index]);
+    }
+    return chosen;
+  }
+  function snapshot() {
+    const ids = orderedIds();
+    let count = 0;
+    for (let index = 0; index < items.length; index++) if (selectable(index)) count++;
+    return {
+      selected: ids,
+      selectedSet: new Set(ids),
+      items: selectedItems(),
+      cursor,
+      anchor,
+      count: ids.length,
+      allSelected: count > 0 && ids.length === count,
+      partiallySelected: ids.length > 0 && ids.length < count,
+      marquee: marqueeBase !== null
+    };
+  }
+  function summary() {
+    let count = 0;
+    for (let index = 0; index < items.length; index++) if (selectable(index)) count++;
+    return `${cursor}:${anchor}:${count}:${orderedIds().join("\0")}`;
+  }
+  let reported = [];
+  function emit() {
+    const state = snapshot();
+    opts.onChange?.(state);
+    for (const listener of listeners) listener(state);
+    const ids = state.selected;
+    if (ids.length !== reported.length || ids.some((id, index) => id !== reported[index])) {
+      reported = ids;
+      opts.onSelectionChange?.(ids, state.items);
+    }
+  }
+  function replace(ids) {
+    selected = new Set(ids);
+  }
+  function nextEnabled(from, step) {
+    for (let index = from; index >= 0 && index < items.length; index += step) {
+      if (selectable(index)) return index;
+    }
+    return -1;
+  }
+  function rangeIds(from, to) {
+    const [low, high] = from < to ? [from, to] : [to, from];
+    const ids = [];
+    for (let index = low; index <= high; index++) {
+      if (!selectable(index)) continue;
+      const id = idOf(index);
+      if (id !== null) ids.push(id);
+    }
+    return ids;
+  }
+  function applyRange(index, additive) {
+    const from = anchor >= 0 ? anchor : index;
+    const ids = rangeIds(from, index);
+    if (additive) {
+      rangeBase = rangeBase ?? new Set(selected);
+      replace([...rangeBase, ...ids]);
+    } else {
+      rangeBase = null;
+      replace(ids);
+    }
+    cursor = index;
+  }
+  function table() {
+    if (opts.shortcuts === false) return {};
+    return { ...DEFAULT_SELECTION_SHORTCUTS, ...opts.shortcuts ?? {} };
+  }
+  function commandFor(event) {
+    const bindings = table();
+    let match = null;
+    for (const [command, spec] of Object.entries(bindings)) {
+      if (spec === false || spec == null) continue;
+      const hit = shortcutList(spec).find((shortcut) => matchesShortcut(event, shortcut));
+      if (!hit) continue;
+      const length = specificity(hit);
+      if (!match || length > match.length) match = { command, length };
+    }
+    return match?.command ?? null;
+  }
+  function specificity(shortcut) {
+    return Number(Boolean(shortcut.mod)) + Number(Boolean(shortcut.ctrl)) + Number(Boolean(shortcut.meta)) + Number(Boolean(shortcut.shift)) + Number(Boolean(shortcut.alt));
+  }
+  function perform(command) {
+    const step = columns();
+    const page = Math.max(1, opts.page ?? 10);
+    switch (command) {
+      case "selectAll":
+        instance.selectAll();
+        return true;
+      case "clear":
+        instance.clear();
+        return true;
+      case "invert":
+        instance.invert();
+        return true;
+      case "moveUp":
+        instance.moveCursor(-step);
+        return true;
+      case "moveDown":
+        instance.moveCursor(step);
+        return true;
+      case "moveLeft":
+        instance.moveCursor(-1);
+        return true;
+      case "moveRight":
+        instance.moveCursor(1);
+        return true;
+      case "moveHome":
+        instance.moveCursor(-items.length);
+        return true;
+      case "moveEnd":
+        instance.moveCursor(items.length);
+        return true;
+      case "movePageUp":
+        instance.moveCursor(-page * step);
+        return true;
+      case "movePageDown":
+        instance.moveCursor(page * step);
+        return true;
+      case "extendUp":
+        instance.moveCursor(-step, true);
+        return true;
+      case "extendDown":
+        instance.moveCursor(step, true);
+        return true;
+      case "extendLeft":
+        instance.moveCursor(-1, true);
+        return true;
+      case "extendRight":
+        instance.moveCursor(1, true);
+        return true;
+      case "extendHome":
+        instance.moveCursor(-items.length, true);
+        return true;
+      case "extendEnd":
+        instance.moveCursor(items.length, true);
+        return true;
+      case "extendPageUp":
+        instance.moveCursor(-page * step, true);
+        return true;
+      case "extendPageDown":
+        instance.moveCursor(page * step, true);
+        return true;
+      case "cursorUp":
+        instance.moveCursor(-step, false, true);
+        return true;
+      case "cursorDown":
+        instance.moveCursor(step, false, true);
+        return true;
+      case "toggleCursor":
+        if (cursor >= 0) instance.toggle(cursor);
+        return true;
+      default:
+        return false;
+    }
+  }
+  const instance = {
+    get state() {
+      return snapshot();
+    },
+    click(index, modifiers = {}) {
+      if (destroyed || !selectable(index)) return;
+      const mod = Boolean(modifiers.ctrlKey || modifiers.metaKey);
+      const shift = Boolean(modifiers.shiftKey) && multiple();
+      if (shift) {
+        applyRange(index, mod && multiple());
+        emit();
+        return;
+      }
+      rangeBase = null;
+      if (mod && multiple()) {
+        this.toggle(index);
+        return;
+      }
+      const id = idOf(index);
+      if (id === null) return;
+      replace([id]);
+      cursor = index;
+      anchor = index;
+      emit();
+    },
+    keyDown(event) {
+      if (destroyed) return false;
+      const command = commandFor(event);
+      if (!command) return false;
+      const targets = selected.size > 0 ? selectedItems() : cursor >= 0 && items[cursor] !== void 0 ? [items[cursor]] : [];
+      const ids = selected.size > 0 ? orderedIds() : cursor >= 0 ? [idOf(cursor)].filter((id) => id !== null) : [];
+      let prevented = false;
+      const report = {
+        command,
+        items: targets,
+        ids,
+        cursor: cursor >= 0 ? items[cursor] ?? null : null,
+        cursorIndex: cursor,
+        event,
+        preventDefault() {
+          prevented = true;
+          report.defaultPrevented = true;
+        },
+        defaultPrevented: false
+      };
+      opts.onCommand?.(report);
+      if (!prevented) perform(command);
+      return OWNED.has(command) || opts.onCommand !== void 0;
+    },
+    select(ids) {
+      if (destroyed) return;
+      replace(ids);
+      emit();
+    },
+    selectIndex(index, additive = false) {
+      if (destroyed || !selectable(index)) return;
+      const id = idOf(index);
+      if (id === null) return;
+      if (additive && multiple()) selected.add(id);
+      else replace([id]);
+      cursor = index;
+      anchor = index;
+      emit();
+    },
+    toggle(index) {
+      if (destroyed || !selectable(index)) return;
+      const id = idOf(index);
+      if (id === null) return;
+      if (!multiple()) {
+        replace([id]);
+      } else if (selected.has(id)) selected.delete(id);
+      else selected.add(id);
+      cursor = index;
+      anchor = index;
+      emit();
+    },
+    selectRange(index, additive = false) {
+      if (destroyed || !selectable(index) || !multiple()) return;
+      applyRange(index, additive);
+      emit();
+    },
+    selectAll() {
+      if (destroyed || !multiple()) return;
+      const ids = [];
+      for (let index = 0; index < items.length; index++) {
+        if (!selectable(index)) continue;
+        const id = idOf(index);
+        if (id !== null) ids.push(id);
+      }
+      replace(ids);
+      emit();
+    },
+    clear() {
+      if (destroyed || selected.size === 0) return;
+      selected = /* @__PURE__ */ new Set();
+      rangeBase = null;
+      emit();
+    },
+    invert() {
+      if (destroyed || !multiple()) return;
+      const next = /* @__PURE__ */ new Set();
+      for (let index = 0; index < items.length; index++) {
+        if (!selectable(index)) continue;
+        const id = idOf(index);
+        if (id !== null && !selected.has(id)) next.add(id);
+      }
+      selected = next;
+      emit();
+    },
+    moveCursor(delta, extend = false, carry = false) {
+      if (destroyed || items.length === 0) return;
+      const from = cursor >= 0 ? cursor : anchor >= 0 ? anchor : delta > 0 ? -1 : items.length;
+      const wanted = Math.max(0, Math.min(items.length - 1, from + delta));
+      const forward = delta >= 0 ? 1 : -1;
+      const ahead = nextEnabled(wanted, forward);
+      const next = ahead >= 0 ? ahead : nextEnabled(wanted, -forward);
+      if (next < 0) return;
+      if (extend && multiple()) {
+        applyRange(next, false);
+        emit();
+        return;
+      }
+      cursor = next;
+      if (carry) {
+        emit();
+        return;
+      }
+      const id = idOf(next);
+      if (id === null) return;
+      replace([id]);
+      anchor = next;
+      rangeBase = null;
+      emit();
+    },
+    setCursor(index) {
+      if (destroyed || index === cursor) return;
+      if (index < -1 || index >= items.length) return;
+      cursor = index;
+      emit();
+    },
+    targets(index) {
+      const id = idOf(index);
+      const item = items[index];
+      if (item === void 0) return selectedItems();
+      return id !== null && selected.has(id) ? selectedItems() : [item];
+    },
+    beginMarquee(additive = false) {
+      if (destroyed || !multiple()) return;
+      marqueeBase = additive ? new Set(selected) : /* @__PURE__ */ new Set();
+      if (!additive && selected.size > 0) selected = /* @__PURE__ */ new Set();
+      emit();
+    },
+    marqueeTo(indices) {
+      if (destroyed || marqueeBase === null) return;
+      const next = new Set(marqueeBase);
+      for (const index of indices) {
+        if (!selectable(index)) continue;
+        const id = idOf(index);
+        if (id !== null) next.add(id);
+      }
+      if (next.size === selected.size && [...next].every((id) => selected.has(id))) return;
+      selected = next;
+      emit();
+    },
+    endMarquee() {
+      if (destroyed || marqueeBase === null) return;
+      marqueeBase = null;
+      emit();
+    },
+    bindings() {
+      return table();
+    },
+    binding(command) {
+      return table()[command] ?? false;
+    },
+    update(next) {
+      if (destroyed) return;
+      const before = summary();
+      const hadItems = next.items !== void 0;
+      opts = { ...opts, ...next };
+      if (hadItems) {
+        items = next.items ?? [];
+        const live = /* @__PURE__ */ new Set();
+        for (let index = 0; index < items.length; index++) {
+          const id = idOf(index);
+          if (id !== null) live.add(id);
+        }
+        for (const id of selected) if (!live.has(id)) selected.delete(id);
+        if (cursor >= items.length) cursor = items.length - 1;
+        if (anchor >= items.length) anchor = items.length - 1;
+      }
+      if (summary() !== before) emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      destroyed = true;
+      listeners.clear();
+    }
+  };
+  return instance;
+}
+
+export { DEFAULT_SELECTION_SHORTCUTS, createSelection };