@enigmax/primitives 0.17.0 → 0.19.0

package/dist/chunk-IXVMRVD4.js

@@ -0,0 +1,96 @@
+// src/core/relative-time.ts
+var ZONED = /([zZ]|[+-]\d{2}:?\d{2})$/;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+var HAS_TIME = /\d{2}:\d{2}/;
+var DURATION = /^([+-])?P(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var WEEK = 7 * DAY;
+var MONTH = 30 * DAY;
+var YEAR = 365 * DAY;
+function ensureZone(text) {
+  const trimmed = text.trim();
+  if (!trimmed || DATE_ONLY.test(trimmed) || ZONED.test(trimmed)) return trimmed;
+  const iso = trimmed.replace(" ", "T");
+  return HAS_TIME.test(iso) ? `${iso}Z` : iso;
+}
+function normalizeDate(value) {
+  if (value == null) return null;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === "number") return Number.isFinite(value) ? new Date(value) : null;
+  const date = new Date(ensureZone(value));
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function parseDuration(value) {
+  const match = DURATION.exec(value.trim());
+  if (!match) return 0;
+  const [, sign, years, months, weeks, days, hours, minutes, seconds] = match;
+  const n = (part) => part ? Number(part) : 0;
+  const total = n(years) * YEAR + n(months) * MONTH + n(weeks) * WEEK + n(days) * DAY + n(hours) * HOUR + n(minutes) * MINUTE + n(seconds) * SECOND;
+  return sign === "-" ? -total : total;
+}
+function dateTimeOptions(options) {
+  const { second, minute, hour, weekday, day, month, year, timeZone, timeZoneName } = options;
+  const parts = { timeZone, timeZoneName, second, minute, hour, weekday, day, month, year };
+  for (const key of Object.keys(parts)) {
+    if (parts[key] === void 0) delete parts[key];
+  }
+  return parts;
+}
+function format(date, locale, options) {
+  try {
+    return new Intl.DateTimeFormat(locale, options).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+function relativeTimeView(value, options = {}, now = /* @__PURE__ */ new Date()) {
+  const date = normalizeDate(value);
+  if (!date) return { date: null, iso: "", label: "", exact: "", beyondThreshold: false, absoluteOnly: false };
+  const { locale, threshold = "P30D", prefix = "on", numericBeyondThreshold = false } = options;
+  const age = Math.abs(date.getTime() - now.getTime());
+  const beyondThreshold = age > parseDuration(threshold);
+  const absoluteOnly = numericBeyondThreshold && beyondThreshold;
+  const parts = absoluteOnly ? { day: "numeric", month: "numeric", year: "numeric", timeZone: options.timeZone } : { day: "numeric", month: "short", year: "numeric", ...dateTimeOptions(options) };
+  const label = format(date, locale, parts);
+  return {
+    date,
+    iso: date.toISOString(),
+    label: !absoluteOnly && prefix ? `${prefix} ${label}` : label,
+    exact: format(date, locale, { dateStyle: "full", timeStyle: "long", timeZone: options.timeZone }),
+    beyondThreshold,
+    absoluteOnly
+  };
+}
+function relativeTimeAttributes(view, options = {}) {
+  const attributes = {
+    datetime: view.iso,
+    format: options.format,
+    tense: options.tense,
+    precision: options.precision,
+    threshold: options.threshold,
+    prefix: options.prefix,
+    "format-style": options.formatStyle,
+    second: options.second,
+    minute: options.minute,
+    hour: options.hour,
+    weekday: options.weekday,
+    day: options.day,
+    month: options.month,
+    year: options.year,
+    lang: options.locale,
+    "time-zone": options.timeZone,
+    "time-zone-name": options.timeZoneName,
+    // Boolean attributes are read by presence: "false" would still be true.
+    "no-title": options.noTitle ? "" : void 0
+  };
+  const out = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+
+export { ensureZone, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView };

package/dist/chunk-KJINGUQN.js

@@ -0,0 +1,188 @@
+import { iconMarkup, INPUT_ICON_PATHS } from './chunk-F25CGNQC.js';
+
+// src/core/input.ts
+var EYE = iconMarkup(INPUT_ICON_PATHS.eye);
+var EYE_OFF = iconMarkup(INPUT_ICON_PATHS.eyeOff);
+function resolve(value, state) {
+  return typeof value === "function" ? value(state) : value;
+}
+function paint(target, icon) {
+  if (typeof icon === "string") target.innerHTML = icon;
+  else {
+    target.replaceChildren(icon);
+  }
+}
+function createInput(input, options = {}) {
+  let opts = { ...options };
+  let revealed = false;
+  let destroyed = false;
+  let restoreTimer = null;
+  const owned = !opts.container;
+  const container = opts.container ?? document.createElement("span");
+  const buttons = /* @__PURE__ */ new Map();
+  function state() {
+    return { input, revealed, locked: input.disabled || input.readOnly };
+  }
+  function revealConfig() {
+    return typeof opts.reveal === "object" ? opts.reveal : {};
+  }
+  function revealAction() {
+    const config = revealConfig();
+    return {
+      name: "reveal",
+      label: (current) => current.revealed ? config.hideLabel ?? "Hide password" : config.showLabel ?? "Show password",
+      icon: (current) => current.revealed ? config.hideIcon ?? EYE_OFF : config.showIcon ?? EYE,
+      pressed: (current) => current.revealed,
+      onSelect: () => setRevealed(!revealed)
+    };
+  }
+  function isPasswordField() {
+    return input.type === "password" || revealed && input.dataset.enigmaInputReveal === "on";
+  }
+  function activeActions() {
+    const custom = opts.actions ?? [];
+    const wantsReveal = opts.reveal !== false && isPasswordField();
+    const builtIn = wantsReveal && !custom.some((action) => action.name === "reveal") ? [revealAction()] : [];
+    return [...builtIn, ...custom];
+  }
+  function setRevealed(next) {
+    if (!isPasswordField() && next) return;
+    const selection = readSelection();
+    revealed = next;
+    input.type = next ? "text" : "password";
+    input.dataset.enigmaInputReveal = next ? "on" : "off";
+    render();
+    if (selection) {
+      applySelection(selection);
+      if (restoreTimer !== null) clearTimeout(restoreTimer);
+      restoreTimer = setTimeout(() => {
+        restoreTimer = null;
+        if (!destroyed && document.activeElement === input) applySelection(selection);
+      }, 0);
+    }
+    opts.onRevealChange?.(next);
+  }
+  function readSelection() {
+    if (document.activeElement !== input) return null;
+    try {
+      const { selectionStart, selectionEnd } = input;
+      return selectionStart === null || selectionEnd === null ? null : [selectionStart, selectionEnd];
+    } catch {
+      return null;
+    }
+  }
+  function applySelection(selection) {
+    try {
+      input.setSelectionRange(selection[0], selection[1]);
+    } catch {
+    }
+  }
+  function render() {
+    if (destroyed) return;
+    const selection = readSelection();
+    const current = state();
+    const actions = activeActions();
+    const seen = /* @__PURE__ */ new Set();
+    for (const action of actions) {
+      seen.add(action.name);
+      const visible = action.visible ? action.visible(current) : true;
+      let button = buttons.get(action.name);
+      if (!button) {
+        button = document.createElement("button");
+        button.type = "button";
+        button.dataset.enigmaInputAction = action.name;
+        buttons.set(action.name, button);
+        container.append(button);
+      }
+      if (!visible) {
+        button.remove();
+        buttons.delete(action.name);
+        continue;
+      }
+      if (!button.isConnected) container.append(button);
+      const label = resolve(action.label, current);
+      button.setAttribute("aria-label", label);
+      button.title = label;
+      button.disabled = current.locked;
+      if (action.pressed) button.setAttribute("aria-pressed", String(action.pressed(current)));
+      else button.removeAttribute("aria-pressed");
+      paint(button, resolve(action.icon, current));
+    }
+    for (const [name, button] of [...buttons]) {
+      if (seen.has(name)) continue;
+      button.remove();
+      buttons.delete(name);
+    }
+    container.hidden = buttons.size === 0;
+    if (selection) {
+      try {
+        input.setSelectionRange(selection[0], selection[1]);
+      } catch {
+      }
+    }
+  }
+  function onMouseDown(event) {
+    if (!event.target?.closest("[data-enigma-input-action]")) return;
+    event.preventDefault();
+  }
+  function onClick(event) {
+    const target = event.target?.closest("[data-enigma-input-action]");
+    if (!target) return;
+    const action = activeActions().find((candidate) => candidate.name === target.dataset.enigmaInputAction);
+    if (!action) return;
+    event.preventDefault();
+    action.onSelect(state());
+  }
+  const observer = typeof MutationObserver === "function" ? new MutationObserver(() => {
+    if (!isPasswordField() && revealed) revealed = false;
+    render();
+  }) : null;
+  function mount() {
+    input.dataset.enigmaInput = "";
+    container.dataset.enigmaInputActions = "";
+    container.dataset.position = opts.position ?? "end";
+    if (owned && !container.isConnected) {
+      if ((opts.position ?? "end") === "start") input.before(container);
+      else input.after(container);
+    }
+    container.addEventListener("mousedown", onMouseDown);
+    container.addEventListener("click", onClick);
+    observer?.observe(input, { attributes: true, attributeFilter: ["type", "disabled", "readonly"] });
+    render();
+  }
+  mount();
+  return {
+    get revealed() {
+      return revealed;
+    },
+    reveal(next) {
+      setRevealed(next ?? !revealed);
+    },
+    refresh: render,
+    update(next) {
+      const moved = next.position !== void 0 && next.position !== opts.position;
+      opts = { ...opts, ...next };
+      if (moved && owned) {
+        container.dataset.position = opts.position ?? "end";
+        if (opts.position === "start") input.before(container);
+        else input.after(container);
+      }
+      render();
+    },
+    destroy() {
+      destroyed = true;
+      if (restoreTimer !== null) clearTimeout(restoreTimer);
+      observer?.disconnect();
+      container.removeEventListener("mousedown", onMouseDown);
+      container.removeEventListener("click", onClick);
+      for (const button of buttons.values()) button.remove();
+      buttons.clear();
+      if (owned) container.remove();
+      delete input.dataset.enigmaInput;
+      delete input.dataset.enigmaInputReveal;
+      if (revealed) input.type = "password";
+    }
+  };
+}
+
+export { createInput };

package/dist/chunk-MMQPZGSU.js

@@ -0,0 +1,161 @@
+// src/core/button.ts
+var TICK_MS = 100;
+function store(cooldown) {
+  if (!cooldown.key || typeof window === "undefined") return null;
+  try {
+    const target = cooldown.storage === "local" ? window.localStorage : window.sessionStorage;
+    const probe = "__enigma_probe__";
+    target.setItem(probe, "1");
+    target.removeItem(probe);
+    return target;
+  } catch {
+    return null;
+  }
+}
+function normalize(cooldown) {
+  if (cooldown == null) return null;
+  return typeof cooldown === "number" ? { ms: cooldown } : cooldown;
+}
+function isTyping(target) {
+  const element = target;
+  if (!element) return false;
+  const tag = element.tagName;
+  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || element.isContentEditable === true;
+}
+function createButton(options = {}) {
+  let opts = { ...options };
+  let loading = Boolean(opts.loading);
+  let readyAt = 0;
+  let timer = null;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const storageKey = () => {
+    const cooldown = normalize(opts.cooldown);
+    return cooldown?.key ? `enigma:cooldown:${cooldown.key}` : null;
+  };
+  function restore() {
+    const cooldown = normalize(opts.cooldown);
+    if (!cooldown) return;
+    const target = store(cooldown);
+    const key = storageKey();
+    if (!target || !key) return;
+    const saved = Number(target.getItem(key));
+    if (Number.isFinite(saved) && saved > Date.now()) readyAt = saved;
+  }
+  function remaining() {
+    return Math.max(0, readyAt - Date.now());
+  }
+  function snapshot() {
+    const disabled = Boolean(opts.disabled);
+    const cooldown = remaining();
+    return {
+      element: opts.href ? "a" : "button",
+      available: !disabled && !loading && cooldown === 0,
+      loading,
+      disabled,
+      cooldown,
+      shortcut: opts.shortcut ?? null
+    };
+  }
+  function emit() {
+    const state = snapshot();
+    opts.onChange?.(state);
+    for (const listener of listeners) listener(state);
+  }
+  function stopTicking() {
+    if (timer === null) return;
+    clearInterval(timer);
+    timer = null;
+  }
+  function startTicking() {
+    if (timer !== null || remaining() === 0) return;
+    timer = setInterval(() => {
+      if (remaining() > 0) {
+        emit();
+        return;
+      }
+      stopTicking();
+      emit();
+    }, TICK_MS);
+  }
+  function beginCooldown() {
+    const cooldown = normalize(opts.cooldown);
+    if (!cooldown || cooldown.ms <= 0) return;
+    readyAt = Date.now() + cooldown.ms;
+    const target = store(cooldown);
+    const key = storageKey();
+    if (target && key) {
+      try {
+        target.setItem(key, String(readyAt));
+      } catch {
+      }
+    }
+    startTicking();
+  }
+  async function press(event) {
+    if (destroyed || !snapshot().available) return;
+    const result = opts.onPress?.(event);
+    if (result instanceof Promise) {
+      loading = true;
+      emit();
+      try {
+        await result;
+      } finally {
+        loading = false;
+        beginCooldown();
+        emit();
+      }
+      return;
+    }
+    beginCooldown();
+    emit();
+  }
+  function onKeyDown(event) {
+    if (!opts.shortcut || isTyping(event.target)) return;
+    if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) return;
+    if (event.key.toLowerCase() !== opts.shortcut.toLowerCase()) return;
+    if (!snapshot().available) return;
+    event.preventDefault();
+    void press(event);
+  }
+  if (typeof window !== "undefined") {
+    restore();
+    startTicking();
+    window.addEventListener("keydown", onKeyDown);
+  }
+  return {
+    get state() {
+      return snapshot();
+    },
+    press,
+    update(next) {
+      const hadCooldown = JSON.stringify(normalize(opts.cooldown));
+      opts = { ...opts, ...next };
+      if (next.loading !== void 0) loading = Boolean(next.loading);
+      if (JSON.stringify(normalize(opts.cooldown)) !== hadCooldown) restore();
+      emit();
+    },
+    reset() {
+      readyAt = 0;
+      stopTicking();
+      const cooldown = normalize(opts.cooldown);
+      const key = storageKey();
+      if (cooldown && key) store(cooldown)?.removeItem(key);
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      destroyed = true;
+      stopTicking();
+      listeners.clear();
+      if (typeof window !== "undefined") window.removeEventListener("keydown", onKeyDown);
+    }
+  };
+}
+
+export { createButton };

package/dist/chunk-OCMI7R6H.js

@@ -0,0 +1,79 @@
+import { relativeTimeView, relativeTimeAttributes } from './chunk-IXVMRVD4.js';
+import { useEffect, useCallback, createElement } from 'react';
+
+var loading = null;
+function loadElement() {
+  if (loading || typeof window === "undefined") return;
+  loading = import('@github/relative-time-element').catch(() => {
+    return null;
+  });
+}
+function RelativeTime({
+  date,
+  fallback = null,
+  capitalize = false,
+  capitalizeFirst = true,
+  now,
+  format,
+  tense,
+  precision,
+  threshold,
+  prefix,
+  formatStyle,
+  locale,
+  timeZone,
+  second,
+  minute,
+  hour,
+  weekday,
+  day,
+  month,
+  year,
+  timeZoneName,
+  noTitle,
+  numericBeyondThreshold,
+  ...rest
+}) {
+  useEffect(loadElement, []);
+  const applyPrefix = useCallback((node) => {
+    if (!node) return;
+    if (prefix === void 0 || prefix === "") node.removeAttribute("prefix");
+    else node.setAttribute("prefix", prefix);
+  }, [prefix]);
+  const options = {
+    format,
+    tense,
+    precision,
+    threshold,
+    prefix,
+    formatStyle,
+    locale,
+    timeZone,
+    second,
+    minute,
+    hour,
+    weekday,
+    day,
+    month,
+    year,
+    timeZoneName,
+    noTitle,
+    numericBeyondThreshold
+  };
+  const view = relativeTimeView(date, options, now);
+  if (!view.date) return fallback;
+  const marks = {
+    "data-relative-time-capitalize": capitalize ? "true" : void 0,
+    "data-relative-time-capitalize-first-letter": capitalizeFirst ? "true" : void 0,
+    // The text differs between the server's instant and the browser's, which is the
+    // one hydration difference React has an escape hatch for rather than a bug.
+    suppressHydrationWarning: true
+  };
+  if (view.absoluteOnly) {
+    return createElement("time", { dateTime: view.iso, title: noTitle ? void 0 : view.exact, ...marks, ...rest }, view.label);
+  }
+  const { prefix: prefixAttribute, ...attributes } = relativeTimeAttributes(view, options);
+  return createElement("relative-time", { ...attributes, ...marks, ...rest, ref: applyPrefix }, view.label);
+}
+
+export { RelativeTime };

package/dist/chunk-QQFNAKMY.js

@@ -0,0 +1,47 @@
+import { createSearch } from './chunk-D5A2ZMAG.js';
+import { useRef, useState, useMemo, useEffect } from 'react';
+
+function useSearch(options = {}) {
+  const inputRef = useRef(null);
+  const instanceRef = useRef(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [query, setQuery] = useState("");
+  const [results, setResults] = useState([]);
+  const instance = useMemo(() => {
+    const created = createSearch({
+      ...optionsRef.current,
+      onResults: (next, nextQuery) => {
+        setResults(next);
+        setQuery(nextQuery);
+        optionsRef.current.onResults?.(next, nextQuery);
+      }
+    });
+    instanceRef.current = created;
+    return created;
+  }, []);
+  useEffect(() => () => instance.destroy(), [instance]);
+  useEffect(() => {
+    instance.setItems(options.items ?? []);
+  }, [instance, options.items]);
+  useEffect(() => {
+    const input = inputRef.current;
+    if (!input) return;
+    return instance.attach(input);
+  }, [instance]);
+  return {
+    inputRef,
+    query,
+    results,
+    search: (next) => instance.search(next),
+    searchNow: (next) => {
+      instance.searchNow(next);
+    },
+    clear: () => {
+      if (inputRef.current) inputRef.current.value = "";
+      instance.searchNow("");
+    }
+  };
+}
+
+export { useSearch };

package/dist/chunk-QYMUIW5I.js

@@ -0,0 +1,28 @@
+import { createNotifications } from './chunk-SNYUBXWQ.js';
+import { useRef, useSyncExternalStore, useMemo } from 'react';
+
+var defaultQueue = createNotifications();
+function useNotifications(queue = defaultQueue) {
+  const snapshot = useRef(queue.items);
+  const items = useSyncExternalStore(
+    (listener) => queue.subscribe((next) => {
+      snapshot.current = next;
+      listener();
+    }),
+    () => snapshot.current,
+    () => snapshot.current
+  );
+  return useMemo(() => ({
+    items,
+    notify: queue.notify,
+    dismiss: queue.dismiss,
+    dismissAll: queue.dismissAll,
+    pause: queue.pause,
+    resume: queue.resume
+  }), [items, queue]);
+}
+function createNotificationQueue(options) {
+  return createNotifications(options);
+}
+
+export { createNotificationQueue, defaultQueue, useNotifications };