@cosmicdrift/kumiko-renderer 0.389.0 → 0.390.0

package/dist/app/projection-list-body.js

@@ -1,31 +1,25 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useMemo, useState } from "react";
 import { ListGroupPageBridges } from "../components/list-group-page-bridges.js";
-import { RenderList } from "../components/render-list.js";
 import { useOptionalDispatcher } from "../context/dispatcher-context.js";
 import { useIsEmbeddedScreen } from "../context/embedded-screen-context.js";
 import { useUserRoles } from "../context/user-roles-context.js";
-import { useListUrlState } from "../hooks/use-list-url-state.js";
 import { useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
-import { screenFillsHeight } from "../screen-fills-height.js";
-import { DrawerHost, useDrawerAction } from "./action-form-body.js";
+import { useDrawerAction } from "./action-form-body.js";
 import { useAppFeatures } from "./app-features-context.js";
 import { useClientActionRuntime } from "./client-actions.js";
-import { useListBulk } from "./list-bulk-actions.js";
-import { isListNarrowed, useListEmptyContent } from "./list-empty-content.js";
-import { buildFilterFacets, buildFilterPayload, mergeReferenceFacetOptions, resolveProjectionFacetSpecs, } from "./list-facets.js";
 import { useNav } from "./nav.js";
-import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim.js";
-import { QueryErrorBanner, QueryLoadingBanner } from "./query-state-banners.js";
+import { renderProjectionDrawerHost } from "./projection-drawer-host.js";
+import { renderBadShapeBanner, renderProjectionList, renderQueryRetryBanner, } from "./projection-list-render.js";
+import { resolveWrappedRowClick } from "./projection-list-row-click.js";
+import { QueryLoadingBanner } from "./query-state-banners.js";
 import { ReferenceFacetBridges } from "./reference-facet-bridge.js";
 import { useReturnHost } from "./return-to.js";
-import { buildDefaultEditRowAction, buildProjectionRowActions, buildProjectionToolbarActions, findRowClickAction, runDrawerRowAction, runProjectionRowNavigate, } from "./row-actions.js";
-import { findEditScreenFor } from "./screen-access.js";
-import { buildListQueryPayload } from "./screen-shared.js";
-import { useProjectionDateRange } from "./use-projection-date-range.js";
-import { listPager, useScreenListRows } from "./use-screen-list-rows.js";
-import { useScreenListTable } from "./use-screen-list-table.js";
+import { useProjectionListActions } from "./use-projection-list-actions.js";
+import { useProjectionListData } from "./use-projection-list-data.js";
+import { useProjectionListDefinitions } from "./use-projection-list-definitions.js";
+import { useProjectionListQuery } from "./use-projection-list-query.js";
+import { listPager } from "./use-screen-list-rows.js";
 // ---- projection-list ----
 // Like entityList, but the list query comes DIRECTLY from `screen.query`
 // (instead of being derived from an entity) — cross-feature capable.
@@ -45,206 +39,92 @@ export function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
     const effectiveTranslate = translate ?? t;
     const userRoles = useUserRoles();
     const appFeatures = useAppFeatures();
-    const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
-    const defaultEditScreen = useMemo(() => {
-        const detailFor = screen.detailFor;
-        if (detailFor === undefined)
-            return undefined;
-        return findEditScreenFor(detailFor, appFeatures, userRoles);
-    }, [appFeatures, screen.detailFor, userRoles]);
-    // searchable/sortable/paginated are derived at buildAppSchema time from the
-    // query handler's Zod schema — not authored on the screen.
-    const searchable = screen.searchable ?? false;
-    const sortable = screen.sortable ?? false;
-    const paginated = screen.paginated ?? false;
-    const entity = useMemo(() => synthesizeProjectionEntity(screen.columns, sortable), [screen.columns, sortable]);
-    const listScreen = useMemo(() => synthesizeProjectionScreen(screen), [screen]);
-    const urlState = useListUrlState(screen.id);
-    // Gated on the derived capability, not just on whether URL-state happens to
-    // carry a value — a stale/hand-crafted URL (?…q=x on a non-searchable
-    // screen) must not smuggle a param the query's Zod schema doesn't accept.
-    const activeSearch = searchable ? urlState.q : "";
-    // Same predicate that makes a header clickable: a stale link onto a
-    // sortable:false/unknown column must not reach the server (it answers 400).
-    const urlSort = urlState.sort;
-    const urlSortField = urlSort === null ? undefined : entity.fields[urlSort.field];
-    const urlSortAllowed = urlSortField !== undefined && "sortable" in urlSortField && urlSortField.sortable === true;
-    const activeSort = sortable
-        ? ((urlSortAllowed ? urlSort : null) ?? screen.defaultSort ?? null)
-        : null;
-    const limit = urlState.pageSize ?? screen.pageSize ?? 50;
-    // Pages-mode only (see header comment) — an author-set pagination:
-    // "infinite" on a paginated projectionList is silently a no-op today.
-    const usePager = paginated && (screen.pagination ?? "pages") === "pages";
-    // Facets — a projectionList has no entity, so screen.facets is
-    // the only field inventory; resolveProjectionFacetSpecs reshapes +
-    // translates its explicit labels into the same ResolvedFacetSpec the
-    // entityList adapter produces, so both feed the same
-    // buildFilterFacets/buildFilterPayload.
-    const facetSpecs = useMemo(() => resolveProjectionFacetSpecs(screen.facets, effectiveTranslate, schema.featureName), [screen.facets, effectiveTranslate, schema.featureName]);
-    const [projectionReferenceFacetOptions, setProjectionReferenceFacetOptions] = useState({});
-    const handleProjectionFacetOptions = useCallback((field, options) => setProjectionReferenceFacetOptions((prev) => prev[field] === options ? prev : { ...prev, [field]: options }), []);
-    const resolvedFacetSpecs = useMemo(() => mergeReferenceFacetOptions(facetSpecs, projectionReferenceFacetOptions), [facetSpecs, projectionReferenceFacetOptions]);
-    const filterPayload = useMemo(() => buildFilterPayload(urlState.filters, (field) => facetSpecs.find((spec) => spec.field === field)?.type), [urlState.filters, facetSpecs]);
-    const { dateRangePayload, dateRangeFacets, handleDateRangeChange } = useProjectionDateRange(screen.facets, effectiveTranslate, urlState);
-    const queryPayload = useMemo(() => {
-        const payload = buildListQueryPayload({
-            limit,
-            search: activeSearch,
-            sort: activeSort,
-            usePager,
-            page: urlState.page,
-            useInfinite: false,
-            cursor: undefined,
-        });
-        // Gated on screen.filter/screen.facets being declared (not just on
-        // urlState/filterPayload happening to carry a value) — same rule as
-        // activeSearch/activeSort above: a stale URL must not smuggle a param
-        // the bound query's Zod schema doesn't accept.
-        if (screen.filter !== undefined) {
-            payload["filter"] = screen.filter;
-        }
-        if (screen.facets !== undefined && filterPayload.length > 0) {
-            payload["filters"] = filterPayload;
-        }
-        Object.assign(payload, dateRangePayload);
-        return payload;
-    }, [
-        limit,
-        activeSearch,
-        activeSort,
-        usePager,
-        urlState.page,
-        screen.filter,
-        screen.facets,
-        filterPayload,
-        dateRangePayload,
-    ]);
-    const facetFilterFields = useMemo(() => (screen.facets ?? []).map((facet) => facet.field), [screen.facets]);
-    const listTable = useScreenListTable({
+    const drawer = useDrawerAction(schema);
+    const { openDrawer } = drawer;
+    const definitions = useProjectionListDefinitions(screen, appFeatures, userRoles);
+    const { defaultEditScreen, searchable, sortable, paginated, entity } = definitions;
+    const query = useProjectionListQuery({
         screen,
         featureName: schema.featureName,
-        payload: queryPayload,
-        filterFields: facetFilterFields,
-        queryType: screen.query,
-        pageSize: limit,
-        paging: usePager ? "offset" : "cursor",
-        translate: effectiveTranslate,
+        effectiveTranslate,
+        entity,
+        searchable,
+        sortable,
+        paginated,
     });
-    const listRows = useScreenListRows({
-        queryType: screen.query,
-        payload: queryPayload,
-        infinite: false,
-        aggregates: listTable.aggregates,
+    const data = useProjectionListData({
+        screen,
+        featureName: schema.featureName,
+        queryPayload: query.queryPayload,
+        limit: query.limit,
+        usePager: query.usePager,
+        effectiveTranslate,
+        resolvedFacetSpecs: query.resolvedFacetSpecs,
     });
+    const { listRows } = data;
     const refreshRows = listRows.refreshAfterWrite;
-    const filterFacets = useMemo(() => buildFilterFacets(resolvedFacetSpecs), [resolvedFacetSpecs]);
-    // Entity targets: see EntityListBody.runNavigate for why the resolution happens
-    // in the NavApi impl. Unlike there: NO row["id"]
-    // fallback — projectionList rows come from an arbitrary query projection
-    // with no guaranteed "id" field. The boot validator therefore enforces an
-    // explicit entityId for projectionList entity targets. Same helper
-    // relatedList's rowActions reuse (related-list-section.tsx) — a
-    // projectionDetail relatedList row has the identical "no guaranteed id"
-    // shape.
-    const runNavigate = useCallback((action, row) => runProjectionRowNavigate(nav, action, row, host), [nav, host]);
-    const defaultEditRowAction = useMemo(() => buildDefaultEditRowAction(defaultEditScreen), [defaultEditScreen]);
-    const rowActions = useMemo(() => buildProjectionRowActions({
-        rowActions: screen.rowActions,
-        translate: effectiveTranslate,
-        dispatcher,
-        nav,
-        refetch: refreshRows,
-        openDrawer,
-        defaultEditRowAction,
-        host,
-        clientActions,
-    }), [
-        screen.rowActions,
+    const actions = useProjectionListActions({
+        screen,
         effectiveTranslate,
         dispatcher,
         clientActions,
         nav,
-        refreshRows,
-        openDrawer,
-        defaultEditRowAction,
-        host,
-    ]);
-    const toolbarActions = useMemo(() => buildProjectionToolbarActions({
-        toolbarActions: screen.toolbarActions,
-        translate: effectiveTranslate,
-        dispatcher,
-        nav,
-        refetch: refreshRows,
-        openDrawer,
-        host,
-        access: { appFeatures, userRoles },
-    }), [
-        screen.toolbarActions,
-        effectiveTranslate,
-        nav,
         host,
-        dispatcher,
         refreshRows,
         openDrawer,
         appFeatures,
         userRoles,
-    ]);
-    const bulk = useListBulk({
-        bulkActions: screen.bulkActions,
-        rowActions: screen.rowActions,
-        translate: effectiveTranslate,
-        dispatcher,
-        reload: refreshRows,
-    });
-    const emptyContent = useListEmptyContent(screen.emptyState, effectiveTranslate, {
-        nav,
-        host,
-        dispatcher,
-        openDrawer,
-        onWriteSuccess: refreshRows,
+        defaultEditScreen,
     });
     if (listRows.firstLoad) {
         return _jsx(QueryLoadingBanner, {});
     }
     if (listRows.error && !listRows.hasData) {
-        return (_jsx(QueryErrorBanner, { error: listRows.error, translate: effectiveTranslate, onRetry: listRows.retry }));
+        return renderQueryRetryBanner(listRows, listRows.error, effectiveTranslate);
     }
     // A failed refetch keeps the last good data on screen.
-    const refetchErrorBanner = listRows.error ? (_jsx(QueryErrorBanner, { error: listRows.error, translate: effectiveTranslate, onRetry: listRows.retry })) : null;
+    const refetchErrorBanner = listRows.error
+        ? renderQueryRetryBanner(listRows, listRows.error, effectiveTranslate)
+        : null;
     // listRows.page is typed as PagedRows but the query handler is free to
     // return anything at runtime (a bare array silently rendered an empty
     // table instead of surfacing the mismatch), so the shape is checked.
     if (listRows.page !== null && !Array.isArray(listRows.page.rows)) {
-        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-list-bad-shape", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " query", " ", _jsx(Text, { variant: "code", children: screen.query }), " did not return a PagedRows envelope; a projectionList query must return ", _jsx(Text, { variant: "code", children: "{ rows, nextCursor }" }), "."] }));
+        return renderBadShapeBanner(screen, { Banner, Text });
     }
-    const rowClickAction = findRowClickAction(screen.rowActions);
-    const wrappedOnRowClick = rowClickAction
-        ? (row) => rowClickAction.kind === "drawer"
-            ? runDrawerRowAction(rowClickAction, openDrawer, row)
-            : runNavigate(rowClickAction, row)
-        : onRowClick !== undefined
-            ? (row) => onRowClick(row, listScreen.entity)
-            : undefined;
+    const wrappedOnRowClick = resolveWrappedRowClick({
+        screen,
+        onRowClick,
+        entityName: definitions.listScreen.entity,
+        openDrawer,
+        runNavigate: actions.runNavigate,
+    });
     // Same pager-construction as EntityListBody: no Pager UI until the
     // server-provided `total` arrives (guards pagination="pages" without
     // totalCount support).
-    const pager = listPager({ usePager, page: listRows.page, limit, urlState });
-    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ListGroupPageBridges, { ...listTable.aggregates.groupPages }), _jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleProjectionFacetOptions }), _jsx(RenderList, { screen: listScreen, entity: entity, rows: listRows.rows, featureName: schema.featureName, searchable: searchable, narrowed: isListNarrowed(activeSearch, urlState.filters), ...(screen.description !== undefined && {
-                    description: effectiveTranslate(screen.description),
-                }), ...(emptyContent !== undefined && { emptyContent }), searchValue: urlState.q, onSearchChange: urlState.setQ, sort: activeSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
-                    ? { screenPadding: false, chromeless: true }
-                    : { screenPadding: true }), ...(screenFillsHeight(listScreen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }), ...(bulk !== undefined && { bulk }), ...(toolbarActions !== undefined && { toolbarActions }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
-                    filterFacets,
-                    onFilterChange: urlState.setFilter,
-                }), ...(dateRangeFacets.length > 0 && {
-                    dateRangeFacets,
-                    onDateRangeChange: handleDateRangeChange,
-                }), ...listTable.props, ...((filterFacets.length > 0 || dateRangeFacets.length > 0) && {
-                    filterValues: urlState.filters,
-                    onFilterReset: urlState.clearFilters,
-                }) }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
-                    closeDrawer();
-                    void refreshRows();
-                } })] }));
+    const pager = listPager({
+        usePager: query.usePager,
+        page: listRows.page,
+        limit: query.limit,
+        urlState: query.urlState,
+    });
+    return (_jsxs(_Fragment, { children: [refetchErrorBanner, _jsx(ListGroupPageBridges, { ...data.listTable.aggregates.groupPages }), _jsx(ReferenceFacetBridges, { specs: query.facetSpecs, onOptions: query.handleProjectionFacetOptions }), renderProjectionList({
+                schema,
+                screen,
+                translate,
+                effectiveTranslate,
+                isEmbeddedScreen,
+                definitions,
+                query,
+                data,
+                actions,
+                pager,
+                wrappedOnRowClick,
+            }), renderProjectionDrawerHost({
+                schema,
+                translate,
+                userRoles,
+                drawer,
+                refreshRows,
+            })] }));
 }

package/dist/app/projection-list-render-props.d.ts

@@ -0,0 +1,56 @@
+import type { ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { ListRowViewModel, Translate } from "../headless/index.ts";
+import type { ListUrlStateApi } from "../hooks/use-list-url-state.ts";
+import type { useProjectionListActions } from "./use-projection-list-actions.ts";
+import type { useProjectionListData } from "./use-projection-list-data.ts";
+import type { useProjectionListDefinitions } from "./use-projection-list-definitions.ts";
+import type { useProjectionListQuery } from "./use-projection-list-query.ts";
+import type { listPager } from "./use-screen-list-rows.ts";
+export declare function projectionLeadProps(screen: ProjectionListScreenDefinition, effectiveTranslate: Translate, emptyContent: ReturnType<typeof useProjectionListActions>["emptyContent"]): {
+    description?: string | undefined;
+    emptyContent?: import("../components/list-empty-state.tsx").ListEmptyStateContent | undefined;
+};
+export declare function projectionLayoutProps(isEmbeddedScreen: boolean, screen: ProjectionListScreenDefinition, listScreen: ReturnType<typeof useProjectionListDefinitions>["listScreen"], pager: ReturnType<typeof listPager>, rowActions: ReturnType<typeof useProjectionListActions>["rowActions"]): {
+    screenPadding: boolean;
+    chromeless: boolean;
+    scrollBody?: boolean | undefined;
+    pager?: {
+        readonly page: number;
+        readonly limit: number;
+        readonly total: number;
+        readonly onPageChange: (next: number) => void;
+        readonly pageSizeOptions?: readonly number[];
+        readonly onPageSizeChange?: (next: number) => void;
+    } | undefined;
+    rowActions?: readonly import("../primitives.tsx").DataTableRowAction[] | undefined;
+    rowActionMode?: import("@cosmicdrift/kumiko-framework/ui-types").RowActionMode | undefined;
+} | {
+    screenPadding: boolean;
+    scrollBody?: boolean | undefined;
+    pager?: {
+        readonly page: number;
+        readonly limit: number;
+        readonly total: number;
+        readonly onPageChange: (next: number) => void;
+        readonly pageSizeOptions?: readonly number[];
+        readonly onPageSizeChange?: (next: number) => void;
+    } | undefined;
+    rowActions?: readonly import("../primitives.tsx").DataTableRowAction[] | undefined;
+    rowActionMode?: import("@cosmicdrift/kumiko-framework/ui-types").RowActionMode | undefined;
+};
+export declare function projectionActionProps(actions: ReturnType<typeof useProjectionListActions>, translate: Translate | undefined, wrappedOnRowClick: ((row: ListRowViewModel) => void) | undefined): {
+    bulk?: import("../data-table-bulk-types.ts").DataTableBulk | undefined;
+    toolbarActions?: readonly import("../components/render-list-toolbar-action.tsx").ToolbarActionButton[] | undefined;
+    translate?: Translate | undefined;
+    onRowClick?: ((row: ListRowViewModel) => void) | undefined;
+};
+export declare function projectionFacetProps(filterFacets: ReturnType<typeof useProjectionListData>["filterFacets"], dateRangeFacets: ReturnType<typeof useProjectionListQuery>["dateRangeFacets"], onDateRangeChange: ReturnType<typeof useProjectionListQuery>["handleDateRangeChange"], urlState: ListUrlStateApi): {
+    filterFacets?: import("../data-table-facet-types.ts").DataTableFacet[] | undefined;
+    onFilterChange?: ((field: string, values: readonly string[]) => void) | undefined;
+    dateRangeFacets?: import("../data-table-facet-types.ts").DataTableDateRangeFacet[] | undefined;
+    onDateRangeChange?: ((field: string, bound: "from" | "to", value: string) => void) | undefined;
+};
+export declare function projectionFilterStateProps(filterFacets: ReturnType<typeof useProjectionListData>["filterFacets"], dateRangeFacets: ReturnType<typeof useProjectionListQuery>["dateRangeFacets"], urlState: ListUrlStateApi): {
+    filterValues?: Readonly<Record<string, readonly string[]>> | undefined;
+    onFilterReset?: (() => void) | undefined;
+};

package/dist/app/projection-list-render-props.js

@@ -0,0 +1,47 @@
+import { screenFillsHeight } from "../screen-fills-height.js";
+export function projectionLeadProps(screen, effectiveTranslate, emptyContent) {
+    return {
+        ...(screen.description !== undefined && {
+            description: effectiveTranslate(screen.description),
+        }),
+        ...(emptyContent !== undefined && { emptyContent }),
+    };
+}
+export function projectionLayoutProps(isEmbeddedScreen, screen, listScreen, pager, rowActions) {
+    return {
+        ...(isEmbeddedScreen ? { screenPadding: false, chromeless: true } : { screenPadding: true }),
+        ...(screenFillsHeight(listScreen) && { scrollBody: true }),
+        ...(pager !== undefined && { pager }),
+        ...(rowActions !== undefined && { rowActions }),
+        ...(screen.rowActionMode !== undefined && { rowActionMode: screen.rowActionMode }),
+    };
+}
+export function projectionActionProps(actions, translate, wrappedOnRowClick) {
+    const { bulk, toolbarActions } = actions;
+    return {
+        ...(bulk !== undefined && { bulk }),
+        ...(toolbarActions !== undefined && { toolbarActions }),
+        ...(translate !== undefined && { translate }),
+        ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }),
+    };
+}
+export function projectionFacetProps(filterFacets, dateRangeFacets, onDateRangeChange, urlState) {
+    return {
+        ...(filterFacets.length > 0 && {
+            filterFacets,
+            onFilterChange: urlState.setFilter,
+        }),
+        ...(dateRangeFacets.length > 0 && {
+            dateRangeFacets,
+            onDateRangeChange,
+        }),
+    };
+}
+export function projectionFilterStateProps(filterFacets, dateRangeFacets, urlState) {
+    return {
+        ...((filterFacets.length > 0 || dateRangeFacets.length > 0) && {
+            filterValues: urlState.filters,
+            onFilterReset: urlState.clearFilters,
+        }),
+    };
+}

package/dist/app/projection-list-render.d.ts

@@ -0,0 +1,26 @@
+import type { ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { ReactNode } from "react";
+import type { ListRowViewModel, Translate } from "../headless/index.ts";
+import type { usePrimitives } from "../primitives.tsx";
+import type { FeatureSchema } from "./feature-schema.ts";
+import type { useProjectionListActions } from "./use-projection-list-actions.ts";
+import type { useProjectionListData } from "./use-projection-list-data.ts";
+import type { useProjectionListDefinitions } from "./use-projection-list-definitions.ts";
+import type { useProjectionListQuery } from "./use-projection-list-query.ts";
+import type { listPager, ScreenListRows } from "./use-screen-list-rows.ts";
+export type ProjectionListRenderModel = {
+    readonly schema: FeatureSchema;
+    readonly screen: ProjectionListScreenDefinition;
+    readonly translate: Translate | undefined;
+    readonly effectiveTranslate: Translate;
+    readonly isEmbeddedScreen: boolean;
+    readonly definitions: ReturnType<typeof useProjectionListDefinitions>;
+    readonly query: ReturnType<typeof useProjectionListQuery>;
+    readonly data: ReturnType<typeof useProjectionListData>;
+    readonly actions: ReturnType<typeof useProjectionListActions>;
+    readonly pager: ReturnType<typeof listPager>;
+    readonly wrappedOnRowClick: ((row: ListRowViewModel) => void) | undefined;
+};
+export declare function renderQueryRetryBanner(listRows: ScreenListRows, error: NonNullable<ScreenListRows["error"]>, effectiveTranslate: Translate): ReactNode;
+export declare function renderBadShapeBanner(screen: ProjectionListScreenDefinition, primitives: Pick<ReturnType<typeof usePrimitives>, "Banner" | "Text">): ReactNode;
+export declare function renderProjectionList(model: ProjectionListRenderModel): ReactNode;

package/dist/app/projection-list-render.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RenderList } from "../components/render-list.js";
+import { isListNarrowed } from "./list-empty-content.js";
+import { projectionActionProps, projectionFacetProps, projectionFilterStateProps, projectionLayoutProps, projectionLeadProps, } from "./projection-list-render-props.js";
+import { QueryErrorBanner } from "./query-state-banners.js";
+export function renderQueryRetryBanner(listRows, error, effectiveTranslate) {
+    return _jsx(QueryErrorBanner, { error: error, translate: effectiveTranslate, onRetry: listRows.retry });
+}
+export function renderBadShapeBanner(screen, primitives) {
+    const { Banner, Text } = primitives;
+    return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-list-bad-shape", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " query", " ", _jsx(Text, { variant: "code", children: screen.query }), " did not return a PagedRows envelope; a projectionList query must return ", _jsx(Text, { variant: "code", children: "{ rows, nextCursor }" }), "."] }));
+}
+export function renderProjectionList(model) {
+    const { schema, screen, translate, effectiveTranslate, isEmbeddedScreen } = model;
+    const { definitions, query, data, actions, pager, wrappedOnRowClick } = model;
+    const { urlState } = query;
+    const { filterFacets, listRows, listTable } = data;
+    const { dateRangeFacets } = query;
+    return (_jsx(RenderList, { screen: definitions.listScreen, entity: definitions.entity, rows: listRows.rows, featureName: schema.featureName, searchable: definitions.searchable, narrowed: isListNarrowed(query.activeSearch, urlState.filters), ...projectionLeadProps(screen, effectiveTranslate, actions.emptyContent), searchValue: urlState.q, onSearchChange: urlState.setQ, sort: query.activeSort, onSortChange: urlState.setSort, ...projectionLayoutProps(isEmbeddedScreen, screen, definitions.listScreen, pager, actions.rowActions), ...projectionActionProps(actions, translate, wrappedOnRowClick), ...projectionFacetProps(filterFacets, dateRangeFacets, query.handleDateRangeChange, urlState), ...listTable.props, ...projectionFilterStateProps(filterFacets, dateRangeFacets, urlState) }));
+}

package/dist/app/projection-list-row-click.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectionListScreenDefinition, RowActionNavigate } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { ListRowViewModel } from "../headless/index.ts";
+import type { useDrawerAction } from "./action-form-body.tsx";
+type RowClickInput = {
+    readonly screen: ProjectionListScreenDefinition;
+    readonly onRowClick: ((row: ListRowViewModel, entityName: string) => void) | undefined;
+    readonly entityName: string;
+    readonly openDrawer: ReturnType<typeof useDrawerAction>["openDrawer"];
+    readonly runNavigate: (action: RowActionNavigate, row: ListRowViewModel) => unknown;
+};
+export declare function resolveWrappedRowClick(input: RowClickInput): ((row: ListRowViewModel) => void) | undefined;
+export {};

package/dist/app/projection-list-row-click.js

@@ -0,0 +1,14 @@
+import { findRowClickAction, runDrawerRowAction } from "./row-actions.js";
+export function resolveWrappedRowClick(input) {
+    const { screen, onRowClick, entityName, openDrawer, runNavigate } = input;
+    const rowClickAction = findRowClickAction(screen.rowActions);
+    if (rowClickAction) {
+        return (row) => rowClickAction.kind === "drawer"
+            ? runDrawerRowAction(rowClickAction, openDrawer, row)
+            : runNavigate(rowClickAction, row);
+    }
+    // skip: no row-click wiring when neither the screen nor the host supplies a handler
+    if (onRowClick === undefined)
+        return undefined;
+    return (row) => onRowClick(row, entityName);
+}

package/dist/app/use-projection-detail-actions.d.ts

@@ -0,0 +1,35 @@
+import type { ProjectionDetailScreenDefinition, RowAction } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { RenderEditAction } from "../components/render-edit.tsx";
+import type { useOptionalDispatcher } from "../context/dispatcher-context.tsx";
+import type { useUserRoles } from "../context/user-roles-context.tsx";
+import type { Translate } from "../headless/index.ts";
+import type { useDrawerAction } from "./action-form-body.tsx";
+import type { useAppFeatures } from "./app-features-context.tsx";
+import type { useClientActionRuntime } from "./client-actions.tsx";
+import type { FeatureSchema } from "./feature-schema.ts";
+import type { NavApi } from "./nav.tsx";
+import { type useReturnHost, type useReturnTarget } from "./return-to.tsx";
+import type { useProjectionDetailData } from "./use-projection-detail-data.ts";
+type DetailActionsInput = {
+    readonly schema: FeatureSchema;
+    readonly screen: ProjectionDetailScreenDefinition & {
+        readonly detailFor?: string;
+    };
+    readonly effectiveTranslate: Translate;
+    readonly effectiveEntityId: string | undefined;
+    readonly nav: NavApi;
+    readonly host: ReturnType<typeof useReturnHost>;
+    readonly dispatcher: ReturnType<typeof useOptionalDispatcher>;
+    readonly clientActions: ReturnType<typeof useClientActionRuntime>;
+    readonly appFeatures: ReturnType<typeof useAppFeatures>;
+    readonly userRoles: ReturnType<typeof useUserRoles>;
+    readonly returnTarget: ReturnType<typeof useReturnTarget> | undefined;
+    readonly openDrawer: ReturnType<typeof useDrawerAction>["openDrawer"];
+    readonly detailQuery: ReturnType<typeof useProjectionDetailData>["detailQuery"];
+    readonly reloadDetail: ReturnType<typeof useProjectionDetailData>["reloadDetail"];
+};
+export declare function useProjectionDetailActions(input: DetailActionsInput): {
+    buildSectionActions: (actions: readonly RowAction[]) => readonly RenderEditAction[] | undefined;
+    headerActions: readonly RenderEditAction[] | undefined;
+};
+export {};