@enigmax/primitives 0.17.0 → 0.19.0

package/dist/chunk-R4ZAEE7V.js

@@ -0,0 +1,249 @@
+import { INPUT_ICON_PATHS } from './chunk-F25CGNQC.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { lazy, forwardRef, useRef, useState, useId, useCallback, useEffect, Suspense } from 'react';
+
+var ICON_PROPS = {
+  viewBox: "0 0 24 24",
+  width: "1em",
+  height: "1em",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round",
+  "aria-hidden": true
+};
+function Icon({ paths }) {
+  return /* @__PURE__ */ jsx("svg", { ...ICON_PROPS, children: paths.map((path) => /* @__PURE__ */ jsx("path", { d: path }, path)) });
+}
+
+// src/react/input/write-value.ts
+function writeValue(input, next) {
+  const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set;
+  if (setter) setter.call(input, next);
+  else input.value = next;
+  input.dispatchEvent(new Event("input", { bubbles: true }));
+}
+var PasswordExtras = lazy(() => import('./password-3DRQYAYQ.js').then((module) => ({ default: module.PasswordExtras })));
+var SearchExtras = lazy(() => import('./search-UQEXAPQB.js').then((module) => ({ default: module.SearchExtras })));
+var Input = forwardRef(function Input2(props, forwardedRef) {
+  const {
+    reveal,
+    revealLabels,
+    generate = false,
+    generateLabel = "Generate a password",
+    revealOnGenerate = true,
+    copyOnGenerate = false,
+    onGenerate,
+    actions = [],
+    position = "end",
+    strength = false,
+    onStrengthChange,
+    breach,
+    breachDelay = 500,
+    onBreachChange,
+    items,
+    keys,
+    delay,
+    limit,
+    fuse,
+    fuseOptions,
+    matcher,
+    onResults,
+    renderResults,
+    clearable,
+    clearLabel = "Clear",
+    wrapperProps,
+    fieldProps,
+    classNames,
+    children,
+    type = "text",
+    onChange,
+    ...rest
+  } = props;
+  const innerRef = useRef(null);
+  const [element, setElement] = useState(null);
+  const [revealed, setRevealed] = useState(false);
+  const describedBy = useId();
+  const isPassword = type === "password";
+  const isSearch = type === "search";
+  const showReveal = reveal ?? isPassword;
+  const showGenerate = generate !== false && isPassword;
+  const showClear = (clearable ?? isSearch) && isSearch;
+  const controlled = rest.value !== void 0;
+  const [ownValue, setOwnValue] = useState(String(rest.defaultValue ?? ""));
+  const value = controlled ? String(rest.value ?? "") : ownValue;
+  const handleChange = useCallback((event) => {
+    if (!controlled) setOwnValue(event.target.value);
+    onChange?.(event);
+  }, [controlled, onChange]);
+  const caret = useRef(null);
+  const toggleReveal = useCallback(() => {
+    const input = innerRef.current;
+    if (input && typeof document !== "undefined" && document.activeElement === input) {
+      try {
+        const { selectionStart, selectionEnd } = input;
+        caret.current = selectionStart === null || selectionEnd === null ? null : [selectionStart, selectionEnd];
+      } catch {
+        caret.current = null;
+      }
+    }
+    setRevealed((current) => !current);
+  }, []);
+  useEffect(() => {
+    const selection = caret.current;
+    if (!selection) return;
+    caret.current = null;
+    const restore = () => {
+      const input = innerRef.current;
+      if (!input || document.activeElement !== input) return;
+      try {
+        input.setSelectionRange(selection[0], selection[1]);
+      } catch {
+      }
+    };
+    restore();
+    const timer = setTimeout(restore, 0);
+    return () => clearTimeout(timer);
+  }, [revealed]);
+  const handleGenerate = useCallback(async () => {
+    const input = innerRef.current;
+    if (!input) return;
+    const { generatePassword } = await import('./password-FB2CUEKJ.js');
+    const password = generatePassword(typeof generate === "object" ? generate : {});
+    writeValue(input, password);
+    if (revealOnGenerate) setRevealed(true);
+    if (copyOnGenerate) void navigator.clipboard?.writeText(password).catch(() => {
+    });
+    input.focus();
+    onGenerate?.(password);
+  }, [generate, revealOnGenerate, copyOnGenerate, onGenerate]);
+  const handleClear = useCallback(() => {
+    const input = innerRef.current;
+    if (!input) return;
+    writeValue(input, "");
+    input.focus();
+  }, []);
+  const [score, setScore] = useState(null);
+  const [breached, setBreached] = useState(false);
+  const handleBreach = useCallback((state) => {
+    setBreached(state.status === "breached");
+    onBreachChange?.(state);
+  }, [onBreachChange]);
+  const builtIn = [];
+  if (showGenerate) {
+    builtIn.push({
+      name: "generate",
+      label: generateLabel,
+      icon: /* @__PURE__ */ jsx(Icon, { paths: INPUT_ICON_PATHS.generate }),
+      onSelect: () => {
+        void handleGenerate();
+      }
+    });
+  }
+  if (showReveal) {
+    builtIn.push({
+      name: "reveal",
+      label: revealed ? revealLabels?.hide ?? "Hide password" : revealLabels?.show ?? "Show password",
+      icon: /* @__PURE__ */ jsx(Icon, { paths: revealed ? INPUT_ICON_PATHS.eyeOff : INPUT_ICON_PATHS.eye }),
+      pressed: revealed,
+      onSelect: toggleReveal
+    });
+  }
+  if (showClear) {
+    builtIn.push({
+      name: "clear",
+      label: clearLabel,
+      icon: /* @__PURE__ */ jsx(Icon, { paths: INPUT_ICON_PATHS.clear }),
+      // Nothing to clear is nothing to press: the button would be a target that does
+      // not respond, which reads as broken rather than as unavailable.
+      visible: value.length > 0,
+      onSelect: handleClear
+    });
+  }
+  const overridden = new Set(actions.map((action) => action.name));
+  const rendered = [...builtIn.filter((action) => !overridden.has(action.name)), ...actions].filter((action) => action.visible !== false);
+  const locked = rest.disabled === true || rest.readOnly === true;
+  const buttons = rendered.length === 0 ? null : /* @__PURE__ */ jsx("span", { "data-enigma-input-actions": "", "data-position": position, className: classNames?.actions, children: rendered.map((action) => /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      "data-enigma-input-action": action.name,
+      className: classNames?.action,
+      "aria-label": action.label,
+      title: action.label,
+      "aria-pressed": action.pressed,
+      disabled: locked,
+      onMouseDown: (event) => event.preventDefault(),
+      onClick: action.onSelect,
+      children: action.icon
+    },
+    action.name
+  )) });
+  const wantsPasswordChunk = isPassword && (strength !== false || Boolean(breach));
+  const wantsSearchChunk = isSearch && Boolean(items || matcher);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ...wrapperProps,
+      "data-enigma-input-root": "",
+      "data-revealed": revealed ? "" : void 0,
+      "data-breached": breached ? "" : void 0,
+      "data-score": score ?? void 0,
+      children: [
+        /* @__PURE__ */ jsxs("div", { ...fieldProps, "data-enigma-input-field": "", children: [
+          position === "start" && buttons,
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              ...rest,
+              ref: (node) => {
+                innerRef.current = node;
+                setElement(node);
+                if (typeof forwardedRef === "function") forwardedRef(node);
+                else if (forwardedRef) forwardedRef.current = node;
+              },
+              type: revealed && isPassword ? "text" : type,
+              onChange: handleChange,
+              "data-enigma-input": "",
+              "aria-describedby": score !== null ? describedBy : rest["aria-describedby"]
+            }
+          ),
+          position === "end" && buttons
+        ] }),
+        wantsPasswordChunk && /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+          PasswordExtras,
+          {
+            id: describedBy,
+            value,
+            strength,
+            onStrengthChange,
+            onScore: setScore,
+            breach,
+            breachDelay,
+            onBreachChange: handleBreach,
+            classNames: classNames?.strength
+          }
+        ) }),
+        wantsSearchChunk && /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+          SearchExtras,
+          {
+            input: element,
+            items,
+            keys,
+            delay,
+            limit,
+            fuse,
+            fuseOptions,
+            matcher,
+            onResults,
+            renderResults
+          }
+        ) }),
+        children
+      ]
+    }
+  );
+});
+
+export { Input };

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