@cosmicdrift/kumiko-renderer 0.388.0 → 0.389.0

package/dist/hooks/use-list-view-state.d.ts

@@ -0,0 +1,43 @@
+import type { ListColumnPin, ListColumnSpec, ListTableOptions } from "@cosmicdrift/kumiko-types/screen";
+import type { ListStateStore } from "../components/list-state-store.tsx";
+import type { DataTableColumnPins, DataTableColumnWidths, DataTableDensity, DataTableViewColumn } from "../data-table-view-types.ts";
+export type ListViewSchemaColumn = {
+    readonly field: string;
+    readonly hidden?: boolean;
+    readonly pinned?: ListColumnPin;
+    readonly width?: number;
+    readonly minWidth?: number;
+};
+export type ListViewState = {
+    /** Undefined unless `table.columnPicker` is on. */
+    readonly columns: readonly DataTableViewColumn[] | undefined;
+    readonly density: DataTableDensity;
+    readonly userChoosesDensity: boolean;
+    readonly setColumns: (next: readonly DataTableViewColumn[]) => void;
+    readonly setDensity: (next: DataTableDensity) => void;
+    /** Undefined unless `table.pinning` is on. */
+    readonly pins: DataTableColumnPins | undefined;
+    readonly setPins: (next: DataTableColumnPins) => void;
+    /** Undefined unless `table.resizing` is on. */
+    readonly widths: DataTableColumnWidths | undefined;
+    readonly minWidths: DataTableColumnWidths | undefined;
+    readonly setWidth: (field: string, width: number) => void;
+    /** Active group field, "" = not grouped. */
+    readonly groupBy: string;
+    /** Undefined unless `table.grouping.userChoice` is on. */
+    readonly groupByFields: readonly string[] | undefined;
+    readonly setGroupBy: (next: string) => void;
+    readonly resetView: () => void;
+    readonly viewIsDefault: boolean;
+};
+export declare function listViewSchemaColumns(columns: readonly ListColumnSpec[]): ListViewSchemaColumn[];
+type ViewStateArgs = {
+    readonly storeKey: string;
+    readonly store: ListStateStore;
+    readonly table: ListTableOptions;
+    readonly schemaColumns: readonly ListViewSchemaColumn[];
+};
+/** Column choice, order and density of one list. Lives in the list-state store
+ *  (never in the URL) and is independent of `rememberState`. */
+export declare function useListViewState(args: ViewStateArgs): ListViewState;
+export {};

package/dist/hooks/use-list-view-state.js

@@ -0,0 +1,161 @@
+import { normalizeListColumn } from "@cosmicdrift/kumiko-framework/ui-types";
+import { useCallback, useMemo, useState } from "react";
+import { clampWidth, DEFAULT_MIN_COLUMN_WIDTH_PX, defaultPins, defaultWidths, mergeSavedWidths, minWidthsOf, sameRecord, } from "./list-column-layout.js";
+import { sanitizeStoredListState } from "./list-state-schema.js";
+export function listViewSchemaColumns(columns) {
+    return columns.map((column) => {
+        const { field, hidden, pinned, width, minWidth } = normalizeListColumn(column);
+        return {
+            field,
+            ...(hidden === true && { hidden }),
+            ...(pinned !== undefined && { pinned }),
+            ...(width !== undefined && { width }),
+            ...(minWidth !== undefined && { minWidth }),
+        };
+    });
+}
+function schemaDefaultColumns(schema) {
+    return schema.map((column) => ({ field: column.field, visible: column.hidden !== true }));
+}
+/** Saved order wins; a column the saved view has never seen takes its schema
+ *  position (after its schema predecessor) with its schema default. */
+function mergeSavedColumns(schema, saved) {
+    const merged = [...saved];
+    const present = new Set(saved.map((column) => column.field));
+    schema.forEach((column, index) => {
+        // skip: column already saved
+        if (present.has(column.field))
+            return;
+        const predecessor = schema[index - 1];
+        const predecessorAt = predecessor === undefined ? -1 : merged.findIndex((m) => m.field === predecessor.field);
+        merged.splice(predecessorAt + 1, 0, {
+            field: column.field,
+            visible: column.hidden !== true,
+        });
+        present.add(column.field);
+    });
+    return merged;
+}
+function sameColumns(a, b) {
+    return (a.length === b.length &&
+        a.every((c, i) => c.field === b[i]?.field && c.visible === b[i]?.visible));
+}
+function hasVisibleColumn(columns) {
+    return columns.some((column) => column.visible);
+}
+function groupByChoices(grouping) {
+    if (grouping?.userChoice !== true)
+        return undefined;
+    const offered = [
+        ...(grouping.field !== undefined ? [grouping.field] : []),
+        ...(grouping.fields ?? []),
+    ];
+    return [...new Set(offered)];
+}
+function isOfferedGroupBy(grouping, saved) {
+    if (saved === undefined)
+        return false;
+    const choices = groupByChoices(grouping);
+    return choices !== undefined && (saved === "" || choices.includes(saved));
+}
+function readInitialView(args, defaults) {
+    const saved = sanitizeStoredListState(args.store.read(args.storeKey), {
+        columnFields: args.schemaColumns.map((column) => column.field),
+        filterFields: [],
+    })?.view;
+    const savedGroupBy = saved?.groupBy;
+    const merged = args.table.columnPicker === true && saved?.columns !== undefined
+        ? mergeSavedColumns(args.schemaColumns, saved.columns)
+        : defaults.columns;
+    return {
+        columns: hasVisibleColumn(merged) ? merged : defaults.columns,
+        density: args.table.density?.userChoice === true && saved?.density ? saved.density : defaults.density,
+        // Saved pins replace the schema pins entirely, so the user can release a schema pin.
+        pins: args.table.pinning === true && saved?.pins !== undefined ? saved.pins : defaults.pins,
+        widths: args.table.resizing === true && saved?.widths !== undefined
+            ? mergeSavedWidths(defaults.widths, saved.widths, minWidthsOf(args.schemaColumns))
+            : defaults.widths,
+        groupBy: isOfferedGroupBy(args.table.grouping, savedGroupBy) ? savedGroupBy : defaults.groupBy,
+    };
+}
+/** Column choice, order and density of one list. Lives in the list-state store
+ *  (never in the URL) and is independent of `rememberState`. */
+export function useListViewState(args) {
+    const { storeKey, store, table, schemaColumns } = args;
+    const columnPicker = table.columnPicker === true;
+    const userChoosesDensity = table.density?.userChoice === true;
+    const pinning = table.pinning === true;
+    const resizing = table.resizing === true;
+    const groupByFields = useMemo(() => groupByChoices(table.grouping), [table.grouping]);
+    const userChoosesGroupBy = groupByFields !== undefined;
+    const minWidths = useMemo(() => minWidthsOf(schemaColumns), [schemaColumns]);
+    const defaults = useMemo(() => ({
+        columns: schemaDefaultColumns(schemaColumns),
+        density: table.density?.default ?? "comfortable",
+        pins: pinning ? defaultPins(schemaColumns) : {},
+        widths: resizing ? defaultWidths(schemaColumns, minWidths) : {},
+        groupBy: table.grouping?.field ?? "",
+    }), [schemaColumns, table.density?.default, pinning, resizing, minWidths, table.grouping?.field]);
+    const [seeded, setSeeded] = useState(() => ({
+        storeKey,
+        view: readInitialView(args, defaults),
+    }));
+    const view = seeded.storeKey === storeKey ? seeded.view : readInitialView(args, defaults);
+    if (seeded.storeKey !== storeKey)
+        setSeeded({ storeKey, view });
+    const commit = useCallback((next) => {
+        setSeeded({ storeKey, view: next });
+        store.write(storeKey, {
+            ...store.read(storeKey),
+            view: {
+                ...(columnPicker && { columns: next.columns }),
+                ...(userChoosesDensity && { density: next.density }),
+                ...(pinning && { pins: next.pins }),
+                ...(resizing && { widths: next.widths }),
+                ...(userChoosesGroupBy && { groupBy: next.groupBy }),
+            },
+        });
+    }, [store, storeKey, columnPicker, userChoosesDensity, pinning, resizing, userChoosesGroupBy]);
+    const setColumns = useCallback((next) => {
+        // skip: a view must keep at least one visible column
+        if (!hasVisibleColumn(next))
+            return;
+        commit({ ...view, columns: next });
+    }, [commit, view]);
+    const setDensity = useCallback((next) => commit({ ...view, density: next }), [commit, view]);
+    const setPins = useCallback((next) => commit({ ...view, pins: next }), [commit, view]);
+    const setWidth = useCallback((field, width) => commit({
+        ...view,
+        widths: {
+            ...view.widths,
+            [field]: clampWidth(width, minWidths[field] ?? DEFAULT_MIN_COLUMN_WIDTH_PX),
+        },
+    }), [commit, view, minWidths]);
+    const setGroupBy = useCallback((next) => commit({ ...view, groupBy: next }), [commit, view]);
+    const resetView = useCallback(() => {
+        setSeeded({ storeKey, view: defaults });
+        const { view: _dropped, ...rest } = store.read(storeKey) ?? {};
+        store.write(storeKey, rest);
+    }, [store, storeKey, defaults]);
+    return {
+        columns: columnPicker ? view.columns : undefined,
+        density: view.density,
+        userChoosesDensity,
+        setColumns,
+        setDensity,
+        pins: pinning ? view.pins : undefined,
+        setPins,
+        widths: resizing ? view.widths : undefined,
+        minWidths: resizing ? minWidths : undefined,
+        setWidth,
+        groupBy: view.groupBy,
+        groupByFields,
+        setGroupBy,
+        resetView,
+        viewIsDefault: view.density === defaults.density &&
+            (!columnPicker || sameColumns(view.columns, defaults.columns)) &&
+            (!pinning || sameRecord(view.pins, defaults.pins)) &&
+            (!resizing || sameRecord(view.widths, defaults.widths)) &&
+            view.groupBy === defaults.groupBy,
+    };
+}

package/dist/hooks/use-related-list-rows.d.ts

@@ -0,0 +1,27 @@
+import type { EditRelatedListSectionViewModel, Translate } from "../headless/index.ts";
+import type { DataTableSort } from "../primitives.tsx";
+import { type ListAggregates } from "./use-list-aggregates.ts";
+type Row = Readonly<Record<string, unknown>>;
+export type RelatedListRows = {
+    readonly rows: readonly Row[];
+    readonly firstLoad: boolean;
+    readonly error: ListAggregates["error"];
+    readonly hasData: boolean;
+    /** The one-shot fetch stopped early, so the client-side sort covers part of the set. */
+    readonly truncated: boolean;
+    readonly aggregates: ListAggregates;
+    readonly refetchSelfAndHost: () => Promise<void>;
+};
+/** Rows of a relatedList section: one fetch sorted on the client, or the loaded
+ *  rows of its server groups in server order when `table.grouping` is active. */
+export declare function useRelatedListRows(args: {
+    readonly section: EditRelatedListSectionViewModel;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly groupField: string | undefined;
+    readonly sort: DataTableSort | null;
+    readonly locale: string | undefined;
+    readonly refreshToken: unknown;
+    readonly onAfterWrite: (() => Promise<void> | void) | undefined;
+    readonly translate: Translate;
+}): RelatedListRows;
+export {};

package/dist/hooks/use-related-list-rows.js

@@ -0,0 +1,81 @@
+import { normalizeListColumn } from "@cosmicdrift/kumiko-framework/ui-types";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { sortByAccessor } from "../sort-by-accessor.js";
+import { useListAggregates } from "./use-list-aggregates.js";
+import { useQuery } from "./use-query.js";
+const DEFAULT_GROUP_PAGE_SIZE = 50;
+// A handler that omits `nextCursor` (or reports a `total` the fetched rows
+// already cover) has no further rows; only a real cursor marks truncation.
+function isTruncatedFetch(data) {
+    return (data !== null &&
+        typeof data.nextCursor === "string" &&
+        (data.total === undefined || data.total > data.rows.length));
+}
+/** Rows of a relatedList section: one fetch sorted on the client, or the loaded
+ *  rows of its server groups in server order when `table.grouping` is active. */
+export function useRelatedListRows(args) {
+    const { section, payload, groupField, sort, locale, refreshToken, onAfterWrite } = args;
+    const aggregates = useListAggregates({
+        queryType: section.query,
+        payload,
+        table: section.table,
+        groupField,
+        pageSize: section.pageSize ?? DEFAULT_GROUP_PAGE_SIZE,
+        paging: "cursor",
+        translate: args.translate,
+    });
+    const { grouped, refresh: refreshAggregates } = aggregates;
+    const rowsQuery = useQuery(section.query, payload, { enabled: !grouped });
+    const ownRefetch = rowsQuery.refetch;
+    const refetchOwn = useCallback(async () => {
+        refreshAggregates();
+        if (!grouped)
+            await ownRefetch();
+    }, [refreshAggregates, grouped, ownRefetch]);
+    const lastRefreshTokenRef = useRef(refreshToken);
+    useEffect(() => {
+        // skip: the token has not changed since the last refetch
+        if (lastRefreshTokenRef.current === refreshToken)
+            return;
+        lastRefreshTokenRef.current = refreshToken;
+        void refetchOwn();
+    }, [refreshToken, refetchOwn]);
+    const refetchSelfAndHost = useCallback(async () => {
+        await refetchOwn();
+        await onAfterWrite?.();
+    }, [refetchOwn, onAfterWrite]);
+    const sortAccessors = useMemo(() => {
+        const accessors = {};
+        for (const col of section.columns) {
+            const field = normalizeListColumn(col).field;
+            accessors[field] = (row) => {
+                const value = row[field];
+                if (value === null || value === undefined)
+                    return null;
+                return typeof value === "number" ? value : String(value);
+            };
+        }
+        return accessors;
+    }, [section.columns]);
+    const sortedRows = useMemo(() => sortByAccessor(rowsQuery.data?.rows ?? [], sort, sortAccessors, locale), [rowsQuery.data, sort, sortAccessors, locale]);
+    if (grouped) {
+        return {
+            rows: aggregates.rows,
+            firstLoad: aggregates.loading,
+            error: aggregates.error,
+            hasData: aggregates.serverGroups !== undefined,
+            truncated: false,
+            aggregates,
+            refetchSelfAndHost,
+        };
+    }
+    return {
+        rows: sortedRows,
+        firstLoad: rowsQuery.loading && rowsQuery.data === null,
+        error: rowsQuery.error,
+        hasData: rowsQuery.data !== null,
+        truncated: isTruncatedFetch(rowsQuery.data),
+        aggregates,
+        refetchSelfAndHost,
+    };
+}

package/dist/hooks/use-related-list-state.d.ts

@@ -0,0 +1,15 @@
+import type { EditRelatedListSectionViewModel } from "../headless/index.ts";
+/** Search, filters and sort of a relatedList section (component-local: it has
+ *  no URL namespace) plus the DataTable props of its `table` block. */
+export declare function useRelatedListState(section: EditRelatedListSectionViewModel, parentScreenId: string | undefined): {
+    search: string;
+    filters: Readonly<Record<string, readonly string[]>>;
+    sort: import("./use-list-url-state.ts").ListSort | null;
+    setSearch: (search: string) => void;
+    setFilters: import("react").Dispatch<import("react").SetStateAction<Readonly<Record<string, readonly string[]>>>>;
+    setSort: (sort: import("./use-list-url-state.ts").ListSort | null) => void;
+    reset: () => void;
+    atDefault: boolean;
+    listTable: import("./use-list-table.ts").ListTableProps;
+    groupField: string | undefined;
+};

package/dist/hooks/use-related-list-state.js

@@ -0,0 +1,31 @@
+import { useMemo } from "react";
+import { useListStateStore } from "../components/list-state-store.js";
+import { useListTable } from "./use-list-table.js";
+import { listViewSchemaColumns } from "./use-list-view-state.js";
+import { useRememberedLocalListState } from "./use-remembered-local-list-state.js";
+/** Search, filters and sort of a relatedList section (component-local: it has
+ *  no URL namespace) plus the DataTable props of its `table` block. */
+export function useRelatedListState(section, parentScreenId) {
+    const store = useListStateStore();
+    const storeKey = `${parentScreenId ?? ""}#${section.id ?? section.query}`;
+    const defaultSort = useMemo(() => section.defaultSort ?? null, [section.defaultSort]);
+    const schemaColumns = useMemo(() => listViewSchemaColumns(section.columns), [section.columns]);
+    const known = useMemo(() => ({
+        columnFields: schemaColumns.map((column) => column.field),
+        filterFields: (section.facets ?? []).map((facet) => facet.field),
+    }), [schemaColumns, section.facets]);
+    const local = useRememberedLocalListState({
+        storeKey,
+        store,
+        remember: section.table?.rememberState === true,
+        defaultSort,
+        known,
+    });
+    const { props: listTable, groupField } = useListTable({
+        storeKey,
+        table: section.table,
+        schemaColumns,
+        local: { atDefault: local.atDefault, reset: local.reset },
+    });
+    return { ...local, listTable, groupField };
+}

package/dist/hooks/use-remembered-list-params.d.ts

@@ -0,0 +1,13 @@
+import type { ListStateStore } from "../components/list-state-store.tsx";
+import { type KnownListFields } from "./list-state-schema.ts";
+type RememberedListParamsArgs = {
+    readonly screenId: string;
+    readonly enabled: boolean;
+    readonly store: ListStateStore;
+    readonly known: KnownListFields;
+};
+/** URL stays the source of truth: the stored list params are copied into the
+ *  URL once when the screen opens without any, and every later URL change is
+ *  written back. A link that already carries list params is never overridden. */
+export declare function useRememberedListParams({ screenId, enabled, store, known, }: RememberedListParamsArgs): void;
+export {};

package/dist/hooks/use-remembered-list-params.js

@@ -0,0 +1,53 @@
+import { useEffect, useMemo, useRef } from "react";
+import { useNav } from "../app/nav.js";
+import { listParamKeys } from "./list-reset.js";
+import { sanitizeStoredListState } from "./list-state-schema.js";
+function stripScreenPrefix(params, screenId) {
+    const prefix = `${screenId}.`;
+    return Object.fromEntries(listParamKeys(params, screenId).flatMap((key) => {
+        const value = params[key];
+        return value === undefined ? [] : [[key.slice(prefix.length), value]];
+    }));
+}
+function sameParams(a, b) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => a[key] === b[key]);
+}
+/** URL stays the source of truth: the stored list params are copied into the
+ *  URL once when the screen opens without any, and every later URL change is
+ *  written back. A link that already carries list params is never overridden. */
+export function useRememberedListParams({ screenId, enabled, store, known, }) {
+    const nav = useNav();
+    const current = useMemo(() => stripScreenPrefix(nav.searchParams, screenId), [nav.searchParams, screenId]);
+    const phaseRef = useRef({ screenId, phase: "pending" });
+    useEffect(() => {
+        // skip: remembering is not enabled
+        if (!enabled)
+            return;
+        if (phaseRef.current.screenId !== screenId)
+            phaseRef.current = { screenId, phase: "pending" };
+        const state = phaseRef.current;
+        const currentIsEmpty = Object.keys(current).length === 0;
+        if (state.phase === "pending" && currentIsEmpty) {
+            const stored = sanitizeStoredListState(store.read(screenId), known)?.params;
+            if (stored !== undefined && Object.keys(stored).length > 0) {
+                state.phase = "restoring";
+                nav.setSearchParams(Object.fromEntries(Object.entries(stored).map(([k, v]) => [`${screenId}.${k}`, v])));
+                // skip: restore started, effect reruns with the restored URL
+                return;
+            }
+        }
+        // skip: waiting for the restored URL to arrive
+        if (state.phase === "restoring" && currentIsEmpty)
+            return;
+        state.phase = "live";
+        const existing = store.read(screenId);
+        // skip: nothing stored and nothing to store
+        if (existing?.params === undefined && currentIsEmpty)
+            return;
+        // skip: stored state already matches the URL
+        if (existing?.params !== undefined && sameParams(existing.params, current))
+            return;
+        store.write(screenId, { ...existing, params: current });
+    }, [enabled, screenId, current, known, store, nav]);
+}

package/dist/hooks/use-remembered-local-list-state.d.ts

@@ -0,0 +1,26 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { ListStateStore } from "../components/list-state-store.tsx";
+import { type KnownListFields } from "./list-state-schema.ts";
+import type { ListSort } from "./use-list-url-state.ts";
+type LocalFilters = Readonly<Record<string, readonly string[]>>;
+type LocalListStateArgs = {
+    readonly storeKey: string;
+    readonly store: ListStateStore;
+    /** `table.rememberState`: seeds from the store and writes every change back. */
+    readonly remember: boolean;
+    readonly defaultSort: ListSort | null;
+    readonly known: KnownListFields;
+};
+/** Search, facet filters and sort of a list whose state is component-local
+ *  (relatedList has no URL namespace). Same stored `params` format as the URL lists. */
+export declare function useRememberedLocalListState({ storeKey, store, remember, defaultSort, known, }: LocalListStateArgs): {
+    search: string;
+    filters: LocalFilters;
+    sort: ListSort | null;
+    setSearch: (search: string) => void;
+    setFilters: Dispatch<SetStateAction<Readonly<Record<string, readonly string[]>>>>;
+    setSort: (sort: ListSort | null) => void;
+    reset: () => void;
+    atDefault: boolean;
+};
+export {};

package/dist/hooks/use-remembered-local-list-state.js

@@ -0,0 +1,63 @@
+import { useCallback, useEffect, useState } from "react";
+import { sanitizeStoredListState } from "./list-state-schema.js";
+const FILTER_PREFIX = "f.";
+function sameSort(a, b) {
+    return a === b || (a !== null && b !== null && a.field === b.field && a.dir === b.dir);
+}
+function toParams(state, defaultSort) {
+    const params = {};
+    if (state.search !== "")
+        params["q"] = state.search;
+    if (!sameSort(state.sort, defaultSort) && state.sort !== null) {
+        params["sort"] = state.sort.field;
+        params["dir"] = state.sort.dir;
+    }
+    for (const [field, values] of Object.entries(state.filters)) {
+        if (values.length > 0)
+            params[`${FILTER_PREFIX}${field}`] = values.join(",");
+    }
+    return params;
+}
+function fromParams(params, defaultSort) {
+    const sortField = params?.["sort"];
+    const dir = params?.["dir"];
+    const sort = sortField !== undefined && (dir === "asc" || dir === "desc")
+        ? { field: sortField, dir }
+        : defaultSort;
+    const filters = {};
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (key.startsWith(FILTER_PREFIX)) {
+            filters[key.slice(FILTER_PREFIX.length)] = value.split(",").filter((v) => v !== "");
+        }
+    }
+    return { search: params?.["q"] ?? "", filters, sort };
+}
+/** Search, facet filters and sort of a list whose state is component-local
+ *  (relatedList has no URL namespace). Same stored `params` format as the URL lists. */
+export function useRememberedLocalListState({ storeKey, store, remember, defaultSort, known, }) {
+    const [state, setState] = useState(() => remember
+        ? fromParams(sanitizeStoredListState(store.read(storeKey), known)?.params, defaultSort)
+        : { search: "", filters: {}, sort: defaultSort });
+    useEffect(() => {
+        // skip: remembering is not enabled
+        if (!remember)
+            return;
+        const params = toParams(state, defaultSort);
+        const existing = store.read(storeKey);
+        // skip: nothing stored and nothing to store
+        if (existing?.params === undefined && Object.keys(params).length === 0)
+            return;
+        store.write(storeKey, { ...existing, params });
+    }, [remember, state, defaultSort, store, storeKey]);
+    const setSearch = useCallback((search) => setState((prev) => ({ ...prev, search })), []);
+    const setFilters = useCallback((next) => setState((prev) => ({
+        ...prev,
+        filters: typeof next === "function" ? next(prev.filters) : next,
+    })), []);
+    const setSort = useCallback((sort) => setState((prev) => ({ ...prev, sort })), []);
+    const reset = useCallback(() => setState({ search: "", filters: {}, sort: defaultSort }), [defaultSort]);
+    const atDefault = state.search === "" &&
+        Object.values(state.filters).every((values) => values.length === 0) &&
+        sameSort(state.sort, defaultSort);
+    return { ...state, setSearch, setFilters, setSort, reset, atDefault };
+}

package/dist/i18n-defaults.js

@@ -86,6 +86,44 @@ export const kumikoDefaultTranslations = {
         "kumiko.list.sort.unsorted": "Unsorted",
         "kumiko.list.filter.reset": "Reset",
         "kumiko.list.filter.toggle": "Filters",
+        "kumiko.list.reset-all": "Reset",
+        "kumiko.list.export": "Export",
+        "kumiko.list.export-busy": "Exporting…",
+        "kumiko.list.export-too-many": "More than {max} rows. Narrow the list with a filter and export again.",
+        "kumiko.list.export-failed": "The export failed. Please try again.",
+        "kumiko.list.view.menu": "View",
+        "kumiko.list.view.columns": "Columns",
+        "kumiko.list.view.density": "Density",
+        "kumiko.list.view.density.comfortable": "Comfortable",
+        "kumiko.list.view.density.compact": "Compact",
+        "kumiko.list.view.reset": "Reset view",
+        "kumiko.list.group.by": "Group by",
+        "kumiko.list.group.none": "None",
+        "kumiko.list.group.empty": "(empty)",
+        "kumiko.list.group.load-more": "Load more",
+        "kumiko.list.group.loading": "Loading…",
+        "kumiko.list.group.loaded": "{loaded} of {count}",
+        "kumiko.list.measure.sum": "Sum of {label}",
+        "kumiko.list.measure.avg": "Average {label}",
+        "kumiko.list.measure.count": "Count",
+        "kumiko.list.measure.min": "Minimum {label}",
+        "kumiko.list.measure.max": "Maximum {label}",
+        "kumiko.list.measure.kind.sum": "Sum",
+        "kumiko.list.measure.kind.avg": "Average",
+        "kumiko.list.measure.kind.count": "Count",
+        "kumiko.list.measure.kind.min": "Minimum",
+        "kumiko.list.measure.kind.max": "Maximum",
+        "kumiko.list.totals.label": "Total",
+        "kumiko.list.range.min": "From",
+        "kumiko.list.range.max": "To",
+        "kumiko.list.notice.truncated": "Not every group is shown. Please narrow the list with a filter.",
+        "kumiko.list.notice.searchTruncated": "The search matched too many entries; groups and totals cover only part of them. Please filter further.",
+        "kumiko.list.view.column.move-up": "Move {column} up",
+        "kumiko.list.view.pinning": "Pinned columns",
+        "kumiko.list.view.pin-left": "Pin {column} left",
+        "kumiko.list.view.pin-right": "Pin {column} right",
+        "kumiko.list.column.resize": "Resize {column}",
+        "kumiko.list.view.column.move-down": "Move {column} down",
         "kumiko.list.related-list-truncated": "Showing the first {count} entries. More are available but not loaded — this list does not paginate.",
         "kumiko.reference.system-tenant": "System",
         "kumiko.reference.system-user": "System",
@@ -111,6 +149,21 @@ export const kumikoDefaultTranslations = {
         "kumiko.theme.light": "Light theme",
         "kumiko.list.row.collapse": "Collapse {title}",
         "kumiko.list.row.expand": "Expand {title}",
+        "kumiko.list.bulk.selected": "{count} selected",
+        "kumiko.list.bulk.clear": "Clear selection",
+        "kumiko.list.bulk.limit": "At most {max} rows per selection",
+        "kumiko.list.bulk.select-all": "Select all rows on this page",
+        "kumiko.list.bulk.select-row": "Select {title}",
+        "kumiko.list.bulk.progress": "{settled} of {total} done",
+        "kumiko.list.bulk.cancel": "Cancel",
+        "kumiko.list.bulk.cancelling": "Cancelling…",
+        "kumiko.list.bulk.confirm": "Run “{action}” on the selection ({count})?",
+        "kumiko.list.bulk.result.title": "“{action}” finished",
+        "kumiko.list.bulk.result.succeeded": "Succeeded: {count}",
+        "kumiko.list.bulk.result.failed": "Failed: {count}",
+        "kumiko.list.bulk.result.skipped": "Skipped: {count}",
+        "kumiko.list.bulk.result.not-started": "Not run: {count}",
+        "kumiko.list.bulk.result.dismiss": "Dismiss",
         "kumiko.list.sort.by": "Sorted by {column}",
         "kumiko.form.changed": "changed",
         "kumiko.form.on-this-page": "On this page",

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export { type Formality, formalLocaleTag } from "@cosmicdrift/kumiko-framework/u
 export { synthesizeActionFormEntity, synthesizeActionFormScreen } from "./app/action-form-shim.ts";
 export type { AppFeaturesProviderProps } from "./app/app-features-context.tsx";
 export { AppFeaturesProvider, useAppFeatures } from "./app/app-features-context.tsx";
+export { normalizeBasePath, prependBasePath, stripBasePath } from "./app/base-path.ts";
+export { BasePathProvider, useBasePath } from "./app/base-path-context.tsx";
 export type { ActionNotice, ActionNotifier, ClientActionHandler, ClientActionOutcome, ClientActionRuntime, ClientActionsMap, } from "./app/client-actions.tsx";
 export { ActionNoticeProvider, ClientActionsProvider, runClientAction, useClientActionHandler, useClientActionRuntime, } from "./app/client-actions.tsx";
 export type { ColumnRendererComponent, ColumnRendererProps, ColumnRenderersMap, ColumnRenderersProviderProps, } from "./app/column-renderers.tsx";
@@ -86,7 +88,7 @@ export { InsideDrawerProvider, useInsideDrawer } from "./inside-drawer.ts";
 export { hasUnsavedInput, registerUnsavedInputSource, requestLeave, setLeaveConfirmer, useUnsavedInputSource, } from "./leave-guard.ts";
 export { LeaveGuardDialog } from "./leave-guard-dialog.tsx";
 export { PageHeaderCompactProvider, PageHeaderSlotAvailableProvider, usePageHeaderCompact, usePageHeaderSlotAvailable, } from "./page-header-slot.ts";
-export type { ActionMenuItemSpec, ActionOverflowMenuProps, AppPrimitives, BannerProps, ButtonProps, CardOptions, CardProps, CardSlots, CopyButtonProps, CorePrimitives, DataTableDateRangeFacet, DataTableFacet, DataTableFacetChip, DataTableProps, DataTableRowAction, DataTableRowActionMode, DataTableRowGrouping, DataTableSort, DataTableSortDir, DialogProps, DrawerProps, EmbeddedListCellType, EmbeddedListColumn, EmbeddedListInputProps, EmbeddedListTotal, FieldCellWidth, FieldProps, FileValueListProps, FillContainerProps, FooterActionMarker, FooterActionRole, FormProps, FormSectionNavItem, FormWidth, GridCellProps, GridProps, HeadingProps, InputFillAction, InputProps, JsonViewProps, LightboxImage, LightboxProps, LinkProps, MetricBandProps, MetricProps, ModalProps, PageHeaderProps, PickedFile, PrimitivesProviderProps, PrimitivesRegistry, ProgressProps, ProgressTone, PromoPanelAction, PromoPanelProps, RuntimeRenderer, SecretRevealProps, SecretRevealValue, SectionProps, ShareButtonProps, StatusBadgeProps, StatusTone, StepBarProps, StickyActionBarProps, StickyPrimaryActionMarker, TabsProps, TextProps, TrailingInputAction, WizardStepGroupProps, } from "./primitives.tsx";
+export type { ActionMenuItemSpec, ActionOverflowMenuProps, AppPrimitives, BannerProps, BulkRowOutcome, ButtonProps, CardOptions, CardProps, CardSlots, CopyButtonProps, CorePrimitives, DataTableBulk, DataTableBulkAction, DataTableDateRangeFacet, DataTableFacet, DataTableFacetChip, DataTableProps, DataTableRowAction, DataTableRowActionMode, DataTableSort, DataTableSortDir, DialogProps, DrawerProps, EmbeddedListCellType, EmbeddedListColumn, EmbeddedListInputProps, EmbeddedListTotal, FieldCellWidth, FieldProps, FileValueListProps, FillContainerProps, FooterActionMarker, FooterActionRole, FormProps, FormSectionNavItem, FormWidth, GridCellProps, GridProps, HeadingProps, InputFillAction, InputProps, JsonViewProps, LightboxImage, LightboxProps, LinkProps, MetricBandProps, MetricProps, ModalProps, PageHeaderProps, PickedFile, PrimitivesProviderProps, PrimitivesRegistry, ProgressProps, ProgressTone, PromoPanelAction, PromoPanelProps, RuntimeRenderer, SecretRevealProps, SecretRevealValue, SectionProps, ShareButtonProps, StatusBadgeProps, StatusTone, StepBarProps, StickyActionBarProps, StickyPrimaryActionMarker, TabsProps, TextProps, TrailingInputAction, WizardStepGroupProps, } from "./primitives.tsx";
 export { FOOTER_ACTION_ROLE_PROP, NARROW_LABEL_PROP, PrimitivesProvider, STICKY_PRIMARY_ACTION_PROP, shouldRenderActionsIconOnly, statusToneForOptionTone, statusToneForValue, useOptionalPrimitives, usePrimitives, } from "./primitives.tsx";
 export type { SessionEndedSignal, SessionEndedSignalProviderProps, } from "./session/session-ended.tsx";
 export { createSessionEndedSignal, isSessionEndedError, SESSION_ENDED_ERROR_CODES, SessionEndedSignalProvider, useSessionEndedSignal, withSessionEndedDetection, } from "./session/session-ended.tsx";

package/dist/index.js

@@ -11,6 +11,8 @@
 export { formalLocaleTag } from "@cosmicdrift/kumiko-framework/ui-types";
 export { synthesizeActionFormEntity, synthesizeActionFormScreen } from "./app/action-form-shim.js";
 export { AppFeaturesProvider, useAppFeatures } from "./app/app-features-context.js";
+export { normalizeBasePath, prependBasePath, stripBasePath } from "./app/base-path.js";
+export { BasePathProvider, useBasePath } from "./app/base-path-context.js";
 export { ActionNoticeProvider, ClientActionsProvider, runClientAction, useClientActionHandler, useClientActionRuntime, } from "./app/client-actions.js";
 export { ColumnRenderersProvider, useColumnRenderer } from "./app/column-renderers.js";
 export { CONTENT_EDITOR_ELEMENT_ID, ContentEditorsProvider, TextareaContentEditor, useContentEditor, } from "./app/content-editors.js";