@mittwald/flow-react-components 1.5.0-next.9 → 1.5.0

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

@@ -1,56 +1,22 @@
-import { ColumnDef, ColumnFilter, InitialTableState } from '@tanstack/react-table';
-import { default as List } from '../List';
-import { FilterMatcher, FilterMode, FilterShape } from './types';
-import { PropertyName, PropertyValueRenderMethod } from '../types';
+import { FilterShape } from './types';
+import { PropertyName } from '../types';
+import { ListModelContext, ListFilter } from '../../../../_bundled/flow-components-base/index';
+import { ReactNode } from 'react';
+import { List } from '../List';
 import { FilterValue } from './FilterValue';
-import { ListSettingsStoreOperationOptions } from '../ListSettingsStore';
-export declare class Filter<T = never, TProp extends PropertyName<T> = never, TMatchValue = never> {
-    private _values?;
-    private _valuesFromTableState?;
-    readonly list: List<T>;
-    readonly property: TProp;
-    readonly mode: FilterMode;
-    readonly matcher: FilterMatcher<T, never, never>;
-    readonly renderItem: PropertyValueRenderMethod<TMatchValue>;
-    readonly name?: string;
-    readonly autosave: boolean;
-    readonly manualSave: boolean;
-    private onFilterChangeCallbacks;
-    private readonly defaultSelectedValues?;
-    readonly priority: "primary" | "secondary";
-    readonly storageKey: string;
-    constructor(list: List<T>, shape: FilterShape<T, TProp, TMatchValue>);
-    updateInitialState(initialState: InitialTableState): void;
-    private getInitialSelectedIds;
-    private getStoredSelectedIds;
-    private getStoredSelectedValues;
-    static storeFilters<T>(list: List<T>, options: ListSettingsStoreOperationOptions): void;
-    updateTableColumnDef(def: ColumnDef<T>): void;
-    private getReactTableFilterFn;
-    private checkFilterMatches;
-    protected getTableColumnFilter(): ColumnFilter | undefined;
-    private getTableColumn;
-    getValue(): unknown;
-    private getValuesFromTableState;
-    private checkIfValueIsUnknown;
-    deleteUnknownFilterValues(): void;
+/**
+ * React's filter: the shared one, with `renderItem` narrowed.
+ *
+ * Everything a filter does — values, selection, persistence, the predicate the
+ * table runs — is `ListFilter` in `@mittwald/flow-components-base`. The one
+ * thing that is not shareable is what a filter value _looks_ like, so the core
+ * carries the rendered type as a parameter and this fills it with `ReactNode`.
+ */
+export declare class Filter<T = never, TProp extends PropertyName<T> = never, TMatchValue = never> extends ListFilter<T, TProp, TMatchValue, ReactNode> {
+    constructor(context: ListModelContext<T>, shape: FilterShape<T, TProp, TMatchValue>);
+    /** The list this filter belongs to — `context`, typed as React's `List`. */
+    get list(): List<T>;
     get values(): FilterValue[];
-    private get valuesFromTableState();
     getArrayValue(): FilterValue[];
-    isValueActive(value: FilterValue): boolean;
-    isActive(): boolean;
-    deactivateValue(value: FilterValue): void;
-    private callOnChangedHandlers;
-    hasChanges(): boolean;
-    isStoringAvailable(): boolean;
-    resetValues(): void;
-    clear(): void;
-    toggleValue(newValue: FilterValue): void;
-    get isSelectAllAvailable(): boolean;
-    isEveryValueActive(): boolean;
-    selectAll(): void;
-    setActiveValueIds(ids: Iterable<unknown>): void;
-    deselectAll(): void;
-    private setArrayValue;
-    onFilterUpdated(cb: () => unknown): void;
 }
+export default Filter;

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

@@ -1,13 +1,12 @@
 import { Filter } from './Filter';
-export declare class FilterValue {
+import { ListFilterValue } from '../../../../_bundled/flow-components-base/index';
+import { ReactNode } from 'react';
+/**
+ * Framework-free apart from what it renders to, which the core takes as a type
+ * parameter — so React's is that class with `ReactNode` filled in, and its
+ * filter typed as React's, the one that carries `list`.
+ */
+export type FilterValue = ListFilterValue<ReactNode> & {
     readonly filter: Filter<unknown, string, unknown>;
-    readonly value: unknown;
-    readonly id: string;
-    private constructor();
-    static create(filter: Filter<any, any, any>, value: unknown): FilterValue;
-    equals(otherValue: FilterValue): boolean;
-    get isActive(): boolean;
-    render(): import('react').ReactNode;
-    toggle(): void;
-    deactivate(): void;
-}
+};
+export declare const FilterValue: typeof ListFilterValue;

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

@@ -1,22 +1,10 @@
-import { PropertyName, PropertyValue, PropertyValueRenderMethod } from '../types';
-import { ItemType } from '../../../../lib/types/array';
-import { RangeCalendarProps } from '../../../Calendar';
 import { DateRangeFilter } from './DateRangeFilter';
-export type FilterMode = "all" | "some" | "one" | "dateRange";
-export type FilterMatcher<T, P, TMatcherValue> = (filterBy: NonNullable<ItemType<TMatcherValue>>, filterFrom: PropertyValue<T, P>) => boolean;
-export interface FilterShape<T, TProp extends PropertyName<T>, TMatcherValue> {
-    property: TProp;
-    renderItem?: PropertyValueRenderMethod<TMatcherValue>;
-    mode?: FilterMode;
-    matcher?: FilterMatcher<T, TProp, TMatcherValue>;
-    values?: readonly TMatcherValue[];
-    name?: string;
-    defaultSelected?: readonly NonNullable<TMatcherValue>[];
-    onChange?: FilterUpdatedCallback;
-    priority?: "primary" | "secondary";
-    autosave?: boolean;
-    manualSave?: boolean;
+import { PropertyName } from '../types';
+import { RangeCalendarProps } from '../../../Calendar';
+import { ListFilterShape } from '../../../../_bundled/flow-components-base/index';
+import { ReactNode } from 'react';
+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;
 }
-export type FilterUpdatedCallback = (values: unknown[]) => unknown;
 export type AnyDateRangeFilter = DateRangeFilter | DateRangeFilter<any, any>;

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

@@ -1,9 +1,10 @@
+import { ListItem } from '../../../../_bundled/flow-components-base/index';
 import { ItemCollection } from './ItemCollection';
-import { Row } from '@tanstack/react-table';
-export declare class Item<T> {
-    readonly id: string;
-    readonly data: T;
+/**
+ * `ListItem` from `@mittwald/flow-components-base`, with its collection typed
+ * as React's — the one that carries `list`.
+ */
+export type Item<T> = ListItem<T> & {
     readonly collection: ItemCollection<T>;
-    constructor(collection: ItemCollection<T>, id: string, data: T);
-    static fromRow<T>(collection: ItemCollection<T>, row: Row<T>): Item<T>;
-}
+};
+export declare const Item: typeof ListItem;

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

@@ -1,7 +1,12 @@
-import { default as List } from '../List';
+import { ListItemCollection } from '../../../../_bundled/flow-components-base/index';
 import { Item } from './Item';
-export declare class ItemCollection<T> {
-    readonly list: List<T>;
-    constructor(list: List<T>);
+import { List } from '../List';
+/**
+ * React's item collection: `ListItemCollection` from
+ * `@mittwald/flow-components-base`, plus `list` — see `Sorting` for why.
+ */
+export declare class ItemCollection<T> extends ListItemCollection<T> {
+    get list(): List<T>;
     get entries(): Item<T>[];
 }
+export default ItemCollection;

package/dist/types/components/List/model/loading/IncrementalLoaderState.d.ts

@@ -1,30 +1,20 @@
-import { ListData } from './types';
-import { AsyncResource } from '@mittwald/react-use-promise';
 import { default as List } from '../List';
-type AsyncResourceLoadingState = AsyncResource["state"]["value"];
-type DataBatches<T> = ListData<T>[];
-type BatchesLoadingState = AsyncResourceLoadingState[];
-export declare class IncrementalLoaderState<T> {
-    dataBatches: DataBatches<T>;
-    prevDataBatches: DataBatches<T>;
-    batchLoadingStates: BatchesLoadingState;
-    metadata?: unknown;
+import { ListLoaderState } from '../../../../_bundled/flow-components-base/index';
+/**
+ * React's view of the list's loading state.
+ *
+ * Everything the state _is_ — the batches, the deduplication, what counts as
+ * loading — lives in `ListLoaderState` in `@mittwald/flow-components-base`, so
+ * the Vue binding runs the same rules rather than a second implementation of
+ * them. What is left here is the subscription: MobX is framework-agnostic,
+ * reading it in a component is not.
+ */
+export declare class IncrementalLoaderState<T> extends ListLoaderState<T> {
     readonly list: List<T>;
-    isInitiallyLoading: boolean;
     private constructor();
     static useNew<T>(list: List<T>): IncrementalLoaderState<T>;
-    reset(): void;
-    setDataBatch(index: number, data: ListData<T>): void;
-    setBatchLoadingState(index: number, state: AsyncResourceLoadingState): void;
-    setMetadata(metadata?: unknown): void;
-    setIsInitiallyLoading(isInitiallyLoading: boolean): void;
-    get mergedData(): T[];
     useMergedData(): T[];
-    get isLoading(): boolean;
     useIsLoading(): boolean;
-    get isLoadingMore(): boolean;
     useIsLoadingMore(): boolean;
     useIsInitiallyLoading(): boolean;
-    isBatchLoaded(batchIndex: number): boolean;
 }
-export {};

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

@@ -1,31 +1,11 @@
-import { PropertyRecord } from '../types';
-import { FilterMode } from '../filter/types';
+import { ListAsyncDataLoader, ListData, ListDataLoaderOptions, ListDataLoaderResult } from '../../../../_bundled/flow-components-base/index';
 import { AsyncResource } from '@mittwald/react-use-promise';
-import { SearchValue } from '../search/types';
 import { DependencyList } from 'react';
-type DataLoaderSortOptions<T> = PropertyRecord<T, "asc" | "desc">;
-type DataLoaderFilterOptions<T> = PropertyRecord<T, {
-    mode: FilterMode;
-    values: unknown[];
-}>;
-interface DataLoaderPaginationOptions {
-    offset: number;
-    limit: number;
-}
-export interface DataLoaderOptions<T> {
-    sorting?: DataLoaderSortOptions<T>;
-    filtering?: DataLoaderFilterOptions<T>;
-    searchString?: SearchValue;
-    pagination?: DataLoaderPaginationOptions;
-}
-export type ListData<T> = readonly T[];
-export interface DataLoaderResult<T> {
-    data: ListData<T>;
-    itemTotalCount?: number;
-    metadata?: unknown;
-}
+export type DataLoaderOptions<T> = ListDataLoaderOptions<T>;
+export type DataLoaderResult<T> = ListDataLoaderResult<T>;
+export type { ListData };
 export type HooksDataLoader<T> = (options: DataLoaderOptions<T>) => DataLoaderResult<T>;
-export type AsyncDataLoader<T> = (options: DataLoaderOptions<T>) => Promise<DataLoaderResult<T>>;
+export type AsyncDataLoader<T> = ListAsyncDataLoader<T>;
 export type AsyncResourceFactory<T> = (options?: DataLoaderOptions<T>) => AsyncResource<DataLoaderResult<T>>;
 interface DynamicLoaderShape {
     manualSorting?: boolean;
@@ -64,4 +44,3 @@ export interface LoaderInvocationHook {
     useLoadBatch: () => void;
     useRenderSuspense: () => void;
 }
-export {};

package/dist/types/components/List/model/pagination/BatchesController.d.ts

@@ -1,15 +1 @@
-import { default as List } from '../List';
-import { BatchesControllerShape } from './types';
-export declare class BatchesController<T> {
-    readonly batchSize: number;
-    private readonly list;
-    constructor(list: List<T>, shape?: BatchesControllerShape);
-    private get reactTable();
-    getBatchIndex(): number;
-    hasNextBatch(): boolean;
-    getTotalItemsCount(): number;
-    getVisibleItemsCount(): number;
-    updateItemTotalCount(value: number): void;
-    reset(): void;
-    nextBatch(): void;
-}
+export { ListBatchesController as BatchesController } from '../../../../_bundled/flow-components-base/index';

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

@@ -1,3 +1 @@
-export interface BatchesControllerShape {
-    batchSize?: number;
-}
+export type { ListBatchesControllerShape as BatchesControllerShape } from '../../../../_bundled/flow-components-base/index';

package/dist/types/components/List/model/search/Search.d.ts

@@ -1,21 +1,18 @@
-import { default as List } from '../List';
-import { SearchFieldRenderComponent, SearchShape, SearchValue } from './types';
-import { InitialTableState } from '@tanstack/react-table';
-export declare class Search<T> {
-    readonly list: List<T>;
-    readonly render?: SearchFieldRenderComponent;
+import { SearchShape } from './types';
+import { ListModelContext, ListSearch } from '../../../../_bundled/flow-components-base/index';
+import { List } from '../List';
+/**
+ * React's search: the shared one plus how the field is rendered.
+ *
+ * The term, its initial value and its persistence are `ListSearch` in
+ * `@mittwald/flow-components-base`. `render` and `textFieldProps` stay here — a
+ * component type and Flow's `SearchField` props are React, and a binding brings
+ * its own.
+ */
+export declare class Search<T> extends ListSearch<T> {
+    readonly render?: SearchShape<T>["render"];
     readonly textFieldProps: SearchShape<T>["textFieldProps"];
-    private onUpdateCallbacks;
-    private readonly initialValue?;
-    private readonly defaultValue?;
-    private readonly autosave;
-    constructor(list: List<T>, searchShape: SearchShape<T>);
-    get value(): SearchValue;
-    get isSet(): boolean;
-    private callOnUpdateCallbacks;
-    private getInitialValue;
-    updateInitialState(initialState: InitialTableState): void;
-    setValue(value: SearchValue): void;
-    clear(): void;
-    onUpdated(cb: () => unknown): void;
+    constructor(context: ListModelContext<T>, shape: SearchShape<T>);
+    /** The list this search belongs to — `context`, typed as React's `List`. */
+    get list(): List<T>;
 }

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

@@ -1,18 +1,16 @@
-import { ComponentType } from 'react';
 import { SearchFieldProps } from '../../../SearchField';
+import { ListSearchShape } from '../../../../_bundled/flow-components-base/index';
+import { ComponentType } from 'react';
+export type { SearchValue } from '../../../../_bundled/flow-components-base/index';
 type SupportedSearchFieldProps = Pick<SearchFieldProps, "autoFocus">;
 interface SearchFieldRenderProps extends SupportedSearchFieldProps {
-    onChange: (value: SearchValue) => unknown;
-    value: SearchValue;
+    onChange: (value: string | undefined) => unknown;
+    value: string | undefined;
     autoSubmit?: boolean;
     isDisabled?: boolean;
 }
 export type SearchFieldRenderComponent = ComponentType<SearchFieldRenderProps>;
-export type SearchValue = string | undefined;
-export interface SearchShape<IgnoredT> {
+export interface SearchShape<IgnoredT> extends ListSearchShape {
     render?: SearchFieldRenderComponent;
     textFieldProps: SupportedSearchFieldProps;
-    defaultValue?: string;
-    autosave?: boolean;
 }
-export {};

package/dist/types/components/List/model/sorting/Sorting.d.ts

@@ -1,23 +1,15 @@
-import { default as List } from '../List';
-import { SortingDefaultMode, SortingShape } from './types';
-import { PropertyName } from '../types';
-import { Column, ColumnDef, ColumnSort, SortDirection, SortingFn } from '@tanstack/react-table';
-export declare class Sorting<T> {
-    readonly list: List<T>;
-    readonly property: PropertyName<T>;
-    readonly name?: string;
-    readonly directionName?: string;
-    readonly direction: SortDirection;
-    readonly initialEnabled: SortingDefaultMode;
-    readonly customSortingFn?: SortingFn<T>;
-    readonly autosave: boolean;
-    constructor(list: List<T>, shape: SortingShape<T>);
-    private getInitialEnabled;
-    updateTableColumnDef(def: ColumnDef<T>): void;
-    getReactTableColumnSort(): ColumnSort;
-    isSorted(): boolean;
-    getTableColumn(): Column<T>;
-    enable(): void;
-    clear(): void;
-    get id(): string;
+import { ListSorting } from '../../../../_bundled/flow-components-base/index';
+import { List } from '../List';
+/**
+ * React's sorting: the shared one, plus the list it belongs to.
+ *
+ * A sorting only translates between the TanStack table and the settings store,
+ * and both are frameworkless, so everything it does is `ListSorting` in
+ * `@mittwald/flow-components-base`. What is left here is `list` — the shared
+ * class calls its list `context` and types it as the model's port, while
+ * React's API has always handed out the `List` itself.
+ */
+export declare class Sorting<T> extends ListSorting<T> {
+    get list(): List<T>;
 }
+export default Sorting;

package/dist/types/components/List/model/sorting/SortingFunctions.d.ts

@@ -1,4 +1,4 @@
-import { SortingFn } from '@tanstack/react-table';
+import { SortingFn } from '@tanstack/table-core';
 export declare const SortingFunctions: {
     bigInt: SortingFn<unknown>;
     alphanumeric: "alphanumeric";

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

@@ -1,13 +1 @@
-import { PropertyName } from '../types';
-import { SortDirection, SortingFn as SortingFunction } from '@tanstack/react-table';
-export type SortingDefaultMode = boolean | "hidden";
-export type SortingFn<T> = SortingFunction<T>;
-export interface SortingShape<T> {
-    property: PropertyName<T>;
-    name?: string;
-    directionName?: string;
-    direction?: SortDirection;
-    defaultEnabled?: SortingDefaultMode;
-    customSortingFn?: SortingFn<T>;
-    autosave?: boolean;
-}
+export type { ListSortingShape as SortingShape, SortingDefaultMode, SortingFn, } from '../../../../_bundled/flow-components-base/index';

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

@@ -6,15 +6,13 @@ import { BatchesControllerShape } from './pagination/types';
 import { SearchShape } from './search/types';
 import { SortingShape } from './sorting/types';
 import { TableShape } from './table/types';
-import { ItemType } from '../../../lib/types/array';
 import { MultipleSelection, SelectionBehavior } from '@react-types/shared';
-import { DeepKeys, DeepValue } from '@tanstack/react-table';
+import { customPropertyPrefix, CustomPropertyName, ListSettingsDefaults, PropertyName, PropertyValue, PropertyValueRenderMethod as ListPropertyValueRenderMethod, ListViewModeValue } from '../../../_bundled/flow-components-base/index';
 import { ReactNode } from 'react';
-export declare const customPropertyPrefix: "$";
-export type CustomPropertyName = `${typeof customPropertyPrefix}${string}`;
-export type PropertyName<T> = DeepKeys<T> | CustomPropertyName;
-export type PropertyValue<T, TProp> = TProp extends CustomPropertyName ? T : DeepValue<T, TProp>;
-export type PropertyValueRenderMethod<TMatcherValue> = (prop: NonNullable<ItemType<TMatcherValue>>) => ReactNode;
+export { customPropertyPrefix };
+export type { CustomPropertyName, PropertyName, PropertyValue };
+/** React's rendering of a filter value. */
+export type PropertyValueRenderMethod<TMatcherValue> = ListPropertyValueRenderMethod<TMatcherValue, ReactNode>;
 export type OnListChanged<T, TMeta = unknown> = (list: List<T, TMeta>) => void;
 export interface ListSupportedComponentProps extends MultipleSelection {
     /** The ID of the element labelling the list. */
@@ -27,21 +25,7 @@ export interface ListSupportedComponentProps extends MultipleSelection {
      */
     selectionBehavior?: SelectionBehavior;
 }
-export interface ListSettingsStorageDefaults {
-    filters?: {
-        autosave?: boolean;
-        manualSave?: boolean;
-    };
-    sorting?: {
-        autosave?: boolean;
-    };
-    viewMode?: {
-        autosave?: boolean;
-    };
-    search?: {
-        autosave?: boolean;
-    };
-}
+export type ListSettingsStorageDefaults = ListSettingsDefaults;
 export interface ListShape<T, TMeta = unknown> extends ListSupportedComponentProps {
     /**
      * The key the lists settings (view mode, search, filters, sorting) are
@@ -91,11 +75,10 @@ export interface ListShape<T, TMeta = unknown> extends ListSupportedComponentPro
     /** The view rendered when the list contains no items. */
     emptyView?: ReactNode;
 }
-export type PropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;
 export interface ListSettingsStorageShape {
     storageKey: string;
 }
-export type ListViewMode = "table" | "list" | "tiles";
+export type ListViewMode = ListViewModeValue;
 export type ItemActionFn<T> = (data: T) => void;
 export type GetItemId<T> = (data: T) => string;
 export type EmptyViewType = "search" | "list";

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

@@ -3,7 +3,7 @@ import { ComponentType } from 'react';
 export declare const TypedList: <T, TMeta = unknown>() => ComponentType<ListProps<T, TMeta>>;
 export declare const typedList: <T, TMeta = unknown>() => {
     List: ComponentType<ListProps<T, TMeta>>;
-    Filter: <const TProp extends import('./model/types').PropertyName<T>, TMatcherValue = import('./model/types').PropertyValue<T, TProp>>(props: Omit<import('./model/filter/types').FilterShape<T, TProp, TMatcherValue>, "type" | "renderItem"> & {
+    Filter: <const TProp extends import('../../_bundled/flow-components-base/index').PropertyName<T>, TMatcherValue = import('../../_bundled/flow-components-base/index').PropertyValue<T, TProp>>(props: Omit<import('./model/filter/types').FilterShape<T, TProp, TMatcherValue>, "type" | "renderItem"> & {
         children?: import('./model/types').PropertyValueRenderMethod<TMatcherValue> | undefined;
     }) => import('react').ReactNode;
     Search: ComponentType<Omit<import('./model/search/types').SearchShape<T>, "render" | "textFieldProps"> & {
@@ -12,7 +12,7 @@ export declare const typedList: <T, TMeta = unknown>() => {
     } & {
         autoFocus?: boolean | undefined;
     }>;
-    Sorting: ComponentType<import('./model/sorting/types').SortingShape<T>>;
+    Sorting: ComponentType<import('../../_bundled/flow-components-base/index').ListSortingShape<T>>;
     Item: ComponentType<Omit<import('./model/item/ItemView').ItemViewShape<T>, "renderFn"> & {
         children: import('.').RenderItemFn<T>;
     }>;
@@ -220,15 +220,15 @@ export declare const typedList: <T, TMeta = unknown>() => {
         escapeKeyBehavior?: "clearSelection" | "none" | undefined;
         dragAndDropHooks?: import('react-aria-components').DragAndDropHooks | undefined;
         layout?: "auto" | "fixed" | undefined;
+        expandedKeys?: Iterable<import('react-aria-components').Key> | undefined;
+        defaultExpandedKeys?: Iterable<import('react-aria-components').Key> | undefined;
+        onExpandedChange?: ((keys: Set<import('react-aria-components').Key>) => any) | undefined;
         disabledBehavior?: import('react-stately').DisabledBehavior | undefined;
         verticalAlign?: "top" | "middle" | undefined;
         keyboardNavigationBehavior?: "arrow" | "tab" | undefined;
         treeColumn?: import('react-aria-components').Key | undefined;
         sortDescriptor?: import('react-aria-components').SortDescriptor | undefined;
         onSortChange?: ((descriptor: import('react-aria-components').SortDescriptor) => any) | undefined;
-        expandedKeys?: Iterable<import('react-aria-components').Key> | undefined;
-        defaultExpandedKeys?: Iterable<import('react-aria-components').Key> | undefined;
-        onExpandedChange?: ((keys: Set<import('react-aria-components').Key>) => any) | undefined;
         onRowAction?: ((key: import('react-aria-components').Key) => void) | undefined;
     }) => null;
     StaticData: ComponentType<{

package/dist/types/components/Markdown/components/SkeletonBlocks.d.ts

@@ -0,0 +1,15 @@
+import { FC, PropsWithChildren } from 'react';
+import { TextProps } from '../../Text';
+/**
+ * A text bar is an inline element and cannot wrap blocks. Markdown puts lists
+ * and quotes into a `Text`, so in `SkeletonMode` this `Text` renders as real
+ * text, and the blocks inside follow the skeleton rules on their own.
+ */
+export declare const SkeletonBlockText: FC<TextProps>;
+/**
+ * The content of a list item or a table cell: each run of inline content
+ * becomes one text bar, blocks inside — a nested list, the paragraphs of a
+ * loose list — keep their own skeleton rules. Outside an enabled `SkeletonMode`
+ * it renders its children unchanged.
+ */
+export declare const SkeletonInlineContent: FC<PropsWithChildren>;

package/dist/types/components/Modal/components/ModalTrigger/ModalTrigger.d.ts

@@ -6,11 +6,7 @@ export declare const ModalTrigger: import('react').FunctionComponent<{
     isDefaultOpen?: boolean | undefined;
     controller?: import('../../../../lib/controller').OverlayController | undefined;
     wrapWith?: (import('react').ReactElement | null) | undefined;
-    tunnel?: {
-        id: string;
-        component: import('../../../propTypes').FlowComponentName;
-        staticEntryId?: string;
-    } | null | undefined;
+    tunnel?: import('../../../../index/internal').TunnelTarget | undefined;
     ref?: import('react').Ref<HTMLDivElement> | undefined;
     key?: import('react').Key | null | undefined;
     children?: import('react').ReactNode;

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

@@ -2,6 +2,11 @@ import { PropsWithChildren } from 'react';
 import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
 import * as Aria from "react-aria-components";
 export interface NumberFieldProps extends PropsWithChildren<Omit<Aria.NumberFieldProps, "children">>, FlowComponentProps<HTMLInputElement> {
+    /**
+     * A unit displayed after the number, for units `Intl.NumberFormat` does not
+     * support (e.g. "MiB"). For supported units, use `formatOptions` instead.
+     */
+    unit?: string;
 }
 /** @flr-generate all */
 export declare const NumberField: import('react').FunctionComponent<NumberFieldProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/types/components/NumberField/components/NumberFieldUnit.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+interface Props {
+    id: string;
+    unit: string;
+}
+/**
+ * React-aria cannot parse a unit `Intl.NumberFormat` does not know, so the unit
+ * is drawn over the input instead of being part of its value. An invisible copy
+ * of the input text pushes it right behind the number. The input's name
+ * references the unit, like a unit written into the label.
+ */
+export declare const NumberFieldUnit: FC<Props>;
+export {};

package/dist/types/components/PasswordCreationField/components/ComplexityIndicator/ComplexityIndicator.d.ts

@@ -7,5 +7,10 @@ export interface ComplexityIndicatorProps {
     isEmptyValue: boolean;
     validationResultState: StateFromLatestPolicyValidationResult;
     policyValidationResult: ResolvedPolicyValidationResult;
+    /**
+     * The field is invalid for a reason outside the policy, e.g. a server error.
+     * The bar then shows danger like the field, not the password's strength.
+     */
+    isInvalid?: boolean;
 }
 export default ComplexityIndicator;

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

@@ -0,0 +1,16 @@
+import { FC, PropsWithChildren } from 'react';
+export interface SkeletonModeProps extends PropsWithChildren {
+    /**
+     * Whether the components inside render as skeleton. A nested `SkeletonMode`
+     * with `isEnabled={false}` renders its content as real UI.
+     *
+     * @default true
+     */
+    isEnabled?: boolean;
+}
+/**
+ * @flr-generate all
+ * @flowStatus beta, new
+ */
+export declare const SkeletonMode: FC<SkeletonModeProps>;
+export default SkeletonMode;

package/dist/types/components/SkeletonMode/components/SkeletonIconSurface/SkeletonIconSurface.d.ts

@@ -0,0 +1,10 @@
+import { FC, PropsWithChildren } from 'react';
+import { PropsWithClassName } from '../../../../lib/types/props';
+export type SkeletonIconSurfaceProps = PropsWithChildren & PropsWithClassName;
+/**
+ * A round skeleton surface in the size of the icon it wraps. The icon keeps
+ * rendering, invisible, so the surface takes its size from the icon's own size
+ * rules. `className` places the surface where the icon would sit.
+ */
+export declare const SkeletonIconSurface: FC<SkeletonIconSurfaceProps>;
+export default SkeletonIconSurface;

package/dist/types/components/SkeletonMode/components/SkeletonIconSurface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SkeletonIconSurface';
+export { default } from './SkeletonIconSurface';

package/dist/types/components/SkeletonMode/components/SkeletonRawText/SkeletonRawText.d.ts

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from 'react';
+/**
+ * The text rule for containers: turns raw string and number children into bars
+ * and leaves every element child to its own skeleton rendering. Outside an
+ * enabled `SkeletonMode` it renders its children unchanged.
+ */
+export declare const SkeletonRawText: FC<PropsWithChildren>;
+export default SkeletonRawText;

package/dist/types/components/SkeletonMode/components/SkeletonRawText/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SkeletonRawText';
+export { default } from './SkeletonRawText';

package/dist/types/components/SkeletonMode/components/SkeletonTextContent/SkeletonTextContent.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties, FC, PropsWithChildren } from 'react';
+export interface SkeletonTextContentProps extends PropsWithChildren {
+    /** Width of the bar when there is no content to take the width from. */
+    defaultWidth: CSSProperties["width"];
+}
+/**
+ * The text rule of `SkeletonMode`: content becomes one bar per line in the
+ * width of that line, no content becomes a `SkeletonText` in `defaultWidth`.
+ * Outside an enabled `SkeletonMode` it renders its children unchanged.
+ */
+export declare const SkeletonTextContent: FC<SkeletonTextContentProps>;
+export default SkeletonTextContent;