@isoline-ui/react-native 0.0.0-stage → 1.0.0

package/dist/components/slider.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface SliderProps {
+    value: number;
+    onValueChange: (value: number) => void;
+    onSlidingComplete?: (value: number) => void;
+    minimumValue?: number;
+    maximumValue?: number;
+    step?: number;
+    hapticStep?: number;
+    disabled?: boolean;
+    accessibilityLabel: string;
+    valueLabel?: string;
+    leadingLabel?: string;
+    trailingLabel?: string;
+    style?: StyleProp<ViewStyle>;
+    activeColor?: string;
+    trackColor?: string;
+    thumbColor?: string;
+}
+export declare function Slider({ value, onValueChange, onSlidingComplete, minimumValue, maximumValue, step, hapticStep, disabled, accessibilityLabel, valueLabel, leadingLabel, trailingLabel, style, activeColor, trackColor, thumbColor, }: SliderProps): React.JSX.Element;

package/dist/components/snackbar.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { type MaterialOptions } from '../provider.tsx';
+export interface SnackbarProps extends MaterialOptions {
+    message: string;
+    bottom?: number;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+/** Visibility, duration and undo state belong to the caller. Solid is the reading-safe default. */
+export declare function Snackbar({ message, bottom, actionLabel, onAction, material, glassStyle, tintColor, fallbackColor, interactive, }: SnackbarProps): React.JSX.Element;

package/dist/components/split-button.d.ts

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { type MaterialOptions } from '../provider.tsx';
+/**
+ * Material 3 Expressive split button.
+ *
+ * One control holding a primary action and the variations on it: tapping the
+ * leading half does the obvious thing, tapping the trailing half offers the
+ * alternatives. It exists so the common case stays one tap while the rarer
+ * ones stop needing a separate button each.
+ *
+ * The trailing half is where the Expressive part lives — on activation its
+ * chevron spins and its outer corners morph from a pill to a small radius, so
+ * the button visibly *becomes* the open menu's anchor rather than just
+ * toggling a highlight.
+ */
+export interface SplitButtonAction {
+    disabled?: boolean;
+    destructive?: boolean;
+    id: string;
+    label: string;
+    icon: React.ComponentType<{
+        size?: number;
+        color?: string;
+    }>;
+    onPress: () => void;
+}
+export interface SplitButtonProps extends MaterialOptions {
+    menuMaterial?: MaterialOptions['material'];
+    label: string;
+    icon: React.ComponentType<{
+        size?: number;
+        color?: string;
+    }>;
+    onPress: () => void;
+    actions: SplitButtonAction[];
+    optionsLabel?: string;
+}
+export declare function SplitButton({ label, icon: Icon, onPress, actions, optionsLabel, material, menuMaterial, glassStyle, tintColor, fallbackColor, interactive, }: SplitButtonProps): React.JSX.Element;

package/dist/components/squish.d.ts

@@ -0,0 +1,20 @@
+import { type AnimatedStyle } from 'react-native-reanimated';
+/**
+ * A card or tile giving a little under the finger and springing back on
+ * release, as Material 3 Expressive's components do — on top of the ripple,
+ * which only colours. Spread `handlers` on the Pressable and put `style` on
+ * the animated view around it. Under "Remove animations" the spring is
+ * Reanimated's, so the system's setting already stills it.
+ */
+export interface SquishFeedback {
+    style: AnimatedStyle<{
+        transform: {
+            scale: number;
+        }[];
+    }>;
+    handlers: {
+        onPressIn: () => void;
+        onPressOut: () => void;
+    };
+}
+export declare function useSquish(): SquishFeedback;

package/dist/components/swipeable-row.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+export interface SwipeAction {
+    id: string;
+    label: string;
+    onPress: () => void;
+    destructive?: boolean;
+    disabled?: boolean;
+}
+export interface SwipeableRowProps {
+    children: React.ReactNode;
+    accessibilityLabel: string;
+    actionsLabel: string;
+    startActions?: SwipeAction[];
+    endActions?: SwipeAction[];
+    disabled?: boolean;
+    showActionsButton?: boolean;
+    onSwipeStart?: () => void;
+    onSwipeEnd?: () => void;
+}
+export declare function SwipeableRow({ children, accessibilityLabel, actionsLabel, startActions, endActions, disabled, showActionsButton, onSwipeStart, onSwipeEnd, }: SwipeableRowProps): React.JSX.Element;

package/dist/components/switch.d.ts

@@ -0,0 +1,8 @@
+export interface SwitchProps {
+    value: boolean;
+    onValueChange: (value: boolean) => void;
+    disabled?: boolean;
+    accessibilityLabel?: string;
+}
+/** Native switch geometry on each OS, with the app's shared colour roles. */
+export declare function Switch({ value, onValueChange, disabled, accessibilityLabel }: SwitchProps): import("react").JSX.Element;

package/dist/components/tab-bar.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import { type MaterialOptions } from '../provider.tsx';
+import type { IconProps } from './icons.tsx';
+export interface TabBarItem<T extends string> {
+    id: T;
+    label: string;
+    icon?: React.ComponentType<IconProps>;
+    disabled?: boolean;
+    badge?: string | number;
+}
+export interface TabBarProps<T extends string> extends MaterialOptions {
+    items: TabBarItem<T>[];
+    value: T;
+    onChange: (value: T) => void;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+}
+/** Controlled navigation UI: route handling belongs to the consuming app. */
+export declare function TabBar<T extends string>({ items, value, onChange, accessibilityLabel, style, material, glassStyle, tintColor, fallbackColor, interactive, }: TabBarProps<T>): React.JSX.Element;

package/dist/components/text-field.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { TextInput } from 'react-native';
+type TextInputInstance = React.ElementRef<typeof TextInput>;
+export type TextFieldProps = React.ComponentProps<typeof TextInput> & {
+    label: string;
+    /** Shown below the field in the error colour, which the border and label pick up too. */
+    error?: string | null;
+    /**
+     * The `bg-*` class of whatever surface the field sits on. The floated
+     * label needs an opaque patch behind it to mask the border line it
+     * overlaps, and that patch has to match the surface underneath — it
+     * defaults to the app's popover surface because every field so far lives
+     * in a dialog or sheet.
+     */
+    notchClassName?: string;
+};
+/**
+ * Material 3 Expressive outlined text field.
+ *
+ * The label rests inside the field, where a placeholder would sit, until
+ * there is a reason to move it — focus, or a value — at which point it
+ * floats up to overlap the border. Painting an opaque patch behind it there
+ * is the cheap way to get the M3 "notch": the alternative is clipping the
+ * border into two arcs, which this does not need.
+ *
+ * A placeholder is a hint for the empty field the reader is typing into, so
+ * it only shows once the label has floated out of its way; while the label
+ * rests inside the field the two would sit on top of each other.
+ */
+export declare const TextField: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<TextInputInstance>>;
+export {};

package/dist/components/text.d.ts

@@ -0,0 +1,9 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import { Text as RNText } from 'react-native';
+declare const textVariants: (props?: ({
+    variant?: "default" | "display" | "title" | "heading" | "subject" | "body" | "reader" | "muted" | "caption" | "labelLarge" | "label" | "mono" | "value" | "valueLarge" | "meta" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type TextProps = React.ComponentProps<typeof RNText> & VariantProps<typeof textVariants>;
+export declare function Text({ className, variant, style, ...props }: TextProps): React.JSX.Element;
+export { textVariants };

package/dist/components/time-picker.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { type MaterialOptions } from '../provider.tsx';
+export interface TimeOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface TimeChipsProps {
+    value: string | null;
+    onChange: (time: string) => void;
+    options: TimeOption[];
+    disabled?: boolean;
+}
+export declare function TimeChips({ value, onChange, options, disabled }: TimeChipsProps): React.JSX.Element;
+export interface TimeGridProps {
+    value: string | null;
+    onChange: (time: string) => void;
+    hourLabel: string;
+    minuteLabel: string;
+    minuteStep?: number;
+    disabled?: boolean;
+}
+export declare function TimeGrid({ value, onChange, hourLabel, minuteLabel, minuteStep, disabled, }: TimeGridProps): React.JSX.Element;
+export interface TimePickerSheetProps extends TimeGridProps, MaterialOptions {
+    visible: boolean;
+    onClose: () => void;
+    title: string;
+    confirmLabel: string;
+    clearLabel?: string;
+    onClear?: () => void;
+    presets?: TimeOption[];
+    onConfirm?: (time: string) => void;
+}
+export declare function TimePickerSheet({ visible, onClose, title, confirmLabel, clearLabel, onClear, presets, onConfirm, material, glassStyle, tintColor, fallbackColor, interactive, ...grid }: TimePickerSheetProps): React.JSX.Element;
+export interface TimeFieldProps extends Omit<TimePickerSheetProps, 'visible' | 'onClose' | 'title' | 'onChange' | 'onClear'> {
+    label: string;
+    emptyLabel: string;
+    onChange: (time: string | null) => void;
+}
+export declare function TimeField({ label, emptyLabel, onChange, ...props }: TimeFieldProps): React.JSX.Element;

package/dist/components/toolbar.d.ts

@@ -0,0 +1,77 @@
+import * as React from 'react';
+import { type ViewProps, type ViewStyle, type NativeScrollEvent, type NativeSyntheticEvent } from 'react-native';
+import Animated, { type AnimatedStyle } from 'react-native-reanimated';
+import type { IconProps } from './icons.tsx';
+import { type MaterialOptions } from '../provider.tsx';
+export interface ToolbarItem {
+    id: string;
+    disabled?: boolean;
+    icon: React.ComponentType<IconProps>;
+    label: string;
+    onPress: () => void;
+    /** Overrides the icon colour, for a state like "starred". */
+    color?: string;
+    /** Filled icons read as "on" for toggles. */
+    fill?: string;
+    /**
+     * Marks the item as the one currently in charge — a tool whose own panel is
+     * open, rather than a value that is set. It takes the container tone and
+     * squares its corners off, which is how M3 separates a selected toggle from
+     * its neighbours without adding a second row of chrome.
+     */
+    active?: boolean;
+    /**
+     * Colours the rule the icon already draws — the bar under the A, under the
+     * pen — with the colour the item would apply. Only symbols that carry one
+     * have anything to colour.
+     */
+    rule?: string;
+    /**
+     * Renders the item as the toolbar's primary action: a filled pill that
+     * shows its label instead of relying on the icon alone. At most one.
+     */
+    prominent?: boolean;
+    /** A count to overlay on the icon. Zero and below draw nothing. */
+    badge?: number;
+}
+export interface ToolbarProps extends MaterialOptions {
+    items: ToolbarItem[];
+    children?: React.ReactNode;
+    material?: 'auto' | 'glass' | 'solid';
+    className?: string;
+    /** Motion from `useToolbarAutoHide`, when the toolbar scrolls away. */
+    style?: React.ComponentProps<typeof Animated.View>['style'];
+    /** Slims the pill down around the same targets — see `COMPACT_TOOLBAR_HEIGHT`. */
+    compact?: boolean;
+}
+export declare function Toolbar(props: ToolbarProps | ToolbarContainerProps): React.JSX.Element;
+/**
+ * Scrolls the toolbar away downwards, and brings it back on the way up.
+ *
+ * The point of a floating toolbar is that it is a layer over the content
+ * rather than a permanent border around it — so it gets out of the way while
+ * the user is reading, and returns the moment they reverse, without having to
+ * reach the top of the list first.
+ *
+ * The scroll handler is a plain JS one on purpose: it only writes shared
+ * values, so it never re-renders the screen, and it works on `FlashList`
+ * without wrapping the list in `Animated.createAnimatedComponent`.
+ *
+ * @param travel How far down to send it — far enough to clear the screen edge,
+ *   so a hidden toolbar cannot be tapped.
+ */
+export interface ToolbarAutoHide {
+    onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    style: AnimatedStyle<ViewStyle>;
+}
+export declare function useToolbarAutoHide(travel: number): ToolbarAutoHide;
+export interface ToolbarContainerProps extends ViewProps, MaterialOptions {
+    /** Floating navigation uses glass on supported iOS when a surface adapter is supplied. */
+    material?: 'auto' | 'glass' | 'solid';
+}
+export interface NavigationBarProps extends ToolbarContainerProps {
+    title: string;
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+}
+export declare function NavigationBar({ title, leading, trailing, ...props }: NavigationBarProps): React.JSX.Element;

package/dist/components/top-bar.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { type MaterialOptions } from '../provider.tsx';
+/**
+ * The bar every screen below the tabs opens with: the back arrow 8 from the
+ * edge, the screen's own buttons at the other end, and, when a screen wants
+ * one, something small in between (a position, a step). One height, one
+ * inset, so moving between screens moves nothing at the top. The status
+ * bar's room is the screen's: it knows whether it draws under it.
+ */
+export interface TopBarProps extends MaterialOptions {
+    onBack: () => void;
+    backLabel?: string;
+    center?: React.ReactNode;
+    actions?: React.ReactNode;
+    className?: string;
+}
+export declare function TopBar({ onBack, center, actions, backLabel, className, material, glassStyle, tintColor, fallbackColor, interactive, }: TopBarProps): React.JSX.Element;
+/**
+ * A screen's name under its bar: the emphasized title, 16 from the edge, and
+ * a line about it. The same on every screen, so a title is where the eye
+ * expects it.
+ */
+export declare function ScreenTitle({ title, caption, className, }: {
+    title: string;
+    caption?: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;

package/dist/components/undo-bar.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { type MaterialOptions } from '../provider.tsx';
+import { type WavyProgressProps } from './wavy-progress.tsx';
+export interface UndoBarProps extends MaterialOptions {
+    message: string;
+    actionLabel: string;
+    dismissLabel: string;
+    onUndo: () => void;
+    onDismiss: () => void;
+    /** Time supplied by the app's undo clock. This component never executes/expiries undo entries. */
+    remainingMs: number;
+    totalMs: number;
+    progress?: WavyProgressProps['progress'];
+    paused?: boolean;
+    onPause?: () => void;
+    onResume?: () => void;
+    collapsed?: boolean;
+    onExpand?: () => void;
+    countLabel?: string;
+    showDismissButton?: boolean;
+}
+/** A feedback surface only; queue, expiry, collapse policy and screen clearance belong to the app. */
+export declare function UndoBar({ message, actionLabel, dismissLabel, onUndo, onDismiss, remainingMs, totalMs, progress: suppliedProgress, paused, onPause, onResume, collapsed, onExpand, countLabel, showDismissButton, material, glassStyle, tintColor, fallbackColor, interactive, }: UndoBarProps): React.JSX.Element;

package/dist/components/wavy-progress.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { type SharedValue } from 'react-native-reanimated';
+/**
+ * The Expressive determinate progress indicator: the part done is a wave,
+ * the part left a flat track, with a gap between them.
+ *
+ * The wave calms down towards either end — it is flat at nothing done and
+ * flat again at all done, so a finished list reads as finished, not busy.
+ * While something is underway the wave travels slowly; under "Remove
+ * animations" it stands still, and a change of progress arrives at once.
+ */
+export interface WavyProgressProps {
+    /** 0 to 1. */
+    progress: number | SharedValue<number>;
+    height?: number;
+    color?: string;
+    trackColor?: string;
+    /** A still wave, for small previews where motion would only distract. */
+    animated?: boolean;
+}
+export declare function WavyProgress({ progress, color, trackColor, animated, height, }: WavyProgressProps): React.JSX.Element;

package/dist/components/zoomable-image.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { MaterialOptions } from '../provider.tsx';
+/** Material options apply to the floating zoom controls, never the image. */
+export interface ZoomableImageProps extends MaterialOptions {
+    uri: string;
+    accessibilityLabel: string;
+    onTap?: () => void;
+    onDismiss?: () => void;
+    maximumScale?: number;
+    labels: {
+        zoomIn: string;
+        zoomOut: string;
+        reset: string;
+        error?: string;
+    };
+    renderImage?: (onLoad: (width: number, height: number) => void, onError: () => void) => React.ReactNode;
+}
+export declare function ZoomableImage({ uri, accessibilityLabel, onTap, onDismiss, maximumScale, labels, renderImage, material, glassStyle, tintColor, fallbackColor, interactive, }: ZoomableImageProps): React.JSX.Element;

package/dist/expressive-shapes.d.ts

@@ -0,0 +1,8 @@
+export declare const EXPRESSIVE_SHAPES: {
+    readonly clover: string;
+    readonly cookie: string;
+    readonly flower: string;
+    readonly gable: string;
+    readonly square: string;
+};
+export type ExpressiveShapeName = keyof typeof EXPRESSIVE_SHAPES;

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+export * from './provider.tsx';
+export * from './theme.ts';
+export * from './tokens.ts';
+export type { IconProps } from './components/icons.tsx';
+export * from './components/button.tsx';
+export * from './components/button-group.tsx';
+export * from './components/filter-chip.tsx';
+export * from './components/icon-button.tsx';
+export * from './components/loading-indicator.tsx';
+export * from './components/text-field.tsx';
+export * from './components/wavy-progress.tsx';
+export * from './components/menu-sheet.tsx';
+export * from './components/select-field.tsx';
+export * from './components/expressive-shape.tsx';
+export * from './components/squish.ts';
+export * from './components/row-gap.tsx';
+export * from './components/back-icon.tsx';
+export * from './components/pressable.tsx';
+export * from './components/switch.tsx';
+export * from './components/dialog.tsx';
+export * from './components/bottom-sheet.tsx';
+export * from './components/sheet-transition.ts';
+export * from './components/search-field.tsx';
+export * from './components/text.tsx';
+export * from './components/badge.tsx';
+export * from './components/expand-indicator.tsx';
+export * from './components/refresh-control.tsx';
+export * from './components/keyboard-inset-view.tsx';
+export * from './components/back-button.tsx';
+export * from './components/input.tsx';
+export * from './components/toolbar.tsx';
+export * from './components/split-button.tsx';
+export * from './components/top-bar.tsx';
+export * from './components/sheet-frame.tsx';
+export * from './components/panel-sheet.tsx';
+export * from './components/settings-list.tsx';
+export * from './components/empty-state.tsx';
+export * from './components/snackbar.tsx';
+export * from './components/settings-row.tsx';
+export * from './components/fab-menu.tsx';
+export { usesPlatformMaterial } from './material.ts';
+export * from './components/tab-bar.tsx';
+export * from './components/popover.tsx';
+export * from './components/context-menu.tsx';
+export * from './components/floating-action-button.tsx';
+export { spatial } from './motion.ts';
+export { useReducedMotion } from './reduced-motion.ts';
+export * from './components/checkbox.tsx';
+export * from './components/avatar.tsx';
+export * from './components/slider.tsx';
+export * from './components/action-chip.tsx';
+export * from './components/color-picker.tsx';
+export * from './components/amount-field.tsx';
+export * from './components/date-picker.tsx';
+export * from './components/time-picker.tsx';
+export * from './components/banner.tsx';
+export * from './components/undo-bar.tsx';
+export * from './components/list-controls.tsx';
+export * from './components/swipeable-row.tsx';
+export * from './components/zoomable-image.tsx';
+export { parseLocalizedAmount, formatLocalizedAmount } from './amount.ts';
+export { validDate, validTime, addDays, addMonths, monthDays, formatCalendarDate } from './calendar.ts';

package/dist/keyboard.d.ts

@@ -0,0 +1,2 @@
+/** Browser keyboard occlusion only while editing, at normal zoom. Resized layouts need no extra inset. */
+export declare function keyboardOcclusion(layoutHeight: number, visualHeight: number, offsetTop?: number, scale?: number, editing?: boolean): number;

package/dist/material.d.ts

@@ -0,0 +1,11 @@
+/** Shared across core controls and the optional native material adapter. */
+export interface MaterialOptions {
+    material?: 'auto' | 'glass' | 'solid';
+    glassStyle?: 'regular' | 'clear';
+    tintColor?: string;
+    fallbackColor?: string;
+    /** Enables material interaction, not an action handler. */
+    interactive?: boolean;
+}
+/** Surface requests are platform-aware; explicit solid always wins. */
+export declare function usesPlatformMaterial(platform: string, material?: MaterialOptions['material']): boolean;

package/dist/media.d.ts

@@ -0,0 +1,11 @@
+export declare function clampZoom(value: number, maximum?: number): number;
+/** Pan limits for a contained image, rather than the larger bounds of a cover image. */
+export declare function imagePanBounds(width: number, height: number, aspect: number, scale: number): {
+    x: number;
+    y: number;
+};
+/** RN uses source dimensions; React Native Web forwards the DOM image load event. */
+export declare function imageDimensions(event: unknown): {
+    width: number;
+    height: number;
+} | null;

package/dist/motion.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Material 3 Expressive motion physics.
+ *
+ * Expressive replaced M3's duration-and-easing curves with springs. A spring
+ * has no fixed duration: it is described by how hard it pulls (stiffness) and
+ * how quickly it stops wobbling (damping ratio), and it re-targets mid-flight
+ * instead of restarting. That is what makes an interrupted gesture feel like
+ * an object being redirected rather than an animation being cancelled.
+ *
+ * Two families, and they are not interchangeable:
+ *
+ * - **Spatial** springs move things — position, size, shape, rotation. They
+ *   are under-damped (ratio < 1) so they overshoot slightly and settle back.
+ * - **Effects** springs change appearance — color, opacity, elevation. They
+ *   are critically damped (ratio = 1), because a colour that overshoots reads
+ *   as a flicker, not as weight.
+ *
+ * The values below are the *expressive* motion scheme. The standard scheme is
+ * stiffer and flatter; expressive trades a few milliseconds of settle time for
+ * motion you can actually feel. This app uses it everywhere.
+ */
+export interface SpringToken {
+    /** 1 = critically damped (no overshoot); below 1 overshoots and settles. */
+    dampingRatio: number;
+    stiffness: number;
+}
+/** Movement: bounds, offset, scale, shape. Slightly under-damped. */
+export declare const spatialTokens: {
+    readonly fast: {
+        readonly dampingRatio: 0.6;
+        readonly stiffness: 800;
+    };
+    readonly default: {
+        readonly dampingRatio: 0.8;
+        readonly stiffness: 380;
+    };
+    readonly slow: {
+        readonly dampingRatio: 0.8;
+        readonly stiffness: 200;
+    };
+};
+/** Appearance: color, opacity, elevation. Critically damped. */
+export declare const effectsTokens: {
+    readonly fast: {
+        readonly dampingRatio: 1;
+        readonly stiffness: 3800;
+    };
+    readonly default: {
+        readonly dampingRatio: 1;
+        readonly stiffness: 1600;
+    };
+    readonly slow: {
+        readonly dampingRatio: 1;
+        readonly stiffness: 800;
+    };
+};
+export interface SpringConfig {
+    mass: number;
+    stiffness: number;
+    damping: number;
+}
+/**
+ * Converts an M3 spring token to the physical constants Reanimated wants.
+ *
+ * M3 specifies a damping *ratio* — dimensionless, and therefore stable across
+ * stiffness changes — while Reanimated's physics springs take an absolute
+ * damping coefficient. The two are related by `c = 2ζ√(km)`, so a token can be
+ * retuned by stiffness alone without accidentally changing its bounciness.
+ */
+export declare function springConfig(token: SpringToken, mass?: number): SpringConfig;
+/** Ready-made configs, so call sites read as `spatial.fast` not as numbers. */
+export declare const spatial: {
+    readonly fast: SpringConfig;
+    readonly default: SpringConfig;
+    readonly slow: SpringConfig;
+};
+export declare const effects: {
+    readonly fast: SpringConfig;
+    readonly default: SpringConfig;
+    readonly slow: SpringConfig;
+};
+/**
+ * Stagger between items in a group that animates in together (FAB menu items,
+ * toolbar contents). Expressive sequences items rather than moving them as one
+ * block — the offset is what makes a menu feel unfolded instead of pasted on.
+ */
+export declare const STAGGER_MS = 28;
+/**
+ * The stagger to actually use, given the reader's motion preference.
+ *
+ * Collapses to zero under "Remove animations": a sequence unfolding is the
+ * effect itself, and with nothing moving, a delay is only a row arriving late
+ * for no visible reason. Here rather than in `~/lib/reduced-motion` so it
+ * stays free of Reanimated and testable under `node --test`.
+ */
+export declare function staggerFor(reduced: boolean, stagger?: number): number;

package/dist/platform.d.ts

@@ -0,0 +1,3 @@
+export type IsolinePlatform = 'ios' | 'android';
+/** Native follows the OS. Web can preview either design without spoofing Platform.OS. */
+export declare function resolvePlatform(os: string, requested?: IsolinePlatform, inherited?: IsolinePlatform): IsolinePlatform;