@xaui/native 0.9.1-alpha.9 → 0.9.1-alpha.91

package/dist/components/input-otp/input-otp.style.d.cts

@@ -0,0 +1,23 @@
+/**
+ * The hidden input, and why it is hidden this way.
+ *
+ * It covers the boxes so a tap anywhere on the row lands on it, which is what makes the
+ * keyboard appear without a `Pressable` wrapping everything. It cannot be
+ * `display: 'none'` or zero-sized: an input the platform considers invisible is one iOS
+ * refuses to focus, and one the autofill heuristics skip — which would cost the
+ * `one-time-code` suggestion that is the whole point of the component.
+ *
+ * iOS keeps a hair of opacity for that reason; Android is happy at zero. Both paint their
+ * text transparent so a stray caret or selection never shows through the boxes.
+ */
+export declare const inputOTPSheet: {
+    hiddenInput: {
+        opacity: number;
+        color: string;
+        position: "absolute";
+        left: 0;
+        right: 0;
+        top: 0;
+        bottom: 0;
+    };
+};

package/dist/components/input-otp/input-otp.style.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The hidden input, and why it is hidden this way.
+ *
+ * It covers the boxes so a tap anywhere on the row lands on it, which is what makes the
+ * keyboard appear without a `Pressable` wrapping everything. It cannot be
+ * `display: 'none'` or zero-sized: an input the platform considers invisible is one iOS
+ * refuses to focus, and one the autofill heuristics skip — which would cost the
+ * `one-time-code` suggestion that is the whole point of the component.
+ *
+ * iOS keeps a hair of opacity for that reason; Android is happy at zero. Both paint their
+ * text transparent so a stray caret or selection never shows through the boxes.
+ */
+export declare const inputOTPSheet: {
+    hiddenInput: {
+        opacity: number;
+        color: string;
+        position: "absolute";
+        left: 0;
+        right: 0;
+        top: 0;
+        bottom: 0;
+    };
+};

package/dist/components/input-otp/input-otp.type.d.cts

@@ -0,0 +1,170 @@
+import type { ReactNode, RefObject } from 'react';
+import type { StyleProp, TextInput, TextInputProps, TextProps, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { TextStyleProps, ViewStyleProps } from '../../system/style-props';
+import type { RadiusKey, Size } from '../../theme/theme.type';
+import type { OTPSlotState } from './input-otp.utils';
+export type InputOTPSlot = 'root' | 'group' | 'box' | 'value' | 'placeholder' | 'caret' | 'separator';
+/**
+ * Three of the `Input`'s four levels — a one-time code is a field, and a box of it is a
+ * field one character wide. `primary` is the `fieldBackground` fill plus the theme's
+ * `field` shadow, `secondary` the neutral fill and the default here, `tertiary` the border
+ * alone.
+ *
+ * **No `ghost`**, where the `Input` has one, and it is the shape of the component that
+ * removes it: an input is one wide field whose position the caret and the label already
+ * give away, so it survives having neither fill nor edge. A code is *six* boxes, and their
+ * only job before anything is typed is to say **how many characters are expected and where
+ * they go**. With no fill and no border there is nothing to count. It is the reason the
+ * `Checkbox` has no `ghost` either — a box that is not a box is not a box.
+ *
+ * HeroUI splits their OTP slot the same two ways their input is split, and they reach for
+ * the `field` shadow on `primary` here explicitly — which is the same reading our `Input`
+ * takes.
+ */
+export type InputOTPVariant = 'primary' | 'secondary' | 'tertiary';
+/**
+ * Three of the four, and `xs` is the one missing. The box's width is the control height
+ * less one spacing step, so `xs` is 28 by 32 — a box that small has to carry an 18pt
+ * character to stay legible, and 18 in 28 leaves no room for the two-point active ring
+ * without the digit touching it. A code is also the one field a user reads back to
+ * themselves character by character, which is the worst place to save eight points.
+ *
+ * `sm` is the compact size; below it, use fewer boxes rather than smaller ones.
+ */
+export type InputOTPSize = Exclude<Size, 'xs'>;
+/** What the boxes are allowed to contain. A string is compiled once, per §. */
+export type InputOTPPattern = string | RegExp;
+/** What `ref` gives you: the three things only the hidden input can do. */
+export type InputOTPHandle = {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+};
+type InputOTPOwnProps = {
+    /** How many boxes, and therefore how long the code is. */
+    maxLength: number;
+    variant?: InputOTPVariant;
+    /** The box's height and width, the type inside it, and the gaps. */
+    size?: InputOTPSize;
+    /** Overrides the `lg` radius the theme chose for every size. */
+    radius?: RadiusKey;
+    /**
+     * A raw tint (`'#7c3aed'`), never a token (R7). It lands where the variant put its
+     * tokens, and it is also the ring the active box takes — the focus colour is a role
+     * like any other.
+     */
+    color?: string;
+    /** Controlled. Leave it out and the component keeps the value itself. */
+    value?: string;
+    /** The starting value when uncontrolled. */
+    defaultValue?: string;
+    onChangeText?: (value: string) => void;
+    /** Fired once the last box is filled — the only event most callers need. */
+    onComplete?: (value: string) => void;
+    /**
+     * What a box may contain. `OTP_DIGITS`, `OTP_LETTERS` and `OTP_ALPHANUMERIC` are
+     * exported for the three usual answers; anything else is your own expression.
+     *
+     * It is tested against the **whole** value rather than each character, so a pattern
+     * that allows a shape rather than a set works too.
+     */
+    pattern?: InputOTPPattern;
+    /**
+     * One character per box, or a single character repeated across all of them. Shown only
+     * where there is neither a typed character nor the caret.
+     */
+    placeholder?: string;
+    /** Paints the boxes in `danger` and takes the active ring off the accent. */
+    isInvalid?: boolean;
+    /** Dims the boxes and stops the hidden input. */
+    isDisabled?: boolean;
+    /** The keyboard the hidden input asks for. @default 'numeric' */
+    inputMode?: TextInputProps['inputMode'];
+    /**
+     * Everything else the hidden `TextInput` should carry — `autoComplete="one-time-code"`,
+     * `textContentType`, `onSubmitEditing`. It is a prop rather than a slot because the
+     * input is not composed: it is the one node this component owns and hides.
+     */
+    textInputProps?: Omit<TextInputProps, 'value' | 'defaultValue' | 'onChangeText' | 'onFocus' | 'onBlur' | 'editable' | 'maxLength' | 'style'>;
+    style?: StyleProp<ViewStyle>;
+    children?: ReactNode;
+};
+/**
+ * R14 — the component's own props, the `Pressable`'s, and every `ViewStyle` key neither
+ * already claims.
+ *
+ * **No `asChild`** (the one root in the library without it, deliberately): this root is
+ * not a pass-through container. It owns a hidden `TextInput` that has to be its own
+ * child, and `Slot` merges into a *single* element. A caller who wants their own element
+ * around the boxes wraps the `InputOTP` instead of replacing it.
+ */
+export type InputOTPProps = InputOTPOwnProps & Omit<ViewProps, keyof InputOTPOwnProps> & Omit<ViewStyleProps, keyof InputOTPOwnProps | keyof ViewProps>;
+/** `View`'s own props win over the `ViewStyle` keys of the same name (R14). */
+type InputOTPViewProps = ViewProps & Omit<ViewStyleProps, keyof ViewProps> & {
+    children?: ReactNode;
+};
+/**
+ * A group takes a render function as well as elements, which is what lets a caller draw
+ * `maxLength` boxes without writing them out — the one place in the library where a slot
+ * does, because the number of children is data here rather than markup.
+ */
+export type InputOTPGroupProps = Omit<InputOTPViewProps, 'children'> & {
+    children?: ReactNode | ((state: InputOTPRenderState) => ReactNode);
+};
+/** What the render function is handed. Everything the boxes are drawn from. */
+export type InputOTPRenderState = {
+    slots: readonly OTPSlotState[];
+    value: string;
+    maxLength: number;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isInvalid: boolean;
+};
+export type InputOTPBoxProps = Omit<InputOTPViewProps, 'children'> & {
+    /** Which box this is. It is what the root's state is read by. */
+    index: number;
+    /** Replaces the value, the placeholder and the caret with your own. */
+    children?: ReactNode;
+};
+export type InputOTPSeparatorProps = InputOTPViewProps;
+/** `Text`'s own props win over the `TextStyle` keys of the same name (R14). */
+type InputOTPTextProps = TextProps & Omit<TextStyleProps, keyof TextProps> & {
+    children?: ReactNode;
+};
+export type InputOTPValueProps = InputOTPTextProps;
+export type InputOTPPlaceholderProps = InputOTPTextProps;
+type InputOTPCaretOwnProps = {
+    /** `false` stops the blink. The bar stays, so nothing moves. */
+    animation?: boolean;
+    style?: StyleProp<ViewStyle>;
+};
+export type InputOTPCaretProps = InputOTPCaretOwnProps & Omit<ViewStyleProps, keyof InputOTPCaretOwnProps>;
+/**
+ * R5 — resolved styles, not props for a slot to resolve a second time.
+ *
+ * The box comes in two, because exactly one box is active at a time and a slot that
+ * resolved its own would be re-running the recipe per box. The root resolves both once —
+ * two cache reads — and each box picks the reference that applies to it.
+ */
+export type InputOTPContextValue = {
+    groupStyle: StyleProp<ViewStyle>;
+    boxStyle: StyleProp<ViewStyle>;
+    boxActiveStyle: StyleProp<ViewStyle>;
+    valueStyle: StyleProp<TextStyle>;
+    placeholderStyle: StyleProp<TextStyle>;
+    caretStyle: StyleProp<ViewStyle>;
+    separatorStyle: StyleProp<ViewStyle>;
+    slots: readonly OTPSlotState[];
+    value: string;
+    maxLength: number;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    /** So a custom box, or a "change number" link, can put the caret back. */
+    inputRef: RefObject<TextInput | null>;
+};
+/** What one box publishes to whatever it contains. */
+export type InputOTPBoxContextValue = {
+    slot: OTPSlotState | undefined;
+};
+export {};

package/dist/components/input-otp/input-otp.type.d.ts

@@ -0,0 +1,170 @@
+import type { ReactNode, RefObject } from 'react';
+import type { StyleProp, TextInput, TextInputProps, TextProps, TextStyle, ViewProps, ViewStyle } from 'react-native';
+import type { TextStyleProps, ViewStyleProps } from '../../system/style-props';
+import type { RadiusKey, Size } from '../../theme/theme.type';
+import type { OTPSlotState } from './input-otp.utils';
+export type InputOTPSlot = 'root' | 'group' | 'box' | 'value' | 'placeholder' | 'caret' | 'separator';
+/**
+ * Three of the `Input`'s four levels — a one-time code is a field, and a box of it is a
+ * field one character wide. `primary` is the `fieldBackground` fill plus the theme's
+ * `field` shadow, `secondary` the neutral fill and the default here, `tertiary` the border
+ * alone.
+ *
+ * **No `ghost`**, where the `Input` has one, and it is the shape of the component that
+ * removes it: an input is one wide field whose position the caret and the label already
+ * give away, so it survives having neither fill nor edge. A code is *six* boxes, and their
+ * only job before anything is typed is to say **how many characters are expected and where
+ * they go**. With no fill and no border there is nothing to count. It is the reason the
+ * `Checkbox` has no `ghost` either — a box that is not a box is not a box.
+ *
+ * HeroUI splits their OTP slot the same two ways their input is split, and they reach for
+ * the `field` shadow on `primary` here explicitly — which is the same reading our `Input`
+ * takes.
+ */
+export type InputOTPVariant = 'primary' | 'secondary' | 'tertiary';
+/**
+ * Three of the four, and `xs` is the one missing. The box's width is the control height
+ * less one spacing step, so `xs` is 28 by 32 — a box that small has to carry an 18pt
+ * character to stay legible, and 18 in 28 leaves no room for the two-point active ring
+ * without the digit touching it. A code is also the one field a user reads back to
+ * themselves character by character, which is the worst place to save eight points.
+ *
+ * `sm` is the compact size; below it, use fewer boxes rather than smaller ones.
+ */
+export type InputOTPSize = Exclude<Size, 'xs'>;
+/** What the boxes are allowed to contain. A string is compiled once, per §. */
+export type InputOTPPattern = string | RegExp;
+/** What `ref` gives you: the three things only the hidden input can do. */
+export type InputOTPHandle = {
+    focus: () => void;
+    blur: () => void;
+    clear: () => void;
+};
+type InputOTPOwnProps = {
+    /** How many boxes, and therefore how long the code is. */
+    maxLength: number;
+    variant?: InputOTPVariant;
+    /** The box's height and width, the type inside it, and the gaps. */
+    size?: InputOTPSize;
+    /** Overrides the `lg` radius the theme chose for every size. */
+    radius?: RadiusKey;
+    /**
+     * A raw tint (`'#7c3aed'`), never a token (R7). It lands where the variant put its
+     * tokens, and it is also the ring the active box takes — the focus colour is a role
+     * like any other.
+     */
+    color?: string;
+    /** Controlled. Leave it out and the component keeps the value itself. */
+    value?: string;
+    /** The starting value when uncontrolled. */
+    defaultValue?: string;
+    onChangeText?: (value: string) => void;
+    /** Fired once the last box is filled — the only event most callers need. */
+    onComplete?: (value: string) => void;
+    /**
+     * What a box may contain. `OTP_DIGITS`, `OTP_LETTERS` and `OTP_ALPHANUMERIC` are
+     * exported for the three usual answers; anything else is your own expression.
+     *
+     * It is tested against the **whole** value rather than each character, so a pattern
+     * that allows a shape rather than a set works too.
+     */
+    pattern?: InputOTPPattern;
+    /**
+     * One character per box, or a single character repeated across all of them. Shown only
+     * where there is neither a typed character nor the caret.
+     */
+    placeholder?: string;
+    /** Paints the boxes in `danger` and takes the active ring off the accent. */
+    isInvalid?: boolean;
+    /** Dims the boxes and stops the hidden input. */
+    isDisabled?: boolean;
+    /** The keyboard the hidden input asks for. @default 'numeric' */
+    inputMode?: TextInputProps['inputMode'];
+    /**
+     * Everything else the hidden `TextInput` should carry — `autoComplete="one-time-code"`,
+     * `textContentType`, `onSubmitEditing`. It is a prop rather than a slot because the
+     * input is not composed: it is the one node this component owns and hides.
+     */
+    textInputProps?: Omit<TextInputProps, 'value' | 'defaultValue' | 'onChangeText' | 'onFocus' | 'onBlur' | 'editable' | 'maxLength' | 'style'>;
+    style?: StyleProp<ViewStyle>;
+    children?: ReactNode;
+};
+/**
+ * R14 — the component's own props, the `Pressable`'s, and every `ViewStyle` key neither
+ * already claims.
+ *
+ * **No `asChild`** (the one root in the library without it, deliberately): this root is
+ * not a pass-through container. It owns a hidden `TextInput` that has to be its own
+ * child, and `Slot` merges into a *single* element. A caller who wants their own element
+ * around the boxes wraps the `InputOTP` instead of replacing it.
+ */
+export type InputOTPProps = InputOTPOwnProps & Omit<ViewProps, keyof InputOTPOwnProps> & Omit<ViewStyleProps, keyof InputOTPOwnProps | keyof ViewProps>;
+/** `View`'s own props win over the `ViewStyle` keys of the same name (R14). */
+type InputOTPViewProps = ViewProps & Omit<ViewStyleProps, keyof ViewProps> & {
+    children?: ReactNode;
+};
+/**
+ * A group takes a render function as well as elements, which is what lets a caller draw
+ * `maxLength` boxes without writing them out — the one place in the library where a slot
+ * does, because the number of children is data here rather than markup.
+ */
+export type InputOTPGroupProps = Omit<InputOTPViewProps, 'children'> & {
+    children?: ReactNode | ((state: InputOTPRenderState) => ReactNode);
+};
+/** What the render function is handed. Everything the boxes are drawn from. */
+export type InputOTPRenderState = {
+    slots: readonly OTPSlotState[];
+    value: string;
+    maxLength: number;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isInvalid: boolean;
+};
+export type InputOTPBoxProps = Omit<InputOTPViewProps, 'children'> & {
+    /** Which box this is. It is what the root's state is read by. */
+    index: number;
+    /** Replaces the value, the placeholder and the caret with your own. */
+    children?: ReactNode;
+};
+export type InputOTPSeparatorProps = InputOTPViewProps;
+/** `Text`'s own props win over the `TextStyle` keys of the same name (R14). */
+type InputOTPTextProps = TextProps & Omit<TextStyleProps, keyof TextProps> & {
+    children?: ReactNode;
+};
+export type InputOTPValueProps = InputOTPTextProps;
+export type InputOTPPlaceholderProps = InputOTPTextProps;
+type InputOTPCaretOwnProps = {
+    /** `false` stops the blink. The bar stays, so nothing moves. */
+    animation?: boolean;
+    style?: StyleProp<ViewStyle>;
+};
+export type InputOTPCaretProps = InputOTPCaretOwnProps & Omit<ViewStyleProps, keyof InputOTPCaretOwnProps>;
+/**
+ * R5 — resolved styles, not props for a slot to resolve a second time.
+ *
+ * The box comes in two, because exactly one box is active at a time and a slot that
+ * resolved its own would be re-running the recipe per box. The root resolves both once —
+ * two cache reads — and each box picks the reference that applies to it.
+ */
+export type InputOTPContextValue = {
+    groupStyle: StyleProp<ViewStyle>;
+    boxStyle: StyleProp<ViewStyle>;
+    boxActiveStyle: StyleProp<ViewStyle>;
+    valueStyle: StyleProp<TextStyle>;
+    placeholderStyle: StyleProp<TextStyle>;
+    caretStyle: StyleProp<ViewStyle>;
+    separatorStyle: StyleProp<ViewStyle>;
+    slots: readonly OTPSlotState[];
+    value: string;
+    maxLength: number;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    /** So a custom box, or a "change number" link, can put the caret back. */
+    inputRef: RefObject<TextInput | null>;
+};
+/** What one box publishes to whatever it contains. */
+export type InputOTPBoxContextValue = {
+    slot: OTPSlotState | undefined;
+};
+export {};

package/dist/components/input-otp/input-otp.utils.d.cts

@@ -0,0 +1,56 @@
+/**
+ * The two decisions this component makes that are worth pinning down: which box shows
+ * what, and what survives a paste. Both are pure string work, so they live here and are
+ * tested — the component around them is verified by its demo screen like every other.
+ */
+/** What one box knows about itself. The slots read it; nothing else does. */
+export type OTPSlotState = {
+    index: number;
+    /** The character typed here, or `null` while the box is empty. */
+    char: string | null;
+    /** The placeholder for this box, or `null` when a char or the caret takes the room. */
+    placeholderChar: string | null;
+    /** The box the next character will land in. Only ever one, and only while focused. */
+    isActive: boolean;
+    /** Active **and** empty: a caret over a character would sit on top of it. */
+    isCaretVisible: boolean;
+};
+export type BuildSlotsArgs = {
+    value: string;
+    maxLength: number;
+    isFocused: boolean;
+    /** One character per box, or a single character repeated across all of them. */
+    placeholder?: string;
+};
+/**
+ * The boxes, from the value. One pass, no state: what a box shows is a function of the
+ * value's length and where the caret is, and deriving it is what keeps a paste, a
+ * backspace and a keystroke from each needing their own update path.
+ *
+ * The active box is the one **after** the last character — `value.length` — which is
+ * also why a full value has no active box: there is nowhere left to type.
+ */
+export declare function buildSlots({ value, maxLength, isFocused, placeholder, }: BuildSlotsArgs): OTPSlotState[];
+/**
+ * The code inside whatever the platform handed us on paste.
+ *
+ * A one-time code arrives surrounded by prose far more often than alone — "Your code is
+ * 482913, it expires in 10 minutes" — and the naïve `slice(0, maxLength)` takes "Your c".
+ * This looks for a run of exactly `maxLength` digits with no digit on either side, which
+ * is what rules out the "10" in that sentence and the year in a date.
+ *
+ * Returns `''` when nothing matches, so a paste of unrelated text clears nothing and
+ * fills nothing.
+ */
+export declare function extractPastedCode(pasted: string, maxLength: number): string;
+/**
+ * Whether the platform gave us a paste rather than a keystroke.
+ *
+ * Typing adds one character; anything longer arrived at once. React Native reports both
+ * through the same `onChangeText`, and there is no event that distinguishes them.
+ */
+export declare function isPaste(text: string, previous: string): boolean;
+/** The three patterns a one-time code is normally restricted to. */
+export declare const OTP_DIGITS = "^\\d+$";
+export declare const OTP_LETTERS = "^[a-zA-Z]+$";
+export declare const OTP_ALPHANUMERIC = "^[a-zA-Z0-9]+$";

package/dist/components/input-otp/input-otp.utils.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The two decisions this component makes that are worth pinning down: which box shows
+ * what, and what survives a paste. Both are pure string work, so they live here and are
+ * tested — the component around them is verified by its demo screen like every other.
+ */
+/** What one box knows about itself. The slots read it; nothing else does. */
+export type OTPSlotState = {
+    index: number;
+    /** The character typed here, or `null` while the box is empty. */
+    char: string | null;
+    /** The placeholder for this box, or `null` when a char or the caret takes the room. */
+    placeholderChar: string | null;
+    /** The box the next character will land in. Only ever one, and only while focused. */
+    isActive: boolean;
+    /** Active **and** empty: a caret over a character would sit on top of it. */
+    isCaretVisible: boolean;
+};
+export type BuildSlotsArgs = {
+    value: string;
+    maxLength: number;
+    isFocused: boolean;
+    /** One character per box, or a single character repeated across all of them. */
+    placeholder?: string;
+};
+/**
+ * The boxes, from the value. One pass, no state: what a box shows is a function of the
+ * value's length and where the caret is, and deriving it is what keeps a paste, a
+ * backspace and a keystroke from each needing their own update path.
+ *
+ * The active box is the one **after** the last character — `value.length` — which is
+ * also why a full value has no active box: there is nowhere left to type.
+ */
+export declare function buildSlots({ value, maxLength, isFocused, placeholder, }: BuildSlotsArgs): OTPSlotState[];
+/**
+ * The code inside whatever the platform handed us on paste.
+ *
+ * A one-time code arrives surrounded by prose far more often than alone — "Your code is
+ * 482913, it expires in 10 minutes" — and the naïve `slice(0, maxLength)` takes "Your c".
+ * This looks for a run of exactly `maxLength` digits with no digit on either side, which
+ * is what rules out the "10" in that sentence and the year in a date.
+ *
+ * Returns `''` when nothing matches, so a paste of unrelated text clears nothing and
+ * fills nothing.
+ */
+export declare function extractPastedCode(pasted: string, maxLength: number): string;
+/**
+ * Whether the platform gave us a paste rather than a keystroke.
+ *
+ * Typing adds one character; anything longer arrived at once. React Native reports both
+ * through the same `onChangeText`, and there is no event that distinguishes them.
+ */
+export declare function isPaste(text: string, previous: string): boolean;
+/** The three patterns a one-time code is normally restricted to. */
+export declare const OTP_DIGITS = "^\\d+$";
+export declare const OTP_LETTERS = "^[a-zA-Z]+$";
+export declare const OTP_ALPHANUMERIC = "^[a-zA-Z0-9]+$";

package/dist/components/line-chart/index.cjs

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk3PAFQB45cjs = require('../../chunk-3PAFQB45.cjs');
+require('../../chunk-JJ3Q4IAS.cjs');
+require('../../chunk-UMY36NP2.cjs');
+require('../../chunk-FHNIGHN5.cjs');
+require('../../chunk-SL3V7R2Y.cjs');
+require('../../chunk-TVJXC4HY.cjs');
+require('../../chunk-CDRGTUYF.cjs');
+require('../../chunk-H4E4HDEP.cjs');
+require('../../chunk-EJQCQPET.cjs');
+require('../../chunk-IIAQISBG.cjs');
+require('../../chunk-TK44VBIE.cjs');
+
+
+exports.LineChart = _chunk3PAFQB45cjs.LineChart;

package/dist/components/line-chart/index.d.cts

@@ -0,0 +1,2 @@
+export { LineChart } from './line-chart';
+export type { LineChartProps } from './line-chart.type';

package/dist/components/line-chart/index.d.ts

@@ -0,0 +1,2 @@
+export { LineChart } from './line-chart';
+export type { LineChartProps } from './line-chart.type';

package/dist/components/line-chart/index.js

@@ -0,0 +1,16 @@
+import {
+  LineChart
+} from "../../chunk-TZYZARRW.js";
+import "../../chunk-CP23WMFJ.js";
+import "../../chunk-6QFJKHSX.js";
+import "../../chunk-WFZDAXDI.js";
+import "../../chunk-DKVXTMIJ.js";
+import "../../chunk-3Q42X6EQ.js";
+import "../../chunk-TTZOIXKE.js";
+import "../../chunk-36PRYGAM.js";
+import "../../chunk-EGLLDKN6.js";
+import "../../chunk-Z6JBWRPL.js";
+import "../../chunk-M63GFNKV.js";
+export {
+  LineChart
+};

package/dist/components/line-chart/line-chart.d.cts

@@ -0,0 +1,33 @@
+import type { ChartDatum } from '../chart';
+import type { LineChartProps } from './line-chart.type';
+/**
+ * A line per series, over a shared scale.
+ *
+ * ```tsx
+ * <LineChart
+ *   data={rows}
+ *   xKey="month"
+ *   yKeys={['organic', 'paid']}
+ *   formatY={value => `${value / 1000}k`}
+ * />
+ * ```
+ *
+ * **The series are props, not children**, and that is the one place a chart parts company
+ * with the rest of this library. A line is not a component a caller composes — it is a
+ * column of their data — so `yKeys` names the columns and the palette walks a shade for
+ * each. What composition there is lives on the escape hatch: `ChartPlot` takes a render
+ * function, and a caller who needs a band behind a line writes it there.
+ *
+ * **A shade per series rather than a colour per series.** A chart's series are usually one
+ * quantity split — organic and paid, mobile and desktop — so shades of one colour say
+ * "parts of a whole" where a rainbow says "unrelated things", and a caller changing the
+ * accent changes the whole chart with it.
+ *
+ * **The curve is monotone**: it bends through the readings without ever leaving the interval
+ * its neighbours set. A smooth line that dips between two rising points is drawing a number
+ * nobody measured, and on the `AreaChart` it is ink under the axis.
+ */
+export declare function LineChart<Data extends ChartDatum, XK extends keyof Data & string, YK extends keyof Data & string>({ curve, strokeWidth, hasPoints, ...props }: LineChartProps<Data, XK, YK>): import("react").JSX.Element;
+export declare namespace LineChart {
+    var displayName: string;
+}

package/dist/components/line-chart/line-chart.d.ts

@@ -0,0 +1,33 @@
+import type { ChartDatum } from '../chart';
+import type { LineChartProps } from './line-chart.type';
+/**
+ * A line per series, over a shared scale.
+ *
+ * ```tsx
+ * <LineChart
+ *   data={rows}
+ *   xKey="month"
+ *   yKeys={['organic', 'paid']}
+ *   formatY={value => `${value / 1000}k`}
+ * />
+ * ```
+ *
+ * **The series are props, not children**, and that is the one place a chart parts company
+ * with the rest of this library. A line is not a component a caller composes — it is a
+ * column of their data — so `yKeys` names the columns and the palette walks a shade for
+ * each. What composition there is lives on the escape hatch: `ChartPlot` takes a render
+ * function, and a caller who needs a band behind a line writes it there.
+ *
+ * **A shade per series rather than a colour per series.** A chart's series are usually one
+ * quantity split — organic and paid, mobile and desktop — so shades of one colour say
+ * "parts of a whole" where a rainbow says "unrelated things", and a caller changing the
+ * accent changes the whole chart with it.
+ *
+ * **The curve is monotone**: it bends through the readings without ever leaving the interval
+ * its neighbours set. A smooth line that dips between two rising points is drawing a number
+ * nobody measured, and on the `AreaChart` it is ink under the axis.
+ */
+export declare function LineChart<Data extends ChartDatum, XK extends keyof Data & string, YK extends keyof Data & string>({ curve, strokeWidth, hasPoints, ...props }: LineChartProps<Data, XK, YK>): import("react").JSX.Element;
+export declare namespace LineChart {
+    var displayName: string;
+}

package/dist/components/line-chart/line-chart.type.d.cts

@@ -0,0 +1,15 @@
+import type { ChartDatum, ChartSeriesProps, Curve } from '../chart';
+type LineChartOwnProps = {
+    /**
+     * How the line travels between two points. `monotone` bends through them without ever
+     * leaving the interval its neighbours set — the reason `chart-path` implements
+     * Fritsch–Carlson rather than a midpoint cubic. @default 'monotone'
+     */
+    curve?: Curve;
+    /** The line's thickness, in points. @default 2 */
+    strokeWidth?: number;
+    /** A dot on every reading. Off by default: twelve months of dots is a dotted line. */
+    hasPoints?: boolean;
+};
+export type LineChartProps<Data extends ChartDatum, XK extends keyof Data & string, YK extends keyof Data & string> = LineChartOwnProps & ChartSeriesProps<Data, XK, YK>;
+export {};

package/dist/components/line-chart/line-chart.type.d.ts

@@ -0,0 +1,15 @@
+import type { ChartDatum, ChartSeriesProps, Curve } from '../chart';
+type LineChartOwnProps = {
+    /**
+     * How the line travels between two points. `monotone` bends through them without ever
+     * leaving the interval its neighbours set — the reason `chart-path` implements
+     * Fritsch–Carlson rather than a midpoint cubic. @default 'monotone'
+     */
+    curve?: Curve;
+    /** The line's thickness, in points. @default 2 */
+    strokeWidth?: number;
+    /** A dot on every reading. Off by default: twelve months of dots is a dotted line. */
+    hasPoints?: boolean;
+};
+export type LineChartProps<Data extends ChartDatum, XK extends keyof Data & string, YK extends keyof Data & string> = LineChartOwnProps & ChartSeriesProps<Data, XK, YK>;
+export {};