@mittwald/flow-react-components 1.6.0-next.5 → 1.6.0-next.50

package/dist/types/_bundled/flow-components-base/index.d.ts

@@ -2,7 +2,9 @@ export { ActionState, actionStateDurations, type ActionStateValue, } from "./act
 export { toArray, type ItemType } from "./lib/array";
 export { ListFilter } from "./list/filter/ListFilter";
 export { ListDateRangeFilter } from "./list/filter/ListDateRangeFilter";
-export { applyDateRangeColumnDef, dateRangeFilterFn, isListDateRange, type ListDateParts, type ListDateRange, } from "./list/filter/dateRange";
+export { applyDateRangeColumnDef, dateRangeFilterFn, isListDateRange, listDateToDateTime, resolveListDateRange, type ListDateParts, type ListDateRange, } from "./list/filter/dateRange";
+export { formatListDateRange, type ListDateRangeTextFormat, } from "./list/filter/formatDateRange";
+export { getListDateTimeRangeUpdate, isListDateTimeRangeEndBeforeStart, isListDateValid, listDateTimeRangeFieldsFromValue, toListCalendarDate, toListTime, type ListDateTimeRange, type ListDateTimeRangeFields, type ListDateTimeRangeLimits, } from "./list/filter/dateTimeRangeFields";
 export { ListFilterValue } from "./list/filter/ListFilterValue";
 export type { FilterMatcher, FilterMode, FilterUpdatedCallback, ListFilterShape, } from "./list/filter/types";
 export { getListColumn, type ListModelContext } from "./list/ListModelContext";
@@ -21,3 +23,4 @@ export type { ListSortingShape, SortingDefaultMode, SortingFn, } from "./list/so
 export { ListViewMode } from "./list/viewMode/ListViewMode";
 export type { ListViewModeOptions, ListViewModeValue, } from "./list/viewMode/types";
 export { customPropertyPrefix, type CustomPropertyName, type PropertyName, type PropertyValue, type PropertyValueRenderMethod, } from "./list/types";
+export { OverlayState, type AnyOverlayOpenStateHandler, type DisposerFn, type OverlayCloseHandler, type OverlayCloseOptions, type OverlayOpenHandler, type OverlayOpenStateHandler, type OverlayStateOptions, } from "./overlay/OverlayState";

package/dist/types/_bundled/flow-components-base/list/filter/ListFilter.d.ts

@@ -83,6 +83,8 @@ export declare class ListFilter<T = never, TProp extends PropertyName<T> = never
     isActive(): boolean;
     deactivateValue(value: ListFilterValue<TRendered>): void;
     private callOnChangedHandlers;
+    /** Tells the listeners — the list resetting its batches among them. */
+    protected notifyFilterUpdated(values: unknown[]): void;
     hasChanges(): boolean;
     isStoringAvailable(): boolean;
     resetValues(): void;

package/dist/types/_bundled/flow-components-base/list/filter/dateRange.d.ts

@@ -1,9 +1,16 @@
 import type { ColumnDef, Row } from "@tanstack/table-core";
-/** A calendar date, in whichever shape it reached the filter. */
+import { DateTime } from "luxon";
+/**
+ * A calendar date, in whichever shape it reached the filter — with a time of
+ * day when the filter narrows down by minute.
+ */
 export interface ListDateParts {
     readonly year: number;
     readonly month: number;
     readonly day: number;
+    readonly hour?: number;
+    readonly minute?: number;
+    readonly second?: number;
 }
 export interface ListDateRange {
     readonly start?: ListDateParts;
@@ -11,6 +18,22 @@ export interface ListDateRange {
 }
 /** A range needs both ends present to be one, even if either may be unset. */
 export declare const isListDateRange: (value: unknown) => value is ListDateRange;
+/**
+ * The date as a local point in time. A `ZonedDateTime` is the instant it names;
+ * anything else is read field by field, since after crossing the remote
+ * boundary a `CalendarDate` is a plain object.
+ */
+export declare const listDateToDateTime: (date: ListDateParts) => DateTime;
+/**
+ * Resolves a range to the instants it spans, for filtering on the server side.
+ * Both bounds are inclusive: a date covers its whole day and a date with time
+ * its whole minute, in the user's local time zone. A missing side has no
+ * bound.
+ */
+export declare const resolveListDateRange: (range: ListDateRange) => {
+    start?: Date;
+    end?: Date;
+};
 /**
  * Whether a row's date falls inside the selected range.
  *

package/dist/types/_bundled/flow-components-base/list/filter/dateTimeRangeFields.d.ts

@@ -0,0 +1,34 @@
+import { CalendarDate, type CalendarDateTime, Time } from "@internationalized/date";
+import { type ListDateParts, type ListDateRange } from "./dateRange";
+export interface ListDateTimeRangeFields {
+    readonly startDate: CalendarDate | null;
+    readonly startTime: Time | null;
+    readonly endDate: CalendarDate | null;
+    readonly endTime: Time | null;
+}
+export interface ListDateTimeRangeLimits {
+    readonly minValue?: ListDateParts | null;
+    readonly maxValue?: ListDateParts | null;
+    readonly isDateUnavailable?: (date: CalendarDate) => boolean;
+}
+type Bound = CalendarDate | CalendarDateTime;
+export interface ListDateTimeRange {
+    readonly start?: Bound;
+    readonly end?: Bound;
+}
+export declare const toListCalendarDate: (value?: ListDateParts | null) => CalendarDate | null;
+export declare const toListTime: (value?: {
+    readonly hour?: number;
+    readonly minute?: number;
+} | null) => Time | null;
+export declare const listDateTimeRangeFieldsFromValue: (value: ListDateRange | null) => ListDateTimeRangeFields;
+/** Not while a year is still being typed: "2" would read as an early end. */
+export declare const isListDateTimeRangeEndBeforeStart: (fields: ListDateTimeRangeFields) => boolean;
+export declare const isListDateValid: (date: CalendarDate | null, limits?: ListDateTimeRangeLimits) => boolean;
+/**
+ * The range the fields stand for, or `undefined` while it must not be applied:
+ * an invalid input keeps the last valid range, and an unchanged one needs no
+ * update. `null` clears the filter.
+ */
+export declare const getListDateTimeRangeUpdate: (fields: ListDateTimeRangeFields, applied: ListDateRange | null, limits?: ListDateTimeRangeLimits) => ListDateTimeRange | null | undefined;
+export {};

package/dist/types/_bundled/flow-components-base/list/filter/formatDateRange.d.ts

@@ -0,0 +1,7 @@
+import { type ListDateRange } from "./dateRange";
+/** Formats the text of an open range ("from {date}", "until {date}"). */
+export type ListDateRangeTextFormat = (key: "dateRange.from" | "dateRange.until", values: {
+    date: string;
+}) => string;
+/** The active filter chip's text: an end with time shows its time. */
+export declare const formatListDateRange: (value: ListDateRange, locale: string, format: ListDateRangeTextFormat) => string;

package/dist/types/_bundled/flow-components-base/list/loading/ListLoaderState.d.ts

@@ -32,6 +32,11 @@ export declare class ListLoaderState<T> {
     private readonly getItemId?;
     constructor(options?: ListLoaderStateOptions<T>);
     reset(): void;
+    /**
+     * Keeps the current batch when `data` holds the same items in the same order.
+     * A loader that builds a new array on every fetch — a refetch whose items its
+     * data layer reuses — would otherwise re-render the whole list for nothing.
+     */
     setDataBatch(index: number, data: ListData<T>): void;
     setBatchLoadingState(index: number, state: BatchLoadingState): void;
     setMetadata(metadata?: unknown): void;

package/dist/types/_bundled/flow-components-base/overlay/OverlayState.d.ts

@@ -0,0 +1,94 @@
+export type OverlayOpenHandler = () => unknown;
+export type OverlayCloseHandler = () => unknown;
+export type OverlayOpenStateHandler = (isOpen: boolean) => unknown;
+export type AnyOverlayOpenStateHandler = OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler;
+export type DisposerFn = () => void;
+export interface OverlayCloseOptions {
+    /** Close without asking, even when the overlay requires confirmation. */
+    bypassConfirmation?: boolean;
+}
+export interface OverlayStateOptions {
+    isDefaultOpen?: boolean;
+    /**
+     * Whether closing the overlay must be confirmed while no source has an
+     * opinion (`setConfirmOnCloseSource`).
+     */
+    confirmOnClose?: boolean;
+}
+/**
+ * Whether an overlay is open, and whether closing it has to be confirmed first.
+ * Each binding adds its subscription and its lifecycle: React's
+ * `OverlayController` subclasses it, Vue's adapter wraps it in refs.
+ *
+ * `TCloseOptions` lets a binding pass more on a close than the state reads —
+ * React's `overlay`, resolved by `Action` before the close arrives here.
+ */
+export declare class OverlayState<TCloseOptions extends OverlayCloseOptions = OverlayCloseOptions> {
+    isOpen: boolean;
+    isContentSuspended: boolean;
+    private onOpenHandlers;
+    private onCloseHandlers;
+    private onOpenChangeHandlers;
+    showConfirmationModal: boolean;
+    closeIsConfirmed: boolean;
+    private readonly confirmOnCloseFromOptions;
+    /**
+     * Every mounted component that has an opinion on close confirmation
+     * contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop
+     * and a `Form` tracking its dirty state. Combining them instead of assigning
+     * a single flag keeps them from overwriting each other.
+     */
+    private confirmOnCloseSources;
+    /**
+     * Active grants that allow closing without a confirmation. Each entry is
+     * scoped to an ongoing operation that legitimately closes the overlay – e.g.
+     * a `Form` submit – and is dropped again when that operation has finished, so
+     * an operation that does _not_ close the overlay leaves the confirmation
+     * armed.
+     */
+    private closeWithoutConfirmationGrants;
+    /**
+     * The open state a `setOpen` call is currently applying. Handlers run before
+     * `isOpen` is assigned, so a handler that calls `setOpen` again would not be
+     * caught by the equality check at the top and would recurse.
+     */
+    private openStateInFlight;
+    constructor(options?: OverlayStateOptions);
+    /** Whether closing this overlay currently requires a confirmation. */
+    get confirmOnCloseEnabled(): boolean;
+    private withdrawUnneededConfirmation;
+    private addOpenStateHandler;
+    private executeHandlers;
+    private executeOnClose;
+    private executeOnOpen;
+    private executeOnOpenChange;
+    addOnClose(handler: OverlayCloseHandler): DisposerFn;
+    addOnOpen(handler: OverlayOpenHandler): DisposerFn;
+    addOnOpenChange(handler: OverlayOpenStateHandler): DisposerFn;
+    open(): void;
+    close(options?: TCloseOptions): void;
+    toggle(): void;
+    setOpen(toOpen: boolean, options?: TCloseOptions): void;
+    /**
+     * Sets the open state without running any handler. Use it to mirror a
+     * controlled `isOpen` prop, whose change comes from the consumer – notifying
+     * them of their own state would echo it back. Closing this way drops a
+     * pending close confirmation as well.
+     */
+    syncOpen(toOpen: boolean): void;
+    /** A closed overlay has no close left to confirm. */
+    private assignOpenState;
+    private applyOpenState;
+    setIsContentSuspended(to: boolean): void;
+    /**
+     * Allows closing this overlay without a confirmation until the returned
+     * disposer is called. Use it around an operation that may legitimately close
+     * the overlay – e.g. a `Form` submit, where a "discard unsaved changes?"
+     * prompt would be nonsense – and dispose it as soon as that operation has
+     * finished. An operation that ends without closing the overlay therefore
+     * leaves the confirmation armed (#2775).
+     */
+    grantCloseWithoutConfirmation(): DisposerFn;
+    confirmClose(): void;
+    cancelConfirmation(): void;
+}

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

@@ -1,8 +1,8 @@
 import { PropsWithChildren } from 'react';
 import { PropsWithStatus, PropsWithClassName } from '../../lib/types/props';
 import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
-export interface AlertBadgeProps extends PropsWithChildren, PropsWithStatus, FlowComponentProps, PropsWithClassName {
+export interface AlertBadgeProps extends PropsWithChildren, PropsWithStatus, FlowComponentProps<HTMLSpanElement>, PropsWithClassName {
 }
 /** @flr-generate all */
-export declare const AlertBadge: import('react').FunctionComponent<AlertBadgeProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const AlertBadge: import('react').FunctionComponent<AlertBadgeProps & import('react').RefAttributes<HTMLSpanElement>>;
 export default AlertBadge;

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

@@ -4,7 +4,7 @@ import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
 import { PressEvent } from '@react-types/shared';
 export declare const badgeColors: readonly ["neutral", "blue", "navy", "violet", "teal", "lilac", "green", "orange", "red", "dark", "light", "dark-static", "light-static"];
 export type BadgeColors = (typeof badgeColors)[number];
-export interface BadgeProps extends PropsWithChildren, FlowComponentProps, PropsWithClassName {
+export interface BadgeProps extends PropsWithChildren, FlowComponentProps<HTMLSpanElement>, PropsWithClassName {
     /** Handler that is called when the badge is pressed. */
     onPress?: (e: PressEvent) => void;
     /** Handler that is called when the badges close icon is pressed. */
@@ -15,5 +15,5 @@ export interface BadgeProps extends PropsWithChildren, FlowComponentProps, Props
     isDisabled?: boolean;
 }
 /** @flr-generate all */
-export declare const Badge: import('react').FunctionComponent<BadgeProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const Badge: import('react').FunctionComponent<BadgeProps & import('react').RefAttributes<HTMLSpanElement>>;
 export default Badge;

package/dist/types/components/CartesianChart/hooks/useTickLabelWidth.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -8,7 +8,7 @@ export interface CodeBlockProps extends PropsWithClassName, PropsWithChildren, P
      * Controls truncation of long code blocks. `false` disables it, `true`
      * truncates after 8 lines, and a number sets the maximum line count.
      *
-     * @default: false
+     * @default false
      */
     truncateLines?: boolean | number;
 }

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

@@ -15,10 +15,7 @@ export interface DonutChartProps extends Omit<Aria.ProgressBarProps, "children"
     size?: "m" | "l";
     /** Divides the fill of the donut chart into segments */
     segments?: DonutChartSegment[];
-    /**
-     * Whether the legend component is shown when segments are used. @default:
-     * true
-     */
+    /** Whether the legend component is shown when segments are used. @default true */
     showLegend?: boolean;
     /** The position of the legend. @default "right" */
     legendPosition?: "top" | "left" | "bottom" | "right";

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

@@ -2,7 +2,7 @@ import { ComponentProps, ComponentType, CSSProperties, PropsWithChildren } from
 import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
 import { AlphaColor, PropsWithClassName } from '../../lib/types/props';
 import * as Aria from "react-aria-components";
-export interface LinkProps extends PropsWithChildren<Omit<Aria.LinkProps, "children" | "slot" | "className">>, FlowComponentProps<HTMLAnchorElement>, PropsWithClassName {
+export interface LinkProps extends PropsWithChildren<Omit<Aria.LinkProps, "children" | "slot" | "className" | "aria-current">>, FlowComponentProps<HTMLAnchorElement>, PropsWithClassName {
     /** Whether the link should be styled for being displayed inside a text. */
     inline?: boolean;
     /** An alternative link component. */

package/dist/types/components/List/components/Header/components/DateTimeRangeFields/DateTimeRangeFields.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { AnyDateRangeFilter } from '../../../../model/filter/types';
+interface Props {
+    filter: AnyDateRangeFilter;
+    className?: string;
+}
+export declare const DateTimeRangeFields: FC<Props>;
+export default DateTimeRangeFields;

package/dist/types/components/List/components/Items/components/Item/Item.d.ts

@@ -7,6 +7,8 @@ interface Props extends PropsWithChildren {
     triggerRef?: Ref<HTMLDivElement>;
     list: ListModel<never>;
     isTile: boolean;
+    /** Stable invoker of the list's latest `onAction` */
+    onAction?: (data: never) => void;
 }
 export declare const Item: import('react').MemoExoticComponent<(props: Props) => import('react').JSX.Element | null>;
 interface ItemContainerProps extends PropsWithChildren {

package/dist/types/components/List/components/Items/components/Item/hooks/useGridItemProps.d.ts

@@ -2,6 +2,7 @@ import { PropsWithChildren } from 'react';
 import { default as List } from '../../../../../model/List';
 interface P extends PropsWithChildren {
     data: never;
+    onAction?: (data: never) => void;
 }
 export declare const useGridItemProps: (props: P, list: List<never>) => {
     gridItemProps: {

package/dist/types/components/List/components/ListSummary/ListSummary.d.ts

@@ -1,7 +1,8 @@
 import { PropsWithChildren } from 'react';
 import { FlowComponentProps } from '../../../../lib/componentFactory/flowComponent';
-export interface ListSummaryProps extends FlowComponentProps, PropsWithChildren {
-    /** Whether the summary is placed above or underneath the list @default: "top" */
+import { PropsWithClassName } from '../../../../lib/types/props';
+export interface ListSummaryProps extends PropsWithClassName, FlowComponentProps, PropsWithChildren {
+    /** Whether the summary is placed above or underneath the list @default "top" */
     position?: "top" | "bottom";
 }
 /** @flr-generate all */

package/dist/types/components/List/components/Table/components/Row.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'react';
+import { Key } from 'react-aria-components';
+import { default as ListModel } from '../../../model/List';
+interface Props {
+    id: Key;
+    data: never;
+    list: ListModel<never>;
+    /** Stable invoker of the list's latest `onAction` */
+    onAction?: (data: never) => void;
+    triggerRef?: Ref<HTMLTableRowElement>;
+}
+export declare const Row: import('react').MemoExoticComponent<(props: Props) => import('react').JSX.Element | null>;
+export default Row;

package/dist/types/components/List/hooks/useLatestOnAction.d.ts

@@ -0,0 +1,7 @@
+import { default as List } from '../model/List';
+/**
+ * A stable invoker of the list's latest `onAction`, or `undefined` without one.
+ * An event handler only ever needs to be the latest one, so items and rows do
+ * not re-render for an inline `onAction`.
+ */
+export declare const useLatestOnAction: (list: List<never>) => ((data: never) => void | undefined) | undefined;

package/dist/types/components/List/hooks/useListSelector.d.ts

@@ -0,0 +1,6 @@
+import { default as List } from '../model/List';
+/**
+ * A value read from the list model, re-rendering only when it changes. The
+ * selector has to return a primitive or a value that keeps its identity.
+ */
+export declare const useListSelector: <R, T = never>(selector: (list: List<T>) => R) => R;

package/dist/types/components/List/index.d.ts

@@ -1,6 +1,8 @@
 export type { RenderItemFn } from './model/item/types';
 export type { AsyncDataLoader, AsyncResourceFactory, DataLoaderOptions, DataLoaderResult, } from './model/loading/types';
 export type { SortingFn } from './model/sorting/types';
+export type { DateRangeFilterOptions, DateRangeFilterValue, } from './model/filter/types';
+export { resolveDateRangeFilterValue } from './model/filter/resolveDateRangeFilterValue';
 export { SortingFunctions } from './model/sorting/SortingFunctions';
 export * from './components/Items/views/GridList';
 export * from './components/Items/views/GridListItem';

package/dist/types/components/List/listContext.d.ts

@@ -3,4 +3,20 @@ interface ListContext {
     list: List<never>;
 }
 export declare const listContext: import('react').Context<ListContext>;
+/**
+ * Hands the committed list model to `useListSelector` without changing the
+ * context value. The model is rebuilt on every render of `List`; read from
+ * `listContext`, it re-renders every consumer, including the ones inside items
+ * that skip their own render. A selector re-renders only when the value it
+ * reads changes.
+ */
+export declare class ListContextStore {
+    private list;
+    private readonly listeners;
+    constructor(list: List<never>);
+    static useNew(list: List<never>): ListContextStore;
+    readonly getList: () => List<never>;
+    readonly subscribe: (listener: () => void) => (() => void);
+}
+export declare const listStoreContext: import('react').Context<ListContextStore>;
 export {};

package/dist/types/components/List/model/filter/DateRangeFilter.d.ts

@@ -1,9 +1,7 @@
 import { ListDateRangeFilter, ListModelContext } from '../../../../_bundled/flow-components-base/index';
-import { FilterShape } from './types';
+import { DateRangeFilterOptions, DateRangeFilterValue, FilterShape } from './types';
 import { PropertyName } from '../types';
 import { RangeCalendarProps } from '../../../Calendar';
-import { DateValue } from '@internationalized/date';
-import { DateRange, RangeValue } from 'react-aria-components';
 import { ReactNode } from 'react';
 import { List } from '../List';
 import { FilterValue } from './FilterValue';
@@ -12,14 +10,23 @@ import { FilterValue } from './FilterValue';
  *
  * The column, the comparison and the stored value are `ListDateRangeFilter` in
  * `@mittwald/flow-components-base`, so the Vue binding filters the same dates
- * the same way. What is left here is the calendar's own options, which are
- * Flow's `RangeCalendar` props.
+ * the same way. What is left here are the options of the fields that pick the
+ * range: Flow's `RangeCalendar` props, or with `granularity: "minute"` those of
+ * the date and time fields.
  */
 export declare class DateRangeFilter<T = never, TProp extends PropertyName<T> = never> extends ListDateRangeFilter<T, TProp, ReactNode> {
-    readonly dateRangeOptions?: RangeCalendarProps;
+    readonly dateRangeOptions?: DateRangeFilterOptions;
     constructor(context: ListModelContext<T>, shape: FilterShape<T, TProp, never>);
-    getValue(): DateRange | null;
-    setValue(range: RangeValue<DateValue> | null): void;
+    get granularity(): "day" | "minute";
+    get rangeCalendarProps(): RangeCalendarProps;
+    get dateTimeRangeOptions(): {
+        granularity: "minute";
+        minValue?: import('@internationalized/date').DateValue | null;
+        maxValue?: import('@internationalized/date').DateValue | null;
+        isDateUnavailable?: (date: import('@internationalized/date').DateValue) => boolean;
+    } | undefined;
+    getValue(): DateRangeFilterValue | null;
+    setValue(range: DateRangeFilterValue | null): void;
     /** The list this filter belongs to — `context`, typed as React's `List`. */
     get list(): List<T>;
     get values(): FilterValue[];

package/dist/types/components/List/model/filter/resolveDateRangeFilterValue.d.ts

@@ -0,0 +1,11 @@
+import { DateRangeFilterValue } from './types';
+/**
+ * Resolves the value of a date range filter to the instants it spans, for
+ * filtering on the server side. Both bounds are inclusive: a date covers its
+ * whole day and a date with time its whole minute, in the user's local time
+ * zone. A missing side has no bound.
+ */
+export declare const resolveDateRangeFilterValue: (range: DateRangeFilterValue) => {
+    start?: Date;
+    end?: Date;
+};

package/dist/types/components/List/model/filter/types.d.ts

@@ -3,8 +3,30 @@ import { PropertyName } from '../types';
 import { RangeCalendarProps } from '../../../Calendar';
 import { ListFilterShape } from '../../../../_bundled/flow-components-base/index';
 import { ReactNode } from 'react';
+import { DateValue } from '@internationalized/date';
 export type { FilterMatcher, FilterMode, FilterUpdatedCallback, } from '../../../../_bundled/flow-components-base/index';
 export interface FilterShape<T, TProp extends PropertyName<T>, TMatcherValue> extends ListFilterShape<T, TProp, TMatcherValue, ReactNode> {
-    dateRangeOptions?: RangeCalendarProps;
+    dateRangeOptions?: DateRangeFilterOptions;
+}
+export type DateRangeFilterOptions = ({
+    /**
+     * Whether the filter narrows down by date only, or by date and time.
+     *
+     * @default "day"
+     */
+    granularity?: "day";
+} & RangeCalendarProps) | {
+    granularity: "minute";
+    minValue?: DateValue | null;
+    maxValue?: DateValue | null;
+    isDateUnavailable?: (date: DateValue) => boolean;
+};
+/**
+ * A date covers its whole day, a date with time its whole minute. A missing
+ * side has no bound.
+ */
+export interface DateRangeFilterValue {
+    start?: DateValue;
+    end?: DateValue;
 }
 export type AnyDateRangeFilter = DateRangeFilter | DateRangeFilter<any, any>;

package/dist/types/components/List/model/item/ItemView.d.ts

@@ -2,7 +2,15 @@ import { DependencyList, HTMLAttributeAnchorTarget, ReactElement, ReactNode } fr
 import { RenderItemFn } from './types';
 import { default as List } from '../List';
 export interface ItemViewShape<T> {
+    /**
+     * Runs on every render of the list to tell whether the item changed, so it
+     * should be cheap and pure.
+     */
     textValue?: (data: T) => string;
+    /**
+     * Runs on every render of the list to tell whether the item changed, so it
+     * should be cheap and pure.
+     */
     href?: (data: T) => string;
     target?: HTMLAttributeAnchorTarget;
     defaultExpanded?: (data: T) => boolean;
@@ -14,14 +22,23 @@ export interface ItemViewShape<T> {
     showTiles?: boolean;
     tileMaxWidth?: number;
     /**
-     * Values this item's content depends on besides its own data.
+     * Everything the render function reads besides the item's data.
      *
-     * An item re-renders when its data changes, or when one of the render
-     * functions on its `List.Item` changes identity — which a function written
-     * inline in JSX does on every render of its parent. A render function with a
-     * stable identity (hoisted out of the component, wrapped in `useCallback`, or
-     * reading from an external store) has to list what it reads here, or the item
-     * keeps the values it first saw.
+     * With `renderDependencies`, an item re-renders only when its data or one of
+     * these values changes. The render function's identity no longer counts, so a
+     * function written inline in JSX keeps the item from re-rendering on every
+     * render of its parent. List every value it reads from outside the item,
+     * including state read through the `list` argument — one left out keeps the
+     * item on the value it last rendered.
+     *
+     * Without it, an item re-renders whenever its render function changes
+     * identity, which an inline function does on every render of its parent.
+     */
+    renderDependencies?: DependencyList;
+    /**
+     * @deprecated Use `renderDependencies` instead. `dependencies` only adds to
+     *   the render function's identity, so an inline render function still
+     *   re-renders the item on every render of its parent.
      */
     dependencies?: DependencyList;
 }
@@ -35,15 +52,21 @@ export declare class ItemView<T> {
     readonly showTiles?: boolean;
     readonly showList?: boolean;
     readonly tileMaxWidth: number;
+    readonly renderDependencies?: DependencyList;
     readonly dependencies?: DependencyList;
     private readonly renderFn?;
+    private lastComparison?;
     constructor(list: List<T>, shape?: ItemViewShape<T>);
     private static fallbackRenderItemFn;
     /**
-     * Whether `other` would render this item identically — i.e. all render
-     * functions taken from the consumer's `ListItem` element are still the same,
-     * and the dependencies it declared have not changed.
+     * Whether `other` would render the item holding `data` identically. The
+     * render function counts by its `renderDependencies` where given, otherwise
+     * by its identity and the deprecated `dependencies`. `textValue` and `href`
+     * count by what they return for `data`, so inline functions do not re-render
+     * the item. `defaultExpanded` is read on mount only, so it does not count at
+     * all.
      */
-    rendersSameAs(other?: ItemView<T>): boolean;
+    rendersSameFor(other: ItemView<T> | undefined, data: T): boolean;
+    private rendersSameContentAs;
     render(data: T): ReactNode;
 }

package/dist/types/components/List/model/table/Table.d.ts

@@ -8,4 +8,11 @@ export declare class Table<T> {
     readonly body: TableBody<T>;
     readonly componentProps: TableSupportedComponentProps;
     constructor(list: List<T>, shape?: TableShape<T>);
+    /**
+     * Whether `other` would render the table identically, rows aside. Like
+     * `TableRow.rendersSameAs`, it only holds for rows that declare
+     * `renderDependencies`. Props count by identity, one by one, including the
+     * list's own.
+     */
+    rendersSameAs(other?: Table<T>): boolean;
 }

package/dist/types/components/List/model/table/TableBody.d.ts

@@ -6,4 +6,5 @@ export declare class TableBody<T> {
     readonly componentProps: TableBodySupportedComponentProps;
     readonly row: TableRow<T>;
     constructor(table: Table<T>, shape?: TableBodyShape<T>);
+    rendersSameAs(other: TableBody<T>): boolean;
 }

package/dist/types/components/List/model/table/TableColumn.d.ts

@@ -4,4 +4,5 @@ export declare class TableColumn<T> {
     readonly tableHeader: TableHeader<T>;
     readonly componentProps: TableColumnSupportedComponentProps;
     constructor(tableHeader: TableHeader<T>, shape?: TableColumnShape);
+    rendersSameAs(other: TableColumn<T>): boolean;
 }

package/dist/types/components/List/model/table/TableHeader.d.ts

@@ -6,4 +6,5 @@ export declare class TableHeader<T> {
     readonly componentProps: TableHeaderSupportedComponentProps;
     readonly columns: TableColumn<T>[];
     constructor(table: Table<T>, shape?: TableHeaderShape);
+    rendersSameAs(other: TableHeader<T>): boolean;
 }

package/dist/types/components/List/model/table/TableRow.d.ts

@@ -1,9 +1,23 @@
 import { TableRowShape, TableRowSupportedComponentProps } from './types';
 import { TableCell } from './TableCell';
 import { TableBody } from './TableBody';
+import { DependencyList } from 'react';
 export declare class TableRow<T> {
     readonly tableBody: TableBody<T>;
     readonly cells: TableCell<T>[];
     readonly componentProps: TableRowSupportedComponentProps;
+    readonly renderDependencies?: DependencyList;
+    private lastComparison?;
     constructor(tableBody: TableBody<T>, shape?: TableRowShape<T>);
+    /**
+     * Whether `other` would render a row identically. Only rows that declare
+     * `renderDependencies` can tell, since the cells' render functions count by
+     * those instead of their identity. Rows without them always re-render. Row
+     * and cell props count by identity, one by one.
+     *
+     * Every row of a render shares one model, so the result is cached for the
+     * last `other`.
+     */
+    rendersSameAs(other?: TableRow<T>): boolean;
+    private compareWith;
 }