@cohesivesystems/presentation-react 0.1.0-alpha.1

package/dist/document-workspace-runtime.js

@@ -0,0 +1,699 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable react-refresh/only-export-components */
+import { createContext, useCallback, useContext, useMemo, useState, } from 'react';
+import { findPresentationDocumentProfile, findPresentationView, findPresentationWorkspace, } from '@cohesivesystems/presentation-core';
+import { usePresentationModule } from './presentation-module-context.js';
+import { createPresentationEnumDiscriminator, findPresentationComponentBinding, matchesPresentationEnum, } from '@cohesivesystems/presentation-core';
+import { coordinationActionKinds, coordinationTriggerKinds, presentationBindingKinds, presentationTargetKinds, projectionKindLabels, projectionSubjectKindLabels, semanticReferenceKindLabels, } from '@cohesivesystems/presentation-contracts';
+const DocumentWorkspaceRuntimeContext = createContext(null);
+/**
+ * Resolves the document workspace declared by the presentation IR and provides
+ * the active client-side runtime snapshot to projection renderers. This is the
+ * point where a route page becomes a semantic workspace instance.
+ */
+export function DocumentWorkspaceRuntime({ children, documentInstanceId, fallback = null, pageViewId, }) {
+    const module = usePresentationModule();
+    const resolution = useMemo(() => resolveDocumentWorkspace(module, pageViewId), [module, pageViewId]);
+    const documentProfile = resolution?.documentProfile ?? null;
+    const projections = useMemo(() => documentProfile?.Projections ?? [], [documentProfile]);
+    const initialProjectionIds = useMemo(() => resolveInitialProjectionIds(resolution?.workspaceRef ?? null, projections), [projections, resolution?.workspaceRef]);
+    const projectionViewIds = useMemo(() => initialProjectionIds
+        .map((projectionId) => projections.find((projection) => projection.Id === projectionId))
+        .map((projection) => projection?.ViewId ?? projection?.Id ?? null)
+        .filter((viewId) => Boolean(viewId)), [initialProjectionIds, projections]);
+    const defaultProjectionId = initialProjectionIds[0] ?? projections[0]?.Id ?? null;
+    // Scope runtime state to the semantic workspace/profile and the concrete
+    // document instance so navigating between documents does not leak state.
+    const instanceKey = [
+        resolution?.workspaceRef.WorkspaceId ?? pageViewId,
+        resolution?.documentProfile.Id ?? 'default',
+        documentInstanceId ?? 'transient',
+    ].join(':');
+    const [activeProjectionState, setActiveProjectionState] = useState(() => ({ instanceKey, projectionId: defaultProjectionId }));
+    const [layoutState, setLayoutState] = useState(() => ({
+        instanceKey,
+        value: resolveDefaultLayout(resolution?.documentProfile.Layout ?? null),
+    }));
+    const [runtimeState, setRuntimeState] = useState(() => ({ instanceKey, value: createInitialRuntimeState() }));
+    const runtimeStateValue = runtimeState.instanceKey === instanceKey
+        ? runtimeState.value
+        : createInitialRuntimeState();
+    const coordinationDefinitions = resolution?.documentProfile.Coordination;
+    const coordination = useMemo(() => coordinationDefinitions ?? [], [coordinationDefinitions]);
+    const setTreeExpandedItemIds = useCallback((projectionId, value) => {
+        setRuntimeState((current) => updateRuntimeTreeState(current, instanceKey, projectionId, (treeState) => ({
+            ...treeState,
+            expandedItemIds: applySetStateAction(value, treeState.expandedItemIds),
+        })));
+    }, [instanceKey]);
+    const setTreeNavigationHistory = useCallback((projectionId, value) => {
+        setRuntimeState((current) => updateRuntimeTreeState(current, instanceKey, projectionId, (treeState) => ({
+            ...treeState,
+            navigationHistory: applySetStateAction(value, treeState.navigationHistory),
+        })));
+    }, [instanceKey]);
+    const setTreeSearch = useCallback((projectionId, value) => {
+        setRuntimeState((current) => updateRuntimeTreeState(current, instanceKey, projectionId, (treeState) => ({
+            ...treeState,
+            search: applySetStateAction(value, treeState.search),
+        })));
+    }, [instanceKey]);
+    const selectSemanticReference = useCallback((selection) => {
+        setRuntimeState((current) => {
+            const base = current.instanceKey === instanceKey
+                ? current.value
+                : createInitialRuntimeState();
+            return {
+                instanceKey,
+                value: {
+                    ...base,
+                    semanticSelections: createCoordinatedSemanticSelections(selection, coordination),
+                },
+            };
+        });
+    }, [coordination, instanceKey]);
+    const contextValue = useMemo(() => ({
+        coordination,
+        instanceKey,
+        selectSemanticReference,
+        setTreeExpandedItemIds,
+        setTreeNavigationHistory,
+        setTreeSearch,
+        state: runtimeStateValue,
+    }), [
+        coordination,
+        instanceKey,
+        runtimeStateValue,
+        selectSemanticReference,
+        setTreeExpandedItemIds,
+        setTreeNavigationHistory,
+        setTreeSearch,
+    ]);
+    if (!resolution || !defaultProjectionId) {
+        return _jsx(_Fragment, { children: fallback });
+    }
+    const activeProjectionId = activeProjectionState.instanceKey === instanceKey &&
+        activeProjectionState.projectionId &&
+        initialProjectionIds.includes(activeProjectionState.projectionId)
+        ? activeProjectionState.projectionId
+        : defaultProjectionId;
+    const activeProjection = projections.find((projection) => projection.Id === activeProjectionId) ?? null;
+    const activeViewId = activeProjection?.ViewId ?? activeProjection?.Id ?? null;
+    const layout = layoutState.instanceKey === instanceKey
+        ? layoutState.value
+        : resolveDefaultLayout(resolution.documentProfile.Layout ?? null);
+    const activeLayoutModeId = resolveActiveLayoutModeId(layout, resolution.documentProfile.Layout ?? null);
+    function setActiveViewId(viewId) {
+        const projection = projections.find((candidate) => candidate.ViewId === viewId || candidate.Id === viewId);
+        if (!projection) {
+            return;
+        }
+        setActiveProjectionState({ instanceKey, projectionId: projection.Id });
+    }
+    function setLayout(value) {
+        setLayoutState({ instanceKey, value });
+    }
+    const snapshot = {
+        activeLayoutModeId,
+        activeProjection,
+        activeProjectionId,
+        activeViewId,
+        documentProfile: resolution.documentProfile,
+        initialProjectionIds,
+        instanceKey,
+        layout,
+        pageView: resolution.pageView,
+        projectionViewIds,
+        projections,
+        setActiveViewId,
+        setLayout,
+        state: runtimeStateValue,
+        workspace: resolution.workspace,
+        workspaceRef: resolution.workspaceRef,
+        workspaceView: resolution.workspaceView,
+    };
+    return (_jsx(DocumentWorkspaceRuntimeContext.Provider, { value: contextValue, children: children(snapshot) }));
+}
+export function renderDocumentWorkspaceProjection(runtime, renderers, rendererContext, viewId, options) {
+    const resolution = resolveDocumentWorkspaceProjectionRenderer({
+        componentSet: options.componentSet,
+        module: options.module ?? null,
+        registry: renderers,
+        runtime,
+        viewId,
+    });
+    if (!resolution.projection || !resolution.renderer) {
+        return null;
+    }
+    return resolution.renderer({
+        componentSystem: options.componentSystem,
+        designSystem: options.designSystem,
+        extra: rendererContext,
+        projection: resolution.projection,
+        runtime,
+    });
+}
+export function resolveDocumentWorkspaceProjectionRenderer({ componentSet, module, registry, runtime, viewId, }) {
+    // View ids are used by workspace chrome, while projection ids and renderer
+    // keys are semantic/runtime binding points. Accept either id at this boundary.
+    const projection = runtime.projections.find((candidate) => candidate.ViewId === viewId || candidate.Id === viewId);
+    if (!projection) {
+        return createDocumentProjectionRendererResolution(null);
+    }
+    const componentBinding = resolveDocumentWorkspaceProjectionComponentBinding(module ?? null, projection, componentSet);
+    const componentKey = componentBinding?.componentKey ?? null;
+    const componentRole = componentBinding?.componentRole ?? null;
+    const rendererKey = projection.RendererKey ?? null;
+    const componentRoleRenderer = componentRole
+        ? registry.byComponentRole?.[componentRole]
+        : undefined;
+    if (componentRoleRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: componentRoleRenderer,
+            rendererKey,
+            resolutionSource: 'component-role',
+        };
+    }
+    const componentRenderer = componentKey
+        ? registry.byComponentKey?.[componentKey]
+        : undefined;
+    if (componentRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: componentRenderer,
+            rendererKey,
+            resolutionSource: 'component-key',
+        };
+    }
+    const semanticReferenceRenderer = findDiscriminatorRenderer(registry.bySemanticReferenceKind, projection.Coordinates?.SemanticReferenceKind, semanticReferenceKindLabels);
+    if (semanticReferenceRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: semanticReferenceRenderer,
+            rendererKey,
+            resolutionSource: 'semantic-reference-kind',
+        };
+    }
+    const subjectKindRenderer = findDiscriminatorRenderer(registry.bySubjectKind, projection.Subject.Kind, projectionSubjectKindLabels);
+    if (subjectKindRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: subjectKindRenderer,
+            rendererKey,
+            resolutionSource: 'subject-kind',
+        };
+    }
+    const projectionKindRenderer = findDiscriminatorRenderer(registry.byProjectionKind, projection.Kind, projectionKindLabels);
+    if (projectionKindRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: projectionKindRenderer,
+            rendererKey,
+            resolutionSource: 'projection-kind',
+        };
+    }
+    const projectionIdRenderer = registry.byProjectionId?.[projection.Id];
+    if (projectionIdRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: projectionIdRenderer,
+            rendererKey,
+            resolutionSource: 'projection-id',
+        };
+    }
+    const viewIdRenderer = projection.ViewId ? registry.byViewId?.[projection.ViewId] : undefined;
+    if (viewIdRenderer) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: viewIdRenderer,
+            rendererKey,
+            resolutionSource: 'view-id',
+        };
+    }
+    if (registry.fallback) {
+        return {
+            componentKey,
+            componentRole,
+            projection,
+            renderer: registry.fallback,
+            rendererKey,
+            resolutionSource: 'fallback',
+        };
+    }
+    return {
+        componentKey,
+        componentRole,
+        projection,
+        renderer: null,
+        rendererKey,
+        resolutionSource: null,
+    };
+}
+export function resolveDocumentWorkspaceProjectionCapability({ capability, componentSet, module, projection, registry, }) {
+    const bindings = registry.capabilities?.[capability];
+    if (!bindings) {
+        return false;
+    }
+    const componentBinding = resolveDocumentWorkspaceProjectionComponentBinding(module ?? null, projection, componentSet);
+    const componentKey = componentBinding?.componentKey ?? null;
+    const componentRole = componentBinding?.componentRole ?? null;
+    if (componentRole && bindings.byComponentRole?.[componentRole]) {
+        return true;
+    }
+    if (componentKey && bindings.byComponentKey?.[componentKey]) {
+        return true;
+    }
+    if (findDiscriminatorRenderer(bindings.bySemanticReferenceKind, projection.Coordinates?.SemanticReferenceKind, semanticReferenceKindLabels)) {
+        return true;
+    }
+    if (findDiscriminatorRenderer(bindings.bySubjectKind, projection.Subject.Kind, projectionSubjectKindLabels)) {
+        return true;
+    }
+    if (findDiscriminatorRenderer(bindings.byProjectionKind, projection.Kind, projectionKindLabels)) {
+        return true;
+    }
+    return Boolean(bindings.byProjectionId?.[projection.Id] ||
+        (projection.ViewId ? bindings.byViewId?.[projection.ViewId] : false));
+}
+/**
+ * Resolves the frontend renderer role and optional concrete component override
+ * declared by a presentation target binding for a document projection.
+ */
+function resolveDocumentWorkspaceProjectionComponentBinding(module, projection, componentSet) {
+    if (!module) {
+        return null;
+    }
+    const binding = findPresentationComponentBinding(module, {
+        bindingKind: createPresentationEnumDiscriminator(presentationBindingKinds, 'projectionRenderer', 'ProjectionRenderer'),
+        componentSet,
+        id: projection.Id,
+        targetKind: createPresentationEnumDiscriminator(presentationTargetKinds, 'react', 'React'),
+    });
+    if (!binding) {
+        return null;
+    }
+    return {
+        componentKey: binding.ComponentKey ?? null,
+        componentRole: binding.ComponentRole ?? null,
+    };
+}
+/**
+ * Shared tree-state hook for document projections. It uses workspace runtime
+ * state when mounted under DocumentWorkspaceRuntime, and falls back to local
+ * component state when a tree renderer is tested or rendered in isolation.
+ */
+export function useDocumentWorkspaceTreeState({ createSemanticSelection, initialExpandedItemIds, projectionId, semanticReferenceKind, }) {
+    const runtime = useContext(DocumentWorkspaceRuntimeContext);
+    const runtimeState = runtime?.state;
+    const selectSemanticReference = runtime?.selectSemanticReference;
+    const setRuntimeTreeExpandedItemIds = runtime?.setTreeExpandedItemIds;
+    const setRuntimeTreeNavigationHistory = runtime?.setTreeNavigationHistory;
+    const setRuntimeTreeSearch = runtime?.setTreeSearch;
+    const initialExpandedItemKey = initialExpandedItemIds.join('\u0000');
+    const [localExpandedItemState, setLocalExpandedItemState] = useState(() => ({
+        expandedItemIds: initialExpandedItemIds,
+        initialExpandedItemKey,
+        isUserControlled: false,
+    }));
+    const [localNavigationHistory, setLocalNavigationHistory] = useState(createInitialNavigationHistory);
+    const [localSearch, setLocalSearch] = useState(createInitialTreeSearchState);
+    const persistedTreeState = runtimeState && projectionId ? runtimeState.treeStates[projectionId] : undefined;
+    const treeState = persistedTreeState ??
+        (runtimeState && projectionId ? createInitialTreeState() : null);
+    const localExpandedItemIds = localExpandedItemState.isUserControlled ||
+        localExpandedItemState.initialExpandedItemKey === initialExpandedItemKey
+        ? localExpandedItemState.expandedItemIds
+        : initialExpandedItemIds;
+    const expandedItemIds = persistedTreeState?.expandedItemIds ??
+        (runtimeState && projectionId
+            ? initialExpandedItemIds
+            : localExpandedItemIds);
+    const navigationHistory = treeState?.navigationHistory ?? localNavigationHistory;
+    const search = treeState?.search ?? localSearch;
+    const setExpandedItemIds = useCallback((value) => {
+        if (setRuntimeTreeExpandedItemIds && projectionId) {
+            setRuntimeTreeExpandedItemIds(projectionId, value);
+        }
+        else {
+            setLocalExpandedItemState((current) => ({
+                expandedItemIds: applySetStateAction(value, current.isUserControlled ||
+                    current.initialExpandedItemKey === initialExpandedItemKey
+                    ? current.expandedItemIds
+                    : initialExpandedItemIds),
+                initialExpandedItemKey,
+                isUserControlled: true,
+            }));
+        }
+    }, [
+        initialExpandedItemIds,
+        initialExpandedItemKey,
+        projectionId,
+        setRuntimeTreeExpandedItemIds,
+    ]);
+    const setNavigationHistory = useCallback((value) => {
+        if (setRuntimeTreeNavigationHistory && projectionId) {
+            setRuntimeTreeNavigationHistory(projectionId, value);
+        }
+        else {
+            setLocalNavigationHistory(value);
+        }
+    }, [projectionId, setRuntimeTreeNavigationHistory]);
+    const setSearch = useCallback((value) => {
+        if (setRuntimeTreeSearch && projectionId) {
+            setRuntimeTreeSearch(projectionId, value);
+        }
+        else {
+            setLocalSearch(value);
+        }
+    }, [projectionId, setRuntimeTreeSearch]);
+    const publishSelectedItem = useCallback((itemId) => {
+        if (!selectSemanticReference || !projectionId || !itemId) {
+            return;
+        }
+        selectSemanticReference(normalizeTreeSemanticSelection(createSemanticSelection?.(itemId) ??
+            createDefaultTreeSemanticSelection(itemId, projectionId, semanticReferenceKind), projectionId, semanticReferenceKind));
+    }, [createSemanticSelection, projectionId, selectSemanticReference, semanticReferenceKind]);
+    const semanticSelections = useMemo(() => filterSemanticSelectionsForProjection({
+        coordination: runtime?.coordination ?? [],
+        projectionId,
+        selections: runtimeState?.semanticSelections ?? [],
+    }), [projectionId, runtime?.coordination, runtimeState?.semanticSelections]);
+    return {
+        expandedItemIds,
+        navigationHistory,
+        onSelectedItemIdChange: publishSelectedItem,
+        search,
+        semanticSelections,
+        setExpandedItemIds,
+        setNavigationHistory,
+        setSearch,
+    };
+}
+export function useDocumentWorkspaceSemanticSelections({ projectionId, }) {
+    const runtime = useContext(DocumentWorkspaceRuntimeContext);
+    const runtimeState = runtime?.state;
+    return useMemo(() => filterSemanticSelectionsForProjection({
+        coordination: runtime?.coordination ?? [],
+        projectionId,
+        selections: runtimeState?.semanticSelections ?? [],
+    }), [projectionId, runtime?.coordination, runtimeState?.semanticSelections]);
+}
+export function useDocumentWorkspaceSemanticSelectionPublisher({ projectionId, semanticReferenceKind, }) {
+    const runtime = useContext(DocumentWorkspaceRuntimeContext);
+    const selectSemanticReference = runtime?.selectSemanticReference;
+    return useCallback((selection) => {
+        if (!projectionId || !selectSemanticReference) {
+            return;
+        }
+        selectSemanticReference(normalizeTreeSemanticSelection(selection, projectionId, semanticReferenceKind));
+    }, [projectionId, selectSemanticReference, semanticReferenceKind]);
+}
+export function createDocumentWorkspaceSemanticPath(segments) {
+    return { Segments: segments };
+}
+export function createDocumentWorkspaceSemanticReference({ id, kind, label, path, }) {
+    return {
+        Id: id,
+        Kind: kind,
+        Path: path ??
+            createDocumentWorkspaceSemanticPath([
+                {
+                    Id: id,
+                    Kind: kind,
+                    Label: label ?? id,
+                },
+            ]),
+    };
+}
+export function documentWorkspaceSemanticReferenceMatchesSelection(reference, selection) {
+    return (semanticReferencesMatch(reference, selection.Target) ||
+        semanticPathMatches(reference.Path ?? null, selection.SemanticPath ?? null) ||
+        semanticPathMatches(reference.Path ?? null, selection.Target.Path ?? null) ||
+        semanticPathContainsReference(selection.SemanticPath ?? null, reference) ||
+        semanticPathContainsReference(selection.Target.Path ?? null, reference));
+}
+export function findDocumentWorkspaceSemanticTreeItemId(selection, nodes) {
+    for (const node of nodes) {
+        const references = [
+            node.semanticReference,
+            ...(node.relatedSemanticReferences ?? []),
+        ];
+        if (references.some((reference) => documentWorkspaceSemanticReferenceMatchesSelection(reference, selection))) {
+            return node.itemId;
+        }
+    }
+    return null;
+}
+function resolveDocumentWorkspace(module, pageViewId) {
+    // A route addresses a page view. The workspace may be the page itself or a
+    // hosted child surface within one of the page regions.
+    const pageView = findPresentationView(module, pageViewId);
+    if (!pageView) {
+        return null;
+    }
+    const workspaceView = findWorkspaceHostView(module, pageView);
+    const workspaceRef = workspaceView?.Workspace ?? null;
+    if (!workspaceView || !workspaceRef) {
+        return null;
+    }
+    const workspace = findPresentationWorkspace(module, workspaceRef.WorkspaceId);
+    if (!workspace) {
+        return null;
+    }
+    const documentProfileId = workspaceRef.DocumentProfileId ??
+        workspace.DefaultDocumentProfileId ??
+        workspace.DocumentProfiles?.[0]?.Id ??
+        null;
+    const documentProfile = documentProfileId
+        ? findPresentationDocumentProfile(workspace, documentProfileId)
+        : null;
+    if (!documentProfile) {
+        return null;
+    }
+    return { documentProfile, pageView, workspace, workspaceRef, workspaceView };
+}
+function findWorkspaceHostView(module, pageView) {
+    if (pageView?.Workspace) {
+        return pageView;
+    }
+    for (const region of pageView?.Regions ?? []) {
+        for (const viewId of region.ViewIds ?? []) {
+            const view = findPresentationView(module, viewId);
+            if (view?.Workspace) {
+                return view;
+            }
+        }
+    }
+    return null;
+}
+function resolveInitialProjectionIds(workspaceRef, projections) {
+    // Workspace refs can narrow the active profile to a preferred projection set.
+    // If that declaration is absent or stale, expose every profile projection.
+    const projectionIds = new Set(projections.map((projection) => projection.Id));
+    const initialProjectionIds = (workspaceRef?.InitialProjectionIds ?? []).filter((projectionId) => projectionIds.has(projectionId));
+    return initialProjectionIds.length > 0
+        ? initialProjectionIds
+        : projections.map((projection) => projection.Id);
+}
+function resolveDefaultLayout(layout) {
+    return layout?.DefaultModeId === 'split' ? 'split' : 'single';
+}
+function resolveActiveLayoutModeId(layout, layoutDefinition) {
+    if (layout === 'split') {
+        return layoutDefinition?.Modes?.find((mode) => mode.Id.toLocaleLowerCase() === 'split')?.Id ?? 'split';
+    }
+    return layoutDefinition?.DefaultModeId ?? layoutDefinition?.Modes?.[0]?.Id ?? 'single';
+}
+function createInitialRuntimeState() {
+    return {
+        semanticSelections: [],
+        treeStates: {},
+    };
+}
+function createInitialTreeState() {
+    return {
+        expandedItemIds: [],
+        navigationHistory: createInitialNavigationHistory(),
+        search: createInitialTreeSearchState(),
+    };
+}
+function createInitialNavigationHistory() {
+    return { entries: [], index: -1 };
+}
+function createInitialTreeSearchState() {
+    return { activeMatchIndex: 0, isOpen: false, query: '' };
+}
+function createDefaultTreeSemanticSelection(itemId, projectionId, semanticReferenceKind) {
+    const path = createDocumentWorkspaceSemanticPath([
+        { Id: projectionId, Kind: semanticReferenceKind, Label: projectionId },
+        { Id: itemId, Kind: semanticReferenceKind, Label: itemId },
+    ]);
+    return {
+        SourceProjectionId: projectionId,
+        SemanticPath: path,
+        Target: {
+            Id: itemId,
+            Kind: semanticReferenceKind,
+            Path: path,
+        },
+    };
+}
+function normalizeTreeSemanticSelection(selection, projectionId, semanticReferenceKind) {
+    const targetPath = selection.Target.Path ??
+        selection.SemanticPath ??
+        createDocumentWorkspaceSemanticPath([
+            {
+                Id: selection.Target.Id,
+                Kind: selection.Target.Kind ?? semanticReferenceKind,
+                Label: selection.Target.Id,
+            },
+        ]);
+    return {
+        SourceProjectionId: selection.SourceProjectionId ?? projectionId,
+        SemanticPath: selection.SemanticPath ?? targetPath,
+        Target: {
+            ...selection.Target,
+            Kind: selection.Target.Kind ?? semanticReferenceKind,
+            Path: targetPath,
+        },
+    };
+}
+function createCoordinatedSemanticSelections(selection, coordination) {
+    if (!hasSemanticSelectionCoordination(coordination, selection.SourceProjectionId ?? null)) {
+        return [selection];
+    }
+    return [selection];
+}
+function filterSemanticSelectionsForProjection({ coordination, projectionId, selections, }) {
+    if (!projectionId) {
+        return selections;
+    }
+    return selections.filter((selection) => canRevealSemanticSelectionForProjection(coordination, projectionId, selection));
+}
+function hasSemanticSelectionCoordination(coordination, sourceProjectionId) {
+    return coordination.some((definition) => matchesCoordinationTrigger(definition, sourceProjectionId) &&
+        matchesPresentationEnum(definition.Action.Kind, setSemanticSelectionActionKind));
+}
+function canRevealSemanticSelectionForProjection(coordination, projectionId, selection) {
+    const revealDefinitions = coordination.filter((definition) => matchesCoordinationTrigger(definition, selection.SourceProjectionId ?? null) &&
+        matchesPresentationEnum(definition.Action.Kind, revealSemanticSelectionActionKind));
+    if (revealDefinitions.length === 0) {
+        return true;
+    }
+    return revealDefinitions.some((definition) => definition.Action.TargetProjectionIds.includes(projectionId));
+}
+function matchesCoordinationTrigger(definition, sourceProjectionId) {
+    return (matchesPresentationEnum(definition.Trigger.Kind, selectionChangedTriggerKind) &&
+        (!definition.Trigger.SourceProjectionId ||
+            definition.Trigger.SourceProjectionId === sourceProjectionId));
+}
+function semanticReferencesMatch(left, right) {
+    return (left.Id === right.Id &&
+        semanticReferenceKindsMatch(left.Kind ?? null, right.Kind ?? null));
+}
+function semanticPathMatches(left, right) {
+    if (!left || !right || left.Segments.length !== right.Segments.length) {
+        return false;
+    }
+    return left.Segments.every((leftSegment, index) => {
+        const rightSegment = right.Segments[index];
+        return (leftSegment.Id === rightSegment.Id &&
+            semanticReferenceKindsMatch(leftSegment.Kind ?? null, rightSegment.Kind ?? null));
+    });
+}
+function semanticPathContainsReference(path, reference) {
+    return (path?.Segments.some((segment) => segment.Id === reference.Id &&
+        semanticReferenceKindsMatch(segment.Kind ?? null, reference.Kind ?? null)) ?? false);
+}
+function semanticReferenceKindsMatch(left, right) {
+    if (left === null || right === null) {
+        return true;
+    }
+    const leftKeys = createDiscriminatorKeys(left, semanticReferenceKindLabels);
+    const rightKeys = createDiscriminatorKeys(right, semanticReferenceKindLabels);
+    for (const key of leftKeys) {
+        if (rightKeys.has(key)) {
+            return true;
+        }
+    }
+    return false;
+}
+function createDocumentProjectionRendererResolution(projection) {
+    return {
+        componentKey: null,
+        componentRole: null,
+        projection,
+        renderer: null,
+        rendererKey: projection?.RendererKey ?? null,
+        resolutionSource: null,
+    };
+}
+const selectionChangedTriggerKind = createPresentationEnumDiscriminator(coordinationTriggerKinds, 'selectionChanged', 'SelectionChanged');
+const setSemanticSelectionActionKind = createPresentationEnumDiscriminator(coordinationActionKinds, 'setSemanticSelection', 'SetSemanticSelection');
+const revealSemanticSelectionActionKind = createPresentationEnumDiscriminator(coordinationActionKinds, 'revealSemanticSelection', 'RevealSemanticSelection');
+function findDiscriminatorRenderer(renderers, value, labels) {
+    if (!renderers || value === null || value === undefined) {
+        return undefined;
+    }
+    for (const key of createDiscriminatorKeys(value, labels)) {
+        const renderer = renderers[key];
+        if (renderer) {
+            return renderer;
+        }
+    }
+    return undefined;
+}
+function createDiscriminatorKeys(value, labels) {
+    const keys = new Set([String(value)]);
+    const directLabel = labels[value];
+    if (directLabel) {
+        keys.add(directLabel);
+    }
+    if (typeof value === 'string') {
+        const normalizedValue = value.toLocaleLowerCase();
+        for (const [enumValue, label] of Object.entries(labels)) {
+            if (label.toLocaleLowerCase() === normalizedValue) {
+                keys.add(enumValue);
+                keys.add(label);
+            }
+        }
+    }
+    return keys;
+}
+function updateRuntimeTreeState(current, instanceKey, projectionId, update) {
+    // Treat an instance-key change as a new workspace session. This prevents tree
+    // state from one document/profile from being reused by another.
+    const base = current.instanceKey === instanceKey ? current.value : createInitialRuntimeState();
+    const currentTreeState = base.treeStates[projectionId] ?? createInitialTreeState();
+    return {
+        instanceKey,
+        value: {
+            ...base,
+            treeStates: {
+                ...base.treeStates,
+                [projectionId]: update(currentTreeState),
+            },
+        },
+    };
+}
+function applySetStateAction(action, current) {
+    return typeof action === 'function'
+        ? action(current)
+        : action;
+}
+//# sourceMappingURL=document-workspace-runtime.js.map