@cohesivesystems/presentation-core 0.1.0-alpha.1

package/dist/projected-collection-runtime.js

@@ -0,0 +1,832 @@
+import { createCollectionChromeRuntime, matchesCollectionChromeSlotPlacement, resolveCollectionChromeSlots, } from './collection-chrome-runtime.js';
+import { findPresentationAction, findPresentationField, } from './module.js';
+import { getPresentationViewProjectedActions, } from './presentation-semantics.js';
+import { readObjectPath, readObjectProperty, } from './object-path.js';
+import { resolvePresentationPageInfo, } from './presentation-pagination.js';
+import { collectionDetailActivations, collectionChromeSlotPlacements, collectionRowActionKinds, collectionSelectionActionParameterSources, collectionSelectionModes, presentationValueKinds, } from '@cohesivesystems/presentation-contracts';
+/**
+ * Annotation name used on collection chrome definitions to describe how the
+ * chrome was projected.
+ */
+export const collectionChromeProjectionAnnotationName = 'cohesive.presentation.collection-chrome.projection';
+/**
+ * Annotation name used on collection chrome slot definitions to describe how a
+ * specific slot was projected.
+ */
+export const collectionChromeSlotProjectionAnnotationName = 'cohesive.presentation.collection-chrome.slot.projection';
+/**
+ * Projection-mode tokens emitted by compatibility and declared collection
+ * chrome projection paths.
+ */
+export const collectionChromeProjectionModes = {
+    compatibilitySynthesized: 'compatibility-synthesized',
+    declared: 'declared',
+    mixed: 'mixed',
+};
+/**
+ * Creates the host-facing runtime for a projected collection.
+ *
+ * @param options View IR, data, module metadata, selection state, pagination,
+ * and navigation hooks used to bind collection semantics to runtime behavior.
+ */
+export function createProjectedCollectionRuntime({ createHref, data, module, pagination: paginationInput, selectionState = null, view, }) {
+    const collection = view?.Collection ?? null;
+    const chrome = createProjectedCollectionChromeRuntime(collection);
+    const bodySlot = chrome.bodySlot;
+    const selectionMode = resolveProjectedCollectionSelectionMode(collection);
+    const selectionEnabled = isCollectionSelectionEnabled(selectionMode);
+    const activeSelectionState = selectionEnabled ? selectionState : null;
+    const rowIdentityPath = bodySlot?.RowIdentityPath ?? null;
+    const rowLabelPath = bodySlot?.RowLabelPath ?? null;
+    const getRowId = rowIdentityPath
+        ? (row, index) => readProjectedCollectionRowIdentity(row, rowIdentityPath, index)
+        : undefined;
+    const selectedRowIds = activeSelectionState?.selectedRowIds ?? [];
+    const selectedRowIdSet = new Set(selectedRowIds);
+    const selectedRows = getRowId && selectedRowIds.length > 0
+        ? data.filter((row, index) => selectedRowIdSet.has(getRowId(row, index)))
+        : [];
+    const selectedRow = selectedRows[0] ?? null;
+    const detailSlot = chrome.detailSlot;
+    const detailIsRenderable = isRenderableCollectionDetailSlot(detailSlot);
+    const columns = createProjectedCollectionColumnRuntime({
+        bodySlot,
+        module,
+    });
+    const projectedActionRefs = getPresentationViewProjectedActions(view ?? null);
+    const rowActions = resolveProjectedCollectionRowActions(module, projectedActionRefs);
+    const selectionActions = resolveProjectedCollectionSelectionActions(module, projectedActionRefs);
+    const actionRuntime = createProjectedCollectionActionRuntime({
+        createHref,
+        rowActions,
+        selectionActions,
+        bodySlot,
+        selectedRowIds,
+        selectedRows,
+    });
+    const pagination = createProjectedCollectionPaginationRuntime({
+        chrome,
+        input: paginationInput,
+        itemCount: data.length,
+    });
+    return {
+        actions: actionRuntime,
+        chrome,
+        columns,
+        collection,
+        data,
+        detail: {
+            data: selectedRow,
+            emptyMessage: detailSlot?.EmptyMessage,
+            isRenderable: detailIsRenderable,
+            placement: detailSlot?.Placement,
+            title: detailSlot?.Title,
+            viewId: detailIsRenderable
+                ? detailSlot?.DetailViewId ?? null
+                : null,
+        },
+        getRowId,
+        pagination,
+        readRowLabel(row) {
+            return readProjectedCollectionRowLabel(row, rowLabelPath);
+        },
+        rowActions: rowActions.map(({ rowAction }) => rowAction),
+        selection: {
+            activateRow(row, index) {
+                const rowId = getRowId?.(row, index) ?? null;
+                if (!rowId || !activeSelectionState) {
+                    return;
+                }
+                if (isMultipleCollectionSelection(selectionMode)) {
+                    activeSelectionState.toggleRowId(rowId, selectionMode);
+                    return;
+                }
+                activeSelectionState.selectRowId(rowId, selectionMode);
+            },
+            isEnabled: selectionEnabled,
+            isMultiple: isMultipleCollectionSelection(selectionMode),
+            isRowSelected: activeSelectionState && getRowId
+                ? (row, index) => selectedRowIdSet.has(getRowId(row, index))
+                : undefined,
+            mode: selectionMode,
+            pruneToVisibleRows() {
+                if (!bodySlot?.ClearSelectionOnQueryChange ||
+                    !activeSelectionState ||
+                    !getRowId ||
+                    selectedRowIds.length === 0) {
+                    return;
+                }
+                const visibleRowIds = new Set(data.map((row, index) => getRowId(row, index)));
+                const visibleSelectedRowIds = selectedRowIds.filter((rowId) => visibleRowIds.has(rowId));
+                if (visibleSelectedRowIds.length !== selectedRowIds.length) {
+                    activeSelectionState.setSelectedRowIds(visibleSelectedRowIds);
+                }
+            },
+            selectedRow,
+            selectedRowIdSet,
+            selectedRowIds,
+            selectedRows,
+            state: activeSelectionState,
+        },
+        selectionActions: selectionActions.map(({ selectionAction }) => selectionAction),
+    };
+}
+/**
+ * Creates the collection chrome runtime for a projected collection definition.
+ */
+export function createProjectedCollectionChromeRuntime(collection) {
+    return createCollectionChromeRuntime(collection);
+}
+/**
+ * Resolves all collection chrome slots from a collection definition.
+ */
+export function resolveProjectedCollectionChromeSlots(collection) {
+    return resolveCollectionChromeSlots(collection);
+}
+/**
+ * Resolves the selection state identifier implied by collection chrome.
+ *
+ * Body state is preferred, followed by selection actions and detail state.
+ */
+export function resolveProjectedCollectionSelectionStateId(collection) {
+    const chrome = createProjectedCollectionChromeRuntime(collection);
+    return chrome.bodySlot?.StateId ??
+        chrome.selectionActionsSlot?.StateId ??
+        chrome.detailSlot?.StateId ??
+        null;
+}
+/**
+ * Resolves the collection selection mode, defaulting to `none` when no body
+ * slot declares selection.
+ */
+export function resolveProjectedCollectionSelectionMode(collection) {
+    return createProjectedCollectionChromeRuntime(collection).bodySlot?.SelectionMode ??
+        collectionSelectionModes.none;
+}
+/**
+ * Reads the projection mode annotation from collection chrome.
+ */
+export function readCollectionChromeProjectionMode(chrome) {
+    return readCollectionChromeProjectionModeAnnotation(chrome?.Annotations, collectionChromeProjectionAnnotationName);
+}
+/**
+ * Reads the projection mode annotation from a collection chrome slot.
+ */
+export function readCollectionChromeSlotProjectionMode(slot) {
+    return readCollectionChromeProjectionModeAnnotation(slot?.Annotations, collectionChromeSlotProjectionAnnotationName);
+}
+/**
+ * Checks whether a collection chrome slot carries a specific projection mode.
+ */
+export function isCollectionChromeSlotProjectionMode(slot, mode) {
+    return readCollectionChromeSlotProjectionMode(slot) === mode;
+}
+/**
+ * Resolves the first data source identifier attached to the collection
+ * pagination slot.
+ */
+export function resolveProjectedCollectionPaginationDataSourceId(collection) {
+    const paginationSlot = createProjectedCollectionChromeRuntime(collection).paginationSlot;
+    return paginationSlot?.DataSourceIds[0] ?? null;
+}
+/**
+ * Checks whether collection pagination chrome is declared.
+ */
+export function isProjectedCollectionPaginationEnabled(collection) {
+    return Boolean(createProjectedCollectionChromeRuntime(collection).paginationSlot);
+}
+/**
+ * Checks whether collection pagination is declared for footer placement.
+ */
+export function isProjectedCollectionPaginationFooterEnabled(collection) {
+    const chrome = createProjectedCollectionChromeRuntime(collection);
+    return Boolean(chrome.paginationFooterSlot);
+}
+/**
+ * Creates the pagination runtime by combining declared pagination chrome with a
+ * host pagination runtime and the current data-source response.
+ */
+function createProjectedCollectionPaginationRuntime({ chrome, input, itemCount, }) {
+    const slot = chrome.paginationSlot;
+    const definition = slot;
+    const isEnabled = Boolean(slot);
+    const dataSourceId = slot?.DataSourceIds[0] ?? null;
+    const placement = slot?.Placement ?? null;
+    const runtime = input?.runtime ?? null;
+    const pageInfo = runtime
+        ? resolvePresentationPageInfo({
+            binding: runtime.binding,
+            itemCount,
+            readDataSource: input?.readDataSource,
+            response: input?.response,
+            state: runtime.state,
+            totalCount: input?.totalCount,
+        })
+        : null;
+    return {
+        dataSourceId,
+        definition,
+        isEnabled,
+        isFetching: Boolean(input?.isFetching),
+        isFooterEnabled: isEnabled && isCollectionChromeFooterPlacement(slot?.Placement ?? null),
+        placement,
+        slot,
+        window: runtime && pageInfo
+            ? {
+                binding: runtime.binding,
+                canGoNextPage: pageInfo.hasNextPage,
+                canGoPreviousPage: runtime.canGoPreviousPage,
+                dataSourceId: runtime.dataSourceId,
+                goToFirstPage: runtime.goToFirstPage,
+                goToNextPage: () => runtime.goToNextPage(input?.response),
+                goToPreviousPage: runtime.goToPreviousPage,
+                pageIndex: runtime.pageIndex,
+                pageInfo,
+                pageSize: runtime.pageSize,
+                state: runtime.state,
+            }
+            : null,
+    };
+}
+/**
+ * Reads and validates collection chrome projection-mode annotations.
+ */
+function readCollectionChromeProjectionModeAnnotation(annotations, annotationName) {
+    const annotation = annotations?.find((candidate) => candidate.Name.toLocaleLowerCase() === annotationName);
+    if (!annotation) {
+        return null;
+    }
+    const value = annotation.Value;
+    const mode = typeof value === 'string'
+        ? value
+        : value && typeof value === 'object'
+            ? value.mode
+            : null;
+    return isCollectionChromeProjectionMode(mode) ? mode : null;
+}
+/**
+ * Checks whether an arbitrary annotation value is a known projection mode.
+ */
+function isCollectionChromeProjectionMode(value) {
+    return value === collectionChromeProjectionModes.declared ||
+        value === collectionChromeProjectionModes.compatibilitySynthesized ||
+        value === collectionChromeProjectionModes.mixed;
+}
+/**
+ * Checks whether a slot placement is semantically the footer placement.
+ */
+function isCollectionChromeFooterPlacement(placement) {
+    return matchesCollectionChromeSlotPlacement(placement, collectionChromeSlotPlacements.footer);
+}
+/**
+ * Builds visible column runtimes by resolving body-slot column declarations
+ * against field definitions in the presentation module.
+ */
+function createProjectedCollectionColumnRuntime({ bodySlot, module, }) {
+    if (!module || !bodySlot) {
+        return [];
+    }
+    return resolveCollectionBodyColumns(bodySlot).flatMap((column) => {
+        const field = findPresentationField(module, column.FieldId);
+        if (!field) {
+            return [];
+        }
+        const valuePath = column.ValuePath ?? field.Field;
+        return [{
+                column,
+                field,
+                header: field.Label,
+                id: column.Id || field.Id,
+                readValue: (row) => readProjectedCollectionValue(row, valuePath),
+                valuePath,
+            }];
+    });
+}
+/**
+ * Returns visible body columns in declared order.
+ */
+function resolveCollectionBodyColumns(bodySlot) {
+    return bodySlot.Columns
+        .filter((column) => column.IsVisible)
+        .sort((left, right) => left.Order - right.Order);
+}
+/**
+ * Creates the action runtime that resolves row and selection action items,
+ * builds execution contexts, and delegates invocation to host action runtimes.
+ */
+function createProjectedCollectionActionRuntime({ bodySlot, createHref, rowActions, selectionActions, selectedRowIds, selectedRows, }) {
+    const primaryRowActions = rowActions.filter(({ rowAction }) => isPrimaryCollectionRowAction(rowAction));
+    const contextRowActions = rowActions.filter(({ rowAction }) => isContextMenuCollectionRowAction(rowAction));
+    const activatedRowAction = resolveActivatedCollectionRowAction(bodySlot, rowActions);
+    return {
+        activatedRowAction,
+        canInvokeAction: canInvokeProjectedCollectionAction,
+        canInvokeRowAction: canInvokeProjectedRowAction,
+        canInvokeSelectionAction: canInvokeProjectedSelectionAction,
+        contextRowActions,
+        createRowActionContext(resolvedAction, row) {
+            return createProjectedRowActionExecutionContext(resolvedAction, row, createHref);
+        },
+        invokeAction: invokeProjectedCollectionAction,
+        invokeRowAction: invokeProjectedRowAction,
+        invokeSelectionAction: invokeProjectedSelectionAction,
+        primaryRowActions,
+        resolveRowActionItems(row, resolvedActions, options) {
+            return resolvedActions.flatMap((resolvedAction) => {
+                const { action, actionRef, rowAction } = resolvedAction;
+                if (!evaluateProjectedRowActionPredicate(rowAction.IsVisible, row, true)) {
+                    return [];
+                }
+                const actionContext = createProjectedRowActionExecutionContext(resolvedAction, row, createHref);
+                const isEnabled = evaluateProjectedRowActionPredicate(rowAction.IsEnabled, row, true) &&
+                    (options?.canExecuteAction?.(actionContext) ?? true);
+                return [{
+                        action,
+                        actionContext,
+                        actionRef,
+                        isEnabled,
+                        rowAction,
+                    }];
+            });
+        },
+        resolveSelectionActionItems(options) {
+            if (selectedRowIds.length === 0) {
+                return [];
+            }
+            return (options?.selectionActions ?? selectionActions)
+                .slice()
+                .sort((left, right) => left.selectionAction.Order - right.selectionAction.Order)
+                .flatMap((resolvedAction) => {
+                const { action, actionRef, selectionAction } = resolvedAction;
+                if (!evaluateProjectedSelectionActionPredicate(selectionAction.IsVisible, selectedRows, true)) {
+                    return [];
+                }
+                const actionContext = createProjectedSelectionActionExecutionContext(resolvedAction, selectedRows, selectedRowIds, createHref);
+                const isEnabled = isSelectionActionSelectionCountEnabled(selectionAction, selectedRowIds.length) &&
+                    evaluateProjectedSelectionActionPredicate(selectionAction.IsEnabled, selectedRows, true) &&
+                    (options?.canExecuteAction?.(actionContext) ?? true);
+                return [{
+                        action,
+                        actionContext,
+                        actionRef,
+                        isEnabled,
+                        selectionAction,
+                    }];
+            });
+        },
+        rowActions,
+        selectionActions,
+    };
+}
+/**
+ * Resolves row action references to concrete module actions.
+ */
+function resolveProjectedCollectionRowActions(module, actionRefs) {
+    return sortResolvedCollectionRowActions(actionRefs.flatMap((actionRef) => {
+        if (actionRef.contextKind !== 'collection-row' || !actionRef.rowAction) {
+            return [];
+        }
+        const action = findPresentationAction(module ?? null, actionRef.actionId);
+        return action
+            ? [{
+                    action,
+                    actionRef,
+                    rowAction: actionRef.rowAction,
+                    slotId: actionRef.slotId ?? null,
+                }]
+            : [];
+    }));
+}
+/**
+ * Resolves selection action references to concrete module actions.
+ */
+function resolveProjectedCollectionSelectionActions(module, actionRefs) {
+    return sortResolvedCollectionSelectionActions(actionRefs.flatMap((actionRef) => {
+        if (actionRef.contextKind !== 'collection-selection' || !actionRef.selectionAction) {
+            return [];
+        }
+        const action = findPresentationAction(module ?? null, actionRef.actionId);
+        return action
+            ? [{
+                    action,
+                    actionRef,
+                    selectionAction: actionRef.selectionAction,
+                    slotId: actionRef.slotId ?? null,
+                }]
+            : [];
+    }));
+}
+/**
+ * Sorts resolved row actions by declared action order.
+ */
+function sortResolvedCollectionRowActions(actions) {
+    return actions.slice().sort((left, right) => left.rowAction.Order - right.rowAction.Order);
+}
+/**
+ * Sorts resolved selection actions by declared action order.
+ */
+function sortResolvedCollectionSelectionActions(actions) {
+    return actions
+        .slice()
+        .sort((left, right) => left.selectionAction.Order - right.selectionAction.Order);
+}
+/**
+ * Resolves the row action invoked by row activation.
+ *
+ * An explicit activated-row action wins; otherwise the first primary row action
+ * is used when row activation is enabled.
+ */
+function resolveActivatedCollectionRowAction(bodySlot, rowActions) {
+    if (!bodySlot?.ActivateOnRowClick) {
+        return null;
+    }
+    return bodySlot.ActivatedRowActionId
+        ? rowActions.find(({ rowAction }) => rowAction.Id === bodySlot.ActivatedRowActionId ||
+            rowAction.ActionId === bodySlot.ActivatedRowActionId) ?? null
+        : rowActions.find(({ rowAction }) => isPrimaryCollectionRowAction(rowAction)) ?? null;
+}
+/**
+ * Checks whether a row action is intended for the primary action surface.
+ */
+function isPrimaryCollectionRowAction(rowAction) {
+    return matchesProjectionEnum(rowAction.Kind, collectionRowActionKinds.primary, 'primary');
+}
+/**
+ * Checks whether a row action is intended for contextual menu surfaces.
+ */
+function isContextMenuCollectionRowAction(rowAction) {
+    return matchesProjectionEnum(rowAction.Kind, collectionRowActionKinds.contextMenu, 'contextMenu');
+}
+/**
+ * Creates a row action execution context with row-bound parameters and optional
+ * navigation href.
+ */
+function createProjectedRowActionExecutionContext(resolvedAction, row, createHref) {
+    const { action, actionRef, rowAction } = resolvedAction;
+    const parameters = createProjectedRowActionParameters(actionRef, action, row);
+    return {
+        action,
+        actionRef,
+        contextKind: 'collection-row',
+        href: createProjectedActionHrefFromParameters(action, parameters, createHref),
+        parameters,
+        row,
+        rowAction,
+    };
+}
+/**
+ * Creates a selection action execution context with selection-bound parameters
+ * and optional navigation href.
+ */
+function createProjectedSelectionActionExecutionContext(resolvedAction, selectedRows, selectedRowIds, createHref) {
+    const { action, actionRef, selectionAction } = resolvedAction;
+    const parameters = createProjectedSelectionActionParameters(actionRef, selectedRows, selectedRowIds);
+    return {
+        action,
+        actionRef,
+        contextKind: 'collection-selection',
+        href: createProjectedActionHrefFromParameters(action, parameters, createHref),
+        parameters,
+        selectedRowIds,
+        selectedRows,
+        selectionAction,
+    };
+}
+/**
+ * Builds a navigation href for actions that target a route.
+ */
+function createProjectedActionHrefFromParameters(action, parameters, createHref) {
+    const routeId = action.Binding?.RouteId ?? action.Result?.NavigateToRouteId ?? null;
+    if (!routeId || !createHref) {
+        return null;
+    }
+    return createHref(routeId, parameters);
+}
+/**
+ * Creates row action parameters from explicit row-action bindings when present,
+ * otherwise from action parameter names read directly from the row.
+ */
+function createProjectedRowActionParameters(actionRef, action, row) {
+    const rowAction = actionRef.rowAction;
+    if (!rowAction) {
+        return createProjectedActionParameters(row, action.Parameters ?? []);
+    }
+    return rowAction.Parameters.length > 0
+        ? createProjectedBoundActionParameters(row, rowAction.Parameters)
+        : createProjectedActionParameters(row, action.Parameters ?? []);
+}
+/**
+ * Creates route parameters for a selection action from its declared selection
+ * parameter bindings.
+ */
+function createProjectedSelectionActionParameters(actionRef, selectedRows, selectedRowIds) {
+    const selectionAction = actionRef.selectionAction;
+    if (!selectionAction) {
+        return {};
+    }
+    const routeParameters = {};
+    for (const binding of selectionAction.Parameters) {
+        const value = readProjectedSelectionActionParameterValue(binding, selectedRows, selectedRowIds);
+        if (value === null || value === undefined || isEmptySelectionParameterValue(value)) {
+            if (!binding.OmitWhenEmpty) {
+                routeParameters[binding.Name] = '';
+            }
+            continue;
+        }
+        routeParameters[binding.Name] = Array.isArray(value)
+            ? value.map(toRouteParameterValue).join(',')
+            : toRouteParameterValue(value);
+    }
+    return routeParameters;
+}
+/**
+ * Reads the raw value for a selection action parameter binding.
+ */
+function readProjectedSelectionActionParameterValue(binding, selectedRows, selectedRowIds) {
+    if (matchesCollectionSelectionActionParameterSource(binding.Source, 'selectedRowIdentity')) {
+        return selectedRowIds[0];
+    }
+    if (matchesCollectionSelectionActionParameterSource(binding.Source, 'selectedRowIdentityList')) {
+        return selectedRowIds;
+    }
+    if (matchesCollectionSelectionActionParameterSource(binding.Source, 'selectedRowValue')) {
+        return binding.ValuePath && selectedRows[0]
+            ? readProjectedCollectionValue(selectedRows[0], binding.ValuePath)
+            : undefined;
+    }
+    if (matchesCollectionSelectionActionParameterSource(binding.Source, 'selectedRowValueList')) {
+        return binding.ValuePath
+            ? selectedRows.map((row) => readProjectedCollectionValue(row, binding.ValuePath ?? ''))
+            : [];
+    }
+    if (matchesCollectionSelectionActionParameterSource(binding.Source, 'selectionCount')) {
+        return selectedRowIds.length;
+    }
+    return undefined;
+}
+/**
+ * Matches generated enum values and string fallback keys for selection action
+ * parameter sources.
+ */
+function matchesCollectionSelectionActionParameterSource(source, key) {
+    return source === collectionSelectionActionParameterSources[key] ||
+        String(source).toLocaleLowerCase() === key.toLocaleLowerCase();
+}
+/**
+ * Checks whether a selection parameter should be treated as empty.
+ */
+function isEmptySelectionParameterValue(value) {
+    return Array.isArray(value) && value.length === 0;
+}
+/**
+ * Creates route parameters from row action parameter bindings.
+ */
+function createProjectedBoundActionParameters(row, bindings) {
+    const routeParameters = {};
+    for (const binding of bindings) {
+        const value = readProjectedCollectionValue(row, binding.ValuePath);
+        if (value === null || value === undefined) {
+            if (!binding.OmitWhenNull) {
+                routeParameters[binding.Name] = '';
+            }
+            continue;
+        }
+        routeParameters[binding.Name] = toRouteParameterValue(value);
+    }
+    return routeParameters;
+}
+/**
+ * Creates route parameters by reading action parameter names from a row object.
+ */
+function createProjectedActionParameters(row, parameters) {
+    const routeParameters = {};
+    for (const parameter of parameters) {
+        const value = readObjectProperty(row, parameter.Name);
+        if (value === null || value === undefined) {
+            continue;
+        }
+        routeParameters[parameter.Name] = toRouteParameterValue(value);
+    }
+    return routeParameters;
+}
+/**
+ * Checks host runtime visibility, disabled state, and optional `canExecute`
+ * before allowing action invocation.
+ */
+function canInvokeProjectedCollectionAction(context, actionRuntimes) {
+    const runtime = resolveProjectedCollectionActionRuntime(actionRuntimes, context);
+    if (runtime?.isHidden || runtime?.isDisabled) {
+        return false;
+    }
+    if (runtime?.execute) {
+        return runtime.canExecute?.(context) ?? true;
+    }
+    return false;
+}
+/**
+ * Row-action convenience wrapper around generic collection action invocation
+ * checks.
+ */
+function canInvokeProjectedRowAction(context, actionRuntimes) {
+    return canInvokeProjectedCollectionAction(context, actionRuntimes);
+}
+/**
+ * Invokes an action through the host action runtime when it is executable.
+ */
+async function invokeProjectedCollectionAction(context, actionRuntimes) {
+    const runtime = resolveProjectedCollectionActionRuntime(actionRuntimes, context);
+    if (runtime?.execute &&
+        !runtime.isHidden &&
+        !runtime.isDisabled &&
+        (runtime.canExecute?.(context) ?? true)) {
+        await runtime.execute(context);
+        return;
+    }
+}
+/**
+ * Row-action convenience wrapper around generic collection action invocation.
+ */
+async function invokeProjectedRowAction(context, actionRuntimes) {
+    await invokeProjectedCollectionAction(context, actionRuntimes);
+}
+/**
+ * Selection-action convenience wrapper around generic collection action
+ * invocation checks.
+ */
+function canInvokeProjectedSelectionAction(context, actionRuntimes) {
+    return canInvokeProjectedCollectionAction(context, actionRuntimes);
+}
+/**
+ * Selection-action convenience wrapper around generic collection action
+ * invocation.
+ */
+async function invokeProjectedSelectionAction(context, actionRuntimes) {
+    await invokeProjectedCollectionAction(context, actionRuntimes);
+}
+/**
+ * Resolves the host action runtime by action identifier.
+ */
+function resolveProjectedCollectionActionRuntime(actionRuntimes, context) {
+    return actionRuntimes?.[context.action.Id] ?? null;
+}
+/**
+ * Checks whether the current selection count is inside an action's declared
+ * min/max bounds.
+ */
+function isSelectionActionSelectionCountEnabled(selectionAction, selectionCount) {
+    return selectionCount >= selectionAction.MinimumSelectionCount &&
+        (selectionAction.MaximumSelectionCount === null ||
+            selectionAction.MaximumSelectionCount === undefined ||
+            selectionCount <= selectionAction.MaximumSelectionCount);
+}
+/**
+ * Evaluates row action visibility or enablement predicates against a row.
+ */
+function evaluateProjectedRowActionPredicate(predicate, row, fallback) {
+    if (!predicate) {
+        return fallback;
+    }
+    if (predicate.Kind === presentationValueKinds.literal ||
+        String(predicate.Kind).toLocaleLowerCase() === 'literal') {
+        return coercePredicateValue(predicate.Literal, fallback);
+    }
+    if (predicate.Field &&
+        (predicate.Kind === presentationValueKinds.field ||
+            String(predicate.Kind).toLocaleLowerCase() === 'field')) {
+        return coercePredicateValue(readProjectedCollectionValue(row, predicate.Field), fallback);
+    }
+    return fallback;
+}
+/**
+ * Evaluates selection action visibility or enablement predicates against the
+ * first selected row.
+ */
+function evaluateProjectedSelectionActionPredicate(predicate, selectedRows, fallback) {
+    if (!predicate) {
+        return fallback;
+    }
+    if (predicate.Kind === presentationValueKinds.literal ||
+        String(predicate.Kind).toLocaleLowerCase() === 'literal') {
+        return coercePredicateValue(predicate.Literal, fallback);
+    }
+    if (predicate.Field &&
+        selectedRows[0] &&
+        (predicate.Kind === presentationValueKinds.field ||
+            String(predicate.Kind).toLocaleLowerCase() === 'field')) {
+        return coercePredicateValue(readProjectedCollectionValue(selectedRows[0], predicate.Field), fallback);
+    }
+    return fallback;
+}
+/**
+ * Coerces presentation predicate values into booleans while preserving the
+ * caller-provided fallback for unsupported values.
+ */
+function coercePredicateValue(value, fallback) {
+    if (value === null || value === undefined) {
+        return fallback;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLocaleLowerCase();
+        if (normalized === 'true' || normalized === '1' || normalized === 'yes') {
+            return true;
+        }
+        if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === '') {
+            return false;
+        }
+    }
+    return fallback;
+}
+/**
+ * Converts arbitrary parameter values into route parameter primitives.
+ */
+function toRouteParameterValue(value) {
+    return typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string'
+        ? value
+        : String(value);
+}
+/**
+ * Reads a projected collection value from a row.
+ *
+ * Exact object-path lookup is attempted first. If it is missing, the final path
+ * segment is used as a direct property fallback for flatter data shapes.
+ */
+export function readProjectedCollectionValue(row, fieldPath) {
+    const exactValue = readObjectPath(row, fieldPath);
+    if (exactValue !== undefined) {
+        return exactValue;
+    }
+    const fieldName = fieldPath.split('.').at(-1) ?? fieldPath;
+    return readObjectProperty(row, fieldName);
+}
+/**
+ * Reads a stable row identity from a row, falling back to the visible row index
+ * when the declared identity path is missing.
+ */
+export function readProjectedCollectionRowIdentity(row, rowIdentityPath, index) {
+    const value = readProjectedCollectionValue(row, rowIdentityPath);
+    return value === null || value === undefined ? String(index) : String(value);
+}
+/**
+ * Reads a display label for a row.
+ *
+ * The declared label path is preferred, followed by conventional `Name` and
+ * `Id` properties.
+ */
+export function readProjectedCollectionRowLabel(row, rowLabelPath) {
+    const pathValue = rowLabelPath
+        ? readObjectPath(row, rowLabelPath)
+        : undefined;
+    const value = pathValue ??
+        readObjectProperty(row, 'Name') ??
+        readObjectProperty(row, 'Id');
+    return value === null || value === undefined ? null : String(value);
+}
+/**
+ * Checks whether a collection selection mode enables any row selection.
+ */
+export function isCollectionSelectionEnabled(mode) {
+    return matchesProjectionEnum(mode, collectionSelectionModes.single, 'single') ||
+        matchesProjectionEnum(mode, collectionSelectionModes.multiple, 'multiple');
+}
+/**
+ * Checks whether a collection selection mode allows multiple selected rows.
+ */
+export function isMultipleCollectionSelection(mode) {
+    return matchesProjectionEnum(mode, collectionSelectionModes.multiple, 'multiple');
+}
+/**
+ * Checks whether a detail slot can render as a persistent detail surface.
+ */
+function isRenderableCollectionDetailSlot(slot) {
+    return Boolean(slot?.DetailViewId &&
+        !isCollectionDetailActivationNone(slot.DetailActivation) &&
+        !isCollectionDetailActivationHover(slot.DetailActivation));
+}
+/**
+ * Checks whether detail activation is explicitly disabled.
+ */
+function isCollectionDetailActivationNone(activation) {
+    return matchesProjectionEnum(activation, collectionDetailActivations.none, 'none');
+}
+/**
+ * Checks whether detail activation is hover-only and therefore not renderable
+ * as the selected-row detail surface.
+ */
+function isCollectionDetailActivationHover(activation) {
+    return matchesProjectionEnum(activation, collectionDetailActivations.hover, 'hover');
+}
+/**
+ * Matches generated enum values while tolerating string fallback keys from
+ * non-generated or serialized projection inputs.
+ */
+function matchesProjectionEnum(value, generatedValue, fallbackKey) {
+    return value === generatedValue ||
+        String(value).toLocaleLowerCase() === fallbackKey.toLocaleLowerCase();
+}
+//# sourceMappingURL=projected-collection-runtime.js.map