@cohesivesystems/presentation-core 0.1.0-alpha.1

package/dist/view-chrome-slot-renderer-registry.js

@@ -0,0 +1,62 @@
+import { viewChromeSlotKindLabels, viewChromeSlotPlacementLabels, } from '@cohesivesystems/presentation-contracts';
+export const viewChromeSlotAnyPlacement = '*';
+export function createViewChromeSlotRendererRegistry(bindings) {
+    return Object.fromEntries(bindings.map((binding) => [
+        createViewChromeSlotRendererKey(binding.kind, binding.placement),
+        binding.render,
+    ]));
+}
+export function createViewChromeSlotRendererKey(kind, placement) {
+    return `${normalizeViewChromeSlotKind(kind)}:${placement == null
+        ? viewChromeSlotAnyPlacement
+        : normalizeViewChromeSlotPlacement(placement)}`;
+}
+export function getViewChromeSlotRendererRegistryKeys(registry) {
+    return Object.keys(registry ?? {});
+}
+export function getViewChromeSlotRendererCandidateKeys(slot) {
+    return [
+        createViewChromeSlotRendererKey(slot.Kind, slot.Placement),
+        createViewChromeSlotRendererKey(slot.Kind),
+    ];
+}
+export function hasViewChromeSlotRendererBinding(keys, slot) {
+    return getViewChromeSlotRendererCandidateKeys(slot).some((key) => keys.includes(key));
+}
+export function resolveViewChromeSlotRenderer(registry, slot) {
+    const renderers = registry ?? {};
+    for (const key of getViewChromeSlotRendererCandidateKeys(slot)) {
+        const renderer = renderers[key];
+        if (renderer) {
+            return renderer;
+        }
+    }
+    return null;
+}
+export function isViewChromeSlotPlacement(slot, placement) {
+    return isViewChromeSlotPlacementValue(slot.Placement, placement);
+}
+export function isViewChromeSlotKind(slot, kind) {
+    return normalizeViewChromeSlotKind(slot.Kind) ===
+        normalizeViewChromeSlotKind(kind);
+}
+export function isViewChromeSlotPlacementValue(value, placement) {
+    if (value == null) {
+        return false;
+    }
+    return normalizeViewChromeSlotPlacement(value) ===
+        normalizeViewChromeSlotPlacement(placement);
+}
+function normalizeViewChromeSlotKind(value) {
+    return normalizeGeneratedEnumToken(value, viewChromeSlotKindLabels);
+}
+function normalizeViewChromeSlotPlacement(value) {
+    return normalizeGeneratedEnumToken(value, viewChromeSlotPlacementLabels);
+}
+function normalizeGeneratedEnumToken(value, labels) {
+    const label = typeof value === 'number'
+        ? labels[value] ?? String(value)
+        : String(value);
+    return label.replace(/[^a-z0-9]/gi, '').toLocaleLowerCase();
+}
+//# sourceMappingURL=view-chrome-slot-renderer-registry.js.map

package/dist/view-chrome-slot-renderer-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-chrome-slot-renderer-registry.js","sourceRoot":"","sources":["../src/view-chrome-slot-renderer-registry.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@cohesivesystems/presentation-core",
+  "version": "0.1.0-alpha.1",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx"
+  ],
+  "dependencies": {
+    "@cohesivesystems/presentation-contracts": "0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "typescript": "~5.9.3",
+    "vitest": "^4.1.7"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Runtime-agnostic TypeScript helpers for interpreting Cohesive presentation IR.",
+  "keywords": [
+    "cohesive",
+    "presentation",
+    "ir",
+    "runtime",
+    "typescript"
+  ],
+  "author": "Cohesive Systems",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cohesivesystems/cohesive.git",
+    "directory": "src/frontend/presentation-core"
+  },
+  "bugs": {
+    "url": "https://github.com/cohesivesystems/cohesive/issues"
+  },
+  "homepage": "https://github.com/cohesivesystems/cohesive#readme",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node ../../../eng/fix-package-js-imports.mjs dist",
+    "test": "vitest run"
+  }
+}

package/src/api-scope-request.ts

@@ -0,0 +1,186 @@
+import {
+  normalizePresentationScopeRequestSelection,
+  type PresentationScopeRequestSelection,
+} from './scope-selection'
+
+/**
+ * Generated API scope policy metadata projected into frontend runtimes.
+ */
+export interface ApiScopePolicyMetadata {
+  readonly kind: string
+  readonly cardinality: 'single' | 'multiple'
+  readonly binding: 'ambient' | 'header' | 'query' | 'route' | 'body' | 'resource'
+  readonly access: 'requireSelected' | 'filterToAccessible' | 'validateAccessible'
+  readonly singleScopeParameterName?: string
+  readonly multipleScopesParameterName?: string
+  readonly scopeModeParameterName?: string
+  readonly resourceParameterName?: string
+  readonly resourceDerivation?: {
+    readonly strategy: string
+    readonly format?: string
+    readonly scopeField?: string
+  }
+  readonly allowDefaultScope: boolean
+}
+
+/**
+ * Minimal HTTP client contract used by generated API clients.
+ */
+export type ApiRequestHttpClient = (
+  path: string,
+  init: RequestInit,
+) => Promise<unknown>
+
+/**
+ * Projected request after scope policies have been applied.
+ */
+export interface ScopedApiRequest {
+  readonly path: string
+  readonly init: RequestInit
+}
+
+/**
+ * Applies generated API scope policies to a request using the current ambient selection.
+ */
+export function projectApiScopeRequest(
+  path: string,
+  init: RequestInit,
+  selection: PresentationScopeRequestSelection,
+  policies: readonly ApiScopePolicyMetadata[],
+): ScopedApiRequest {
+  const normalizedSelection = normalizePresentationScopeRequestSelection(selection)
+  let projectedPath = path
+  let projectedInit = init
+
+  for (const policy of policies) {
+    if (policy.binding === 'header') {
+      const next = applyHeaderScopePolicy(
+        projectedPath,
+        projectedInit,
+        normalizedSelection,
+        policy,
+      )
+      projectedPath = next.path
+      projectedInit = next.init
+      continue
+    }
+
+    if (policy.binding === 'query') {
+      const next = applyQueryScopePolicy(
+        projectedPath,
+        projectedInit,
+        normalizedSelection,
+        policy,
+      )
+      projectedPath = next.path
+      projectedInit = next.init
+    }
+  }
+
+  return {
+    init: projectedInit,
+    path: projectedPath,
+  }
+}
+
+/**
+ * Wraps an HTTP client so scope metadata is applied at request time.
+ */
+export function createScopedApiHttpClient<TClient extends ApiRequestHttpClient>(
+  http: TClient,
+  {
+    getSelection,
+    policies,
+  }: {
+    readonly getSelection: () => PresentationScopeRequestSelection
+    readonly policies: readonly ApiScopePolicyMetadata[]
+  },
+): TClient {
+  return (async (path, init) => {
+    const projected = projectApiScopeRequest(path, init, getSelection(), policies)
+    return await http(projected.path, projected.init)
+  }) as TClient
+}
+
+function applyHeaderScopePolicy(
+  path: string,
+  init: RequestInit,
+  selection: PresentationScopeRequestSelection,
+  policy: ApiScopePolicyMetadata,
+): ScopedApiRequest {
+  if (policy.cardinality !== 'single' || !policy.singleScopeParameterName) {
+    return { init, path }
+  }
+
+  if (selection.mode !== 'single' || selection.scopeId === null) {
+    return { init, path }
+  }
+
+  const headers = new Headers(init.headers)
+  if (headers.has(policy.singleScopeParameterName)) {
+    return { init, path }
+  }
+
+  headers.set(policy.singleScopeParameterName, selection.scopeId)
+  return {
+    init: {
+      ...init,
+      headers,
+    },
+    path,
+  }
+}
+
+function applyQueryScopePolicy(
+  path: string,
+  init: RequestInit,
+  selection: PresentationScopeRequestSelection,
+  policy: ApiScopePolicyMetadata,
+): ScopedApiRequest {
+  if (policy.cardinality !== 'multiple' || !policy.multipleScopesParameterName) {
+    return { init, path }
+  }
+
+  const scopeIds = readRequestedScopeIds(selection)
+  if (scopeIds.length === 0) {
+    return { init, path }
+  }
+
+  const url = new URL(path, scopeProjectionBaseUrl)
+  if (url.searchParams.has(policy.multipleScopesParameterName)) {
+    return { init, path }
+  }
+
+  for (const scopeId of scopeIds) {
+    url.searchParams.append(policy.multipleScopesParameterName, scopeId)
+  }
+
+  return {
+    init,
+    path: formatProjectedPath(path, url),
+  }
+}
+
+function readRequestedScopeIds(selection: PresentationScopeRequestSelection) {
+  switch (selection.mode) {
+    case 'single':
+      return selection.scopeId ? [selection.scopeId] : []
+    case 'multiple':
+      return [...selection.scopeIds]
+    case 'all':
+    case 'default':
+      return []
+  }
+}
+
+function formatProjectedPath(originalPath: string, url: URL) {
+  return isAbsoluteUrl(originalPath)
+    ? url.toString()
+    : `${url.pathname}${url.search}${url.hash}`
+}
+
+function isAbsoluteUrl(value: string) {
+  return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(value)
+}
+
+const scopeProjectionBaseUrl = 'https://cohesive.local'

package/src/collection-chrome-icons.ts

@@ -0,0 +1,89 @@
+import type {
+  CollectionChromeRuntime,
+} from './collection-chrome-runtime'
+
+export const collectionChromeIconIds = {
+  detailClose: 'collection.detail.close',
+  paginationFirstPage: 'collection.pagination.first-page',
+  paginationLoading: 'collection.pagination.loading',
+  paginationNextPage: 'collection.pagination.next-page',
+  paginationPreviousPage: 'collection.pagination.previous-page',
+  rowActionsMenu: 'collection.row-actions.menu',
+} as const
+
+export interface CollectionChromeIconSubject {
+  readonly details?: Readonly<Record<string, unknown>>
+  readonly icon: string
+  readonly id: string
+  readonly kind: string
+  readonly label?: string | null
+}
+
+export function resolveCollectionChromeIconSubjects(
+  chrome: CollectionChromeRuntime,
+): readonly CollectionChromeIconSubject[] {
+  const subjects: CollectionChromeIconSubject[] = []
+
+  if (chrome.paginationSlot) {
+    subjects.push(
+      createCollectionChromeIconSubject({
+        icon: collectionChromeIconIds.paginationLoading,
+        label: 'Pagination loading',
+        slotId: chrome.paginationSlot.Id,
+      }),
+      createCollectionChromeIconSubject({
+        icon: collectionChromeIconIds.paginationFirstPage,
+        label: 'First page',
+        slotId: chrome.paginationSlot.Id,
+      }),
+      createCollectionChromeIconSubject({
+        icon: collectionChromeIconIds.paginationPreviousPage,
+        label: 'Previous page',
+        slotId: chrome.paginationSlot.Id,
+      }),
+      createCollectionChromeIconSubject({
+        icon: collectionChromeIconIds.paginationNextPage,
+        label: 'Next page',
+        slotId: chrome.paginationSlot.Id,
+      }),
+    )
+  }
+
+  if (chrome.rowActionsSlot) {
+    subjects.push(createCollectionChromeIconSubject({
+      icon: collectionChromeIconIds.rowActionsMenu,
+      label: 'Row actions menu',
+      slotId: chrome.rowActionsSlot.Id,
+    }))
+  }
+
+  if (chrome.detailSlot) {
+    subjects.push(createCollectionChromeIconSubject({
+      icon: collectionChromeIconIds.detailClose,
+      label: 'Close detail panel',
+      slotId: chrome.detailSlot.Id,
+    }))
+  }
+
+  return subjects
+}
+
+function createCollectionChromeIconSubject({
+  icon,
+  label,
+  slotId,
+}: {
+  readonly icon: string
+  readonly label: string
+  readonly slotId: string
+}): CollectionChromeIconSubject {
+  return {
+    details: {
+      slotId,
+    },
+    icon,
+    id: `${slotId}:${icon}`,
+    kind: 'collection-chrome-icon',
+    label,
+  }
+}

package/src/collection-chrome-runtime.ts

@@ -0,0 +1,151 @@
+import type {
+  CollectionChromeDefinition,
+  CollectionChromeSlotDefinition,
+  CollectionChromeSlotKind,
+  CollectionChromeSlotPlacement,
+  ViewDefinition,
+} from './module'
+import {
+  collectionChromeSlotKinds,
+  collectionChromeSlotPlacements,
+} from '@cohesivesystems/presentation-contracts'
+
+export type CollectionChromeRuntimeDefinition = NonNullable<ViewDefinition['Collection']>
+
+export interface CollectionChromeRuntime {
+  readonly bodySlot: CollectionChromeSlotDefinition | null
+  readonly definition: CollectionChromeDefinition | null
+  readonly detailSlot: CollectionChromeSlotDefinition | null
+  readonly paginationFooterSlot: CollectionChromeSlotDefinition | null
+  readonly paginationSlot: CollectionChromeSlotDefinition | null
+  readonly queryFormSlot: CollectionChromeSlotDefinition | null
+  readonly rowActionsSlot: CollectionChromeSlotDefinition | null
+  readonly selectionActionsSlot: CollectionChromeSlotDefinition | null
+  readonly slots: readonly CollectionChromeSlotDefinition[]
+  readonly summarySlot: CollectionChromeSlotDefinition | null
+  readonly findSlot: (
+    kind: CollectionChromeSlotKind,
+    placement?: CollectionChromeSlotPlacement,
+  ) => CollectionChromeSlotDefinition | null
+  readonly findSlots: (
+    kind: CollectionChromeSlotKind,
+    placement?: CollectionChromeSlotPlacement,
+  ) => readonly CollectionChromeSlotDefinition[]
+}
+
+export function createCollectionChromeRuntime(
+  collection: CollectionChromeRuntimeDefinition | null | undefined,
+): CollectionChromeRuntime {
+  const slots = resolveCollectionChromeSlots(collection)
+  const findSlots = (
+    kind: CollectionChromeSlotKind,
+    placement?: CollectionChromeSlotPlacement,
+  ) =>
+    slots.filter((slot) =>
+      isCollectionChromeSlotKind(slot, kind) &&
+      (placement === undefined || isCollectionChromeSlotPlacement(slot, placement)))
+  const findSlot = (
+    kind: CollectionChromeSlotKind,
+    placement?: CollectionChromeSlotPlacement,
+  ) => findSlots(kind, placement)[0] ?? null
+
+  return {
+    bodySlot: findSlot(collectionChromeSlotKinds.body),
+    definition: collection?.Chrome ?? null,
+    detailSlot: findSlot(collectionChromeSlotKinds.detail),
+    findSlot,
+    findSlots,
+    paginationFooterSlot: findSlot(
+      collectionChromeSlotKinds.pagination,
+      collectionChromeSlotPlacements.footer,
+    ),
+    paginationSlot: findSlot(collectionChromeSlotKinds.pagination),
+    queryFormSlot: findSlot(collectionChromeSlotKinds.queryForm),
+    rowActionsSlot: findSlot(collectionChromeSlotKinds.rowActions),
+    selectionActionsSlot: findSlot(collectionChromeSlotKinds.selectionActions),
+    slots,
+    summarySlot: findSlot(collectionChromeSlotKinds.summary),
+  }
+}
+
+export function resolveCollectionChromeSlots(
+  collection: CollectionChromeRuntimeDefinition | null | undefined,
+): readonly CollectionChromeSlotDefinition[] {
+  return collection?.Chrome?.Slots ?? []
+}
+
+export function resolveCollectionChromeDataSourceIds(
+  collection: CollectionChromeRuntimeDefinition | null | undefined,
+) {
+  return resolveCollectionChromeSlots(collection).flatMap((slot) => slot.DataSourceIds)
+}
+
+export function resolveCollectionChromePrimaryDataSourceId(
+  collection: CollectionChromeRuntimeDefinition | null | undefined,
+) {
+  const chrome = createCollectionChromeRuntime(collection)
+  return chrome.bodySlot?.DataSourceIds[0] ??
+    chrome.slots.flatMap((slot) => slot.DataSourceIds)[0] ??
+    null
+}
+
+export function isCollectionChromeSlotKind(
+  slot: CollectionChromeSlotDefinition,
+  kind: CollectionChromeSlotKind,
+) {
+  return matchesCollectionChromeSlotKind(slot.Kind, kind)
+}
+
+export function isCollectionChromeSlotPlacement(
+  slot: CollectionChromeSlotDefinition,
+  placement: CollectionChromeSlotPlacement,
+) {
+  return matchesCollectionChromeSlotPlacement(slot.Placement, placement)
+}
+
+export function matchesCollectionChromeSlotKind(
+  value: unknown,
+  kind: CollectionChromeSlotKind,
+) {
+  const labelsByKind: Readonly<Record<CollectionChromeSlotKind, string>> = {
+    [collectionChromeSlotKinds.queryForm]: 'queryForm',
+    [collectionChromeSlotKinds.pagination]: 'pagination',
+    [collectionChromeSlotKinds.selectionActions]: 'selectionActions',
+    [collectionChromeSlotKinds.rowActions]: 'rowActions',
+    [collectionChromeSlotKinds.detail]: 'detail',
+    [collectionChromeSlotKinds.summary]: 'summary',
+    [collectionChromeSlotKinds.custom]: 'custom',
+    [collectionChromeSlotKinds.body]: 'body',
+  }
+  return matchesGeneratedEnumValue(value, kind, labelsByKind[kind])
+}
+
+export function matchesCollectionChromeSlotPlacement(
+  value: unknown,
+  placement: CollectionChromeSlotPlacement,
+) {
+  const labelsByPlacement: Readonly<Record<CollectionChromeSlotPlacement, string>> = {
+    [collectionChromeSlotPlacements.none]: 'none',
+    [collectionChromeSlotPlacements.header]: 'header',
+    [collectionChromeSlotPlacements.toolbar]: 'toolbar',
+    [collectionChromeSlotPlacements.above]: 'above',
+    [collectionChromeSlotPlacements.inline]: 'inline',
+    [collectionChromeSlotPlacements.footer]: 'footer',
+    [collectionChromeSlotPlacements.sidePanel]: 'sidePanel',
+    [collectionChromeSlotPlacements.drawer]: 'drawer',
+  }
+  return matchesGeneratedEnumValue(value, placement, labelsByPlacement[placement])
+}
+
+function matchesGeneratedEnumValue<TValue extends number>(
+  value: unknown,
+  numericValue: TValue,
+  camelLabel: string,
+) {
+  const normalizedValue = String(value).toLocaleLowerCase()
+  return (
+    value === numericValue ||
+    String(value) === String(numericValue) ||
+    normalizedValue === camelLabel.toLocaleLowerCase()
+  )
+}