@enigmax/primitives 0.17.0 → 0.18.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-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 };

package/dist/chunk-HC2ME5PU.js

@@ -0,0 +1,168 @@
+// src/core/password.ts
+var LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+var UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var DIGITS = "0123456789";
+var SYMBOLS = "!@#$%^&*()-_=+[]{};:,.?";
+var AMBIGUOUS = "Il1O0";
+function randomIndex(bound) {
+  const random = globalThis.crypto?.getRandomValues?.bind(globalThis.crypto);
+  if (!random) {
+    throw new Error("Generating a password needs crypto.getRandomValues, which browsers only expose over HTTPS (or on localhost).");
+  }
+  const limit = Math.floor(2 ** 32 / bound) * bound;
+  const buffer = new Uint32Array(1);
+  let value;
+  do {
+    random(buffer);
+    value = buffer[0];
+  } while (value >= limit);
+  return value % bound;
+}
+function pick(alphabet) {
+  return alphabet[randomIndex(alphabet.length)];
+}
+function classes(options) {
+  const { lowercase = true, uppercase = true, digits = true, symbols = true, excludeAmbiguous = false, exclude = "" } = options;
+  const banned = /* @__PURE__ */ new Set([...excludeAmbiguous ? AMBIGUOUS : "", ...exclude]);
+  const clean = (source) => [...source].filter((character) => !banned.has(character)).join("");
+  return [
+    lowercase ? clean(LOWERCASE) : "",
+    uppercase ? clean(UPPERCASE) : "",
+    digits ? clean(DIGITS) : "",
+    symbols ? clean(SYMBOLS) : ""
+  ].filter(Boolean);
+}
+function shuffle(characters) {
+  for (let index = characters.length - 1; index > 0; index--) {
+    const swap = randomIndex(index + 1);
+    [characters[index], characters[swap]] = [characters[swap], characters[index]];
+  }
+  return characters;
+}
+function generatePassword(options = {}) {
+  const { length = 20, requireEachClass = true } = options;
+  const pools = classes(options);
+  if (!pools.length) throw new Error("generatePassword: every character class was excluded.");
+  if (length < 1) throw new Error("generatePassword: length must be at least 1.");
+  if (requireEachClass && length < pools.length) {
+    throw new Error(`generatePassword: length ${length} cannot hold one character from each of the ${pools.length} classes requested.`);
+  }
+  const everything = pools.join("");
+  const required = requireEachClass ? pools.map(pick) : [];
+  const rest = Array.from({ length: length - required.length }, () => pick(everything));
+  return shuffle([...required, ...rest]).join("");
+}
+var COMMON = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "123456",
+  "12345678",
+  "123456789",
+  "1234567890",
+  "qwerty",
+  "qwertyuiop",
+  "abc123",
+  "111111",
+  "123123",
+  "admin",
+  "letmein",
+  "welcome",
+  "monkey",
+  "dragon",
+  "sunshine",
+  "iloveyou",
+  "princess",
+  "football",
+  "baseball",
+  "master",
+  "shadow",
+  "superman",
+  "batman",
+  "trustno1",
+  "hello",
+  "freedom",
+  "whatever",
+  "starwars",
+  "changeme",
+  "secret",
+  "login",
+  "root",
+  "toor",
+  "test",
+  "guest",
+  "azerty",
+  "1q2w3e4r",
+  "zaq12wsx"
+]);
+var SEQUENCES = ["abcdefghijklmnopqrstuvwxyz", "0123456789", "qwertyuiop", "asdfghjkl", "zxcvbnm"];
+function poolSize(password) {
+  let size = 0;
+  if (/[a-z]/.test(password)) size += 26;
+  if (/[A-Z]/.test(password)) size += 26;
+  if (/\d/.test(password)) size += 10;
+  if (/[^\w\s]|_/.test(password)) size += SYMBOLS.length;
+  if (/\s/.test(password)) size += 1;
+  return size || 1;
+}
+function longestRun(password) {
+  let longest = 1, run = 1;
+  for (let index = 1; index < password.length; index++) {
+    run = password[index] === password[index - 1] ? run + 1 : 1;
+    longest = Math.max(longest, run);
+  }
+  return longest;
+}
+function longestSequence(password) {
+  const lower = password.toLowerCase();
+  let longest = 0;
+  for (const line of SEQUENCES) {
+    const reversed = [...line].reverse().join("");
+    for (const source of [line, reversed]) {
+      for (let start = 0; start < source.length; start++) {
+        for (let end = source.length; end > start + longest; end--) {
+          if (lower.includes(source.slice(start, end))) {
+            longest = Math.max(longest, end - start);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return longest;
+}
+function core(password) {
+  return password.toLowerCase().replace(/^[^a-z]+/, "").replace(/[^a-z]+$/, "").replace(/[0!@$]/g, (character) => ({ "0": "o", "!": "i", "@": "a", "$": "s" })[character] ?? character);
+}
+function estimatePasswordStrength(password, options = {}) {
+  if (!password) return { score: 0, bits: 0, warnings: [], empty: true };
+  const warnings = [];
+  let bits = password.length * Math.log2(poolSize(password));
+  const stripped = core(password);
+  if (COMMON.has(password.toLowerCase()) || COMMON.has(stripped)) {
+    bits = Math.min(bits, 8);
+    warnings.push("This is one of the most common passwords there is.");
+  }
+  for (const input of options.userInputs ?? []) {
+    const needle = input.trim().toLowerCase();
+    if (needle.length < 4 || !password.toLowerCase().includes(needle)) continue;
+    bits = Math.min(bits, 16);
+    warnings.push("It contains something you already typed on this form.");
+    break;
+  }
+  const run = longestRun(password);
+  if (run >= 3) {
+    bits -= (run - 2) * Math.log2(poolSize(password));
+    warnings.push("A character repeats several times in a row.");
+  }
+  const sequence = longestSequence(password);
+  if (sequence >= 4) {
+    bits -= sequence * Math.log2(poolSize(password)) * 0.75;
+    warnings.push("Part of it runs straight along the keyboard or the alphabet.");
+  }
+  if (password.length < 8) warnings.push("Short passwords fall to a brute force whatever they contain.");
+  bits = Math.max(0, Math.round(bits));
+  const score = bits < 28 ? 0 : bits < 40 ? 1 : bits < 60 ? 2 : bits < 80 ? 3 : 4;
+  return { score, bits, warnings, empty: false };
+}
+
+export { estimatePasswordStrength, generatePassword };

package/dist/chunk-HS3X3XCW.js

@@ -0,0 +1,43 @@
+import { forwardRef, Children, isValidElement, cloneElement } from 'react';
+
+// src/react/slot.tsx
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    }
+  };
+}
+function mergeSlotProps(slotProps, childProps) {
+  const merged = { ...slotProps, ...childProps };
+  for (const key of Object.keys(slotProps)) {
+    const slotValue = slotProps[key];
+    const childValue = childProps[key];
+    const isHandler = /^on[A-Z]/.test(key);
+    if (isHandler && typeof slotValue === "function" && typeof childValue === "function") {
+      merged[key] = (...args) => {
+        slotValue(...args);
+        return childValue(...args);
+      };
+    } else if (isHandler && typeof slotValue === "function" && childValue === void 0) {
+      merged[key] = slotValue;
+    } else if (key === "style") {
+      merged[key] = { ...slotValue, ...childValue };
+    } else if (key === "className") {
+      merged[key] = [slotValue, childValue].filter(Boolean).join(" ");
+    }
+  }
+  return merged;
+}
+var Slot = forwardRef(function Slot2({ children, ...slotProps }, forwardedRef) {
+  const child = Children.only(children);
+  if (!isValidElement(child)) return null;
+  const childProps = child.props;
+  const childRef = child.ref;
+  const merged = mergeSlotProps(slotProps, childProps);
+  if (forwardedRef || childRef) merged.ref = composeRefs(forwardedRef, childRef ?? null);
+  return cloneElement(child, merged);
+});
+
+export { Slot, mergeSlotProps };