@thomasfosterau/components 0.0.0 → 0.2.0

package/dist/data/TreeList.svelte

@@ -0,0 +1,41 @@
+<!-- @component
+One collapsible node of a hierarchy: an always-visible summary row and a subtree that folds away under it.
+-->
+<!--
+  TreeList — one collapsible node of a hierarchy: a summary row that is always
+  visible, and a subtree that folds away under it.
+
+  Built on `<details>` / `<summary>` rather than a `{#if}` and a button, and
+  deliberately NOT on a bits-ui primitive: the element already gives the
+  disclosure semantics, the keyboard behaviour, and — on a modern browser —
+  find-in-page inside the collapsed content, which no JavaScript
+  implementation matches. A hand-rolled equivalent is three ARIA attributes
+  that have to stay in step with each other.
+
+  Open by default: a taxonomy the reader has to unfold node by node hides the
+  shape they came to see. Pass `open={false}` where the subtree is an aside.
+
+  ARIA contract: the platform's disclosure semantics, plus a `<ul>`/`<li>`
+  structure so the nesting is announced as nesting. No `aria-expanded` is
+  written by hand — the browser maps `open`, and a second copy can only ever
+  disagree with it. This is a disclosure tree, not an ARIA `tree` widget:
+  `role="tree"` would commit the caller to roving tabindex and typeahead over
+  arbitrary nested content, which is a much larger promise than folding a
+  taxonomy.
+-->
+<script lang="ts">let { open = $bindable(true), title, children, class: className, ...rest } = $props();
+export {};
+</script>
+
+<ul {...rest} class={['ml-1 pl-0', className]}>
+  <li class="relative block pl-2">
+    <details bind:open>
+      <summary
+        class="focus-visible:outline-primary block cursor-pointer marker:hidden focus:outline-hidden focus-visible:outline-1 focus-visible:outline-dotted"
+      >
+        {#if typeof title === 'string'}{title}{:else}{@render title()}{/if}
+      </summary>
+      {@render children?.()}
+    </details>
+  </li>
+</ul>

package/dist/data/TreeList.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+interface Props extends Omit<HTMLAttributes<HTMLUListElement>, 'title' | 'children'> {
+    /**
+     * Whether the subtree starts unfolded. Bindable.
+     * @defaultValue `true`
+     */
+    open?: boolean | undefined;
+    /** The always-visible summary row — its own text, or richer markup. */
+    title: string | Snippet<[]>;
+    /** The subtree — typically nested `TreeListItem`s. */
+    children?: Snippet<[]> | undefined;
+}
+/** One collapsible node of a hierarchy: an always-visible summary row and a subtree that folds away under it. */
+declare const TreeList: import("svelte").Component<Props, {}, "open">;
+type TreeList = ReturnType<typeof TreeList>;
+export default TreeList;

package/dist/data/TreeListItem.svelte

@@ -0,0 +1,29 @@
+<!-- @component
+One leaf under a `TreeList`, drawn with the connector rule that makes the nesting readable.
+-->
+<!--
+  TreeListItem — one leaf under a `TreeList`, drawn with the connector rule
+  that makes the nesting readable.
+
+  The rule is a border on the item rather than a line drawn between items, so
+  a subtree that grows or folds redraws itself; `last:border-transparent`
+  stops it running past the final child, which is the detail that separates a
+  tree from a stack of indented rows.
+
+  ARIA contract: a plain `<li>`. It is a list item inside its parent's list,
+  and the nesting is the structure — nothing is added.
+-->
+<script lang="ts">let { children, class: className, ...rest } = $props();
+export {};
+</script>
+
+<li
+  {...rest}
+  class={[
+    "border-base-300 border-l-2 before:absolute before:top-2 before:left-1 before:block before:content-['']",
+    'last:border-transparent',
+    className,
+  ]}
+>
+  {@render children?.()}
+</li>

package/dist/data/TreeListItem.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+interface Props extends Omit<HTMLAttributes<HTMLLIElement>, 'children'> {
+    /** The leaf's content, beside the connector rule. */
+    children?: Snippet<[]> | undefined;
+}
+/** One leaf under a `TreeList`, drawn with the connector rule that makes the nesting readable. */
+declare const TreeListItem: import("svelte").Component<Props, {}, "">;
+type TreeListItem = ReturnType<typeof TreeListItem>;
+export default TreeListItem;

package/dist/data/description-context.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How a {@link DescriptionRow} learns which {@link DescriptionList} it is
+ * inside.
+ *
+ * The list variants render their rows differently — a `grid` row is a
+ * wrapper holding a stacked `<dt>`/`<dd>` pair, while a `card` or `bare`
+ * row's `<dt>` and `<dd>` are direct children of the `<dl>`, because a
+ * wrapper would break the alignment of a two-column grid (the list's own for
+ * `card`, the consumer's for `bare`). A call site writes the same
+ * `<DescriptionRow>` either way.
+ *
+ * The variant travels down as context rather than as a prop so a caller
+ * cannot get a list and its rows out of step, and so the list stays the
+ * single place the choice is made. A row mounted with no list above it gets
+ * the defaults, which is what makes one usable inside an app's own `<dl>`.
+ *
+ * @module
+ */
+/** The presentation a `DescriptionList` asks its rows for. */
+export interface DescriptionListStyle {
+    /**
+     * The layout. `bare` adds no layout classes to the list and renders each
+     * row's `<dt>`/`<dd>` as direct children of the `<dl>`, for a consumer that
+     * lays the list out itself.
+     */
+    readonly variant: 'grid' | 'card' | 'divided' | 'inline' | 'bare';
+    /** Render values in a fixed-width face that breaks anywhere. */
+    readonly mono: boolean;
+    /** Render a row whose value is empty, using `emptyLabel`. */
+    readonly showEmpty: boolean;
+    /** What an empty value reads as when `showEmpty`. */
+    readonly emptyLabel: string;
+}
+/** The presentation a `DescriptionRow` uses outside any `DescriptionList`: the `grid` variant, proportional text, empty rows hidden. */
+export declare const defaultDescriptionListStyle: DescriptionListStyle;
+/** Declare the style every descendant `DescriptionRow` renders in. */
+export declare function setDescriptionListStyle(style: () => DescriptionListStyle): void;
+/** The enclosing list's style, or the defaults when there is no enclosing list. */
+export declare function getDescriptionListStyle(): () => DescriptionListStyle;

package/dist/data/description-context.js

@@ -0,0 +1,36 @@
+/**
+ * How a {@link DescriptionRow} learns which {@link DescriptionList} it is
+ * inside.
+ *
+ * The list variants render their rows differently — a `grid` row is a
+ * wrapper holding a stacked `<dt>`/`<dd>` pair, while a `card` or `bare`
+ * row's `<dt>` and `<dd>` are direct children of the `<dl>`, because a
+ * wrapper would break the alignment of a two-column grid (the list's own for
+ * `card`, the consumer's for `bare`). A call site writes the same
+ * `<DescriptionRow>` either way.
+ *
+ * The variant travels down as context rather than as a prop so a caller
+ * cannot get a list and its rows out of step, and so the list stays the
+ * single place the choice is made. A row mounted with no list above it gets
+ * the defaults, which is what makes one usable inside an app's own `<dl>`.
+ *
+ * @module
+ */
+import { getContext, setContext } from 'svelte';
+/** The presentation a `DescriptionRow` uses outside any `DescriptionList`: the `grid` variant, proportional text, empty rows hidden. */
+export const defaultDescriptionListStyle = {
+    variant: 'grid',
+    mono: false,
+    showEmpty: false,
+    emptyLabel: 'unrecorded',
+};
+const STYLE_KEY = Symbol('@thomasfosterau/components:description-list');
+/** Declare the style every descendant `DescriptionRow` renders in. */
+export function setDescriptionListStyle(style) {
+    setContext(STYLE_KEY, style);
+}
+/** The enclosing list's style, or the defaults when there is no enclosing list. */
+export function getDescriptionListStyle() {
+    return (getContext(STYLE_KEY) ??
+        (() => defaultDescriptionListStyle));
+}

package/dist/data/diff.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The segment shape `DiffText` renders.
+ *
+ * A `.ts` module rather than a `<script module>` block so the diff algorithm
+ * that produces these — which is the app's, not this package's — can import
+ * the type without reaching through a component.
+ *
+ * @module
+ */
+/** One run of a word- or character-level diff. */
+export interface DiffSegment {
+    readonly kind: 'equal' | 'insert' | 'delete';
+    readonly text: string;
+}

package/dist/data/diff.js

@@ -0,0 +1,10 @@
+/**
+ * The segment shape `DiffText` renders.
+ *
+ * A `.ts` module rather than a `<script module>` block so the diff algorithm
+ * that produces these — which is the app's, not this package's — can import
+ * the type without reaching through a component.
+ *
+ * @module
+ */
+export {};

package/dist/data/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * data — the tables, lists and pagers an index page and a detail page are
+ * built from.
+ *
+ * Two shapes of list run through this family, and the split is worth stating
+ * once. `Table` and `ItemList` present a window a caller already chose:
+ * they never decide which rows exist, so they serve a server-paged collection
+ * of 40,000 as happily as a list of four. `DataGrid` is the other shape —
+ * it sorts, filters and pages a bounded set the page already holds, entirely
+ * on the client — and it composes the first two rather than duplicating them.
+ *
+ * Every optional prop in this family is declared `T | undefined`, not bare
+ * `T`: the workspace compiles with `exactOptionalPropertyTypes`, under which
+ * `prop?: T` rejects an explicitly passed `undefined`, and a caller
+ * forwarding its own optional prop straight through would not compile.
+ *
+ * @module
+ */
+export { default as ChatBubble } from './ChatBubble.svelte';
+export { default as DataGrid } from './DataGrid.svelte';
+export { default as DescriptionList } from './DescriptionList.svelte';
+export { default as DescriptionRow } from './DescriptionRow.svelte';
+export { default as DiffText } from './DiffText.svelte';
+export { default as ItemList } from './ItemList.svelte';
+export { default as LinkListItem } from './LinkListItem.svelte';
+export { default as MessageThread } from './MessageThread.svelte';
+export { default as Pagination } from './Pagination.svelte';
+export { default as PaginationFooter } from './PaginationFooter.svelte';
+export { default as ResultCount } from './ResultCount.svelte';
+export { default as Table } from './Table.svelte';
+export { default as TreeList } from './TreeList.svelte';
+export { default as TreeListItem } from './TreeListItem.svelte';
+export * from './description-context.ts';
+export * from './diff.ts';
+export * from './list-item.ts';
+export * from './pagination.ts';
+export * from './table-types.ts';

package/dist/data/index.js

@@ -0,0 +1,37 @@
+/**
+ * data — the tables, lists and pagers an index page and a detail page are
+ * built from.
+ *
+ * Two shapes of list run through this family, and the split is worth stating
+ * once. `Table` and `ItemList` present a window a caller already chose:
+ * they never decide which rows exist, so they serve a server-paged collection
+ * of 40,000 as happily as a list of four. `DataGrid` is the other shape —
+ * it sorts, filters and pages a bounded set the page already holds, entirely
+ * on the client — and it composes the first two rather than duplicating them.
+ *
+ * Every optional prop in this family is declared `T | undefined`, not bare
+ * `T`: the workspace compiles with `exactOptionalPropertyTypes`, under which
+ * `prop?: T` rejects an explicitly passed `undefined`, and a caller
+ * forwarding its own optional prop straight through would not compile.
+ *
+ * @module
+ */
+export { default as ChatBubble } from './ChatBubble.svelte';
+export { default as DataGrid } from './DataGrid.svelte';
+export { default as DescriptionList } from './DescriptionList.svelte';
+export { default as DescriptionRow } from './DescriptionRow.svelte';
+export { default as DiffText } from './DiffText.svelte';
+export { default as ItemList } from './ItemList.svelte';
+export { default as LinkListItem } from './LinkListItem.svelte';
+export { default as MessageThread } from './MessageThread.svelte';
+export { default as Pagination } from './Pagination.svelte';
+export { default as PaginationFooter } from './PaginationFooter.svelte';
+export { default as ResultCount } from './ResultCount.svelte';
+export { default as Table } from './Table.svelte';
+export { default as TreeList } from './TreeList.svelte';
+export { default as TreeListItem } from './TreeListItem.svelte';
+export * from "./description-context.js";
+export * from "./diff.js";
+export * from "./list-item.js";
+export * from "./pagination.js";
+export * from "./table-types.js";

package/dist/data/list-item.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The row shape an index page maps its data into before handing it to
+ * `ItemList`.
+ *
+ * A type, not a resource: the caller's own mappers turn a wire document into
+ * it, which is what keeps every API's shape out of this package. It lives in
+ * a `.ts` module rather than a `<script module>` block so a mapper — and the
+ * mapper's unit test — can import it without reaching through a component.
+ *
+ * Both optional members are declared `?: T | undefined` rather than bare
+ * `?: T`. The workspace compiles under `exactOptionalPropertyTypes`, where
+ * `{ subtitle: undefined }` is not the same thing as an absent key: with the
+ * narrow declaration every mapper reading a possibly-absent attribute has to
+ * spread the member conditionally, which is three lines and a comment at
+ * every call site. Widening it here is what removes them.
+ *
+ * @module
+ */
+/** One row of a `LinkListItem`-shaped list. */
+export interface LinkListItemData {
+    /** Stable identity — the list's `{#each}` key. */
+    readonly id: string;
+    /** Where the row's title links to; resolved through the components context. */
+    readonly href: string;
+    readonly title: string;
+    /** A line of context under the title — an owner, a parent, a date. */
+    readonly subtitle?: string | undefined;
+    /** Short markers rendered as badges (a visibility state, a kind). */
+    readonly badges?: readonly string[] | undefined;
+}

package/dist/data/list-item.js

@@ -0,0 +1,19 @@
+/**
+ * The row shape an index page maps its data into before handing it to
+ * `ItemList`.
+ *
+ * A type, not a resource: the caller's own mappers turn a wire document into
+ * it, which is what keeps every API's shape out of this package. It lives in
+ * a `.ts` module rather than a `<script module>` block so a mapper — and the
+ * mapper's unit test — can import it without reaching through a component.
+ *
+ * Both optional members are declared `?: T | undefined` rather than bare
+ * `?: T`. The workspace compiles under `exactOptionalPropertyTypes`, where
+ * `{ subtitle: undefined }` is not the same thing as an absent key: with the
+ * narrow declaration every mapper reading a possibly-absent attribute has to
+ * spread the member conditionally, which is three lines and a comment at
+ * every call site. Widening it here is what removes them.
+ *
+ * @module
+ */
+export {};

package/dist/data/pagination.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Offset / limit pagination arithmetic, and the href that carries it.
+ *
+ * Pure functions, deliberately: the window a pager renders (first page, last
+ * page, the current page's neighbours, the gaps between them) is arithmetic
+ * with a dozen edge cases — an offset past the end, a zero limit, a total of
+ * zero — and arithmetic is far cheaper to pin in a unit test than in a
+ * rendered component. `Pagination` is then markup over {@link pageWindow}.
+ *
+ * Ported from an Effect implementation with `Option` replaced by
+ * `undefined` and the query Schema left behind in the app that needs it:
+ * decoding an app's own URL is the app's job, and a component library that
+ * owned it would drag a validation library onto every consumer's page.
+ *
+ * @module
+ */
+/** The JSON:API offset query parameter — the default {@link pageHref} writes. */
+export declare const PAGE_OFFSET_PARAM = "page[offset]";
+/** The JSON:API limit query parameter — the default {@link pageHref} writes. */
+export declare const PAGE_LIMIT_PARAM = "page[limit]";
+/** A resolved page position. */
+export interface Page {
+    readonly offset: number;
+    readonly limit: number;
+}
+/** The query-parameter names {@link pageHref} writes the position into. */
+export interface PageParamNames {
+    readonly offset?: string | undefined;
+    readonly limit?: string | undefined;
+}
+/**
+ * Build the href for `page` from `base` (a path, optionally with a query
+ * string and a fragment).
+ *
+ * Every other query parameter is preserved and the page parameters are
+ * replaced — paging through a filtered list that silently dropped the filter
+ * is the bug this shape exists to prevent. A relative `base` yields a
+ * relative href: the absolute origin below is a parsing scaffold, never part
+ * of the result.
+ */
+export declare function pageHref(base: string, page: Page, names?: PageParamNames): string;
+/** One entry in a rendered page window: a page link, or the gap before one. */
+export type PageWindowItem = {
+    readonly kind: 'page';
+    /** 1-based page number, as rendered. */
+    readonly page: number;
+    /** The offset that page starts at. */
+    readonly offset: number;
+    readonly current: boolean;
+} | {
+    readonly kind: 'gap'; /** The page number the gap follows. */
+    readonly after: number;
+};
+/** Everything a pager needs to draw itself, from one position and a total. */
+export interface PageWindow {
+    /** 1-based current page. */
+    readonly page: number;
+    /** Total pages; at least 1, even with no rows. */
+    readonly pageCount: number;
+    /** 1-based index of the first row shown, or 0 when there are no rows. */
+    readonly from: number;
+    /** 1-based index of the last row shown, or 0 when there are no rows. */
+    readonly to: number;
+    /** Offset of the previous page, or `undefined` on the first. */
+    readonly previous: number | undefined;
+    /** Offset of the next page, or `undefined` on the last. */
+    readonly next: number | undefined;
+    /** First page, last page, and `siblings` pages either side of the current. */
+    readonly items: readonly PageWindowItem[];
+}
+/**
+ * Compute the window of page links to render around `page`: the first and
+ * last pages always, plus `siblings` pages either side of the current one,
+ * with a gap marker wherever the sequence skips.
+ *
+ * Tolerant by construction — a zero or negative limit, a negative offset and
+ * an offset past the end all resolve to a real page rather than throwing,
+ * because every one of them arrives from a hand-edited URL sooner or later
+ * and a 500 is a worse answer than the first page.
+ */
+export declare function pageWindow(page: Page, total: number, siblings?: number): PageWindow;

package/dist/data/pagination.js

@@ -0,0 +1,79 @@
+/**
+ * Offset / limit pagination arithmetic, and the href that carries it.
+ *
+ * Pure functions, deliberately: the window a pager renders (first page, last
+ * page, the current page's neighbours, the gaps between them) is arithmetic
+ * with a dozen edge cases — an offset past the end, a zero limit, a total of
+ * zero — and arithmetic is far cheaper to pin in a unit test than in a
+ * rendered component. `Pagination` is then markup over {@link pageWindow}.
+ *
+ * Ported from an Effect implementation with `Option` replaced by
+ * `undefined` and the query Schema left behind in the app that needs it:
+ * decoding an app's own URL is the app's job, and a component library that
+ * owned it would drag a validation library onto every consumer's page.
+ *
+ * @module
+ */
+/** The JSON:API offset query parameter — the default {@link pageHref} writes. */
+export const PAGE_OFFSET_PARAM = 'page[offset]';
+/** The JSON:API limit query parameter — the default {@link pageHref} writes. */
+export const PAGE_LIMIT_PARAM = 'page[limit]';
+/**
+ * Build the href for `page` from `base` (a path, optionally with a query
+ * string and a fragment).
+ *
+ * Every other query parameter is preserved and the page parameters are
+ * replaced — paging through a filtered list that silently dropped the filter
+ * is the bug this shape exists to prevent. A relative `base` yields a
+ * relative href: the absolute origin below is a parsing scaffold, never part
+ * of the result.
+ */
+export function pageHref(base, page, names = {}) {
+    const url = new URL(base, 'http://pagination.invalid');
+    url.searchParams.set(names.offset ?? PAGE_OFFSET_PARAM, String(page.offset));
+    url.searchParams.set(names.limit ?? PAGE_LIMIT_PARAM, String(page.limit));
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+/**
+ * Compute the window of page links to render around `page`: the first and
+ * last pages always, plus `siblings` pages either side of the current one,
+ * with a gap marker wherever the sequence skips.
+ *
+ * Tolerant by construction — a zero or negative limit, a negative offset and
+ * an offset past the end all resolve to a real page rather than throwing,
+ * because every one of them arrives from a hand-edited URL sooner or later
+ * and a 500 is a worse answer than the first page.
+ */
+export function pageWindow(page, total, siblings = 1) {
+    const limit = Math.max(1, Math.floor(page.limit));
+    const offset = Math.max(0, Math.floor(page.offset));
+    const rows = Math.max(0, total);
+    const pageCount = Math.max(1, Math.ceil(rows / limit));
+    const current = Math.min(pageCount, Math.floor(offset / limit) + 1);
+    const wanted = [];
+    const want = (n) => {
+        if (n >= 1 && n <= pageCount && !wanted.includes(n))
+            wanted.push(n);
+    };
+    want(1);
+    for (let n = current - siblings; n <= current + siblings; n += 1)
+        want(n);
+    want(pageCount);
+    wanted.sort((left, right) => left - right);
+    const items = [];
+    for (const [index, n] of wanted.entries()) {
+        const previous = index > 0 ? wanted[index - 1] : undefined;
+        if (previous !== undefined && n - previous > 1)
+            items.push({ kind: 'gap', after: previous });
+        items.push({ kind: 'page', page: n, offset: (n - 1) * limit, current: n === current });
+    }
+    return {
+        page: current,
+        pageCount,
+        from: rows > 0 ? (current - 1) * limit + 1 : 0,
+        to: rows > 0 ? Math.min(rows, current * limit) : 0,
+        previous: current > 1 ? (current - 2) * limit : undefined,
+        next: current < pageCount ? current * limit : undefined,
+        items,
+    };
+}

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

@@ -0,0 +1,71 @@
+/**
+ * The column spec `Table` and `DataGrid` share.
+ *
+ * Declarative data rather than a table engine. The apps this is consolidated
+ * from were built on `@tanstack/svelte-table` — a column helper, a
+ * `createTable` instance, four row-model factories and a `FlexRender`
+ * indirection — which is ~40 kB of client JavaScript for tables whose whole
+ * job is to show rows, sort one column and page. The spec below is data, and
+ * the sorting / filtering / paging live in `DataGrid`'s own derivations.
+ * Reach for an engine again when something needs column resizing, grouping
+ * or virtualisation; none of those are on the map.
+ *
+ * @module
+ */
+import type { Snippet } from 'svelte';
+/**
+ * One column of a table.
+ *
+ * `value` is required and does triple duty: it is the cell's text, the key
+ * the column sorts on, and the corpus `DataGrid`'s filter searches. One
+ * accessor for all three is what stops a grid that sorts a column by one
+ * thing and shows another — the failure mode of a spec where they are
+ * separate. `cell` layers richer markup (a link, a badge, a formatted date)
+ * over that same value.
+ */
+export interface TableColumn<T> {
+    /** Stable id — the `{#each}` key and the sort state's handle. */
+    readonly key: string;
+    /** The `<th>` text, already in the caller's language. */
+    readonly header: string;
+    /** The cell's text, its sort key, and what a filter matches against. */
+    readonly value: (row: T) => string | number;
+    /** Richer cell markup; `value`'s result is rendered when omitted. */
+    readonly cell?: Snippet<[T]> | undefined;
+    /** Whether the header offers a sort control on this column. */
+    readonly sortable?: boolean | undefined;
+    /**
+     * Render this column's body cells as `<th scope="row">` — the row's header,
+     * so a screen reader moving down another column announces it with each cell
+     * ("Jane Smith, 48,000"). Give it to the column that names the row, usually
+     * one per table.
+     */
+    readonly rowHeader?: boolean | undefined;
+    /** Right-align numeric columns. */
+    readonly align?: 'start' | 'end' | undefined;
+    /** Extra classes on this column's header and body cells. */
+    readonly class?: string | undefined;
+}
+/**
+ * Which column a table is sorted by, and which way.
+ *
+ * Unsorted is `undefined`, not a `SortState` with an empty key: "no column"
+ * is the absence of a sort, and modelling it as a sentinel key means every
+ * reader of the state has to know the sentinel.
+ */
+export interface SortState {
+    /** The `key` of the sorted {@link TableColumn}. */
+    readonly key: string;
+    readonly direction: 'asc' | 'desc';
+}
+/**
+ * The next state in the three-step cycle a sortable header runs:
+ * unsorted → ascending → descending → unsorted.
+ *
+ * A pure function rather than a method on the component so `DataGrid` and a
+ * server-sorted caller cycle identically, and so the cycle is unit-testable
+ * without a DOM.
+ */
+export declare function nextSortState(current: SortState | undefined, key: string): SortState | undefined;
+/** What a column's `<th>` announces in `aria-sort`. */
+export declare function columnAriaSort(sort: SortState | undefined, key: string): 'ascending' | 'descending' | 'none';

package/dist/data/table-types.js

@@ -0,0 +1,35 @@
+/**
+ * The column spec `Table` and `DataGrid` share.
+ *
+ * Declarative data rather than a table engine. The apps this is consolidated
+ * from were built on `@tanstack/svelte-table` — a column helper, a
+ * `createTable` instance, four row-model factories and a `FlexRender`
+ * indirection — which is ~40 kB of client JavaScript for tables whose whole
+ * job is to show rows, sort one column and page. The spec below is data, and
+ * the sorting / filtering / paging live in `DataGrid`'s own derivations.
+ * Reach for an engine again when something needs column resizing, grouping
+ * or virtualisation; none of those are on the map.
+ *
+ * @module
+ */
+/**
+ * The next state in the three-step cycle a sortable header runs:
+ * unsorted → ascending → descending → unsorted.
+ *
+ * A pure function rather than a method on the component so `DataGrid` and a
+ * server-sorted caller cycle identically, and so the cycle is unit-testable
+ * without a DOM.
+ */
+export function nextSortState(current, key) {
+    if (current === undefined || current.key !== key)
+        return { key, direction: 'asc' };
+    if (current.direction === 'asc')
+        return { key, direction: 'desc' };
+    return undefined;
+}
+/** What a column's `<th>` announces in `aria-sort`. */
+export function columnAriaSort(sort, key) {
+    if (sort === undefined || sort.key !== key)
+        return 'none';
+    return sort.direction === 'asc' ? 'ascending' : 'descending';
+}