@enigmax/primitives 0.17.0 → 0.19.0

package/dist/button-CaXaqG_K.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Button behaviour: what makes it unavailable, and everything that follows from that.
+ *
+ * Disabled, loading and a cooldown are three reasons for the same state, so they collapse
+ * into one `available` the renderer reads, instead of three flags every call site has to
+ * combine correctly. The element to render is reported rather than chosen, because a
+ * framework-agnostic package cannot import next/link.
+ */
+/** Which tag the consumer should render. An href makes it a link, and a link is not a button. */
+type ButtonElement = "button" | "a";
+interface ButtonCooldown {
+    /** How long the button stays unavailable after a press, in ms. */
+    ms: number;
+    /**
+     * Survive a reload under this key. Without it the cooldown is in memory only, and a
+     * refresh is a free retry - which is the whole thing a cooldown exists to prevent.
+     */
+    key?: string;
+    storage?: "local" | "session";
+}
+interface ButtonOptions {
+    /** Turns into an `a`, and a link cannot be `disabled` - only `aria-disabled`. */
+    href?: string;
+    disabled?: boolean;
+    /** Unavailable and busy. Set it yourself, or let an async `onPress` manage it. */
+    loading?: boolean;
+    /** ms, or the full shape for a cooldown that outlives a reload. */
+    cooldown?: number | ButtonCooldown;
+    /**
+     * A single key that presses the button. Ignored while the visitor is typing, and
+     * while any modifier is held, so it never steals a real shortcut.
+     */
+    shortcut?: string;
+    /** Async work flips `loading` for its duration and only then starts the cooldown. */
+    onPress?: (event?: Event) => void | Promise<void>;
+    /** Called whenever anything below changes. */
+    onChange?: (state: ButtonState) => void;
+}
+interface ButtonState {
+    /** The tag to render. */
+    element: ButtonElement;
+    /** Pressable: not disabled, not loading, not cooling down. */
+    available: boolean;
+    loading: boolean;
+    disabled: boolean;
+    /** ms left on the cooldown, 0 when there is none. */
+    cooldown: number;
+    /** The accessible name for the shortcut, when there is one. */
+    shortcut: string | null;
+}
+interface ButtonInstance {
+    readonly state: ButtonState;
+    /** Run the press as if it had been clicked. Ignored while unavailable. */
+    press(event?: Event): Promise<void>;
+    update(options: Partial<ButtonOptions>): void;
+    /** Clear a cooldown early, including its stored entry. */
+    reset(): void;
+    subscribe(listener: (state: ButtonState) => void): () => void;
+    destroy(): void;
+}
+declare function createButton(options?: ButtonOptions): ButtonInstance;
+
+export { type ButtonCooldown as B, type ButtonElement as a, type ButtonInstance as b, type ButtonOptions as c, type ButtonState as d, createButton as e };

package/dist/chunk-2QFTRNAZ.js

@@ -0,0 +1,88 @@
+// src/core/network.ts
+var SERVER_NETWORK_STATE = {
+  online: true,
+  downlink: null,
+  downlinkMax: null,
+  effectiveType: null,
+  rtt: null,
+  saveData: null,
+  type: null,
+  recovered: false,
+  slow: false
+};
+function connection() {
+  if (typeof navigator === "undefined") return null;
+  const nav = navigator;
+  return nav.connection ?? nav.mozConnection ?? nav.webkitConnection ?? null;
+}
+function shallowEqual(left, right) {
+  for (const key of Object.keys(left)) {
+    if (left[key] !== right[key]) return false;
+  }
+  return true;
+}
+function createNetworkMonitor() {
+  if (typeof window === "undefined") {
+    return {
+      get state() {
+        return SERVER_NETWORK_STATE;
+      },
+      subscribe() {
+        return () => {
+        };
+      },
+      destroy() {
+      }
+    };
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  let hasBeenOffline = false;
+  let state = read();
+  function read() {
+    const link2 = connection();
+    const online = navigator.onLine;
+    const effectiveType = link2?.effectiveType ?? null;
+    const saveData = link2?.saveData ?? null;
+    return {
+      online,
+      downlink: link2?.downlink ?? null,
+      downlinkMax: link2?.downlinkMax ?? null,
+      effectiveType,
+      rtt: link2?.rtt ?? null,
+      saveData,
+      type: link2?.type ?? null,
+      recovered: online && hasBeenOffline,
+      slow: saveData === true || effectiveType === "2g" || effectiveType === "slow-2g"
+    };
+  }
+  function update() {
+    if (!navigator.onLine) hasBeenOffline = true;
+    const next = read();
+    if (shallowEqual(state, next)) return;
+    state = next;
+    for (const listener of listeners) listener(state);
+  }
+  const link = connection();
+  window.addEventListener("online", update, { passive: true });
+  window.addEventListener("offline", update, { passive: true });
+  link?.addEventListener("change", update, { passive: true });
+  return {
+    get state() {
+      return state;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      listeners.clear();
+      window.removeEventListener("online", update);
+      window.removeEventListener("offline", update);
+      link?.removeEventListener("change", update);
+    }
+  };
+}
+
+export { SERVER_NETWORK_STATE, createNetworkMonitor };

package/dist/chunk-6BGBYUSZ.js

@@ -0,0 +1,114 @@
+import { createButton } from './chunk-MMQPZGSU.js';
+import { Slot } from './chunk-HS3X3XCW.js';
+import { forwardRef, createElement, useRef, useMemo, useState, useEffect, useCallback, isValidElement } from 'react';
+
+function useButton(options = {}) {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const instance = useMemo(() => createButton({
+    ...optionsRef.current,
+    onPress: (event) => optionsRef.current.onPress?.(event),
+    onChange: (next) => optionsRef.current.onChange?.(next)
+    // Built once: recreating it would drop a running cooldown on every render.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), []);
+  const [state, setState] = useState(() => instance.state);
+  useEffect(() => {
+    const unsubscribe = instance.subscribe(setState);
+    setState(instance.state);
+    return () => {
+      unsubscribe();
+      instance.destroy();
+    };
+  }, [instance]);
+  useEffect(() => {
+    instance.update({
+      href: options.href,
+      disabled: options.disabled,
+      loading: options.loading,
+      cooldown: options.cooldown,
+      shortcut: options.shortcut
+    });
+  }, [instance, options.href, options.disabled, options.loading, options.cooldown, options.shortcut]);
+  const press = useCallback(() => {
+    void instance.press();
+  }, [instance]);
+  return {
+    ...state,
+    press,
+    reset: () => instance.reset(),
+    props: {
+      onClick: (event) => {
+        if (!state.available) {
+          event.preventDefault();
+          return;
+        }
+        void instance.press(event);
+      },
+      "aria-disabled": !state.available,
+      "aria-busy": state.loading,
+      ...state.loading ? { "data-loading": "" } : {},
+      ...state.cooldown > 0 ? { "data-cooldown": "" } : {},
+      ...state.element === "button" ? { disabled: state.disabled } : { href: options.href },
+      ...state.shortcut ? { title: `Shortcut: ${state.shortcut.toUpperCase()}`, "aria-keyshortcuts": state.shortcut } : {}
+    }
+  };
+}
+
+// src/react/link.ts
+var linkComponent = null;
+function setLinkComponent(component) {
+  linkComponent = component;
+}
+function getLinkComponent() {
+  return linkComponent ?? "a";
+}
+function hasText(node) {
+  if (node === null || node === void 0 || typeof node === "boolean") return false;
+  if (typeof node === "string") return node.trim().length > 0;
+  if (typeof node === "number") return true;
+  if (Array.isArray(node)) return node.some(hasText);
+  if (isValidElement(node)) return hasText(node.props.children);
+  return false;
+}
+var Button = forwardRef(function Button2({
+  as,
+  children,
+  pending,
+  href,
+  disabled,
+  loading,
+  cooldown,
+  shortcut,
+  onPress,
+  onClick,
+  onChange,
+  type = "button",
+  shortcutHint = "auto",
+  renderShortcut,
+  asChild = false,
+  ...rest
+}, ref) {
+  const button = useButton({ href, disabled, loading, cooldown, shortcut, onPress: onPress ?? onClick, onChange });
+  const state = button;
+  const Tag = asChild ? Slot : as ?? (state.element === "a" ? getLinkComponent() : "button");
+  const native = Tag === "button" ? { type } : {};
+  const label = typeof children === "function" ? children(state) : children;
+  const content = state.loading && pending !== void 0 ? pending : label;
+  const showHint = !asChild && Boolean(state.shortcut) && !state.loading && (shortcutHint === "auto" ? hasText(content) : shortcutHint);
+  const hint = showHint && state.shortcut ? renderShortcut?.(state.shortcut) ?? createElement(
+    "kbd",
+    // Hidden from the accessible name - the button already carries
+    // `aria-keyshortcuts`, and "Save n" is not what anyone wants read out.
+    { "data-enigma-button-key": "", "aria-hidden": true },
+    state.shortcut
+  ) : null;
+  return createElement(
+    Tag,
+    { ref, ...button.props, ...native, ...rest },
+    content,
+    hint
+  );
+});
+
+export { Button, getLinkComponent, setLinkComponent, useButton };

package/dist/chunk-AU3H5WIY.js

@@ -0,0 +1,107 @@
+// src/core/flags.ts
+var FLAG_CDN = "https://cdn.jsdelivr.net/gh/FJRG2007/enigma@main/assets/flags";
+var DEFAULTS = {
+  shape: "rect",
+  format: "svg",
+  source: "cdn",
+  basePath: "/flags",
+  size: 16
+};
+var config = { ...DEFAULTS };
+function configureFlags(patch) {
+  config = { ...config, ...patch };
+  return config;
+}
+function flagConfig() {
+  return config;
+}
+function resetFlagConfig() {
+  config = { ...DEFAULTS };
+  return config;
+}
+var FLAG_RATIO = { rect: 4 / 3, square: 1, circle: 1 };
+var EMOJI_FLAG = /^[\u{1F1E6}-\u{1F1FF}]{2}$/u;
+var LOCALE_TAG = /^([A-Za-z]{2,3})[-_]([A-Z]{2})$/;
+var FILE_CODE = /^[a-z]{2,}(?:[-_][a-z0-9]+)*$/;
+var COUNTRY_CODE = /^[a-z]{2}$/;
+function normalizeFlagCode(value) {
+  if (!value) return null;
+  const raw = value.trim();
+  if (!raw) return null;
+  if (EMOJI_FLAG.test(raw)) {
+    const letters = [...raw].map((char) => String.fromCharCode((char.codePointAt(0) ?? 0) - 127462 + 97));
+    return letters.join("");
+  }
+  const locale = LOCALE_TAG.exec(raw);
+  if (locale) return locale[2].toLowerCase();
+  const code = raw.toLowerCase();
+  return FILE_CODE.test(code) ? code : null;
+}
+function flagName(code, locale) {
+  const normalized = normalizeFlagCode(code);
+  if (!normalized || !COUNTRY_CODE.test(normalized)) return null;
+  const region = normalized.toUpperCase();
+  try {
+    const names = new Intl.DisplayNames([locale ?? documentLocale() ?? "en"], { type: "region" });
+    const name = names.of(region);
+    return !name || name === region ? null : name;
+  } catch {
+    return null;
+  }
+}
+function documentLocale() {
+  if (typeof document === "undefined") return void 0;
+  return document.documentElement.lang || void 0;
+}
+var warnedAboutFormat = false;
+function flagSrc(code, options = {}) {
+  const settings = { ...config, ...options };
+  const normalized = normalizeFlagCode(code);
+  if (!normalized) return null;
+  const remote = settings.source === "cdn";
+  let format = settings.format;
+  if (remote && format !== "svg") {
+    if (!warnedAboutFormat && typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
+      warnedAboutFormat = true;
+      console.warn(`[enigma/flags] The flags are served as SVG, so "${format}" was served as SVG. Download a local set for raster formats: enigma add flags --flags local --flag-formats ${format}`);
+    }
+    format = "svg";
+  }
+  const base = remote ? FLAG_CDN : (settings.source === "local" ? settings.basePath : settings.source).replace(/\/+$/, "");
+  return `${base}/${settings.shape}/${normalized}.${format}`;
+}
+function flagView(code, options = {}) {
+  const settings = { ...config, ...options };
+  const normalized = normalizeFlagCode(code);
+  const src = flagSrc(normalized, options);
+  if (!normalized || !src) return null;
+  const height = Math.max(1, Math.round(settings.size));
+  return {
+    code: normalized,
+    src,
+    shape: settings.shape,
+    format: settings.source === "cdn" ? "svg" : settings.format,
+    width: Math.round(height * FLAG_RATIO[settings.shape]),
+    height,
+    name: flagName(normalized, settings.locale)
+  };
+}
+function flagAttributes(code, options = {}) {
+  const view = flagView(code, options);
+  if (!view) return null;
+  const label = options.decorative ? "" : options.label?.trim() || view.name || "";
+  return {
+    src: view.src,
+    alt: label,
+    width: view.width,
+    height: view.height,
+    loading: "lazy",
+    decoding: "async",
+    "data-enigma-flag": "",
+    "data-flag-code": view.code,
+    "data-flag-shape": view.shape,
+    ...label ? {} : { "aria-hidden": "true" }
+  };
+}
+
+export { FLAG_CDN, FLAG_RATIO, configureFlags, flagAttributes, flagConfig, flagName, flagSrc, flagView, normalizeFlagCode, resetFlagConfig };

package/dist/{chunk-UZFEEFMF.js → chunk-D5A2ZMAG.js}

@@ -29,6 +29,38 @@ function substringMatcher(query, items, keys) {
   }
   return results.sort((left, right) => left.score - right.score);
 }
+function subsequenceMatcher(keys = []) {
+  return (query, items) => {
+    const needle = fold(query);
+    const results = [];
+    for (const item of items) {
+      const fields = keys.length ? keys : [""];
+      let best = null;
+      for (const key of fields) {
+        const haystack = fold(key ? readPath(item, key) : String(item));
+        const score = subsequenceScore(needle, haystack);
+        if (score < 0) continue;
+        const ranked = -score;
+        if (!best || ranked < best.score) best = { item, score: ranked, key: key || void 0 };
+      }
+      if (best) results.push(best);
+    }
+    return results.sort((left, right) => left.score - right.score);
+  };
+}
+function subsequenceScore(query, text) {
+  if (!query) return 0;
+  let from = 0, score = 0, run = 0;
+  for (let i = 0; i < query.length; i++) {
+    const at = text.indexOf(query[i], from);
+    if (at === -1) return -1;
+    run = i > 0 && at === from ? run + 1 : 0;
+    const wordStart = at === 0 || /[^a-z0-9]/.test(text[at - 1]);
+    score += 10 + run * 6 + (wordStart ? 8 : 0) - Math.min(at - from, 6);
+    from = at + 1;
+  }
+  return score;
+}
 function createSearch(options = {}) {
   let opts = { ...options };
   let items = opts.items ?? [];
@@ -121,6 +153,7 @@ function createSearch(options = {}) {
       input.addEventListener("input", onInput);
       input.addEventListener("keydown", onKeyDown);
       input.dataset.enigmaSearch = "";
+      if (input.value) this.searchNow(input.value);
       return () => {
         input.removeEventListener("input", onInput);
         input.removeEventListener("keydown", onKeyDown);
@@ -142,4 +175,4 @@ function createSearch(options = {}) {
   };
 }
 
-export { createSearch };
+export { createSearch, subsequenceMatcher };

package/dist/chunk-DTWZDONY.js

@@ -0,0 +1,99 @@
+// src/core/palette.ts
+function recentKey(entry) {
+  return `${entry.scope ?? ""}\0${entry.href ?? ""}\0${entry.href ? "" : entry.term.trim().toLowerCase()}`;
+}
+function createRecentStore(options = {}) {
+  const { key = "enigma:palette:recent", limit = 8, storage = "local" } = options;
+  function backing() {
+    if (typeof window === "undefined") return null;
+    try {
+      return storage === "session" ? window.sessionStorage : window.localStorage;
+    } catch {
+      return null;
+    }
+  }
+  function read() {
+    const store = backing();
+    if (!store) return [];
+    try {
+      const raw = store.getItem(key);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter((entry) => Boolean(entry) && typeof entry.term === "string").sort((a, b) => b.at - a.at).slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+  function write(entries) {
+    const store = backing();
+    const kept = entries.slice(0, limit);
+    try {
+      store?.setItem(key, JSON.stringify(kept));
+    } catch {
+    }
+    return kept;
+  }
+  return {
+    list: read,
+    remember(entry) {
+      const next = { ...entry, at: entry.at ?? Date.now() };
+      if (!next.term.trim() && !next.href) return read();
+      const id = recentKey(next);
+      return write([next, ...read().filter((existing) => recentKey(existing) !== id)]);
+    },
+    forget(entry) {
+      const id = recentKey(entry);
+      return write(read().filter((existing) => recentKey(existing) !== id));
+    },
+    clear() {
+      const store = backing();
+      try {
+        store?.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+function groupRows(rows, labelOf) {
+  const groups = [];
+  const index = /* @__PURE__ */ new Map();
+  rows.forEach((row, position) => {
+    const label = labelOf(row);
+    let group = index.get(label);
+    if (!group) {
+      group = { label, rows: [] };
+      index.set(label, group);
+      groups.push(group);
+    }
+    group.rows.push({ row, position });
+  });
+  return groups;
+}
+function moveActive(current, length, key, page = 5) {
+  if (length <= 0) return 0;
+  switch (key) {
+    case "ArrowDown":
+      return (current + 1) % length;
+    case "ArrowUp":
+      return (current - 1 + length) % length;
+    case "Home":
+      return 0;
+    case "End":
+      return length - 1;
+    case "PageDown":
+      return Math.min(length - 1, current + page);
+    case "PageUp":
+      return Math.max(0, current - page);
+  }
+}
+function shortcutLabel(key = "K") {
+  const mac = typeof navigator !== "undefined" && /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent || "");
+  return `${mac ? "\u2318" : "Ctrl"} ${key.toUpperCase()}`;
+}
+function isPaletteShortcut(event, key = "k") {
+  if (event.key.toLowerCase() !== key.toLowerCase()) return false;
+  return event.metaKey || event.ctrlKey;
+}
+
+export { createRecentStore, groupRows, isPaletteShortcut, moveActive, recentKey, shortcutLabel };

package/dist/chunk-F25CGNQC.js

@@ -0,0 +1,19 @@
+// src/core/input-icons.ts
+var INPUT_ICON_PATHS = {
+  eye: ["M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7-10-7-10-7Z", "M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"],
+  eyeOff: [
+    "M10.6 5.2A9.8 9.8 0 0 1 12 5c6.5 0 10 7 10 7a17.6 17.6 0 0 1-3.2 4.2M6.2 6.2A17.7 17.7 0 0 0 2 12s3.5 7 10 7a9.6 9.6 0 0 0 4.2-.9",
+    "m2 2 20 20",
+    "M9.9 9.9a3 3 0 0 0 4.2 4.2"
+  ],
+  generate: ["m12 3 1.9 4.6L18.5 9.5 13.9 11.4 12 16l-1.9-4.6L5.5 9.5l4.6-1.9Z", "M19 15l.8 2.2 2.2.8-2.2.8-.8 2.2-.8-2.2-2.2-.8 2.2-.8Z"],
+  /** Clears a search field. The platform draws one only in WebKit, and not on mobile. */
+  clear: ["m6 6 12 12", "m18 6-12 12"],
+  search: ["M11 4a7 7 0 1 0 0 14 7 7 0 0 0 0-14Z", "m20 20-4.2-4.2"]
+};
+function iconMarkup(paths) {
+  const body = paths.map((path) => `<path d="${path}"/>`).join("");
+  return `<svg viewBox="0 0 24 24" width="1em" height="1em" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${body}</svg>`;
+}
+
+export { INPUT_ICON_PATHS, iconMarkup };