@slotted/react 0.0.0-stage → 0.1.0-beta.0

package/dist/types/table/index.d.ts

@@ -0,0 +1,7 @@
+export { Table, TABLE_ROW_SELECTOR, useOptionalTable, useTable } from './table';
+export { TableContent } from './table-content';
+export { TableBooleanFilter, TableDateFilter, TableDateTimeFilter, TableNumberFilter, TableSetFilter, TableTextFilter, TableTimeFilter, } from './table-filter';
+export { TableDefaultsProvider, useTableDefaults } from './table-defaults';
+export { TableBody, TableCaption, TableCell, TableColumnActions, TableColumnHeader, TableDetail, TableEmpty, TableExpander, TableFooter, TableHead, TableLoader, TableRow, TableRowHeader, TableSelect, TableSelectAll, TableSort, TableSummary, useTableColumn, useTableRow, } from './table-parts';
+export type { TableAlign, TableBodyProps, TableCaptionProps, TableCellAxes, TableCellProps, TableColumnActionsProps, TableColumnHeaderProps, TableContentProps, TableContextValue, TableDefaults, TableDefaultsProviderProps, TableDetailProps, TableEmptyProps, TableExpandedReason, TableExpandedRequest, TableFilterOption, TableBooleanFilterProps, TableConditionFilterProps, TableDateFilterProps, TableDateTimeFilterProps, TableFilterOperandProps, TableFilterSharedProps, TableNumberFilterProps, TableSetFilterProps, TableTextFilterProps, TableTimeFilterProps, TableFilterReason, TableFilterRequest, TableExpanderProps, TableFooterProps, TableHandle, TableHeadProps, TableLayout, TableLoaderProps, TableProps, TableRootProps, TableRowContextValue, TableRowHeaderProps, TableRowProps, TableSelectAllProps, TableSelectionMode, TableSelectionReason, TableSelectionRequest, TableSelectProps, TableSortDescriptor, TableSortDirection, TableSortProps, TableSortReason, TableSortRequest, TableSticky, TableSummaryProps, TableText, TableVariant, } from './table.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/table/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,eAAe,GAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EACL,SAAS,EACT,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,aAAa,EACb,WAAW,EACX,SAAS,EACT,WAAW,EACX,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,YAAY,EACZ,cAAc,EACd,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,0BAA0B,EAC1B,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,uBAAuB,EACvB,yBAAyB,EACzB,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,YAAY,GACb,MAAM,eAAe,CAAC"}

package/dist/types/table/table-content.d.ts

@@ -0,0 +1,18 @@
+import type { TableContentProps } from './table.types';
+/**
+ * The scroller and the table it holds.
+ *
+ * Two elements and one component, because neither is a decision a consumer
+ * makes: the `table` carries the semantics and the scroller carries the
+ * overflow. Native props reach the `table`, which is the element the platform
+ * gives the role to; `scrollProps` reaches the box around it.
+ *
+ * **The region wiring is written only while the table overflows.** `role`,
+ * `tabindex` and a name arrive together, measured by `@slotted/core/overflow` —
+ * the rule `prose` set. A tab stop on a table that fits makes a reader press
+ * Tab for nothing, and a wide table with no tab stop is unreachable without a
+ * pointer. The measurement never runs during render, so the server renders a
+ * plain scroller and hydration finds the same DOM.
+ */
+export declare function TableContent({ children, handleRef, ref, scrollLabelledBy, scrollProps, totalRowCount, ...nativeProps }: TableContentProps): import("react").JSX.Element;
+//# sourceMappingURL=table-content.d.ts.map

package/dist/types/table/table-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-content.d.ts","sourceRoot":"","sources":["../../../src/table/table-content.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAe,MAAM,eAAe,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,SAAS,EACT,GAAG,EACH,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,GAAG,WAAW,EACf,EAAE,iBAAiB,+BA4FnB"}

package/dist/types/table/table-defaults.d.ts

@@ -0,0 +1,10 @@
+import type { TableDefaults, TableDefaultsProviderProps } from './table.types';
+export declare function useTableDefaults(): TableDefaults;
+/**
+ * An application decides once how its tables are framed and how they select. A
+ * table that states any of it itself still wins: an explicit prop is never
+ * overridden by context. Its words come from the language in force
+ * (`SlottedProvider`).
+ */
+export declare function TableDefaultsProvider({ children, ...defaults }: TableDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=table-defaults.d.ts.map

package/dist/types/table/table-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-defaults.d.ts","sourceRoot":"","sources":["../../../src/table/table-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAI/E,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,0BAA0B,+BAoB1F"}

package/dist/types/table/table-filter.d.ts

@@ -0,0 +1,47 @@
+import type { TableBooleanFilterProps, TableDateFilterProps, TableDateTimeFilterProps, TableNumberFilterProps, TableSetFilterProps, TableTextFilterProps, TableTimeFilterProps } from './table.types';
+/** A column of words. Its comparisons are the collator's, never a fold. */
+export declare function TableTextFilter(props: TableTextFilterProps): import("react").JSX.Element;
+/** A column of quantities. The operand parses in the reader's own locale. */
+export declare function TableNumberFilter(props: TableNumberFilterProps): import("react").JSX.Element;
+/**
+ * A column of days. The operand is the whole `date-picker` — the segmented field
+ * and the calendar behind it — rather than the field alone: every surveyed
+ * implementation that filters a date column offers a grid to point at, and a
+ * reader who has to type a date they could have pointed at is the one thing a
+ * date filter exists to spare them. The calendar opens a layer inside the
+ * panel's layer, which `dismissable-layer` already stacks for the operator
+ * chooser beside it.
+ *
+ * The descriptor holds the ISO day the picker produces, never a `Date`.
+ */
+export declare function TableDateFilter(props: TableDateFilterProps): import("react").JSX.Element;
+/**
+ * A column of times of day. The operand is `time-picker` — the segmented field
+ * and the list behind it — at the column's own granularity, which is what
+ * decides the precision the descriptor is written at and the engine compares
+ * at: a picker writing minutes produces `09:14`, and `is 09:14` then matches
+ * every second of that minute.
+ */
+export declare function TableTimeFilter(props: TableTimeFilterProps): import("react").JSX.Element;
+/**
+ * A column of dates with times. The operand is `datetime-picker`, the
+ * seven-segment field and the two surfaces behind it. A value with one half
+ * missing reaches the draft as no operand at all, so the condition stays
+ * inactive until both halves exist — the engine's one rule for a missing
+ * operand, and the reason Apply reports nothing for a date without a time.
+ */
+export declare function TableDateTimeFilter(props: TableDateTimeFilterProps): import("react").JSX.Element;
+/**
+ * A column of yes and no. Three answers rather than two: the third is not being
+ * filtered at all, which is what Clear leaves and what an empty draft is.
+ */
+export declare function TableBooleanFilter(props: TableBooleanFilterProps): import("react").JSX.Element;
+/**
+ * A column filtered to values the consumer named: the list, its search and the
+ * checkbox that covers what the search left.
+ *
+ * One condition, and the design says why: `anyOf A and anyOf B` is
+ * `anyOf (A ∩ B)`, so every pair of set conditions collapses to a single list.
+ */
+export declare function TableSetFilter(props: TableSetFilterProps): import("react").JSX.Element;
+//# sourceMappingURL=table-filter.d.ts.map

package/dist/types/table/table-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-filter.d.ts","sourceRoot":"","sources":["../../../src/table/table-filter.tsx"],"names":[],"mappings":"AAsDA,OAAO,KAAK,EACV,uBAAuB,EAEvB,oBAAoB,EACpB,wBAAwB,EAIxB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AA4YvB,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,+BAmB1D;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,+BA2C9D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,+BA2C1D;AAkBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,+BAqD1D;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,+BAmDlE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,+BAuBhE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,+BAiCxD"}

package/dist/types/table/table-parts.d.ts

@@ -0,0 +1,114 @@
+import { type ReactNode } from 'react';
+import type { TableBodyProps, TableCaptionProps, TableCellProps, TableColumnActionsProps, TableColumnHeaderProps, TableDetailProps, TableEmptyProps, TableExpanderProps, TableFooterProps, TableHeadProps, TableLoaderProps, TableRowContextValue, TableRowHeaderProps, TableRowProps, TableSelectAllProps, TableSelectProps, TableSortProps, TableSummaryProps } from './table.types';
+/** Which column this part is inside, for the parts that name one. */
+export declare function useTableColumn(): string | undefined;
+/** What the row around this part is, for the parts that belong to one. */
+export declare function useTableRow(): TableRowContextValue;
+/**
+ * The table's name, and the element the platform already associates with it. A
+ * `caption` is the accessible name whether it is read or hidden, so a consumer
+ * who hides it with `visually-hidden` loses the picture and keeps the name —
+ * and the family writes no `aria-labelledby` restating what the browser states.
+ */
+export declare function TableCaption({ ref, ...props }: TableCaptionProps): import("react").JSX.Element;
+export declare function TableHead({ ref, ...props }: TableHeadProps): import("react").JSX.Element;
+export declare function TableBody({ ref, ...props }: TableBodyProps): import("react").JSX.Element;
+/**
+ * The `tfoot`, which the HTML Standard calls the column summaries of the table:
+ * a total, a count, a unit. It is not the `TableFooter`, which is the bar
+ * outside the table holding the consumer's own controls.
+ */
+export declare function TableSummary({ ref, ...props }: TableSummaryProps): import("react").JSX.Element;
+/**
+ * The bar under the table and inside its frame, where a paged listing puts its
+ * control. It is a sibling of the scroller rather than a child, so a table
+ * scrolled sideways does not take its pagination with it.
+ */
+export declare function TableFooter({ ref, ...props }: TableFooterProps): import("react").JSX.Element;
+/**
+ * One record. It carries `data-selected` and `data-expanded` for the stylesheet
+ * and `data-value` for the range and the select-all, which read the rows out of
+ * the DOM at the moment they act.
+ *
+ * A row is not selectable under the `table` role, so it carries no
+ * `aria-selected`: the state is painted here and announced by the checkbox that
+ * owns it.
+ */
+export declare function TableRow({ children, disabled, ref, render, rowIndex, value, ...nativeProps }: TableRowProps): import("react").JSX.Element;
+/**
+ * A column's name. `scope="col"` is what makes a screen reader repeat it for
+ * every cell under it, and `aria-sort` is written here and on no other header.
+ *
+ * A name cut by its own box — `text="truncate"` on a column with no room —
+ * reads `Op…` to the eye while the whole of it is still what a screen reader
+ * repeats under every cell. The hint closes that gap: it opens only while the
+ * name is measured as cut, which a header that wraps or fits never is, and it
+ * is shown rather than read — `describes="none"`, because the header already
+ * states the words.
+ */
+export declare function TableColumnHeader({ align, blockAlign, children, column, numeric, ref, scope, sticky, stickyOffset, style, text, ...nativeProps }: TableColumnHeaderProps): import("react").JSX.Element;
+/**
+ * The cell that identifies the record, which a screen reader repeats in each of
+ * the cells beside it. It states no colour of its own, so a selected record's
+ * name turns with the row and a disabled one dims with it.
+ */
+export declare function TableRowHeader({ align, blockAlign, numeric, ref, scope, sticky, stickyOffset, style, text, ...nativeProps }: TableRowHeaderProps): import("react").JSX.Element;
+export declare function TableCell({ align, blockAlign, numeric, ref, sticky, stickyOffset, style, text, ...nativeProps }: TableCellProps): import("react").JSX.Element;
+/**
+ * The column's name wrapped in a button, which is what the APG's own sortable
+ * example does. The cycle is ascending, descending, then none — the third state
+ * a reader who sorted by accident needs.
+ *
+ * The consumer's own `onClick` runs first and is composed rather than replaced:
+ * a handler that prevents the default keeps the sort from moving.
+ */
+export declare function TableSort({ children, column, onClick, ref, render, ...nativeProps }: TableSortProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * The slot beside a column's name for the controls it carries: a filter
+ * trigger, a column menu, a help hint. The family holds the place and the
+ * geometry; what a filter means is the consumer's query.
+ */
+export declare function TableColumnActions({ ref, ...props }: TableColumnActionsProps): import("react").JSX.Element;
+/**
+ * A row's own checkbox, in the cell the family lays out. The control is
+ * `checkbox`'s: the cell is this family's and the chooser is not, which is the
+ * division `list-item` recorded. Its name is the checkbox's own label, visually
+ * hidden — the label `checkbox` associates with its control and `data-grid`
+ * writes for its own chooser.
+ *
+ * `Shift` while pressing selects every row from the anchor to this one, by
+ * pointer and with `Space` alike — the gesture a file list, a mail client and
+ * React Aria's own table all use.
+ */
+export declare function TableSelect({ align, blockAlign, numeric, ref, sticky, stickyOffset, style, text, value, ...nativeProps }: TableSelectProps): import("react").JSX.Element;
+/**
+ * The header's checkbox. It covers the rows in the DOM, is indeterminate while
+ * some of them are selected, and states the count it covers in its own name — a
+ * selection over a whole result set is a decision only the consumer's query can
+ * make.
+ */
+export declare function TableSelectAll({ align, blockAlign, numeric, ref, sticky, stickyOffset, style, text, ...nativeProps }: TableSelectAllProps): import("react").JSX.Element;
+/**
+ * The Disclosure pattern, borrowed whole: a `button` carrying `aria-expanded`
+ * and naming the row it opens.
+ */
+export declare function TableExpander({ onClick, ref, value, ...nativeProps }: TableExpanderProps): import("react").JSX.Element;
+/**
+ * One row holding one cell that spans the table. It is not rendered while it is
+ * closed, so nothing is in the DOM that a reader is told about and cannot
+ * reach, and the expander says `aria-expanded="false"` in that state.
+ */
+export declare function TableDetail({ children, colSpan, ref, value, ...nativeProps }: TableDetailProps): ReactNode;
+/**
+ * What is shown when there is nothing. It takes a `result-state`, whose status
+ * axis already separates an empty set from a set a filter emptied — a second
+ * empty shape here would be a second answer to a question a family answers.
+ */
+export declare function TableEmpty({ colSpan, ref, ...nativeProps }: TableEmptyProps): import("react").JSX.Element;
+/**
+ * The skeleton rows of a first load: the table's shape before its content. A
+ * refresh over rows already read is the other state and is not this one —
+ * `loading` on the table dims the body and moves nothing.
+ */
+export declare function TableLoader({ children, ref, skeletonRows, ...nativeProps }: TableLoaderProps): import("react").JSX.Element;
+//# sourceMappingURL=table-parts.d.ts.map

package/dist/types/table/table-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-parts.d.ts","sourceRoot":"","sources":["../../../src/table/table-parts.tsx"],"names":[],"mappings":"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"}

package/dist/types/table/table.d.ts

@@ -0,0 +1,33 @@
+
+import type { TableContextValue, TableProps } from './table.types';
+export declare const TABLE_ROW_SELECTOR = "[data-part=\"body\"] > [data-part=\"row\"][data-value]";
+/**
+ * What the table around this part says. A cell outside one has no table to
+ * belong to, so this throws rather than rendering markup that looks right and
+ * announces nothing.
+ */
+export declare function useTable(): TableContextValue;
+/** The same context, for a part that is optional inside a table. */
+export declare function useOptionalTable(): TableContextValue | undefined;
+/**
+ * A table of moderate data: the platform's own structure, with sorting,
+ * selection, expansion and a place for a paging control.
+ *
+ * **The role is `table`, not `grid`.** The APG is explicit — a table "is not an
+ * interactive widget. Thus, its cells are not focusable or selectable" — so
+ * every control inside it is its own tab stop and the family binds no key of
+ * its own. `data-grid` is the composite widget with a cell cursor, and the four
+ * capabilities that need one are deferred to it.
+ *
+ * **The family holds the sort and reorders nothing.** The rows are the
+ * consumer's own children; reordering them would mean owning the data, which is
+ * the line between this family and `data-grid`. It asks, and the consumer
+ * applies the descriptor to its own array or its own query.
+ *
+ * **The root is the frame and the scroller is inside it.** A sticky header
+ * resolves against the nearest scrolling ancestor, and what the frame holds is
+ * everything that must not move when the table scrolls sideways: the border,
+ * the radius and the footer where a paged listing puts its control.
+ */
+export declare function Table({ children, columns, defaultExpanded, defaultSort, defaultValue, expanded, layout, loading, messages, onExpandedChange, onSortChange, onValueChange, ref, render, selectionMode, sort, cellAlign, stickyFooter, stickyHeader, stickyTo, striped, value, variant, ...nativeProps }: TableProps): import("react").JSX.Element;
+//# sourceMappingURL=table.d.ts.map

package/dist/types/table/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/table/table.tsx"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC;AAUzC,OAAO,KAAK,EACV,iBAAiB,EACjB,UAAU,EAIX,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,kBAAkB,2DAAuD,CAAC;AAIvF;;;;GAIG;AACH,wBAAgB,QAAQ,IAAI,iBAAiB,CAM5C;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,IAAI,iBAAiB,GAAG,SAAS,CAEhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CAAC,EACpB,QAAQ,EACR,OAAO,EACP,eAAe,EACf,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,GAAG,EACH,MAAM,EACN,aAAa,EACb,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,KAAK,EACL,OAAO,EACP,GAAG,WAAW,EACf,EAAE,UAAU,+BAyLZ"}