@enigmax/primitives 0.17.0 → 0.18.0

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-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 };

package/dist/chunk-S653GLSF.js

@@ -0,0 +1,17 @@
+import { createNetworkMonitor, SERVER_NETWORK_STATE } from './chunk-2QFTRNAZ.js';
+import { useMemo, useRef, useSyncExternalStore } from 'react';
+
+function useNetworkState() {
+  const monitor = useMemo(() => createNetworkMonitor(), []);
+  const snapshot = useRef(monitor.state);
+  return useSyncExternalStore(
+    (listener) => monitor.subscribe((next) => {
+      snapshot.current = next;
+      listener();
+    }),
+    () => snapshot.current,
+    () => SERVER_NETWORK_STATE
+  );
+}
+
+export { useNetworkState };

package/dist/chunk-SNYUBXWQ.js

@@ -0,0 +1,149 @@
+// src/core/notifications.ts
+var DEFAULT_MAX = 4;
+var DEFAULT_DURATION = 5e3;
+function createNotifications(options = {}) {
+  const view = typeof document === "undefined" ? null : document;
+  const max = options.max ?? DEFAULT_MAX;
+  const defaultDuration = options.duration ?? DEFAULT_DURATION;
+  const sticky = /* @__PURE__ */ new Set([...options.stickyTones ?? ["error"], "loading"]);
+  let items = [];
+  let paused = false;
+  let sequence = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const timers = /* @__PURE__ */ new Map();
+  function emit() {
+    const snapshot = Object.freeze([...items]);
+    for (const listener of listeners) listener(snapshot);
+  }
+  function clearTimer(id) {
+    const timer = timers.get(id);
+    if (timer?.handle) clearTimeout(timer.handle);
+    timers.delete(id);
+  }
+  function startTimer(id, remaining) {
+    if (!Number.isFinite(remaining) || remaining <= 0) return;
+    const handle = paused ? null : setTimeout(() => dismiss(id), remaining);
+    timers.set(id, { handle, remaining, startedAt: Date.now() });
+  }
+  function dismiss(id) {
+    const next = items.filter((item) => item.id !== id);
+    if (next.length === items.length) return;
+    items = next;
+    clearTimer(id);
+    emit();
+  }
+  function notify(input) {
+    const tone = input.tone ?? "info";
+    const duration = input.duration ?? (sticky.has(tone) ? Infinity : defaultDuration);
+    const existing = input.key ? items.find((item) => item.key === input.key) : void 0;
+    const id = existing?.id ?? `n${++sequence}`;
+    const notification = {
+      id,
+      key: input.key,
+      title: input.title,
+      body: input.body,
+      tone,
+      duration,
+      action: input.action,
+      data: input.data,
+      createdAt: Date.now()
+    };
+    items = existing ? items.map((item) => item.id === id ? notification : item) : [...items, notification];
+    if (items.length > max) {
+      const evictable = items.find((item) => Number.isFinite(item.duration) && item.id !== id);
+      if (evictable) {
+        items = items.filter((item) => item.id !== evictable.id);
+        clearTimer(evictable.id);
+      } else {
+        items = items.slice(items.length - max);
+      }
+    }
+    clearTimer(id);
+    startTimer(id, duration);
+    emit();
+    return id;
+  }
+  const onVisibility = () => {
+    if (!view) return;
+    if (view.hidden) instance.pause();
+    else instance.resume();
+  };
+  function update(id, patch) {
+    const current = items.find((item) => item.id === id);
+    if (!current) return;
+    const tone = patch.tone ?? current.tone;
+    const duration = patch.duration ?? (patch.tone ? sticky.has(tone) ? Infinity : defaultDuration : current.duration);
+    items = items.map((item) => item.id === id ? { ...current, ...patch, tone, duration } : item);
+    clearTimer(id);
+    startTimer(id, duration);
+    emit();
+  }
+  function resolveMessage(message, value) {
+    const resolved = typeof message === "function" ? message(value) : message;
+    return typeof resolved === "string" ? { title: resolved } : resolved;
+  }
+  async function promise(work, messages) {
+    const start = typeof messages.loading === "string" ? { title: messages.loading } : messages.loading;
+    const key = start.key ?? `p${++sequence}`;
+    notify({ ...start, key, tone: "loading" });
+    try {
+      const value = await work;
+      notify({ ...resolveMessage(messages.success, value), key, tone: "success" });
+      return value;
+    } catch (error) {
+      notify({ ...resolveMessage(messages.error, error), key, tone: "error" });
+      throw error;
+    }
+  }
+  const instance = {
+    get items() {
+      return Object.freeze([...items]);
+    },
+    notify,
+    update,
+    promise,
+    dismiss,
+    dismissAll() {
+      for (const item of items) clearTimer(item.id);
+      items = [];
+      emit();
+    },
+    pause() {
+      if (paused) return;
+      paused = true;
+      for (const [id, timer] of timers) {
+        if (!timer.handle) continue;
+        clearTimeout(timer.handle);
+        timers.set(id, {
+          handle: null,
+          remaining: Math.max(timer.remaining - (Date.now() - timer.startedAt), 0),
+          startedAt: Date.now()
+        });
+      }
+    },
+    resume() {
+      if (!paused) return;
+      paused = false;
+      for (const [id, timer] of [...timers]) {
+        clearTimer(id);
+        startTimer(id, timer.remaining);
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      for (const item of items) clearTimer(item.id);
+      items = [];
+      listeners.clear();
+      view?.removeEventListener("visibilitychange", onVisibility);
+    }
+  };
+  view?.addEventListener("visibilitychange", onVisibility);
+  return instance;
+}
+
+export { createNotifications };

package/dist/chunk-U3V4EHOB.js

@@ -0,0 +1,41 @@
+import { createInput } from './chunk-KJINGUQN.js';
+import { useRef, useState, useEffect, useLayoutEffect } from 'react';
+
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+function useInput(options = {}) {
+  const inputRef = useRef(null);
+  const actionsRef = useRef(null);
+  const instanceRef = useRef(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [revealed, setRevealed] = useState(false);
+  useIsomorphicLayoutEffect(() => {
+    const input = inputRef.current;
+    if (!input) return;
+    const instance = createInput(input, {
+      ...optionsRef.current,
+      container: actionsRef.current ?? optionsRef.current.container,
+      onRevealChange: (next) => {
+        setRevealed(next);
+        optionsRef.current.onRevealChange?.(next);
+      }
+    });
+    instanceRef.current = instance;
+    return () => {
+      instance.destroy();
+      instanceRef.current = null;
+    };
+  }, []);
+  useIsomorphicLayoutEffect(() => {
+    instanceRef.current?.update(options);
+  }, [options.reveal, options.actions, options.position]);
+  return {
+    inputRef,
+    actionsRef,
+    revealed,
+    reveal: (next) => instanceRef.current?.reveal(next),
+    refresh: () => instanceRef.current?.refresh()
+  };
+}
+
+export { useInput };

package/dist/chunk-UOSSNUSC.js

@@ -0,0 +1,309 @@
+// src/core/marquee.ts
+var DEFAULT_DECAY = 0.12;
+var DRAG_THRESHOLD = 6;
+var STILL_MS = 90;
+var MAX_DT = 0.05;
+var VELOCITY_SMOOTHING = 0.6;
+var TOUCH_HOVER_SUPPRESS_MS = 1e3;
+var IDLE_EPSILON = 0.01;
+var DEFAULTS = {
+  speed: 60,
+  reverse: false,
+  vertical: false,
+  draggable: true,
+  hover: "off",
+  decay: DEFAULT_DECAY,
+  manageStyles: true,
+  copies: "clone"
+};
+var MAX_COPIES = 24;
+function createMarquee(lane, track, options = {}) {
+  let opts = { ...DEFAULTS, ...options };
+  let period = 0;
+  let copyCount = Math.max(2, track.children.length);
+  let offset = 0;
+  let velocity = 0;
+  let running = false;
+  let paused = false;
+  let destroyed = false;
+  let frame = 0;
+  let lastTime = 0;
+  let dragging = false;
+  let pointerId = null;
+  let lastPointer = 0;
+  let startPointer = 0;
+  let lastMoveTime = 0;
+  let maxTravel = 0;
+  let hovering = false;
+  let lastTouchAt = 0;
+  const motionQuery = typeof window.matchMedia === "function" ? window.matchMedia("(prefers-reduced-motion: reduce)") : null;
+  let reducedMotion = motionQuery?.matches ?? false;
+  function hoverTarget(cruise) {
+    const hover = opts.hover ?? "off";
+    if (hover === "off") return cruise;
+    if (hover === "pause") return 0;
+    if (typeof hover === "number") return cruise * hover;
+    return (cruise < 0 ? -1 : 1) * Math.abs(hover.speed);
+  }
+  function target() {
+    if (reducedMotion || paused) return 0;
+    const cruise = opts.reverse ? -opts.speed : opts.speed;
+    return hovering ? hoverTarget(cruise) : cruise;
+  }
+  function axisSize(element) {
+    return opts.vertical ? element.offsetHeight : element.offsetWidth;
+  }
+  function axisStart(element) {
+    return opts.vertical ? element.offsetTop : element.offsetLeft;
+  }
+  function applyStyles() {
+    if (!opts.manageStyles) return;
+    lane.style.overflow = "hidden";
+    lane.style.touchAction = opts.vertical ? "pan-x" : "pan-y";
+    lane.style.userSelect = "none";
+    lane.style.webkitUserSelect = "none";
+    track.style.willChange = "transform";
+  }
+  function render() {
+    const x = opts.vertical ? 0 : -offset;
+    const y = opts.vertical ? -offset : 0;
+    track.style.transform = `translate3d(${x}px, ${y}px, 0)`;
+  }
+  function readPeriod() {
+    const first = track.children[0];
+    const second = track.children[1];
+    if (!first) return 0;
+    if (second) {
+      const step = axisStart(second) - axisStart(first);
+      if (step > 0) return step;
+    }
+    return axisSize(first);
+  }
+  function requiredCopies(measured) {
+    if (measured <= 0) return 2;
+    return Math.min(MAX_COPIES, Math.max(2, Math.ceil(axisSize(lane) / measured) + 1));
+  }
+  function syncClones(count) {
+    const source = track.children[0];
+    if (!source) return;
+    while (track.children.length > count) track.removeChild(track.lastElementChild);
+    while (track.children.length < count) {
+      const clone = source.cloneNode(true);
+      clone.setAttribute("aria-hidden", "true");
+      clone.dataset.enigmaMarqueeCopy = String(track.children.length);
+      track.appendChild(clone);
+    }
+  }
+  function measure() {
+    if (destroyed) return;
+    const cloning = opts.copies === "clone";
+    if (cloning && track.children.length < 2) syncClones(2);
+    let measured = readPeriod();
+    let needed = requiredCopies(measured);
+    if (cloning && track.children.length !== needed) {
+      syncClones(needed);
+      measured = readPeriod();
+      needed = requiredCopies(measured);
+    }
+    const changed = measured !== period || needed !== copyCount;
+    period = measured;
+    if (needed !== copyCount) {
+      copyCount = needed;
+      opts.onCopyCountChange?.(needed);
+    }
+    if (period > 0) offset = wrap(offset);
+    render();
+    if (changed) opts.onMeasure?.(period, copyCount);
+    start();
+  }
+  function wrap(value) {
+    if (period <= 0) return value;
+    return (value % period + period) % period;
+  }
+  function tick(now) {
+    frame = 0;
+    if (destroyed) return;
+    const dt = Math.min((now - lastTime) / 1e3, MAX_DT);
+    lastTime = now;
+    if (!dragging) {
+      velocity += (target() - velocity) * (1 - Math.pow(opts.decay, dt));
+      offset = wrap(offset + velocity * dt);
+    }
+    render();
+    const idle = !dragging && Math.abs(velocity) < IDLE_EPSILON && Math.abs(target()) < IDLE_EPSILON;
+    if (idle) {
+      velocity = 0;
+      running = false;
+      return;
+    }
+    frame = requestAnimationFrame(tick);
+  }
+  function start() {
+    if (destroyed || running) return;
+    running = true;
+    lastTime = performance.now();
+    frame = requestAnimationFrame(tick);
+  }
+  function pointerDelta(event) {
+    return opts.vertical ? event.clientY : event.clientX;
+  }
+  function onPointerDown(event) {
+    if (event.pointerType !== "mouse") noteTouch();
+    if (!opts.draggable || event.button > 0 || pointerId !== null) return;
+    pointerId = event.pointerId;
+    dragging = true;
+    lastPointer = pointerDelta(event);
+    startPointer = lastPointer;
+    lastMoveTime = event.timeStamp;
+    maxTravel = 0;
+    lane.dataset.dragging = "true";
+    window.addEventListener("pointermove", onPointerMove);
+    window.addEventListener("pointerup", onPointerUp);
+    window.addEventListener("pointercancel", onPointerUp);
+    start();
+  }
+  function onPointerMove(event) {
+    if (event.pointerId !== pointerId) return;
+    const position = pointerDelta(event);
+    const delta = position - lastPointer;
+    lastPointer = position;
+    const dt = Math.max((event.timeStamp - lastMoveTime) / 1e3, 1e-3);
+    lastMoveTime = event.timeStamp;
+    maxTravel = Math.max(maxTravel, Math.abs(position - startPointer));
+    offset = wrap(offset - delta);
+    const instant = -delta / dt;
+    velocity = velocity * VELOCITY_SMOOTHING + instant * (1 - VELOCITY_SMOOTHING);
+  }
+  function onPointerUp(event) {
+    if (event.pointerId !== pointerId) return;
+    pointerId = null;
+    dragging = false;
+    delete lane.dataset.dragging;
+    window.removeEventListener("pointermove", onPointerMove);
+    window.removeEventListener("pointerup", onPointerUp);
+    window.removeEventListener("pointercancel", onPointerUp);
+    if (event.timeStamp - lastMoveTime > STILL_MS) velocity = 0;
+    start();
+  }
+  function onClickCapture(event) {
+    if (maxTravel <= DRAG_THRESHOLD) return;
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  function onClick(event) {
+    if (maxTravel > DRAG_THRESHOLD) return;
+    opts.onItemClick?.(event);
+  }
+  function onPointerEnter(event) {
+    if (event.pointerType !== "mouse") {
+      noteTouch();
+      return;
+    }
+    if (Date.now() - lastTouchAt < TOUCH_HOVER_SUPPRESS_MS) return;
+    hovering = true;
+    lane.dataset.hovering = "true";
+    start();
+  }
+  function onPointerLeave() {
+    hovering = false;
+    delete lane.dataset.hovering;
+    start();
+  }
+  function noteTouch() {
+    lastTouchAt = Date.now();
+    if (!hovering) return;
+    hovering = false;
+    delete lane.dataset.hovering;
+    start();
+  }
+  function onMotionChange(event) {
+    reducedMotion = event.matches;
+    lane.dataset.reducedMotion = String(reducedMotion);
+    start();
+  }
+  const resizeObserver = typeof ResizeObserver === "function" ? new ResizeObserver(() => measure()) : null;
+  function init() {
+    applyStyles();
+    lane.dataset.enigmaMarquee = "";
+    lane.dataset.reducedMotion = String(reducedMotion);
+    track.dataset.enigmaMarqueeTrack = "";
+    for (const child of Array.from(track.children)) {
+      child.dataset.enigmaMarqueeCopy ??= "0";
+    }
+    lane.addEventListener("pointerdown", onPointerDown);
+    lane.addEventListener("pointerenter", onPointerEnter);
+    lane.addEventListener("pointerleave", onPointerLeave);
+    lane.addEventListener("touchstart", noteTouch, { passive: true });
+    lane.addEventListener("click", onClickCapture, true);
+    lane.addEventListener("click", onClick);
+    motionQuery?.addEventListener("change", onMotionChange);
+    resizeObserver?.observe(lane);
+    const first = track.children[0];
+    if (first) resizeObserver?.observe(first);
+    measure();
+    void document.fonts?.ready.then(() => measure());
+    remeasureOnImageLoad();
+  }
+  function remeasureOnImageLoad() {
+    for (const image of track.querySelectorAll("img")) {
+      if (image.complete) continue;
+      const done = () => {
+        image.removeEventListener("load", done);
+        image.removeEventListener("error", done);
+        if (!destroyed) measure();
+      };
+      image.addEventListener("load", done);
+      image.addEventListener("error", done);
+    }
+  }
+  init();
+  return {
+    get offset() {
+      return offset;
+    },
+    get period() {
+      return period;
+    },
+    get copyCount() {
+      return copyCount;
+    },
+    get dragging() {
+      return dragging;
+    },
+    get reducedMotion() {
+      return reducedMotion;
+    },
+    update(next) {
+      const styleKeys = next.vertical !== void 0 || next.manageStyles !== void 0;
+      opts = { ...opts, ...next };
+      if (styleKeys) applyStyles();
+      measure();
+    },
+    measure,
+    pause() {
+      paused = true;
+      start();
+    },
+    resume() {
+      paused = false;
+      start();
+    },
+    destroy() {
+      destroyed = true;
+      if (frame) cancelAnimationFrame(frame);
+      resizeObserver?.disconnect();
+      motionQuery?.removeEventListener("change", onMotionChange);
+      lane.removeEventListener("pointerdown", onPointerDown);
+      lane.removeEventListener("pointerenter", onPointerEnter);
+      lane.removeEventListener("pointerleave", onPointerLeave);
+      lane.removeEventListener("touchstart", noteTouch);
+      lane.removeEventListener("click", onClickCapture, true);
+      lane.removeEventListener("click", onClick);
+      window.removeEventListener("pointermove", onPointerMove);
+      window.removeEventListener("pointerup", onPointerUp);
+      window.removeEventListener("pointercancel", onPointerUp);
+    }
+  };
+}
+
+export { createMarquee };

package/dist/chunk-WSB655JB.js

@@ -0,0 +1,47 @@
+import { createSearch } from './chunk-UZFEEFMF.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-XNNQRA35.js

@@ -0,0 +1,31 @@
+import { flagView } from './chunk-AU3H5WIY.js';
+import { jsx } from 'react/jsx-runtime';
+
+function Flag({ code, label, decorative = false, locale, shape, format, source, basePath, size, fallback = null, ...rest }) {
+  const options = { shape, format, source, basePath, size, locale };
+  for (const key of Object.keys(options)) {
+    if (options[key] === void 0) delete options[key];
+  }
+  const view = flagView(code, options);
+  if (!view) return fallback;
+  const name = decorative ? "" : label?.trim() || view.name || "";
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      src: view.src,
+      alt: name,
+      width: view.width,
+      height: view.height,
+      loading: "lazy",
+      decoding: "async",
+      "aria-hidden": name ? void 0 : true,
+      suppressHydrationWarning: true,
+      "data-enigma-flag": "",
+      "data-flag-code": view.code,
+      "data-flag-shape": view.shape,
+      ...rest
+    }
+  );
+}
+
+export { Flag };