@cosmicdrift/kumiko-renderer 0.389.0 → 0.390.0

package/dist/app/projection-detail-header-region.js

@@ -0,0 +1,81 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { resolveRecordTitle } from "../components/render-edit-helpers.js";
+import { requestLeave } from "../leave-guard.js";
+import { HeaderActionsBar } from "./header-actions-bar.js";
+import { buildMetricItems, renderActionErrorBanner, renderBandSubtitle, renderHeaderActionsContent, renderHeaderSubtitleSlot, renderHeaderTitleSlot, renderMetricsBlock, renderStatusBadge, } from "./projection-detail-header.js";
+import { buildDetailTabItems } from "./projection-detail-header-model.js";
+export function deriveDetailRegionPieces(model) {
+    const { screen, record, primitives, actionError, hasHeaderActions } = model;
+    // Grouped into the head Card alongside title/status/metrics:
+    // these are actions on the record the head shows, not on whichever tab is
+    // open, so they must stay in place across tab switches instead of
+    // trailing the active tab's content in the card footer.
+    const headerActionsContent = hasHeaderActions && renderHeaderActionsContent(model);
+    // Rendered as RenderEdit's headerRegion (not as JSX siblings before it) so
+    // this shares the same page padding/width as the record's edit card below
+    // it, instead of sitting flush against the screen edge (fw record-screen
+    // header polish).
+    const recordTitle = screen.recordTitleField !== undefined
+        ? resolveRecordTitle(record[screen.recordTitleField])
+        : undefined;
+    const headerTitleSlot = renderHeaderTitleSlot(model);
+    const headerSubtitleSlot = renderHeaderSubtitleSlot(model);
+    const metricItems = buildMetricItems(model);
+    const usesPageHeaderSlot = model.pageHeaderSlotAvailable && primitives.PageHeader !== undefined;
+    const pageHeaderCompact = model.pageHeaderCompactContext && usesPageHeaderSlot;
+    const statusBadge = renderStatusBadge(model);
+    const bandSubtitle = renderBandSubtitle(model, statusBadge, headerSubtitleSlot, pageHeaderCompact);
+    const actionErrorBanner = actionError !== null && renderActionErrorBanner(model, actionError);
+    return {
+        PageHeader: usesPageHeaderSlot ? primitives.PageHeader : undefined,
+        pageHeaderCompact,
+        recordTitle,
+        headerTitleSlot,
+        headerSubtitleSlot,
+        headerActionsContent,
+        statusBadge,
+        bandSubtitle,
+        metricItems,
+        actionErrorBanner,
+    };
+}
+function renderPageHeaderBranch(model, pieces, headerSlot, PageHeader) {
+    const { screen, record, primitives, setActionError, hasHeaderActions, hasMetrics } = model;
+    const { Grid, Button, Dialog, ActionOverflowMenu, MetricBand } = primitives;
+    const { pageHeaderCompact, recordTitle, statusBadge, bandSubtitle, metricItems } = pieces;
+    const header = screen.header;
+    return (_jsxs(_Fragment, { children: [_jsx(PageHeader, { ...(header !== undefined && { title: String(record[header.title] ?? "") }), ...(header === undefined && recordTitle !== undefined && { title: recordTitle }), ...(!pageHeaderCompact && statusBadge !== undefined && { status: statusBadge }), ...(hasHeaderActions && {
+                    actions: (_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-actions", children: _jsx(HeaderActionsBar, { actions: model.headerActionsList, Button: Button, Dialog: Dialog, ActionOverflowMenu: ActionOverflowMenu, onError: setActionError, collapseAfterPrimary: true, compact: pageHeaderCompact, PageHeader: PageHeader, ...(screen.primaryAction !== undefined && {
+                                preferredPrimaryId: screen.primaryAction,
+                            }) }) })),
+                }) }), MetricBand === undefined && bandSubtitle, MetricBand === undefined && headerSlot, (hasMetrics || bandSubtitle !== undefined || headerSlot !== undefined) &&
+                (MetricBand !== undefined || hasMetrics) &&
+                renderMetricsBlock(model, metricItems, bandSubtitle, MetricBand !== undefined ? headerSlot : undefined), pieces.actionErrorBanner] }));
+}
+function renderHeaderCardBranch(model, pieces, headerSlot) {
+    const { primitives, hasHeaderActions, hasMetrics, hasHeaderCard } = model;
+    const { Card } = primitives;
+    const { recordTitle, headerTitleSlot, headerSubtitleSlot, headerActionsContent } = pieces;
+    return ((hasHeaderCard || headerSlot !== undefined || recordTitle !== undefined) && (_jsxs(Card, { slots: {
+            ...(headerTitleSlot !== undefined && { title: headerTitleSlot }),
+            ...(headerTitleSlot === undefined && recordTitle !== undefined && { title: recordTitle }),
+            ...(headerSubtitleSlot !== undefined && { subtitle: headerSubtitleSlot }),
+            ...(headerSlot !== undefined && { headerContent: headerSlot }),
+            ...(hasHeaderActions && { headerActions: headerActionsContent }),
+        }, children: [hasMetrics && renderMetricsBlock(model, pieces.metricItems), pieces.actionErrorBanner] })));
+}
+function renderDetailTabs(model, activeSection, Tabs) {
+    const { screen, record, effectiveTranslate, nav } = model;
+    return (_jsx(Tabs, { testId: "kumiko-screen-projection-detail-tabs", items: buildDetailTabItems(screen.layout.sections, record, effectiveTranslate), activeId: activeSection.id ?? "", onSelect: (id) => requestLeave(() => nav.setSearchParams({ tab: id })) }));
+}
+export function renderDetailHeaderContent(model, pieces, headerSlot) {
+    const { hasTabs, activeSection } = model;
+    const { PageHeader } = pieces;
+    const { Tabs } = model.primitives;
+    return (_jsxs(_Fragment, { children: [PageHeader !== undefined
+                ? renderPageHeaderBranch(model, pieces, headerSlot, PageHeader)
+                : renderHeaderCardBranch(model, pieces, headerSlot), hasTabs &&
+                activeSection !== undefined &&
+                Tabs !== undefined &&
+                renderDetailTabs(model, activeSection, Tabs)] }));
+}

package/dist/app/projection-detail-header.d.ts

@@ -0,0 +1,29 @@
+import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { type Dispatch, type ReactNode, type SetStateAction } from "react";
+import type { RenderEditAction } from "../components/render-edit.tsx";
+import type { Translate } from "../headless/index.ts";
+import type { usePrimitives } from "../primitives.tsx";
+import { type ErrorNotice } from "./error-reference.tsx";
+import type { FeatureSchema } from "./feature-schema.ts";
+import type { NavApi } from "./nav.tsx";
+import type { ReturnHost } from "./return-to.tsx";
+export type DetailHeaderModel = {
+    readonly screen: ProjectionDetailScreenDefinition;
+    readonly record: Readonly<Record<string, unknown>>;
+    readonly primitives: ReturnType<typeof usePrimitives>;
+    readonly effectiveTranslate: Translate;
+    readonly nav: NavApi;
+    readonly appFeatures: readonly FeatureSchema[];
+    readonly userRoles: readonly string[] | undefined;
+    readonly host: ReturnHost | undefined;
+    readonly headerActionsList: readonly RenderEditAction[];
+    readonly setActionError: Dispatch<SetStateAction<ErrorNotice | null>>;
+};
+export declare function renderHeaderActionsContent(model: DetailHeaderModel): ReactNode;
+export declare function renderHeaderTitleSlot(model: DetailHeaderModel): ReactNode;
+export declare function renderHeaderSubtitleSlot(model: DetailHeaderModel): ReactNode;
+export declare function buildMetricItems(model: DetailHeaderModel): ReactNode[] | undefined;
+export declare function renderMetricsBlock(model: DetailHeaderModel, metricItems: ReactNode[] | undefined, subtitle?: ReactNode, lead?: ReactNode): ReactNode;
+export declare function renderStatusBadge(model: DetailHeaderModel): ReactNode;
+export declare function renderBandSubtitle(model: DetailHeaderModel, statusBadge: ReactNode, headerSubtitleSlot: ReactNode, pageHeaderCompact: boolean): ReactNode;
+export declare function renderActionErrorBanner(model: DetailHeaderModel, actionError: ErrorNotice): ReactNode;

package/dist/app/projection-detail-header.js

@@ -0,0 +1,84 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { ErrorReference } from "./error-reference.js";
+import { HeaderActionsBar } from "./header-actions-bar.js";
+import { headerStatusTone, resolveSubtitleHref } from "./projection-detail-header-model.js";
+import { buildSubtitleParts, runMetricNavigate } from "./projection-detail-navigation.js";
+import { navigateTargetAllows } from "./screen-access.js";
+export function renderHeaderActionsContent(model) {
+    const { screen, primitives, headerActionsList, setActionError } = model;
+    const { Grid, Button, Dialog, ActionOverflowMenu } = primitives;
+    return (_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-actions", children: _jsx(HeaderActionsBar, { actions: headerActionsList, Button: Button, Dialog: Dialog, ActionOverflowMenu: ActionOverflowMenu, onError: setActionError, ...(screen.primaryAction !== undefined && { preferredPrimaryId: screen.primaryAction }) }) }));
+}
+// Plain Text, not Heading — the Card title slot already renders as its own
+// heading element (h3); nesting another heading (h1) inside it is invalid HTML.
+export function renderHeaderTitleSlot(model) {
+    const { screen, record, primitives } = model;
+    const { Grid, Text, StatusBadge } = primitives;
+    const header = screen.header;
+    return header !== undefined ? (header.status !== undefined ? (_jsxs(Grid, { columns: "auto", children: [_jsx(Text, { testId: "kumiko-screen-projection-detail-title", children: String(record[header.title] ?? "") }), StatusBadge !== undefined ? (_jsx(StatusBadge, { value: String(record[header.status] ?? ""), tone: headerStatusTone(header, record), testId: "kumiko-screen-projection-detail-status" })) : (_jsx(Text, { testId: "kumiko-screen-projection-detail-status", children: String(record[header.status] ?? "") }))] })) : (_jsx(Text, { testId: "kumiko-screen-projection-detail-title", children: String(record[header.title] ?? "") }))) : undefined;
+}
+function renderSubtitleParts(model, subtitleParts) {
+    const { Text, Link } = model.primitives;
+    return (_jsx(Text, { testId: "kumiko-screen-projection-detail-subtitle", children: subtitleParts.map((part, index) => (_jsxs(Fragment, { children: [index > 0 && (_jsx(Text, { variant: "muted", decorative: true, children: " · " })), part.href !== undefined ? (_jsx(Link, { href: part.href, ...(part.onPress !== undefined && { onPress: part.onPress }), className: "underline", testId: `kumiko-screen-projection-detail-subtitle-${part.field}`, children: part.text })) : (_jsx(Text, { testId: `kumiko-screen-projection-detail-subtitle-${part.field}`, children: part.text }))] }, part.field))) }));
+}
+function renderSubtitleField(model, subtitleField) {
+    const { screen, record, primitives } = model;
+    const { Text, Link } = primitives;
+    const subtitleHref = resolveSubtitleHref(screen.header, record);
+    return subtitleHref !== undefined ? (_jsx(Link, { href: subtitleHref, target: "_blank", testId: "kumiko-screen-projection-detail-subtitle", children: String(record[subtitleField] ?? "") })) : (_jsx(Text, { variant: "muted", testId: "kumiko-screen-projection-detail-subtitle", children: String(record[subtitleField] ?? "") }));
+}
+export function renderHeaderSubtitleSlot(model) {
+    const { screen, record, nav, appFeatures, userRoles, host } = model;
+    const header = screen.header;
+    const subtitleParts = header !== undefined && typeof header.subtitle === "object"
+        ? buildSubtitleParts(header.subtitle, record, nav, appFeatures, userRoles, host)
+        : undefined;
+    return subtitleParts !== undefined
+        ? subtitleParts.length > 0
+            ? renderSubtitleParts(model, subtitleParts)
+            : undefined
+        : typeof header?.subtitle === "string"
+            ? renderSubtitleField(model, header.subtitle)
+            : undefined;
+}
+// slots.header shares the header card with the actions (one card, actions
+// top right) instead of rendering as an unframed block above it.
+export function buildMetricItems(model) {
+    const { screen, record, primitives, effectiveTranslate, nav, appFeatures, userRoles, host } = model;
+    const { Metric, GridCell, Text } = primitives;
+    return screen.metrics?.map((metric) => {
+        const field = metric.field;
+        const label = effectiveTranslate(metric.label);
+        const value = String(record[field] ?? "");
+        const testId = `kumiko-screen-projection-detail-metric-${field}`;
+        const navigate = metric.navigate;
+        const onPress = navigate !== undefined && navigateTargetAllows(navigate, appFeatures, userRoles)
+            ? () => runMetricNavigate(nav, navigate, record, host)
+            : undefined;
+        return Metric !== undefined ? (_jsx(Metric, { label: label, value: value, testId: testId, ...(onPress !== undefined && { onPress }) }, field)) : (_jsxs(GridCell, { children: [_jsx(Text, { variant: "small", testId: `${testId}-label`, children: label }), _jsx(Text, { testId: `${testId}-value`, children: value })] }, field));
+    });
+}
+// Metrics are a dl band when the primitive exists; the old Grid stays as the fallback.
+export function renderMetricsBlock(model, metricItems, subtitle, lead) {
+    const { screen, primitives } = model;
+    const { MetricBand, Grid } = primitives;
+    return MetricBand !== undefined ? (_jsx(MetricBand, { testId: "kumiko-screen-projection-detail-metrics", subtitle: subtitle, ...(lead !== undefined && { lead }), children: metricItems })) : (_jsx(Grid, { columns: screen.metrics?.length ?? 1, testId: "kumiko-screen-projection-detail-metrics", children: metricItems }));
+}
+// The phone shell header clips a long status mid-word, so on phones the badge
+// sits in the body instead of the shell header slot.
+export function renderStatusBadge(model) {
+    const { screen, record, primitives } = model;
+    const { StatusBadge } = primitives;
+    const header = screen.header;
+    return header?.status !== undefined && StatusBadge !== undefined ? (_jsx(StatusBadge, { value: String(record[header.status] ?? ""), tone: headerStatusTone(header, record), testId: "kumiko-screen-projection-detail-status" })) : undefined;
+}
+// Lives in the band's subtitle row so it shares the metrics' horizontal inset.
+export function renderBandSubtitle(model, statusBadge, headerSubtitleSlot, pageHeaderCompact) {
+    const { Grid } = model.primitives;
+    return pageHeaderCompact && statusBadge !== undefined ? (_jsxs(_Fragment, { children: [_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-status-row", children: statusBadge }), headerSubtitleSlot] })) : (headerSubtitleSlot);
+}
+export function renderActionErrorBanner(model, actionError) {
+    const { Banner } = model.primitives;
+    return (_jsxs(Banner, { variant: "error", testId: "render-edit-action-error", children: [actionError.message, _jsx(ErrorReference, { requestId: actionError.requestId })] }));
+}

package/dist/app/projection-detail-navigation.d.ts

@@ -0,0 +1,13 @@
+import type { MetricNavigate, RecordHeaderSubtitlePart } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { FeatureSchema } from "./feature-schema.ts";
+import type { NavApi } from "./nav.tsx";
+import type { ReturnHost } from "./return-to.tsx";
+export declare function runMetricNavigate(nav: NavApi, navigate: MetricNavigate, record: Readonly<Record<string, unknown>>, host: ReturnHost | undefined): void;
+export declare function isAbsoluteHttpUrl(value: string): boolean;
+export type SubtitlePartView = {
+    readonly field: string;
+    readonly text: string;
+    readonly href?: string;
+    readonly onPress?: () => void;
+};
+export declare function buildSubtitleParts(parts: readonly RecordHeaderSubtitlePart[], record: Readonly<Record<string, unknown>>, nav: NavApi, appFeatures: readonly FeatureSchema[], userRoles: readonly string[] | undefined, host: ReturnHost | undefined): SubtitlePartView[];

package/dist/app/projection-detail-navigation.js

@@ -0,0 +1,91 @@
+import { isSafeHref } from "../headless/index.js";
+import { requestLeave } from "../leave-guard.js";
+import { runProjectionRowNavigate } from "./row-actions.js";
+import { navigateTargetAllows } from "./screen-access.js";
+// Reuses runProjectionRowNavigate (row-actions.ts) instead of re-deriving
+// navigate execution — a metric click has the same entity/screen/params
+// shape as a RowActionNavigate, minus the fields (id, label, style) that
+// function never reads.
+export function runMetricNavigate(nav, navigate, record, host) {
+    // tab alone (no screen/entity) stays on the current record and just
+    // activates that tab — no route change, so runProjectionRowNavigate
+    // (which always navigates) doesn't apply here.
+    if (navigate.screen === undefined && navigate.entity === undefined) {
+        const { tab } = navigate;
+        if (tab !== undefined)
+            requestLeave(() => nav.setSearchParams({ tab }));
+        // skip: tab-only metric navigation never leaves the record
+        return;
+    }
+    const base = { kind: "navigate", id: "metric-navigate", label: "" };
+    const action = navigate.entity !== undefined
+        ? {
+            ...base,
+            entity: navigate.entity,
+            ...(navigate.entityId !== undefined && { entityId: navigate.entityId }),
+            ...(navigate.params !== undefined && { params: navigate.params }),
+            ...(navigate.tab !== undefined && { tab: navigate.tab }),
+        }
+        : navigate.screen !== undefined
+            ? {
+                ...base,
+                screen: navigate.screen,
+                ...(navigate.entityId !== undefined && { entityId: navigate.entityId }),
+                ...(navigate.params !== undefined && { params: navigate.params }),
+                ...(navigate.tab !== undefined && { tab: navigate.tab }),
+            }
+            : undefined;
+    // skip: a navigate without entity or screen target has nothing to open
+    if (action === undefined)
+        return;
+    runProjectionRowNavigate(nav, action, { id: "", values: record }, host);
+}
+// Absolute http(s) check for RecordHeaderSpec.subtitleHref — deliberately
+// stricter than isSafeHref (which also allows relative paths and mailto:),
+// since a relative/mailto value here should render as plain text, not a
+// "_blank" external link.
+export function isAbsoluteHttpUrl(value) {
+    return /^https?:\/\//i.test(value) && isSafeHref(value);
+}
+// hrefFor throws for an entity without a detailFor screen; outside
+// createKumikoApp the feature list is empty, so navigateTargetAllows can't
+// rule that out beforehand. The NavApi owns target resolution, so asking it
+// and falling back to plain text covers both cases.
+function hrefForNavigate(nav, navigate, record) {
+    const entityId = navigate.entityId !== undefined ? String(record[navigate.entityId] ?? "") : undefined;
+    try {
+        if (navigate.entity !== undefined) {
+            return entityId === undefined || entityId === ""
+                ? undefined
+                : nav.hrefFor({ entity: navigate.entity, id: entityId });
+        }
+        if (navigate.screen !== undefined) {
+            return nav.hrefFor({
+                screenId: navigate.screen,
+                ...(entityId !== undefined && entityId !== "" && { entityId }),
+            });
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+export function buildSubtitleParts(parts, record, nav, appFeatures, userRoles, host) {
+    return parts.flatMap((part) => {
+        const field = typeof part === "string" ? part : part.field;
+        const text = String(record[field] ?? "");
+        // skip: empty subtitle parts render nothing
+        if (text === "")
+            return [];
+        const navigate = typeof part === "string" ? undefined : part.navigate;
+        if (navigate === undefined || !navigateTargetAllows(navigate, appFeatures, userRoles)) {
+            return [{ field, text }];
+        }
+        const href = hrefForNavigate(nav, navigate, record);
+        // skip: unresolvable targets fall back to plain text
+        if (href === undefined)
+            return [{ field, text }];
+        return [{ field, text, href, onPress: () => runMetricNavigate(nav, navigate, record, host) }];
+    });
+}

package/dist/app/projection-detail-states.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { ReactNode } from "react";
+import type { Translate } from "../headless/index.ts";
+import type { usePrimitives } from "../primitives.tsx";
+import type { FeatureSchema } from "./feature-schema.ts";
+import type { NavApi } from "./nav.tsx";
+import { QueryErrorBanner } from "./query-state-banners.tsx";
+import { type useReturnTarget } from "./return-to.tsx";
+type DetailScreen = ProjectionDetailScreenDefinition & {
+    readonly detailFor?: string;
+};
+export declare function renderMissingIdBanner(primitives: Pick<ReturnType<typeof usePrimitives>, "Banner" | "Text">, screen: DetailScreen): ReactNode;
+export declare function renderDetailQueryError(error: Parameters<typeof QueryErrorBanner>[0]["error"], translate: Translate, onRetry: () => Promise<void>): ReactNode;
+type NotFoundModel = {
+    readonly schema: FeatureSchema;
+    readonly screen: DetailScreen;
+    readonly nav: NavApi;
+    readonly returnTarget: ReturnType<typeof useReturnTarget> | undefined;
+    readonly effectiveTranslate: Translate;
+};
+export declare function renderRecordNotFound(model: NotFoundModel): ReactNode;
+export {};

package/dist/app/projection-detail-states.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lastSegment } from "./qn.js";
+import { QueryErrorBanner } from "./query-state-banners.js";
+import { navigateToReturnOr } from "./return-to.js";
+import { findEntityListScreen, RecordNotFoundState } from "./screen-shared.js";
+export function renderMissingIdBanner(primitives, screen) {
+    const { Banner, Text } = primitives;
+    return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-detail-missing-id", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " (projectionDetail) needs a row id in the path \u2014 open it from a row action."] }));
+}
+export function renderDetailQueryError(error, translate, onRetry) {
+    return _jsx(QueryErrorBanner, { error: error, translate: translate, onRetry: onRetry });
+}
+export function renderRecordNotFound(model) {
+    const { schema, screen, nav, returnTarget, effectiveTranslate } = model;
+    const backListScreen = screen.listScreenId ??
+        (screen.detailFor !== undefined
+            ? findEntityListScreen(schema, screen.detailFor)?.id
+            : undefined);
+    return (_jsx(RecordNotFoundState, { translate: effectiveTranslate, ...((returnTarget !== undefined || backListScreen !== undefined) && {
+            onBack: () => navigateToReturnOr(nav, returnTarget, () => {
+                if (backListScreen !== undefined) {
+                    nav.navigate({ screenId: lastSegment(backListScreen) });
+                }
+            }),
+        }) }));
+}

package/dist/app/projection-drawer-host.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import type { Translate } from "../headless/index.ts";
+import { DrawerHost, type useDrawerAction } from "./action-form-body.tsx";
+import type { FeatureSchema } from "./feature-schema.ts";
+export type ProjectionDrawerModel = {
+    readonly schema: FeatureSchema;
+    readonly translate: Translate | undefined;
+    readonly userRoles: Parameters<typeof DrawerHost>[0]["userRoles"];
+    readonly drawer: Pick<ReturnType<typeof useDrawerAction>, "drawerAction" | "drawerScreen" | "drawerInitialValues" | "closeDrawer">;
+    readonly refreshRows: () => Promise<void>;
+};
+export declare function renderProjectionDrawerHost(model: ProjectionDrawerModel): ReactNode;

package/dist/app/projection-drawer-host.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DrawerHost } from "./action-form-body.js";
+export function renderProjectionDrawerHost(model) {
+    const { schema, translate, userRoles, drawer, refreshRows } = model;
+    const { drawerAction, drawerScreen, drawerInitialValues, closeDrawer } = drawer;
+    return (_jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+            closeDrawer();
+            void refreshRows();
+        } }));
+}

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

@@ -1,5 +1,5 @@
 import type { ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import { type ReactNode } from "react";
+import type { ReactNode } from "react";
 import type { ListRowViewModel, Translate } from "../headless/index.ts";
 import type { FeatureSchema } from "./feature-schema.ts";
 export declare function ProjectionListBody({ schema, screen, translate, onRowClick, }: {