@enigmax/primitives 0.16.0 → 0.18.0

package/dist/index.d.ts

@@ -1,153 +1,20 @@
+export { M as MarqueeHover, a as MarqueeInstance, b as MarqueeOptions, c as createMarquee } from './marquee-CJ3Uwy3E.js';
+export { I as InputAction, a as InputActionState, b as InputIcon, c as InputInstance, d as InputOptions, e as createInput } from './input-BwXjFenq.js';
 export { F as FuseConstructor, a as FuseLike, S as SearchInstance, b as SearchMatch, c as SearchOptions, d as createSearch } from './search-CsO3L1Lw.js';
+export { B as ButtonCooldown, a as ButtonElement, b as ButtonInstance, c as ButtonOptions, d as ButtonState, e as createButton } from './button-CaXaqG_K.js';
+export { E as EstimateOptions, G as GeneratePasswordOptions, P as PasswordAlphabet, a as PasswordScore, b as PasswordStrengthReport, e as estimatePasswordStrength, g as generatePassword } from './password-C8lG4Zm9.js';
+export { N as Notification, a as NotificationAction, b as NotificationInput, c as NotificationTone, d as Notifications, e as NotificationsOptions, P as PromiseMessages, f as createNotifications } from './notifications-BpVV6sel.js';
+export { N as NetworkMonitor, a as NetworkState, S as SERVER_NETWORK_STATE, c as createNetworkMonitor } from './network-D2LsBG_k.js';
+export { R as RelativeTimeFormat, a as RelativeTimeOptions, b as RelativeTimePrecision, c as RelativeTimeStyle, d as RelativeTimeTense, e as RelativeTimeView, f as ensureZone, n as normalizeDate, p as parseDuration, r as relativeTimeAttributes, g as relativeTimeView } from './relative-time-YpRTG7YH.js';
+export { F as FLAG_CDN, a as FLAG_RATIO, b as FlagConfig, c as FlagFormat, d as FlagOptions, e as FlagShape, f as FlagSource, g as FlagView, h as configureFlags, i as flagAttributes, j as flagConfig, k as flagName, l as flagSrc, m as flagView, n as normalizeFlagCode, r as resetFlagConfig } from './flags-BBJc9unY.js';
 
 /**
- * Draggable infinite marquee: the behaviour engine, with no styling of its own.
+ * The icon shapes both renderers draw.
  *
- * The contract is a SPEED in pixels per second, never a duration. A lap of a
- * looping row is as long as its content, so a duration makes the row run faster
- * every time an item is added to it. See the package README.
- *
- * Every rule encoded here was measured in a browser, not reasoned about. The
- * comments marked "non-negotiable" name the bug that the obvious implementation
- * shipped with.
- */
-/**
- * What a MOUSE resting on the row does to its speed. One option covers every case, so
- * there is no pile of booleans to reconcile:
- *
- * - `"off"`   ignore hover entirely (the default)
- * - `"pause"` stop while the pointer is on it
- * - a number  multiply the cruise speed: `0.15` crawls, `1` changes nothing, `2` doubles
- * - `{ speed }` an ABSOLUTE speed in px/s, whatever the cruise is; direction still
- *   follows `reverse`, so you give a magnitude and not a sign
- *
- * Touch never triggers any of it - see the pointerType note on the hover handler.
- */
-type MarqueeHover = number | "off" | "pause" | {
-    speed: number;
-};
-interface MarqueeOptions {
-    /**
-     * Pixels per second. NOT a duration: a duration ties the speed to the item
-     * count and the row silently accelerates as content grows.
-     */
-    speed?: number;
-    /** Scroll towards the start instead of the end. */
-    reverse?: boolean;
-    /** Scroll on the Y axis instead of the X axis. */
-    vertical?: boolean;
-    /** Allow grabbing and throwing the row. */
-    draggable?: boolean;
-    /** What a mouse resting on the row does to its speed. See {@link MarqueeHover}. */
-    hover?: MarqueeHover;
-    /** Fraction of the remaining velocity gap left after one second. */
-    decay?: number;
-    /**
-     * Apply the styles the behaviour needs (overflow, touch-action, user-select,
-     * will-change, transform). Never theme styles. Turn off to own them yourself.
-     */
-    manageStyles?: boolean;
-    /**
-     * How the repeated copies get into the DOM.
-     * - "clone": the engine clones the first child of the track (vanilla, Astro).
-     * - "external": the consumer renders them and is told the count (React, Vue).
-     */
-    copies?: "clone" | "external";
-    /** Called when the required copy count changes. Required for "external". */
-    onCopyCountChange?: (count: number) => void;
-    /** Called on a click that was not the end of a drag. */
-    onItemClick?: (event: MouseEvent) => void;
-    /** Called whenever the measured lap period changes. */
-    onMeasure?: (period: number, copyCount: number) => void;
-}
-interface MarqueeInstance {
-    /** Current offset in px, normalized to [0, period). */
-    readonly offset: number;
-    /** Measured distance between two copies of the content, in px. */
-    readonly period: number;
-    /** Copies currently required to cover the lane plus one whole period. */
-    readonly copyCount: number;
-    /** True between pointerdown and pointerup while the row is being grabbed. */
-    readonly dragging: boolean;
-    /** True while the OS asks for reduced motion. Autoplay stops, drag does not. */
-    readonly reducedMotion: boolean;
-    update(options: Partial<MarqueeOptions>): void;
-    /** Re-read the lap from the DOM. Called for you on resize and on font load. */
-    measure(): void;
-    pause(): void;
-    resume(): void;
-    destroy(): void;
-}
-declare function createMarquee(lane: HTMLElement, track: HTMLElement, options?: MarqueeOptions): MarqueeInstance;
-
-/**
- * Input affordances: the buttons that live inside a field, with no styling of their own.
- *
- * A password field gets its reveal toggle automatically, because a field the visitor
- * cannot read back is the single most common cause of a failed sign-in. Everything about
- * it is replaceable - the icon, the label, the position, the container, whether it exists
- * at all - and the same mechanism takes any other action you want in there.
- *
- * The details below are the ones the hand-rolled version gets wrong; each is commented
- * with the failure it prevents.
+ * Their own module because the React field imports NOTHING else from the vanilla adapter:
+ * pulling `createInput` in for two arrays of path data put the whole imperative renderer
+ * into every React bundle, for a component that never calls it.
  */
-/** What an action renders. A string is parsed as HTML, so an inline SVG works. */
-type InputIcon = string | Node;
-interface InputActionState {
-    /** The field the action belongs to. */
-    input: HTMLInputElement;
-    /** True while the password is readable. Always false for a non-password field. */
-    revealed: boolean;
-    /** The field cannot be acted on: disabled or read-only. */
-    locked: boolean;
-}
-interface InputAction {
-    /** Stable id. Used for `data-action` and to replace a built-in (e.g. "reveal"). */
-    name: string;
-    /** Accessible name. Becomes both `aria-label` and `title`. */
-    label: string | ((state: InputActionState) => string);
-    icon: InputIcon | ((state: InputActionState) => InputIcon);
-    /** Runs on click and on Enter/Space, because it is a real button. */
-    onSelect: (state: InputActionState) => void;
-    /** Renders `aria-pressed`. Omit for actions that are not a toggle. */
-    pressed?: (state: InputActionState) => boolean;
-    /** Hide the action without removing it, e.g. a clear button on an empty field. */
-    visible?: (state: InputActionState) => boolean;
-}
-interface InputOptions {
-    /**
-     * The password reveal. `false` removes it. An object overrides parts of it - the
-     * icons, the labels - without giving up the caret and focus handling.
-     */
-    reveal?: boolean | {
-        /** Shown while the password is hidden; selecting it reveals. */
-        showIcon?: InputIcon;
-        /** Shown while the password is readable. */
-        hideIcon?: InputIcon;
-        showLabel?: string;
-        hideLabel?: string;
-    };
-    /** Extra actions, or a replacement for a built-in when `name` matches. */
-    actions?: InputAction[];
-    /** Which side the actions mount on. Position them yourself with CSS. */
-    position?: "start" | "end";
-    /**
-     * Mount the actions here instead of in a container created next to the input.
-     * Use it when your markup already has a slot for them.
-     */
-    container?: HTMLElement;
-    /** Called whenever the password's visibility changes. */
-    onRevealChange?: (revealed: boolean) => void;
-}
-interface InputInstance {
-    readonly revealed: boolean;
-    /** Show or hide the password. Toggles when the argument is omitted. */
-    reveal(next?: boolean): void;
-    /** Re-read the field and re-render the actions. Call after changing it yourself. */
-    refresh(): void;
-    update(options: Partial<InputOptions>): void;
-    destroy(): void;
-}
 /**
  * The built-in glyphs, as path data.
  *
@@ -160,358 +27,11 @@ declare const INPUT_ICON_PATHS: {
     readonly eye: readonly ["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"];
     readonly eyeOff: readonly ["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"];
     readonly generate: readonly ["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. */
+    readonly clear: readonly ["m6 6 12 12", "m18 6-12 12"];
+    readonly search: readonly ["M11 4a7 7 0 1 0 0 14 7 7 0 0 0 0-14Z", "m20 20-4.2-4.2"];
 };
 /** The same shapes as a standalone SVG string, for the DOM renderer below. */
 declare function iconMarkup(paths: readonly string[]): string;
-/**
- * Wire a field's in-field actions.
- *
- * @param input The field itself. A `type="password"` field gets the reveal for free.
- */
-declare function createInput(input: HTMLInputElement, options?: InputOptions): InputInstance;
-
-/**
- * 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;
-
-/**
- * Making a password, and judging one.
- *
- * Both are opt-in. A sign-in form wants neither: offering to generate a password where one
- * already exists is noise, and scoring one the visitor cannot change is worse. They belong
- * on a registration form and a change-password form, which is where an agent should switch
- * them on.
- */
-/** Character classes a generated password can draw from. */
-interface PasswordAlphabet {
-    lowercase?: boolean;
-    uppercase?: boolean;
-    digits?: boolean;
-    symbols?: boolean;
-}
-interface GeneratePasswordOptions extends PasswordAlphabet {
-    /** Default 20. Long beats clever: length is the only term that scales. */
-    length?: number;
-    /**
-     * Drop the characters that are read wrong off a screen or off paper - I l 1 O 0.
-     * Worth it when the password will be typed by hand, not worth the entropy otherwise.
-     */
-    excludeAmbiguous?: boolean;
-    /** Characters to remove from every class, e.g. ones your backend rejects. */
-    exclude?: string;
-    /**
-     * Guarantee at least one character from every class asked for. Most password policies
-     * demand it; it costs a little entropy, because it removes every password that happens
-     * to lack one.
-     */
-    requireEachClass?: boolean;
-}
-/**
- * A random password from the classes asked for.
- *
- * @throws when the runtime has no CSPRNG, or when the options ask for something impossible
- *         (every class excluded, or a length too short to hold one of each).
- */
-declare function generatePassword(options?: GeneratePasswordOptions): string;
-type PasswordScore = 0 | 1 | 2 | 3 | 4;
-interface PasswordStrengthReport {
-    /** 0 worst, 4 best. What the bars under the field render. */
-    score: PasswordScore;
-    /** Estimated bits of entropy after the penalties below. */
-    bits: number;
-    /**
-     * Why it scored what it scored, worst first. Show the first one; showing all of them
-     * turns a hint into a lecture.
-     */
-    warnings: string[];
-    /** Empty field. Render nothing rather than a zero score, which reads as a failure. */
-    empty: boolean;
-}
-interface EstimateOptions {
-    /**
-     * Values the visitor has already typed elsewhere - email, name, company. A password
-     * containing one of them is guessable by anyone who has the sign-up form in front of
-     * them, and no character-class rule catches it.
-     */
-    userInputs?: string[];
-}
-/**
- * Score a password.
- *
- * The bits are an estimate and the bands are a convention, not a measurement - they exist
- * to move a bar, not to certify anything. Swap this out for zxcvbn where the number has to
- * mean something, and check the breach corpus for the cases no estimator can see.
- */
-declare function estimatePasswordStrength(password: string, options?: EstimateOptions): PasswordStrengthReport;
-
-/**
- * Notification queue: ordering, timers, dedupe and pause. No rendering, no styles.
- *
- * The timer is the part that is always wrong when hand-rolled. A dismiss timer
- * that keeps counting while the tab is hidden fires the moment the visitor comes
- * back and they never see the message, so the remaining time is held, not run.
- */
-type NotificationTone = "info" | "success" | "warning" | "error" | "loading";
-/** One button on a notification. Anything more belongs on the page, not in a toast. */
-interface NotificationAction {
-    label: string;
-    onSelect: () => void;
-    /** Dismiss once it has been pressed. On by default. */
-    dismiss?: boolean;
-}
-interface NotificationInput {
-    /** Reuses the slot of a live notification with the same key instead of stacking. */
-    key?: string;
-    title: string;
-    body?: string;
-    tone?: NotificationTone;
-    /** ms before it dismisses itself. 0 or Infinity keeps it until dismissed. */
-    duration?: number;
-    action?: NotificationAction;
-    /** Arbitrary payload for the renderer: an href, an icon name. */
-    data?: unknown;
-}
-interface Notification extends Required<Omit<NotificationInput, "body" | "data" | "key" | "action">> {
-    id: string;
-    key?: string;
-    body?: string;
-    action?: NotificationAction;
-    data?: unknown;
-    createdAt: number;
-}
-/** What `promise()` shows at each stage. A function receives the resolved value or the error. */
-interface PromiseMessages<T> {
-    loading: string | NotificationInput;
-    success: string | ((value: T) => string | NotificationInput);
-    error: string | ((error: unknown) => string | NotificationInput);
-}
-interface NotificationsOptions {
-    /** Live notifications kept at once. The oldest dismissable one makes room. */
-    max?: number;
-    /** Default ms before self-dismissal. */
-    duration?: number;
-    /** Errors default to staying until dismissed. */
-    stickyTones?: NotificationTone[];
-}
-interface Notifications {
-    readonly items: readonly Notification[];
-    notify(input: NotificationInput): string;
-    /** Change a live notification in place, keeping its slot and restarting its timer. */
-    update(id: string, patch: Partial<NotificationInput>): void;
-    /**
-     * One notification that follows an async operation from loading to its outcome, in the
-     * same slot. The alternative is three toasts stacking up for one action.
-     */
-    promise<T>(work: Promise<T>, messages: PromiseMessages<T>): Promise<T>;
-    dismiss(id: string): void;
-    dismissAll(): void;
-    /** Hold every timer, e.g. while a pointer rests on the stack. */
-    pause(): void;
-    resume(): void;
-    subscribe(listener: (items: readonly Notification[]) => void): () => void;
-    destroy(): void;
-}
-declare function createNotifications(options?: NotificationsOptions): Notifications;
-
-/**
- * Connection state: online/offline plus whatever the Network Information API will say.
- *
- * The part worth not rewriting is the TRANSITION. "You are back online" needs to know the
- * connection had dropped, and every implementation of that ends up as a stray `wasOffline`
- * boolean next to the effect, re-derived per screen and wrong the first time the page
- * loads offline. It is tracked here instead.
- */
-interface NetworkState {
-    online: boolean;
-    /** Estimated downlink in Mbps. Null where the browser does not report it. */
-    downlink: number | null;
-    downlinkMax: number | null;
-    /** "slow-2g" | "2g" | "3g" | "4g", or null. */
-    effectiveType: string | null;
-    /** Estimated round-trip time in ms. */
-    rtt: number | null;
-    /** The visitor asked for reduced data use. */
-    saveData: boolean | null;
-    /** "wifi" | "cellular" | "ethernet" | ..., or null. */
-    type: string | null;
-    /**
-     * The connection dropped earlier and is back. False on a first load, so a page that
-     * opens online never announces a recovery that did not happen.
-     */
-    recovered: boolean;
-    /** On a connection worth degrading for: 2g or slower, or data saver on. */
-    slow: boolean;
-}
-interface NetworkMonitor {
-    readonly state: NetworkState;
-    subscribe(listener: (state: NetworkState) => void): () => void;
-    destroy(): void;
-}
-/** What a server render sees. Assuming offline would flash a warning on every page. */
-declare const SERVER_NETWORK_STATE: NetworkState;
-declare function createNetworkMonitor(): NetworkMonitor;
-
-/**
- * Relative time: "3 hours ago", and everything that has to be right around it.
- *
- * The rendering itself is `<relative-time>` (@github/relative-time-element), which already
- * owns the hard parts - Intl.RelativeTimeFormat per locale, and re-rendering on a schedule
- * that gets slower as the date gets older. What is here is the part every wrapper
- * re-implements and usually gets wrong: parsing a timestamp that does not declare its zone,
- * knowing when the date has aged past the relative threshold, and producing an absolute
- * label to show while the element is still loading, or forever if scripting is off.
- *
- * Nothing in this file touches the DOM, so it renders on a server.
- */
-/** How the element should phrase it. `auto` is relative until the threshold, then a date. */
-type RelativeTimeFormat = "auto" | "relative" | "duration" | "datetime" | "micro" | "elapsed";
-type RelativeTimeTense = "auto" | "past" | "future";
-type RelativeTimePrecision = "year" | "month" | "day" | "hour" | "minute" | "second";
-type RelativeTimeStyle = "long" | "short" | "narrow";
-type NumericStyle = "numeric" | "2-digit";
-interface RelativeTimeOptions {
-    format?: RelativeTimeFormat;
-    tense?: RelativeTimeTense;
-    precision?: RelativeTimePrecision;
-    /** ISO 8601 duration. Past this age `auto` stops being relative. Default `P30D`. */
-    threshold?: string;
-    /** Word before an absolute date, e.g. "on 5 May". Empty string removes it. */
-    prefix?: string;
-    formatStyle?: RelativeTimeStyle;
-    /**
-     * BCP 47 tag. Left undefined the element reads the closest `lang` in the document,
-     * which is what a translated page wants - hardcoding one is how a Spanish page ends
-     * up saying "3 hours ago".
-     */
-    locale?: string;
-    /** IANA zone for the absolute rendering. Undefined means the reader's own. */
-    timeZone?: string;
-    second?: NumericStyle;
-    minute?: NumericStyle;
-    hour?: NumericStyle;
-    weekday?: RelativeTimeStyle;
-    day?: NumericStyle;
-    month?: NumericStyle | "short" | "long" | "narrow";
-    year?: NumericStyle;
-    timeZoneName?: "long" | "short" | "shortOffset" | "longOffset" | "shortGeneric" | "longGeneric";
-    /** Drop the exact timestamp the element otherwise puts in `title`. */
-    noTitle?: boolean;
-    /**
-     * Once the date is older than `threshold`, render it as digits (05/05/2026) instead of
-     * a prefixed month name. The cutoff is the threshold itself, not a guess at it.
-     */
-    numericBeyondThreshold?: boolean;
-}
-/** Everything derived from a date, in one pass, for whichever adapter is rendering it. */
-interface RelativeTimeView {
-    /** Null when the input could not be parsed - nothing else here is meaningful then. */
-    date: Date | null;
-    /** `datetime` attribute value: always UTC, always ISO. */
-    iso: string;
-    /** Absolute text. Shown until the element upgrades, and forever without scripting. */
-    label: string;
-    /** Full timestamp for `title` / `aria-label`. */
-    exact: string;
-    /** The date is older (or further ahead) than `threshold`. */
-    beyondThreshold: boolean;
-    /** Render `label` in a plain `<time>` and skip the element entirely. */
-    absoluteOnly: boolean;
-}
-/**
- * A timestamp with no zone is UTC.
- *
- * This is the single most common defect in a date column: `2026-08-13 22:41:00` comes back
- * from the database with no offset, `new Date()` reads it as LOCAL time, and every reader
- * east or west of the server sees a time that is hours out - silently, because the wrong
- * time is still a valid one.
- *
- * A date with no clock is left exactly as it is. The spec already reads a bare `YYYY-MM-DD`
- * as UTC, so there is nothing to add - and `YYYY-MM-DDZ` is not in the spec's grammar at
- * all, which drops it into each engine's own legacy parser. That is a portability coin
- * flip on a value that was already correct.
- */
-declare function ensureZone(text: string): string;
-/** Parse anything a date column or an API hands over. Null rather than an Invalid Date. */
-declare function normalizeDate(value: string | number | Date | null | undefined): Date | null;
-/**
- * ISO 8601 duration to milliseconds, for comparing an age against `threshold`.
- *
- * Years and months are approximated the way the element approximates them, because the
- * threshold is a rough "old enough to stop counting", not an anniversary.
- */
-declare function parseDuration(value: string): number;
-/**
- * Everything an adapter needs to render one date.
- *
- * `now` is a parameter so a test can pin it, and so a server render can pass the same
- * instant it used elsewhere on the page.
- */
-declare function relativeTimeView(value: string | number | Date | null | undefined, options?: RelativeTimeOptions, now?: Date): RelativeTimeView;
-/**
- * The element's attributes, kebab-cased, with anything undefined left out.
- *
- * Written as attributes rather than properties because that is the half of a custom
- * element's API that works before it is defined - the markup is already correct when the
- * definition arrives late, or never.
- */
-declare function relativeTimeAttributes(view: RelativeTimeView, options?: RelativeTimeOptions): Record<string, string>;
 
-export { type ButtonCooldown, type ButtonElement, type ButtonInstance, type ButtonOptions, type ButtonState, type EstimateOptions, type GeneratePasswordOptions, INPUT_ICON_PATHS, type InputAction, type InputActionState, type InputIcon, type InputInstance, type InputOptions, type MarqueeHover, type MarqueeInstance, type MarqueeOptions, type NetworkMonitor, type NetworkState, type Notification, type NotificationAction, type NotificationInput, type NotificationTone, type Notifications, type NotificationsOptions, type PasswordAlphabet, type PasswordScore, type PasswordStrengthReport, type PromiseMessages, type RelativeTimeFormat, type RelativeTimeOptions, type RelativeTimePrecision, type RelativeTimeStyle, type RelativeTimeTense, type RelativeTimeView, SERVER_NETWORK_STATE, createButton, createInput, createMarquee, createNetworkMonitor, createNotifications, ensureZone, estimatePasswordStrength, generatePassword, iconMarkup, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView };
+export { INPUT_ICON_PATHS, iconMarkup };

package/dist/index.js

@@ -1,2 +1,10 @@
-export { INPUT_ICON_PATHS, SERVER_NETWORK_STATE, createButton, createInput, createMarquee, createNetworkMonitor, createNotifications, ensureZone, estimatePasswordStrength, generatePassword, iconMarkup, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView } from './chunk-53DQY6LP.js';
+export { createInput } from './chunk-KJINGUQN.js';
+export { estimatePasswordStrength, generatePassword } from './chunk-HC2ME5PU.js';
+export { FLAG_CDN, FLAG_RATIO, configureFlags, flagAttributes, flagConfig, flagName, flagSrc, flagView, normalizeFlagCode, resetFlagConfig } from './chunk-AU3H5WIY.js';
+export { createMarquee } from './chunk-UOSSNUSC.js';
+export { SERVER_NETWORK_STATE, createNetworkMonitor } from './chunk-2QFTRNAZ.js';
+export { createNotifications } from './chunk-SNYUBXWQ.js';
+export { ensureZone, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView } from './chunk-IXVMRVD4.js';
+export { INPUT_ICON_PATHS, iconMarkup } from './chunk-F25CGNQC.js';
 export { createSearch } from './chunk-UZFEEFMF.js';
+export { createButton } from './chunk-MMQPZGSU.js';

package/dist/input-BwXjFenq.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Input affordances: the buttons that live inside a field, with no styling of their own.
+ *
+ * A password field gets its reveal toggle automatically, because a field the visitor
+ * cannot read back is the single most common cause of a failed sign-in. Everything about
+ * it is replaceable - the icon, the label, the position, the container, whether it exists
+ * at all - and the same mechanism takes any other action you want in there.
+ *
+ * The details below are the ones the hand-rolled version gets wrong; each is commented
+ * with the failure it prevents.
+ */
+/** What an action renders. A string is parsed as HTML, so an inline SVG works. */
+type InputIcon = string | Node;
+interface InputActionState {
+    /** The field the action belongs to. */
+    input: HTMLInputElement;
+    /** True while the password is readable. Always false for a non-password field. */
+    revealed: boolean;
+    /** The field cannot be acted on: disabled or read-only. */
+    locked: boolean;
+}
+interface InputAction {
+    /** Stable id. Used for `data-action` and to replace a built-in (e.g. "reveal"). */
+    name: string;
+    /** Accessible name. Becomes both `aria-label` and `title`. */
+    label: string | ((state: InputActionState) => string);
+    icon: InputIcon | ((state: InputActionState) => InputIcon);
+    /** Runs on click and on Enter/Space, because it is a real button. */
+    onSelect: (state: InputActionState) => void;
+    /** Renders `aria-pressed`. Omit for actions that are not a toggle. */
+    pressed?: (state: InputActionState) => boolean;
+    /** Hide the action without removing it, e.g. a clear button on an empty field. */
+    visible?: (state: InputActionState) => boolean;
+}
+interface InputOptions {
+    /**
+     * The password reveal. `false` removes it. An object overrides parts of it - the
+     * icons, the labels - without giving up the caret and focus handling.
+     */
+    reveal?: boolean | {
+        /** Shown while the password is hidden; selecting it reveals. */
+        showIcon?: InputIcon;
+        /** Shown while the password is readable. */
+        hideIcon?: InputIcon;
+        showLabel?: string;
+        hideLabel?: string;
+    };
+    /** Extra actions, or a replacement for a built-in when `name` matches. */
+    actions?: InputAction[];
+    /** Which side the actions mount on. Position them yourself with CSS. */
+    position?: "start" | "end";
+    /**
+     * Mount the actions here instead of in a container created next to the input.
+     * Use it when your markup already has a slot for them.
+     */
+    container?: HTMLElement;
+    /** Called whenever the password's visibility changes. */
+    onRevealChange?: (revealed: boolean) => void;
+}
+interface InputInstance {
+    readonly revealed: boolean;
+    /** Show or hide the password. Toggles when the argument is omitted. */
+    reveal(next?: boolean): void;
+    /** Re-read the field and re-render the actions. Call after changing it yourself. */
+    refresh(): void;
+    update(options: Partial<InputOptions>): void;
+    destroy(): void;
+}
+
+/**
+ * Wire a field's in-field actions.
+ *
+ * @param input The field itself. A `type="password"` field gets the reveal for free.
+ */
+declare function createInput(input: HTMLInputElement, options?: InputOptions): InputInstance;
+
+export { type InputAction as I, type InputActionState as a, type InputIcon as b, type InputInstance as c, type InputOptions as d, createInput as e };