@box-kite/react 2.2.4 → 2.2.5

package/registry/designs/store/product-art.d.ts

@@ -0,0 +1,26 @@
+import { Shape } from './store-data';
+export type ArtView = 'front' | 'set';
+export interface ProductArtProps {
+    shape: Shape;
+    finish: string;
+    /** For the `set` view: more finishes, each on its own tile beside the first. */
+    also?: readonly string[];
+    view?: ArtView;
+    /** Names the picture; without one it is decoration, hidden from assistive technology. */
+    label?: string;
+    /** The line's width in the icon's own 24-unit grid: thinner on a large tile, heavier on a thumbnail. */
+    stroke?: 0.5 | 0.75 | 1 | 1.25 | 1.5;
+    /** Rounds the picture’s corners, on the ÷4 scale: the tiles clip themselves, so nothing around them has to. */
+    radius?: 2 | 3 | 4 | 6;
+}
+/** Fills its parent: give the parent a size or an aspect ratio, and the picture takes the rest. */
+export default function ProductArt({ shape, finish, also, view, label, stroke, radius }: ProductArtProps): import("react").JSX.Element;
+/** A flat dot of the finish, for the colour swatches. */
+export declare function finishSwatch(id: string): {
+    vars: {
+        swatch: string;
+    };
+    css: {
+        backgroundColor: string;
+    };
+};

package/registry/designs/store/product-card.d.ts

@@ -0,0 +1,11 @@
+import { Product } from './store-data';
+export interface ProductCardProps {
+    product: Product;
+    /** The heading level the card's name takes in the page around it. */
+    level?: 'h2' | 'h3';
+}
+/**
+ * One product in a grid. The whole card is the link, and its name is the link's text: the picture is
+ * decoration beside it, and the finish swatches are spelled out for a screen reader in one sentence.
+ */
+export default function ProductCard({ product, level }: ProductCardProps): import("react").JSX.Element;

package/registry/designs/store/product-gallery.d.ts

@@ -0,0 +1,11 @@
+import { Product } from './store-data';
+export interface ProductGalleryProps {
+    product?: Product;
+    /** The finish on show — the variant picker beside the gallery owns it. */
+    finish?: string;
+}
+/**
+ * A product's pictures: one large view and a row of thumbnails that choose it. The thumbnails are tabs
+ * (APG's tabbed carousel), so the arrow keys move between them and each picture is named by its tab.
+ */
+export default function ProductGallery({ product, finish }: ProductGalleryProps): import("react").JSX.Element;

package/registry/designs/store/product-grid.d.ts

@@ -0,0 +1,10 @@
+import { Product } from './store-data';
+export interface ProductGridProps {
+    products?: readonly Product[];
+    title?: string;
+}
+/**
+ * A product grid with filters: categories and finishes as checkboxes, a sort, and a count that is announced
+ * as it changes. Filtering is a `useMemo` over the list it is given — hand it the page your API returned.
+ */
+export default function ProductGrid({ products, title }: ProductGridProps): import("react").JSX.Element;

package/registry/designs/store/product-page.d.ts

@@ -0,0 +1,5 @@
+/** One product: the gallery and the picker share the finish, and adding to the cart moves the header's count. */
+export default function ProductPage({ slug, theme }: {
+    slug?: string;
+    theme?: string;
+}): import("react").JSX.Element;

package/registry/designs/store/quantity-stepper.d.ts

@@ -0,0 +1,13 @@
+export interface QuantityStepperProps {
+    value: number;
+    onChange: (value: number) => void;
+    /** What is being counted, for the buttons' names: "Add one Bolt the robot". */
+    item: string;
+    min?: number;
+    max?: number;
+}
+/**
+ * Two buttons and the count between them. The count is an `<output>`, which is a polite live region of its
+ * own, so a screen reader hears the new number after each press with nothing wired up.
+ */
+export default function QuantityStepper({ value, onChange, item, min, max }: QuantityStepperProps): import("react").JSX.Element;

package/registry/designs/store/shipping-method.d.ts

@@ -0,0 +1,14 @@
+import { ShippingMethod as Method } from './store-data';
+export interface ShippingMethodProps {
+    methods?: readonly Method[];
+    value?: string;
+    onValueChange?: (id: string) => void;
+    /** Standard shipping is free above this subtotal. */
+    freeStandard?: boolean;
+}
+/**
+ * Delivery options as cards. Each card is the `<label>` of a native radio, so the whole card is the
+ * target, the set is one tab stop with the arrow keys inside it, and the chosen card is styled with
+ * `:has(:checked)` — the radio itself stays visible, because it is what says this is a choice of one.
+ */
+export default function ShippingMethod({ methods, value, onValueChange, freeStandard }: ShippingMethodProps): import("react").JSX.Element;

package/registry/designs/store/store-data.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The catalogue the store pages render: plain objects, so swapping in your own fetch changes nothing else.
+ * A finish is the object's colour, the wash its picture sits on, and the ink the picture is drawn in.
+ */
+export type Shape = 'lamp' | 'clock' | 'vase' | 'speaker' | 'mug' | 'chair' | 'glass' | 'desk-lamp';
+export interface Finish {
+    id: string;
+    name: string;
+    /** The swatch, as any CSS colour: the finishes are muted on purpose, between the palette's steps. */
+    color: string;
+    /** The wash behind the picture: the finish, lightened. */
+    tile: string;
+    /** The picture's line: a deep tone of the same hue, or a light one on a dark finish. */
+    ink: string;
+}
+export interface Product {
+    slug: string;
+    name: string;
+    shape: Shape;
+    category: string;
+    price: number;
+    finishes: readonly string[];
+    sizes?: readonly string[];
+    badge?: string;
+    summary: string;
+}
+export interface CartLine {
+    id: string;
+    slug: string;
+    finish: string;
+    size?: string;
+    quantity: number;
+}
+export interface ShippingMethod {
+    id: string;
+    name: string;
+    detail: string;
+    price: number;
+}
+export declare const STORE_NAME = "Still";
+export declare const finishes: Record<string, Finish>;
+export declare const products: readonly Product[];
+export declare const categories: string[];
+export declare const sampleCart: readonly CartLine[];
+export declare const shippingMethods: readonly ShippingMethod[];
+/** Orders over this ship free on the standard service. */
+export declare const FREE_SHIPPING_FROM = 250;
+export declare const TAX_RATE = 0.08;
+/** A price as a tag prints it: $240, with cents only when there are some. */
+export declare const formatPrice: (amount: number) => string;
+export declare const productBySlug: (slug: string) => Product;
+export declare const subtotalOf: (lines: readonly CartLine[]) => number;
+export declare const countOf: (lines: readonly CartLine[]) => number;

package/registry/designs/store/store-design.d.ts

@@ -0,0 +1,63 @@
+import { ReactNode } from 'react';
+/**
+ * The store's design: the built-in components restyled for this one brand, in light and dark. It registers
+ * nothing — `Box.createComponents()` returns a design, and `StoreSurface` applies it to its subtree only, so
+ * the store can sit inside an app that looks like something else.
+ */
+export declare const storeDesign: any;
+/** Spread on a heading: a medium weight and tight tracking, in whatever sans the system already has. */
+export declare const heading: {
+    readonly fontWeight: 500;
+    readonly letterSpacing: -0.5;
+};
+/** The small spaced capitals over a section, beside a badge or under a price. */
+export declare const eyebrow: {
+    readonly fontSize: 12;
+    readonly fontWeight: 500;
+    readonly letterSpacing: 1.5;
+    readonly textTransform: "uppercase";
+};
+/** A panel on the page: a hairline and soft corners, nothing else. */
+export declare const card: {
+    readonly b: 1;
+    readonly borderRadius: 4;
+    readonly borderColor: "stone-200";
+    readonly theme: {
+        readonly dark: {
+            readonly borderColor: "stone-800";
+        };
+    };
+};
+/** Secondary text, in both themes. */
+export declare const muted: {
+    readonly color: "stone-500";
+    readonly theme: {
+        readonly dark: {
+            readonly color: "stone-400";
+        };
+    };
+};
+/**
+ * Where the pages and blocks link to. A provider rather than constants, so the same pages work under any
+ * router: wrap them in `<StoreLinks.Provider value={…}>` with your own routes.
+ */
+export interface StoreRoutes {
+    shop: string;
+    product: (slug: string) => string;
+    cart: string;
+    checkout: string;
+}
+export declare const StoreLinks: import('react').Context<StoreRoutes>;
+export declare const useStoreLinks: () => StoreRoutes;
+/** The design and the page colours, with no theme of its own: it follows whatever theme is around it. */
+export declare function StoreSurface({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * A whole store page: its own light/dark switch, remembered under its own key, around `StoreSurface`.
+ * Without `theme` it opens in the reader's saved choice, then their system's.
+ */
+export declare function StoreTheme({ theme, children }: {
+    theme?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/registry/designs/store/store-shell.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export interface StoreShellProps {
+    /** The number on the cart link. */
+    cartCount?: number;
+    /** A checkout's header: the brand and a padlock, with nothing to wander off through. */
+    checkout?: boolean;
+    /** Opens in this theme rather than the reader's saved or system one. */
+    theme?: string;
+    children: ReactNode;
+}
+/** The frame every store page shares: the header, the page, the footer, and the theme switch. */
+export default function StoreShell({ cartCount, checkout, theme, children }: StoreShellProps): import("react").JSX.Element;

package/registry/designs/store/storefront-page.d.ts

@@ -0,0 +1,4 @@
+/** The store's front page: the hero, three promises, the collection with its filters, and the shop's story. */
+export default function StorefrontPage({ theme }: {
+    theme?: string;
+}): import("react").JSX.Element;

package/registry/designs/store/variant-picker.d.ts

@@ -0,0 +1,15 @@
+import { CartLine, Product } from './store-data';
+export interface VariantPickerProps {
+    product?: Product;
+    /** The finish, when the page owns it — the gallery beside the picker shows the same one. */
+    finish?: string;
+    onFinishChange?: (finish: string) => void;
+    /** Called with the line the reader added. */
+    onAdd?: (line: CartLine) => void;
+}
+/**
+ * Colour, size and quantity, then Add to cart. The swatches and the sizes are native radios, each set one
+ * tab stop with the arrow keys inside it, and only the frame around them is drawn here: the `<label>`
+ * finds out which radio is chosen with `:has(:checked)`, so nothing is mirrored into state for the styling.
+ */
+export default function VariantPicker({ product, finish, onFinishChange, onAdd }: VariantPickerProps): import("react").JSX.Element;

package/rsc.cjs

@@ -1 +1 @@
-Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./rolldown-runtime.cjs"),t=require("./react-shared.cjs");let n=require("react");n=e.t(n,1);let r=require("@box-kite/core");(0,r.getDefaultEngine)().configure({sink:`element`});function i(e,r){let{tag:i=`div`,children:a}=e;if(typeof a==`function`)throw Error(`[box-kite] Box children as a function track hover state, which needs the client Box — render it from a 'use client' module.`);let{classNames:o,styleElements:s}=t.l(e,i===`svg`);return n.default.createElement(n.default.Fragment,null,s,n.default.createElement(i,t.d(e,o),a))}function a(e){return i(e)}var o=a;o.extend=r.BoxExtends.extend,o.components=r.BoxExtends.components,o.keyframes=r.BoxExtends.keyframes,o.spring=r.Springs.spring,o.getVariableValue=e=>(0,r.getDefaultEngine)().getVariableValue(e),o.configure=e=>(0,r.getDefaultEngine)().configure(e),o.viewTransition=r.startViewTransition;function s(e,n){return t.p(t.l(e,n?.svg===!0),e.className)}exports.default=o,exports.useBoxElement=i,exports.useClassNames=s;
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./rolldown-runtime.cjs"),t=require("./react-shared.cjs");let n=require("react");n=e.t(n,1);let r=require("@box-kite/core");(0,r.getDefaultEngine)().configure({sink:`element`});function i(e,r){let{tag:i=`div`,children:a}=e;if(typeof a==`function`)throw Error(`[box-kite] Box children as a function track hover state, which needs the client Box — render it from a 'use client' module.`);let{classNames:o,styleElements:s}=t.l(e,i===`svg`);return n.default.createElement(n.default.Fragment,null,s,n.default.createElement(i,t.d(e,o),a))}function a(e){return i(e)}var o=a;o.extend=r.BoxExtends.extend,o.components=r.BoxExtends.components,o.createComponents=r.BoxExtends.createComponents,o.keyframes=r.BoxExtends.keyframes,o.spring=r.Springs.spring,o.getVariableValue=e=>(0,r.getDefaultEngine)().getVariableValue(e),o.configure=e=>(0,r.getDefaultEngine)().configure(e),o.viewTransition=r.startViewTransition;function s(e,n){return t.p(t.l(e,n?.svg===!0),e.className)}exports.default=o,exports.useBoxElement=i,exports.useClassNames=s;

package/rsc.d.ts

@@ -12,6 +12,8 @@ interface RscBoxType {
     <TTag extends keyof React.JSX.IntrinsicElements = 'div', TKey extends keyof ComponentsAndVariants = never>(props: BoxCoreProps<TTag, TKey>): React.ReactNode;
     extend: typeof BoxExtends.extend;
     components: typeof BoxExtends.components;
+    /** A design for one subtree. A Server Component cannot read the provider that applies it; a client one under `<Box.Components>` can. */
+    createComponents: typeof BoxExtends.createComponents;
     keyframes: typeof BoxExtends.keyframes;
     /** A spring of your own, sampled into `{ easing, duration }`. Pure arithmetic, so a Server Component can call it. */
     spring: typeof Springs.spring;

package/rsc.mjs

@@ -13,7 +13,7 @@ function l(e) {
 	return c(e);
 }
 var u = l;
-u.extend = i.extend, u.components = i.components, u.keyframes = i.keyframes, u.spring = a.spring, u.getVariableValue = (e) => o().getVariableValue(e), u.configure = (e) => o().configure(e), u.viewTransition = s;
+u.extend = i.extend, u.components = i.components, u.createComponents = i.createComponents, u.keyframes = i.keyframes, u.spring = a.spring, u.getVariableValue = (e) => o().getVariableValue(e), u.configure = (e) => o().configure(e), u.viewTransition = s;
 function d(e, r) {
 	return n(t(e, r?.svg === !0), e.className);
 }

package/scrolling.cjs

@@ -0,0 +1 @@
+const e=require("./platform.cjs");function t(e,t,n=e.length){let r=0,i=n-1;if(i<=0)return 0;for(;r<i;){let n=r+i+1>>>1;e[n]<=t?r=n:i=n-1}return r}function n(t){let n=e.c(t),r=n?.ownerDocument?.defaultView;if(!n||!r)return null;let i=n.ownerDocument.scrollingElement??n.ownerDocument.documentElement;for(let e=n.parentElement;e&&e!==i&&e!==n.ownerDocument.body;e=e.parentElement)if(/auto|scroll|overlay/.test(r.getComputedStyle(e).overflowY)&&e.scrollHeight>e.clientHeight)return e;return null}Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return t}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return n}});

package/scrolling.mjs

@@ -0,0 +1,22 @@
+import { c as e } from "./platform.mjs";
+//#region src/utils/virtual/rowSearch.ts
+function t(e, t, n = e.length) {
+	let r = 0, i = n - 1;
+	if (i <= 0) return 0;
+	for (; r < i;) {
+		let n = r + i + 1 >>> 1;
+		e[n] <= t ? r = n : i = n - 1;
+	}
+	return r;
+}
+//#endregion
+//#region src/utils/scroll/scrollUtils.ts
+function n(t) {
+	let n = e(t), r = n?.ownerDocument?.defaultView;
+	if (!n || !r) return null;
+	let i = n.ownerDocument.scrollingElement ?? n.ownerDocument.documentElement;
+	for (let e = n.parentElement; e && e !== i && e !== n.ownerDocument.body; e = e.parentElement) if (/auto|scroll|overlay/.test(r.getComputedStyle(e).overflowY) && e.scrollHeight > e.clientHeight) return e;
+	return null;
+}
+//#endregion
+export { t as n, n as t };

package/ssg.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime.cjs"),t=require("./client.cjs");let n=require("react-dom/server");n=e.t(n,1);function r(){return t.r.getStyles()}function i(){return t.r.getStyleTag()}function a(){t.r.clear()}function o(e,t=!0){let o=n.default.renderToStaticMarkup(e),s=r(),c=i();if(t){let e=o.indexOf(`<head>`);if(e>-1){let t=e+6;o=o.substring(0,t)+c+o.substring(t)}}return a(),{html:o,styles:s,styleTag:c}}exports.getStyleTag=i,exports.getStyles=r,exports.renderToStaticMarkup=o,exports.resetStyles=a;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime.cjs"),t=require("./client.cjs");let n=require("react-dom/server");n=e.t(n,1);function r(){return t.i.getStyles()}function i(){return t.i.getStyleTag()}function a(){t.i.clear()}function o(e,t=!0){let o=n.default.renderToStaticMarkup(e),s=r(),c=i();if(t){let e=o.indexOf(`<head>`);if(e>-1){let t=e+6;o=o.substring(0,t)+c+o.substring(t)}}return a(),{html:o,styles:s,styleTag:c}}exports.getStyleTag=i,exports.getStyles=r,exports.renderToStaticMarkup=o,exports.resetStyles=a;

package/ssg.mjs

@@ -1,4 +1,4 @@
-import { r as e } from "./client.mjs";
+import { i as e } from "./client.mjs";
 import t from "react-dom/server";
 //#region src/ssg.ts
 function n() {

package/utils/scroll/scrollUtils.d.ts

@@ -0,0 +1,6 @@
+import { ElementLike } from '../dom/domUtils';
+/**
+ * The element that scrolls `value` into view, or `null` for the page: the nearest ancestor that scrolls and has
+ * something to scroll. Both halves count — `overflow-x: hidden` alone computes `overflow-y` to `auto`.
+ */
+export declare function scrollParentOf(value: ElementLike): HTMLElement | null;

package/utils/sortable/sortableUtils.d.ts

@@ -0,0 +1,25 @@
+/** Where an item sat when a drag began, relative to the list: its top edge and its height, in px. */
+export interface SortableSlot {
+    top: number;
+    height: number;
+}
+/**
+ * The model behind `<SortableList>`: which slot a dragged item is over, how far its neighbours step aside
+ * to make room, and the keyboard's moves. The slots are read once, when the drag starts, so every answer
+ * is about the layout the person is looking at rather than one that moves under the pointer.
+ */
+declare namespace SortableUtils {
+    /** How far a press on a handle travels before it is a drag rather than a press, in px. */
+    const SLOP = 4;
+    /** The index the held item would be dropped at, having travelled `travel` px from slot `from`. */
+    function targetIndex(slots: readonly SortableSlot[], from: number, travel: number): number;
+    /** What the held item takes up in the list: its height and the gap after it, which is what a neighbour steps by. */
+    function pitchOf(slots: readonly SortableSlot[], from: number): number;
+    /** How far the item at `index` steps aside while the item from `from` is held over `to`. */
+    function shiftOf(slots: readonly SortableSlot[], from: number, to: number, index: number): number;
+    /** `array` with the entry at `from` moved to `to`, everything between stepping along by one. A new array. */
+    function move<T>(array: readonly T[], from: number, to: number): T[];
+    /** Where a key moves the held item in a list of `count`, or `null` when the key is not a move. A vertical list, so the block axis. */
+    function keyTarget(key: string, index: number, count: number): number | null;
+}
+export default SortableUtils;

package/utils/swipe/swipeUtils.d.ts

@@ -0,0 +1,53 @@
+/** Which tray a swipe reveals: `start` sits under the inline start edge, so in a left-to-right page a swipe to the right shows it. */
+export type SwipeSide = 'start' | 'end';
+/** How wide each tray is when it is fully open, in px. `0` is a side with no actions, which a swipe cannot open. */
+export interface SwipeTrays {
+    start: number;
+    end: number;
+}
+/** Where a released swipe comes to rest: open on one side, closed, or carried through to the outermost action. */
+export interface SwipeRest {
+    open: SwipeSide | null;
+    full: SwipeSide | null;
+}
+/**
+ * The model behind `<SwipeItem>`. Every offset here is **logical**: positive moves the content towards the
+ * inline end and reveals the `start` tray, so the arithmetic is the same in a right-to-left page and only
+ * the component turns it back into a physical translate. No DOM and no React — a swipe is numbers.
+ */
+declare namespace SwipeUtils {
+    /** How far a press travels before it is a gesture at all, in px — under it, a press is a tap. */
+    const SLOP = 8;
+    /** A release faster than this, in px per ms, is a flick: it goes the way it was going, however far it got. */
+    const FLICK = 0.4;
+    /** How much of the item a full swipe has to cross before letting go performs the outermost action. */
+    const FULL_RATIO = 0.6;
+    /**
+     * What a press is once it has moved past the slop: a swipe when it went more sideways than up or down,
+     * otherwise a scroll the page owns. `null` until then.
+     */
+    function intent(dx: number, dy: number): 'swipe' | 'scroll' | null;
+    /** The offset for a press that started at `rest` and has travelled `travel` along the reading order. */
+    function offsetFor(rest: number, travel: number, trays: SwipeTrays, width: number, fullSwipe: boolean): number;
+    /** The side whose outermost action a release would perform, or `null` when it has not been carried far enough. */
+    function armed(offset: number, trays: SwipeTrays, width: number, fullSwipe: boolean): SwipeSide | null;
+    /**
+     * Where a release settles. A flick goes the way it was moving; otherwise a tray past half open opens and
+     * one short of it closes — the rule every platform swipe follows, because the eye judges halfway.
+     */
+    function settle(offset: number, velocity: number, trays: SwipeTrays, width: number, fullSwipe: boolean): SwipeRest;
+    /** A pointer sample: when, in ms, and where along the line, in px. */
+    interface Sample {
+        t: number;
+        x: number;
+    }
+    /** How far back a release looks to judge its speed: the last tenth of a second is the flick, not the whole drag. */
+    const VELOCITY_WINDOW = 100;
+    /** The samples worth keeping once `next` arrives: those inside the window, and `next`. */
+    function track(samples: readonly Sample[], next: Sample): Sample[];
+    /** The speed along the line at release, in px per ms. Under a frame of samples is no measurement at all, so `0`. */
+    function velocity(samples: readonly Sample[]): number;
+    /** The offset a tray rests at: its whole width, towards the side it is on. */
+    function restOffset(open: SwipeSide | null, trays: SwipeTrays): number;
+}
+export default SwipeUtils;

package/utils/virtual/measuredWindow.d.ts

@@ -0,0 +1,28 @@
+import { VirtualWindow } from './virtualUtils';
+/**
+ * Windowing for a list whose rows each have their own height — `<VirtualList>`'s, where `VirtualUtils` is the
+ * fixed pitch a listbox has. Its own module so neither consumer carries the other's arithmetic.
+ */
+declare namespace MeasuredWindow {
+    /** Rows either side of the screen when the caller names none. */
+    const DEFAULT_OVERSCAN = 4;
+    /** How far a focused row outside the window may be from it and still be kept rendered, so focus is not dropped. */
+    const PIN_REACH = 50;
+    /** Where each row of a list whose rows differ in height starts: `count + 1` entries, the last being the total. */
+    function offsetsOf(sizes: readonly number[]): number[];
+    /** What a row not yet drawn counts as: the mean of the rows that have been, or `fallback` before any has. */
+    function typicalSize(sizes: Iterable<number>, fallback: number): number;
+    interface MeasuredWindowOptions {
+        /** From `offsetsOf`. */
+        offsets: readonly number[];
+        /** The part of the list on screen, in px from the list's own top edge. Either end may be outside the list. */
+        viewStart: number;
+        viewEnd: number;
+        overscan?: number;
+        /** A row that has to stay rendered — the one focus is in — or `-1`. */
+        pin?: number;
+    }
+    /** The rows to render for a list whose rows each have their own height, and the space above and below them. */
+    function measuredWindow(options: MeasuredWindowOptions): VirtualWindow;
+}
+export default MeasuredWindow;

package/utils/virtual/rowSearch.d.ts

@@ -0,0 +1,11 @@
+/** Where each row starts, ascending: an array, or a list that computes an entry when it is asked for one. */
+export type RowTops = {
+    readonly length: number;
+    readonly [index: number]: number;
+};
+/**
+ * The row a point `y` falls in — the last of the first `count` rows that starts at or above it — clamped
+ * to the list. A binary search, since a scroll asks on every frame and a datasource grid lays out a million
+ * rows it never allocates. `DataGrid` and `VirtualList` both window through it.
+ */
+export declare function rowAt(tops: RowTops, y: number, count?: number): number;