@cohesivesystems/presentation-core 0.1.0-alpha.1

package/src/projected-document-action-diagnostics.ts

@@ -0,0 +1,196 @@
+import type {
+  ActionDefinition,
+  ActionPlacementDefinition,
+  PresentationModuleDefinition,
+} from './module'
+import {
+  findPresentationAction,
+} from './module'
+import type {
+  PresentationProjectionDiagnostic,
+} from './presentation-projection-diagnostics'
+import {
+  createPresentationEnumDiscriminator,
+  matchesPresentationEnum,
+} from './target-bindings'
+import {
+  actionSemanticsKinds,
+  localDocumentEditorActionKindLabels,
+  localDocumentEditorActionKinds,
+} from '@cohesivesystems/presentation-contracts'
+
+export type LocalDocumentEditorActionBindingIntent = 'format' | 'reset'
+
+export interface ProjectLocalDocumentEditorActionBindingDiagnosticsOptions {
+  readonly actionPlacements: readonly ActionPlacementDefinition[]
+  readonly module: Pick<PresentationModuleDefinition, 'Actions'> | null
+  readonly supportedIntents: readonly LocalDocumentEditorActionBindingIntent[]
+}
+
+/**
+ * Reports local document editor semantics that the current frontend adapter has
+ * not interpreted. These diagnostics are intentionally about the frontend
+ * binding boundary: the backend declares the action meaning, while Monaco owns
+ * the local execution model.
+ */
+export function projectLocalDocumentEditorActionBindingDiagnostics({
+  actionPlacements,
+  module,
+  supportedIntents,
+}: ProjectLocalDocumentEditorActionBindingDiagnosticsOptions): readonly PresentationProjectionDiagnostic[] {
+  const supportedIntentSet = new Set(supportedIntents)
+  return resolvePlacedActions(module, actionPlacements).flatMap(({ action, placement }) => {
+    if (!matchesLocalDocumentEditorActionSemantics(action)) {
+      return []
+    }
+
+    const localDocumentEditor = action.Semantics?.LocalDocumentEditor
+    if (!localDocumentEditor) {
+      return [
+        createDiagnostic({
+          action,
+          message:
+            `Action '${action.Name}' declares local document editor semantics ` +
+            'but does not specify an editor action kind.',
+          placement,
+          reason: 'missing-local-document-editor-action-kind',
+          severity: 'error',
+        }),
+      ]
+    }
+
+    const intent = resolveLocalDocumentEditorActionIntent(localDocumentEditor.Kind)
+    if (!intent) {
+      return [
+        createDiagnostic({
+          action,
+          details: {
+            localDocumentEditorActionKind: formatLocalDocumentEditorActionKind(
+              localDocumentEditor.Kind,
+            ),
+          },
+          message:
+            `Action '${action.Name}' declares local document editor action ` +
+            `'${formatLocalDocumentEditorActionKind(localDocumentEditor.Kind)}', ` +
+            'but this frontend adapter does not recognize that semantic kind.',
+          placement,
+          reason: 'unknown-local-document-editor-action-kind',
+          severity: 'warning',
+        }),
+      ]
+    }
+
+    if (supportedIntentSet.has(intent)) {
+      return []
+    }
+
+    return [
+      createDiagnostic({
+        action,
+        details: { localDocumentEditorActionKind: intent },
+        message:
+          `Action '${action.Name}' declares local document editor action '${intent}', ` +
+          'but this frontend adapter has not bound an interpretation for it.',
+        placement,
+        reason: 'unbound-local-document-editor-action-kind',
+        severity: 'warning',
+      }),
+    ]
+  })
+}
+
+function resolvePlacedActions(
+  module: Pick<PresentationModuleDefinition, 'Actions'> | null,
+  actionPlacements: readonly ActionPlacementDefinition[],
+) {
+  return actionPlacements.flatMap((placement) => {
+    const action = findPresentationAction<ActionDefinition>(module, placement.ActionId)
+    return action ? [{ action, placement }] : []
+  })
+}
+
+function matchesLocalDocumentEditorActionSemantics(action: ActionDefinition) {
+  return Boolean(
+    action.Semantics &&
+      matchesPresentationEnum(action.Semantics.Kind, localDocumentEditorActionSemanticsKind),
+  )
+}
+
+function resolveLocalDocumentEditorActionIntent(
+  value: string | number | null | undefined,
+): LocalDocumentEditorActionBindingIntent | null {
+  if (value === null || value === undefined) {
+    return null
+  }
+
+  if (matchesPresentationEnum(value, localDocumentEditorActionKindByIntent.format)) {
+    return 'format'
+  }
+
+  if (matchesPresentationEnum(value, localDocumentEditorActionKindByIntent.reset)) {
+    return 'reset'
+  }
+
+  return null
+}
+
+function formatLocalDocumentEditorActionKind(value: string | number | null | undefined) {
+  return typeof value === 'number'
+    ? localDocumentEditorActionKindLabels[
+      value as keyof typeof localDocumentEditorActionKindLabels
+    ] ?? String(value)
+    : String(value ?? 'unknown')
+}
+
+function createDiagnostic({
+  action,
+  details,
+  message,
+  placement,
+  reason,
+  severity,
+}: {
+  readonly action: ActionDefinition
+  readonly details?: Readonly<Record<string, unknown>>
+  readonly message: string
+  readonly placement: ActionPlacementDefinition
+  readonly reason: string
+  readonly severity: PresentationProjectionDiagnostic['severity']
+}): PresentationProjectionDiagnostic {
+  return {
+    details: {
+      actionId: action.Id,
+      placementIntent: placement.Intent,
+      placementRegion: placement.Region,
+      ...details,
+    },
+    id: `local-document-editor-action.${action.Id}.${reason}`,
+    message,
+    severity,
+    source: 'document-action-projection',
+    subject: {
+      id: action.Id,
+      kind: 'action',
+      name: action.Name,
+    },
+  }
+}
+
+const localDocumentEditorActionSemanticsKind = createPresentationEnumDiscriminator(
+  actionSemanticsKinds,
+  'localDocumentEditor',
+  'LocalDocumentEditor',
+)
+
+const localDocumentEditorActionKindByIntent = {
+  format: createPresentationEnumDiscriminator(
+    localDocumentEditorActionKinds,
+    'format',
+    'Format',
+  ),
+  reset: createPresentationEnumDiscriminator(
+    localDocumentEditorActionKinds,
+    'reset',
+    'Reset',
+  ),
+} as const

package/src/projected-document-action-enablements.ts

@@ -0,0 +1,99 @@
+import type {
+  ActionDefinition,
+  ActionEnablementCriterionDefinition,
+} from './module'
+import {
+  createPresentationEnumDiscriminator,
+  matchesPresentationEnum,
+} from './target-bindings'
+import {
+  actionEnablementCriterionKinds,
+} from '@cohesivesystems/presentation-contracts'
+
+export interface ProjectedDocumentLocalActionEnablementContext {
+  readonly isDocumentDirty?: boolean
+  readonly isDocumentValid?: boolean
+  readonly pendingActionIds?: readonly string[]
+}
+
+export interface ProjectedDocumentActionEnablement {
+  readonly blockingCriteria: readonly ActionEnablementCriterionDefinition[]
+  readonly blockingCriterionId: string | null
+  readonly isDisabled: boolean
+  readonly message: string | null
+}
+
+export interface ProjectDocumentLocalActionEnablementOptions {
+  readonly action: ActionDefinition | null | undefined
+  readonly context?: ProjectedDocumentLocalActionEnablementContext | null
+}
+
+/**
+ * Interprets local document action enablement criteria from presentation IR.
+ *
+ * The backend can declare criteria such as "document must be clean" while the
+ * frontend adapter supplies the concrete local editor facts that only the
+ * component host can observe.
+ */
+export function projectDocumentLocalActionEnablement({
+  action,
+  context,
+}: ProjectDocumentLocalActionEnablementOptions): ProjectedDocumentActionEnablement {
+  const blockingCriteria = (action?.Enablement ?? []).filter((criterion) =>
+    isLocalDocumentCriterionBlocked(criterion, context),
+  )
+  const blockingCriterion = blockingCriteria[0] ?? null
+
+  return {
+    blockingCriteria,
+    blockingCriterionId: blockingCriterion?.Id ?? null,
+    isDisabled: blockingCriteria.length > 0,
+    message: blockingCriterion?.Message ?? blockingCriterion?.Name ?? null,
+  }
+}
+
+function isLocalDocumentCriterionBlocked(
+  criterion: ActionEnablementCriterionDefinition,
+  context: ProjectedDocumentLocalActionEnablementContext | null | undefined,
+) {
+  if (
+    matchesPresentationEnum(criterion.Kind, localDocumentCleanCriterionKind)
+  ) {
+    return context?.isDocumentDirty === true
+  }
+
+  if (
+    matchesPresentationEnum(criterion.Kind, localDocumentValidCriterionKind)
+  ) {
+    return context?.isDocumentValid === false
+  }
+
+  if (
+    matchesPresentationEnum(criterion.Kind, noPendingActionCriterionKind)
+  ) {
+    const pendingActionIds = new Set(context?.pendingActionIds ?? [])
+    return criterion.ReferencedActionId
+      ? pendingActionIds.has(criterion.ReferencedActionId)
+      : pendingActionIds.size > 0
+  }
+
+  return false
+}
+
+const localDocumentCleanCriterionKind = createPresentationEnumDiscriminator(
+  actionEnablementCriterionKinds,
+  'localDocumentClean',
+  'LocalDocumentClean',
+)
+
+const localDocumentValidCriterionKind = createPresentationEnumDiscriminator(
+  actionEnablementCriterionKinds,
+  'localDocumentValid',
+  'LocalDocumentValid',
+)
+
+const noPendingActionCriterionKind = createPresentationEnumDiscriminator(
+  actionEnablementCriterionKinds,
+  'noPendingAction',
+  'NoPendingAction',
+)