@allxsmith/bestax-bulma 5.63.0 → 5.65.0

package/dist/index.esm.js

@@ -29,12 +29,14 @@ export { Sidebar } from './esm/components/Sidebar.js';
 export { Toast, ToastContainer, toast } from './esm/components/Toast.js';
 export { Dialog, DialogContainer, dialog } from './esm/components/Dialog.js';
 export { Carousel, CarouselItem } from './esm/components/Carousel.js';
+export { Lightbox, LightboxTrigger } from './esm/components/Lightbox.js';
 export { Reveal } from './esm/components/Reveal.js';
 export { TreeView, TreeViewItem } from './esm/components/TreeView.js';
 export { ScrollArea } from './esm/components/ScrollArea.js';
 export { Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from './esm/components/Command.js';
 export { DataTable } from './esm/components/DataTable.js';
 export { Affix } from './esm/components/Affix.js';
+export { TableOfContents } from './esm/components/TableOfContents.js';
 export { Block } from './esm/elements/Block.js';
 export { Box } from './esm/elements/Box.js';
 export { Button } from './esm/elements/Button.js';
@@ -106,9 +108,11 @@ export { ColorPicker, ColorPickerAlphaSlider, ColorPickerArea, ColorPickerHueSli
 export { InputBase } from './esm/form/InputBase.js';
 export { SelectBase } from './esm/form/SelectBase.js';
 export { TextAreaBase } from './esm/form/TextAreaBase.js';
+export { PasswordInputBase } from './esm/form/PasswordInputBase.js';
 export { Input } from './esm/form/Input.js';
 export { Select } from './esm/form/Select.js';
 export { TextArea } from './esm/form/TextArea.js';
+export { PasswordInput } from './esm/form/PasswordInput.js';
 export { DateInputBase } from './esm/form/DateInputBase.js';
 export { DateInput } from './esm/form/DateInput.js';
 export { TimeInputBase } from './esm/form/TimeInputBase.js';
@@ -150,6 +154,7 @@ export { useColorClasses, useColorStyles } from './esm/helpers/useColorClasses.j
 export { useDataTable } from './esm/components/useDataTable.js';
 export { useFlexboxClasses } from './esm/helpers/useFlexboxClasses.js';
 export { useOtherClasses } from './esm/helpers/useOtherClasses.js';
+export { useScrollSpy } from './esm/helpers/useScrollSpy.js';
 export { useSpacingClasses } from './esm/helpers/useSpacingClasses.js';
 export { useTypographyClasses } from './esm/helpers/useTypographyClasses.js';
 export { useVisibilityClasses } from './esm/helpers/useVisibilityClasses.js';

package/dist/index.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/components/Lightbox.d.ts

@@ -0,0 +1,244 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses.js';
+import { type PolymorphicRef } from '../helpers/polymorphic.js';
+/** One image a Lightbox shows. */
+export interface LightboxItem {
+    /** The full-size image's URL. */
+    src: string;
+    /**
+     * The image's text alternative, which the status line reads after each
+     * move. In a viewer the image is the content, so `''` is almost never
+     * right; a development build warns once for an item without one.
+     */
+    alt: string;
+    /** Shown under the image as its `<figcaption>`. */
+    caption?: React.ReactNode;
+    /** The `<img>`'s `srcSet`, so the browser picks a size for the screen. Preloading uses it too. */
+    srcSet?: string;
+    /** The `<img>`'s `sizes`, read with `srcSet`. */
+    sizes?: string;
+}
+/**
+ * The words a Lightbox writes. Each is English unless you give your own,
+ * and the numbers in the default progress line are written in the
+ * `LocaleProvider`'s locale.
+ */
+export interface LightboxLabels {
+    /**
+     * The close button's name.
+     * @defaultValue 'Close'
+     */
+    close?: string;
+    /**
+     * The previous button's name.
+     * @defaultValue 'Previous image'
+     */
+    previous?: string;
+    /**
+     * The next button's name.
+     * @defaultValue 'Next image'
+     */
+    next?: string;
+    /**
+     * The zoom-in button's name.
+     * @defaultValue 'Zoom in'
+     */
+    zoomIn?: string;
+    /**
+     * The zoom-out button's name.
+     * @defaultValue 'Zoom out'
+     */
+    zoomOut?: string;
+    /**
+     * The button that fits the image again.
+     * @defaultValue 'Reset zoom'
+     */
+    resetZoom?: string;
+    /**
+     * The `Loader`'s name while an image loads.
+     * @defaultValue 'Loading image'
+     */
+    loading?: string;
+    /**
+     * Shown, above the alt text, when an image fails to load. The status line
+     * for a failed image starts with it, then a space and the line a loaded
+     * image gets, so write it as a whole sentence, punctuated as your language
+     * does.
+     * @defaultValue "This image didn't load."
+     */
+    loadError?: string;
+    /**
+     * The button that tries a failed image again.
+     * @defaultValue 'Retry'
+     */
+    retry?: string;
+    /**
+     * The start of the status line read after each move, which goes on with
+     * a colon and the image's alt: "Image 3 of 10: Harbour at dusk". For a
+     * failed image, `loadError` and a space come first. It gets the image's
+     * place counting from 1, and the number of images.
+     * @defaultValue (current, total) => 'Image ' + current + ' of ' + total
+     */
+    progress?: (current: number, total: number) => string;
+}
+/**
+ * Props for the Lightbox component. Its children render where it stands,
+ * with no wrapper. The helper props, the other attributes and the `ref`
+ * land on the viewer's `.modal` element while it's open.
+ * @extraProp {React.Ref<HTMLDivElement>} [ref] - Ref forwarded to the viewer's `.modal` element, `null` while it's closed.
+ */
+export interface LightboxProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'color'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    /** **Required.** The images, in order. */
+    items: LightboxItem[];
+    /** Rendered in place: usually `Lightbox.Trigger`s, in whatever layout you like. */
+    children?: React.ReactNode;
+    /** Whether the viewer is open (controlled). With no `items` it shows nothing. */
+    open?: boolean;
+    /**
+     * Whether the viewer starts open (uncontrolled).
+     * @defaultValue false
+     */
+    defaultOpen?: boolean;
+    /**
+     * Called when a trigger, the close button, Escape, a click on the
+     * background or a swipe down opens or closes the viewer, and with `false`
+     * when `items` goes from some to none while it's open.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The index of the image shown (controlled). A value past either end is
+     * shown as the last or the first image, or wrapped round with `repeat`,
+     * without calling `onChange`.
+     */
+    value?: number;
+    /**
+     * The image an uncontrolled viewer shows when something other than a
+     * trigger opens it. A trigger opens at its own `index`.
+     * @defaultValue 0
+     */
+    defaultValue?: number;
+    /**
+     * Called with the new index when an arrow, a key or a swipe changes the
+     * image, and when a trigger opens the viewer, with the trigger's `index`
+     * even when that's the image already shown, before `onOpenChange(true)`.
+     * A parent that opens the viewer from `value` hears the trigger that way.
+     */
+    onChange?: (value: number) => void;
+    /**
+     * Go from the last image to the first and back, as Carousel does. Off,
+     * the previous and next buttons are `aria-disabled` at the ends.
+     * @defaultValue true
+     */
+    repeat?: boolean;
+    /**
+     * Zoom with the buttons, the wheel, a double click or tap, pinch and the
+     * `+`, `-` and `0` keys, and pan a zoomed image by dragging or with the
+     * arrow keys. Zoom waits for the image to load. `false` drops the zoom
+     * buttons and all of it.
+     * @defaultValue true
+     */
+    zoomable?: boolean;
+    /**
+     * How far an image zooms, as a multiple of its fitted size. The smallest
+     * zoom is always the fitted size.
+     * @defaultValue 3
+     */
+    maxZoom?: number;
+    /**
+     * Close on Escape. Only the topmost open overlay answers, as with Modal.
+     * @defaultValue true
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Close on a click on the dark background around the image. The space
+     * around the image, beside the toolbar's buttons and under the caption is
+     * all background.
+     * @defaultValue true
+     */
+    closeOnClickOutside?: boolean;
+    /**
+     * Renders the viewer into a portal: `true` for the `ConfigProvider`'s
+     * `portalContainer` (`document.body` by default), a selector string, or an
+     * element. `false` renders it in place. It's on by default, unlike Modal's,
+     * Dialog's and Command.Dialog's, because its triggers sit in gallery
+     * cells, and a cell with a transform or a filter would trap a viewer
+     * rendered in place.
+     * @defaultValue true
+     */
+    portal?: boolean | string | HTMLElement;
+    /**
+     * The dialog's accessible name. It stays the same from image to image;
+     * the status line says which image is shown.
+     * @defaultValue 'Image viewer'
+     */
+    ariaLabel?: string;
+    /** The words it writes, for another language. */
+    labels?: LightboxLabels;
+}
+/**
+ * The Lightbox.Trigger component's own props, on top of the attributes of
+ * whatever element `as` renders.
+ */
+export interface LightboxTriggerOwnProps extends Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    /** **Required.** The index in `items` the viewer opens at. */
+    index: number;
+    /**
+     * What the button shows: a thumbnail, or text such as "View all photos".
+     * A ratio `Image` here takes `as="div"`, since its `<figure>` would keep
+     * the image's alt from naming the button.
+     */
+    children?: React.ReactNode;
+    /** Additional CSS classes. */
+    className?: string;
+}
+/**
+ * Props for Lightbox.Trigger, a `<button type="button"
+ * aria-haspopup="dialog">` that opens the viewer. Its content names it, so
+ * give the thumbnail inside a real `alt`. A ratio `Image` renders a
+ * `<figure>`, and an image inside a figure doesn't name the button around
+ * it, so give that `Image` `as="div"`. A development build warns for a
+ * trigger outside a `Lightbox` or with no name.
+ * @extraProp {PolymorphicRef<React.ElementType>} [ref] - Ref forwarded to the element `as` renders: the `<button>`, or what `Button` renders.
+ */
+export type LightboxTriggerProps<T extends React.ElementType = 'button'> = LightboxTriggerOwnProps & Omit<React.ComponentPropsWithoutRef<T>, keyof LightboxTriggerOwnProps | 'as' | ElementColor<T>> & {
+    /**
+     * Renders the trigger through another component, which gets its class,
+     * `aria-haspopup`, `type="button"`, click handler and ref along with
+     * its own props. `as={Button} color="link"` draws it as Bulma's link
+     * button. `color` is taken only with a component: on an element it
+     * would be HTML's old presentational attribute.
+     */
+    as?: T;
+};
+/**
+ * `color`, for an element `as`: a `<button>` or another tag takes no
+ * `color`, as Link and Navbar.Item take none, while a component such as
+ * Button keeps its own.
+ */
+type ElementColor<T extends React.ElementType> = T extends string ? 'color' : never;
+/**
+ * Lightbox.Trigger's call signatures, those of `PolymorphicComponent` over
+ * `LightboxTriggerProps`, so `color` follows `as` as described there.
+ */
+interface LightboxTriggerComponent {
+    <T extends React.ElementType = 'button'>(props: LightboxTriggerProps<T> & {
+        ref?: PolymorphicRef<T>;
+    }): React.ReactElement | null;
+    (props: LightboxTriggerProps & {
+        ref?: PolymorphicRef<'button'>;
+    }): React.ReactElement | null;
+    displayName?: string;
+}
+/**
+ * A button around a thumbnail, or a line of text, that opens the viewer at its `index`.
+ *
+ * @function
+ * @param {LightboxTriggerProps} props - Props for the trigger.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
+ * @returns {JSX.Element} The rendered button.
+ */
+export declare const LightboxTrigger: LightboxTriggerComponent;
+export declare const Lightbox: React.ForwardRefExoticComponent<LightboxProps & React.RefAttributes<HTMLDivElement>> & {
+    Trigger: LightboxTriggerComponent;
+};
+export default Lightbox;

package/dist/types/components/TableOfContents.d.ts

@@ -0,0 +1,87 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses.js';
+export { useScrollSpy } from '../helpers/useScrollSpy.js';
+export type { UseScrollSpyOptions } from '../helpers/useScrollSpy.js';
+/** One entry in a TableOfContents. */
+export interface TableOfContentsItem {
+    /** **Required.** The `id` of the section or heading it links to, without the `#`. Unique on the page. */
+    id: string;
+    /** **Required.** What the link says, usually the heading's own text. */
+    label: React.ReactNode;
+    /** Entries under this one, drawn as a nested list. */
+    children?: TableOfContentsItem[];
+}
+/** The visible strings, in your app's language. */
+export interface TableOfContentsLabels {
+    /**
+     * The list's visible title, which also names its `<nav>`.
+     * @defaultValue 'On this page'
+     */
+    title?: string;
+}
+/**
+ * Props for the TableOfContents component. The helper props, the other
+ * attributes and the `ref` land on the `<nav>`.
+ *
+ * @extraProp {React.Ref<HTMLElement>} [ref] - Ref forwarded to the `<nav>`.
+ */
+export interface TableOfContentsProps extends Omit<React.HTMLAttributes<HTMLElement>, 'color' | 'children'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    /** Additional CSS classes to apply. */
+    className?: string;
+    /**
+     * **Required.** The sections, in page order, as links to their ids. Each
+     * link is a plain `<a href="#id">`, so following one is the browser's own
+     * jump: put `scroll-padding-top` on the page to land clear of a sticky
+     * header, and smooth scrolling, if you want it, in page CSS inside
+     * `@media (prefers-reduced-motion: no-preference)`.
+     */
+    items: TableOfContentsItem[];
+    /**
+     * Called with the current section's id when it changes, or `null` above
+     * the first section. Never called on the server or before hydration.
+     */
+    onCurrentChange?: (id: string | null) => void;
+    /**
+     * Pixels from the viewport's top where a section counts as reached.
+     * Unset, it's the page's `scroll-padding-top`, so the highlight agrees
+     * with where a jump lands under a sticky header.
+     */
+    offset?: number;
+    /**
+     * Sticks to the top of the viewport as the page scrolls, at
+     * `--bulma-table-of-contents-sticky-top`, and scrolls itself when it's
+     * taller than the viewport. Adds `is-sticky`.
+     */
+    isSticky?: boolean;
+    /** The visible strings, in your app's language. */
+    labels?: TableOfContentsLabels;
+    /** Text color helper. */
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    /** Background color helper. */
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+}
+/**
+ * The `TableOfContents` component lists a long page's sections as links in Bulma's menu look, and marks the one being read.
+ *
+ * It's a `<nav>` named by its title, holding `MenuList` and `MenuItem` links
+ * to each `#id`, rendered in full on the server. `useScrollSpy` picks the
+ * current section, and its link alone gets `is-active` and
+ * `aria-current="location"`. Use the hook on its own to mark the section in
+ * view somewhere else, such as an app's nav `Menu`.
+ *
+ * @function
+ * @param {TableOfContentsProps} props - Props for the TableOfContents component.
+ * @param {React.Ref<HTMLElement>} ref - Forwarded ref to the `<nav>`.
+ * @returns {JSX.Element} The rendered table of contents.
+ *
+ * @example
+ * <TableOfContents
+ *   isSticky
+ *   items={[
+ *     { id: 'install', label: 'Install' },
+ *     { id: 'usage', label: 'Usage', children: [{ id: 'props', label: 'Props' }] },
+ *   ]}
+ * />
+ */
+export declare const TableOfContents: React.ForwardRefExoticComponent<TableOfContentsProps & React.RefAttributes<HTMLElement>>;
+export default TableOfContents;

package/dist/types/form/PasswordInput.d.ts

@@ -0,0 +1,98 @@
+import React from 'react';
+import { FieldProps } from './Field.js';
+import { ControlBaseProps } from './Control.js';
+import { PasswordInputBaseProps } from './PasswordInputBase.js';
+/**
+ * Props for the PasswordInput component: PasswordInputBase's, plus Input's
+ * Field and Control props, except the right icon, whose place the toggle
+ * takes. Inside an existing `Control` it renders no `Control` of its own, so
+ * its Control-level props do nothing there and warn in development; set them
+ * on that `Control` instead. Inside an outer `Field`, or a `Control` with no
+ * `Field` around it, it renders no `Field` of its own either. The exception
+ * is `label`, `message`, `horizontal` or `fieldClassName` in that bare
+ * `Control`: it keeps a `Field` for them, nested in the `.control`, and warns
+ * in development. Wrap the `Control` in a `Field` instead, and set the
+ * `label`, `horizontal` and class name on that `Field`.
+ *
+ * @helperProps Helper props go on the `.password-input-container` `<div>`, with
+ * `className` and `style`, so they move and size the field and its toggle
+ * together. The other attributes go on the `<input>`.
+ * @extraProp {string} [autoComplete="current-password"] - Tells the browser and password managers this is an existing password. Pass `"new-password"` where the user makes one up, on a sign-up or change-password form.
+ * @extraProp {boolean} [spellCheck=false] - Off, so a browser's spellcheck never sees the password once it shows.
+ * @extraProp {string} [autoCorrect="off"] - Off, so a phone's keyboard doesn't change what's typed.
+ * @extraProp {string} [autoCapitalize="none"] - Off, so a phone's keyboard doesn't capitalize the first letter.
+ * @extraProp {string} [value] - The password, controlled. React writes a controlled input's value into its `value` attribute, as it does on any input, so the password sits in the page's markup. Uncontrolled, read with `FormData`, the field never puts what's typed there.
+ * @extraProp {React.Ref<HTMLInputElement>} [ref] - Ref forwarded to the `<input>`.
+ */
+export interface PasswordInputProps extends PasswordInputBaseProps {
+    /** Field label. Automatically associated with the input via `htmlFor`, using your `id` when provided, otherwise a generated one. Dropped inside an outer `Field`, whose own label associates instead when that `Field` generates a target id (not `grouped`/`hasAddons`, no explicit `labelProps.htmlFor`) and you set no `id` here. */
+    label?: React.ReactNode;
+    /** Size for the label. */
+    labelSize?: FieldProps['labelSize'];
+    /** Props for the label element when the component renders its own `Field`; dropped inside an outer `Field` (use that `Field`'s `labelProps` instead). An explicit `htmlFor` key, even `undefined`, overrides the automatic association and no id is generated. */
+    labelProps?: FieldProps['labelProps'];
+    /** Horizontal field layout. */
+    horizontal?: boolean;
+    /**
+     * Icon props for the left icon.
+     * Bulma gives control icons `pointer-events: none`, so a clickable node here
+     * never receives a click.
+     */
+    iconLeft?: ControlBaseProps['iconLeft'];
+    /** Shortcut for the left icon's name. */
+    iconLeftName?: string;
+    /** Shortcut for the left icon's size. */
+    iconLeftSize?: ControlBaseProps['iconLeftSize'];
+    /** Force the left icon container. */
+    hasIconsLeft?: boolean;
+    /**
+     * Shows a loading spinner on the `Control` it renders, at the edge the
+     * toggle uses, so the toggle isn't drawn meanwhile, and a shown password is
+     * hidden until it's back. Inside your own
+     * `Control` it renders none, so this draws nothing and warns in
+     * development; set `isLoading` on that `Control`, which hides the toggle
+     * too.
+     */
+    isLoading?: boolean;
+    /** Expand the control. */
+    isExpanded?: boolean;
+    /** Control size. */
+    controlSize?: ControlBaseProps['size'];
+    /** Help/validation message below the input. */
+    message?: React.ReactNode;
+    /** Bulma color for the message. */
+    messageColor?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    /** Additional CSS classes for the Field. */
+    fieldClassName?: string;
+    /** Additional CSS classes for the Control. */
+    controlClassName?: string;
+    /** Not offered: the toggle takes the right icon's place. Warns in development if passed. @internal */
+    iconRight?: never;
+    /** Not offered, as `iconRight`. @internal */
+    iconRightName?: never;
+    /** Not offered, as `iconRight`. @internal */
+    iconRightSize?: never;
+    /** Not offered, as `iconRight`. @internal */
+    hasIconsRight?: never;
+}
+/**
+ * The `PasswordInput` component is a password field with a button inside it that shows what was typed.
+ *
+ * By default the button is an eye named "Show password" that reports
+ * whether the password shows with `aria-pressed`; `variant="text"` makes it
+ * the words "Show" and "Hide". The field asks for
+ * `autocomplete="current-password"` and no spellcheck, and hides the
+ * password again when its form submits.
+ *
+ * @function
+ * @param {PasswordInputProps} props - Props for PasswordInput.
+ * @returns {JSX.Element} The composed field element.
+ *
+ * @example
+ * <PasswordInput label="Password" />
+ *
+ * @example
+ * <PasswordInput label="New password" autoComplete="new-password" variant="text" />
+ */
+export declare const PasswordInput: React.ForwardRefExoticComponent<PasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+export default PasswordInput;

package/dist/types/form/PasswordInputBase.d.ts

@@ -0,0 +1,91 @@
+import { InputBaseProps } from './InputBase.js';
+/** How PasswordInput's visibility toggle draws itself. */
+export type PasswordInputVariant = 'icon' | 'text';
+/** The strings PasswordInput's toggle shows and announces, for translating. */
+export interface PasswordInputLabels {
+    /**
+     * The toggle's name. With the `icon` variant it's the name in both states,
+     * and `aria-pressed` says whether the password shows. With `text`, it's the
+     * name while the password is hidden, and it has to contain `show`, the word
+     * on the button.
+     * @defaultValue 'Show password'
+     */
+    showPassword?: string;
+    /**
+     * The `text` variant's name while the password shows. It has to contain
+     * `hide`.
+     * @defaultValue 'Hide password'
+     */
+    hidePassword?: string;
+    /**
+     * The `text` variant's word while the password is hidden.
+     * @defaultValue 'Show'
+     */
+    show?: string;
+    /**
+     * The `text` variant's word while the password shows.
+     * @defaultValue 'Hide'
+     */
+    hide?: string;
+}
+/**
+ * Props for PasswordInputBase, the input and its toggle without a Field or a
+ * Control.
+ *
+ * @helperProps Helper props go on the `.password-input-container` `<div>`, with
+ * `className` and `style`, so they move and size the field and its toggle
+ * together. The other attributes go on the `<input>`.
+ * @extraProp {string} [autoComplete="current-password"] - Tells the browser and password managers this is an existing password. Pass `"new-password"` where the user makes one up, on a sign-up or change-password form.
+ * @extraProp {boolean} [spellCheck=false] - Off, so a browser's spellcheck never sees the password once it shows.
+ * @extraProp {string} [autoCorrect="off"] - Off, so a phone's keyboard doesn't change what's typed.
+ * @extraProp {string} [autoCapitalize="none"] - Off, so a phone's keyboard doesn't capitalize the first letter.
+ * @extraProp {string} [value] - The password, controlled. React writes a controlled input's value into its `value` attribute, as it does on any input, so the password sits in the page's markup. Uncontrolled, read with `FormData`, the field never puts what's typed there.
+ * @extraProp {React.Ref<HTMLInputElement>} [ref] - Ref forwarded to the `<input>`.
+ */
+export interface PasswordInputBaseProps extends Omit<InputBaseProps, 'type'> {
+    /**
+     * Whether the password shows, when you hold the state. Setting it makes
+     * the visibility controlled: the toggle only calls `onVisibleChange`, and
+     * so does hiding again on its own. Apply that `false` and the field is a
+     * password field by the time the form reads it; keep `visible` true and
+     * the field stays shown.
+     */
+    visible?: boolean;
+    /**
+     * Whether the password shows at first, when the input holds its own state.
+     * @defaultValue false
+     */
+    defaultVisible?: boolean;
+    /**
+     * Called with the new visibility on each toggle, and with `false` when the
+     * form submits or resets, or the page is left, which it also is on the way
+     * into the back-forward cache. React renders those hides at once, a state
+     * update you make here included, so the form reads a password field. One
+     * that fires while React is rendering or committing, which includes your
+     * `useEffect` and `useLayoutEffect` callbacks, such as a `requestSubmit()`
+     * from an effect, can't render there, and lands just after the form is
+     * read: hide the password first, or submit from an event handler.
+     */
+    onVisibleChange?: (visible: boolean) => void;
+    /**
+     * How the toggle draws itself: an eye icon with a fixed name and
+     * `aria-pressed`, or the words "Show" and "Hide" with a name that follows
+     * them.
+     * @defaultValue 'icon'
+     */
+    variant?: PasswordInputVariant;
+    /** Translations for the toggle. */
+    labels?: PasswordInputLabels;
+}
+/**
+ * The raw PasswordInput: a password field with a button inside it that shows what was typed, without Field/Control wrapping.
+ *
+ * Use `PasswordInput` for the convenience wrapper.
+ *
+ * @function
+ * @param {PasswordInputBaseProps} props - Props for PasswordInputBase.
+ * @param {React.Ref<HTMLInputElement>} ref - Forwarded ref to the `<input>`.
+ * @returns {JSX.Element} The input and its toggle, in a container.
+ */
+export declare const PasswordInputBase: import("react").ForwardRefExoticComponent<PasswordInputBaseProps & import("react").RefAttributes<HTMLInputElement>>;
+export default PasswordInputBase;

package/dist/types/helpers/chevronIcons.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Chevron pointing left, for a previous button.
+ *
+ * @function
+ * @returns {JSX.Element} The rendered SVG chevron-left icon.
+ */
+export declare const ChevronPrevIcon: () => import("react").JSX.Element;
+/**
+ * Chevron pointing right, for a next button.
+ *
+ * @function
+ * @returns {JSX.Element} The rendered SVG chevron-right icon.
+ */
+export declare const ChevronNextIcon: () => import("react").JSX.Element;

package/dist/types/helpers/usePrefersReducedMotion.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Detects the user's `prefers-reduced-motion` preference, for motion that
+ * runs in script, where a stylesheet's media query can't reach it. Always
+ * `false` on the server and on the very first client render, so SSR output
+ * and the initial hydration pass always agree.
+ *
+ * @function
+ * @returns {boolean} Whether the user has requested reduced motion.
+ */
+export declare function usePrefersReducedMotion(): boolean;

package/dist/types/helpers/useScrollSpy.d.ts

@@ -0,0 +1,61 @@
+/** Options for useScrollSpy. */
+export interface UseScrollSpyOptions {
+    /**
+     * **Required.** The ids of the sections to watch, without the `#`, in the
+     * order they come on the page. Each one is looked up each time the hook
+     * checks, so an id with no element on the page is skipped until one
+     * appears, and a section replaced under the same id keeps working.
+     */
+    ids: string[];
+    /**
+     * Pixels from the viewport's top where a section counts as reached. Unset,
+     * it's the page's `scroll-padding-top`, read when the hook mounts and on
+     * resize, so the highlight agrees with where a jump lands under a sticky
+     * header. A `scroll-padding-top` that mixes a percentage with a length in
+     * `calc()` isn't read: pass `offset` then.
+     */
+    offset?: number;
+    /** Called with the new current id when it changes, or `null` above the first section. */
+    onCurrentChange?: (id: string | null) => void;
+}
+/**
+ * The `useScrollSpy` hook returns the id of the section being read: the last
+ * of `ids` whose top is at or above the offset line, or the last one once the
+ * page is scrolled to its end. After a jump to one of them, it's that one
+ * until the reader scrolls on. `null` above the first section, on the server
+ * and until the page hydrates.
+ *
+ * It checks once per frame while the page scrolls, and on resize. A jump is
+ * a plain click on a link to one of the ids (the main button, no modifier
+ * key, opening in this page), noted and never stopped, so the browser jumps
+ * as it always does; and the `#id` a page opened afresh opens at. Back,
+ * Forward and a reload aren't jumps. That `#id` is read once, when `ids`
+ * first has some: a section rendered after that isn't held, even if the
+ * page opened at it, and the reading rule marks where the page is. Once the
+ * page has been still for a
+ * moment, the section stays current only if it's where a jump puts it: its
+ * top at the line, give or take a shift of the layout smaller than its own
+ * height, or, at the end of the page, on screen below the line. Otherwise,
+ * as after a flick right after the click, the reading rule takes over. The
+ * next scroll after that lets it go, the browser's own included, so when
+ * content loading above it makes the browser scroll to keep the reader's
+ * place, the rule takes over too.
+ *
+ * A section that isn't drawn (`display: none`) is never current. A section
+ * that moves while nothing scrolls is seen at the next scroll or resize. It
+ * watches the document only: not a panel that scrolls inside it, and not
+ * sections inside a shadow root, which an `#id` link can't reach either.
+ * Whether a page was opened afresh is read from how the document loaded, so
+ * in an app that changes routes on the client, a route change can briefly
+ * mark the address bar's section until the page settles, when the reading
+ * rule takes over, and after a reload a route change to an `#id` holds
+ * nothing.
+ *
+ * @function
+ * @param {UseScrollSpyOptions} options - The ids to watch, the offset, and a change callback.
+ * @returns {string | null} The current section's id, or `null`.
+ *
+ * @example
+ * const current = useScrollSpy({ ids: ['profile', 'security', 'billing'] });
+ */
+export declare function useScrollSpy({ ids, offset, onCurrentChange, }: UseScrollSpyOptions): string | null;