@enigmax/primitives 0.16.0 → 0.18.0

package/dist/chunk-IIT6U7LM.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-P4OHCRXD.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-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 };