@ngbplatform/ui 1.3.0

package/src/ngb/editor/NgbEntityEditorHeader.vue

@@ -0,0 +1,114 @@
+<script setup lang="ts">
+import NgbHeaderActionCluster from '../components/NgbHeaderActionCluster.vue';
+import NgbBadge from '../primitives/NgbBadge.vue';
+import NgbIcon from '../primitives/NgbIcon.vue';
+import NgbPageHeader from '../site/NgbPageHeader.vue';
+
+import type {
+  DocumentHeaderActionGroup,
+  DocumentHeaderActionItem,
+  EditorKind,
+  EditorMode,
+  EntityHeaderIconAction,
+} from './types';
+
+const props = withDefaults(defineProps<{
+  kind: EditorKind;
+  mode: EditorMode;
+  canBack: boolean;
+  title: string;
+  subtitle?: string;
+  documentStatusLabel: string;
+  documentStatusTone: 'neutral' | 'success' | 'warn';
+  loading: boolean;
+  saving: boolean;
+  pageActions?: EntityHeaderIconAction[];
+  documentPrimaryActions: DocumentHeaderActionItem[];
+  documentMoreActionGroups: DocumentHeaderActionGroup[];
+}>(), {
+  subtitle: undefined,
+  pageActions: () => [],
+});
+
+const emit = defineEmits<{
+  (e: 'back'): void;
+  (e: 'close'): void;
+  (e: 'action', action: string): void;
+}>();
+</script>
+
+<template>
+  <template v-if="kind === 'document'">
+    <template v-if="mode === 'page'">
+      <NgbPageHeader :title="title" :can-back="canBack" @back="emit('back')">
+        <template #secondary>
+          <div class="flex min-w-0 items-center">
+            <NgbBadge :tone="documentStatusTone">{{ documentStatusLabel }}</NgbBadge>
+          </div>
+        </template>
+
+        <template #actions>
+          <NgbHeaderActionCluster
+            :primary-actions="documentPrimaryActions"
+            :more-groups="documentMoreActionGroups"
+            :close-disabled="loading || saving"
+            @action="(action) => emit('action', action)"
+            @close="emit('close')"
+          />
+        </template>
+      </NgbPageHeader>
+    </template>
+
+    <div v-else class="border-b border-ngb-border bg-ngb-card px-5 pt-4 pb-4">
+      <div class="min-w-0 w-full">
+        <div class="font-semibold leading-tight truncate whitespace-nowrap text-lg">
+          {{ title }}
+        </div>
+      </div>
+
+      <div class="mt-3 flex items-center justify-between gap-3">
+        <div class="min-w-0 flex items-center gap-2">
+          <NgbBadge :tone="documentStatusTone">{{ documentStatusLabel }}</NgbBadge>
+        </div>
+
+        <div class="flex shrink-0 items-center gap-2">
+          <NgbHeaderActionCluster
+            :primary-actions="documentPrimaryActions"
+            :more-groups="documentMoreActionGroups"
+            :close-disabled="loading || saving"
+            @action="(action) => emit('action', action)"
+            @close="emit('close')"
+          />
+        </div>
+      </div>
+    </div>
+  </template>
+
+  <NgbPageHeader
+    v-else-if="mode === 'page'"
+    :title="title"
+    :can-back="canBack"
+    @back="emit('back')"
+  >
+    <template #secondary>
+      <div v-if="subtitle" class="text-xs text-ngb-muted truncate">{{ subtitle }}</div>
+    </template>
+
+    <template #actions>
+      <button
+        v-for="item in pageActions"
+        :key="item.key"
+        class="ngb-iconbtn"
+        :disabled="item.disabled"
+        :title="item.title"
+        @click="emit('action', item.key)"
+      >
+        <NgbIcon :name="item.icon" />
+      </button>
+
+      <button class="ngb-iconbtn" :disabled="loading || saving" title="Close" @click="emit('close')">
+        <NgbIcon name="x" />
+      </button>
+    </template>
+  </NgbPageHeader>
+</template>

package/src/ngb/editor/catalogNavigation.ts

@@ -0,0 +1,13 @@
+import { resolveNgbEditorRouting } from './config';
+
+export function buildCatalogListUrl(catalogType: string): string {
+  return resolveNgbEditorRouting().buildCatalogListUrl(catalogType);
+}
+
+export function buildCatalogFullPageUrl(catalogType: string, id?: string | null): string {
+  return resolveNgbEditorRouting().buildCatalogFullPageUrl(catalogType, id);
+}
+
+export function buildCatalogCompactPageUrl(catalogType: string, id?: string | null): string {
+  return resolveNgbEditorRouting().buildCatalogCompactPageUrl(catalogType, id);
+}

package/src/ngb/editor/config.ts

@@ -0,0 +1,252 @@
+import type { Awaitable, EntityFormModel, LookupStoreApi } from '../metadata/types';
+import type {
+  AuditLogPage,
+  DocumentHeaderActionItem,
+  DocumentEffects,
+  DocumentRecord,
+  EntityEditorContext,
+  EditorAuditBehavior,
+  EditorAuditLoadOptions,
+  EditorDocumentEffectsBehavior,
+  EditorPrintBehavior,
+  DocumentUiEffects,
+  RelationshipGraph,
+} from './types';
+
+export type EditorRoutingConfig = {
+  buildCatalogListUrl?: (catalogType: string) => string;
+  buildCatalogFullPageUrl?: (catalogType: string, id?: string | null) => string;
+  buildCatalogCompactPageUrl?: (catalogType: string, id?: string | null) => string;
+  buildDocumentFullPageUrl?: (documentType: string, id?: string | null) => string;
+  buildDocumentCompactPageUrl?: (documentType: string, id?: string | null) => string;
+  buildDocumentEffectsPageUrl?: (documentType: string, id: string) => string;
+  buildDocumentFlowPageUrl?: (documentType: string, id: string) => string;
+  buildDocumentPrintPageUrl?: (documentType: string, id: string, options?: { autoPrint?: boolean }) => string;
+};
+
+export type EditorEntityBehaviorArgs = {
+  context: EntityEditorContext;
+  model: EntityFormModel;
+};
+
+export type EditorComputedDisplayMode = 'always' | 'new_or_draft';
+
+export type EditorEntityProfile = {
+  tags?: string[];
+  sanitizeWatchFields?: string[];
+  computedDisplayWatchFields?: string[];
+  computedDisplayMode?: EditorComputedDisplayMode;
+  sanitizeModelForEditing?: (args: EditorEntityBehaviorArgs) => void;
+  syncComputedDisplay?: (args: EditorEntityBehaviorArgs) => void;
+};
+
+export type EditorDocumentActionGroup = {
+  key: string;
+  label: string;
+};
+
+export type EditorConfiguredDocumentAction = {
+  item: DocumentHeaderActionItem;
+  group?: EditorDocumentActionGroup | null;
+  run: () => Awaitable<void>;
+};
+
+export type ResolveEditorDocumentActionsArgs = {
+  context: EntityEditorContext;
+  documentId: string;
+  model: EntityFormModel;
+  uiEffects: DocumentUiEffects | null;
+  loading: boolean;
+  saving: boolean;
+  navigate: (to: string | null | undefined) => void;
+};
+
+export type EditorFrameworkConfig = {
+  routing?: EditorRoutingConfig;
+  loadDocumentById: (documentType: string, id: string) => Promise<DocumentRecord>;
+  loadDocumentEffects: (documentType: string, id: string, limit?: number) => Promise<DocumentEffects>;
+  loadDocumentGraph: (documentType: string, id: string, depth?: number, maxNodes?: number) => Promise<RelationshipGraph>;
+  loadEntityAuditLog: (
+    entityKind: number,
+    entityId: string,
+    options?: EditorAuditLoadOptions,
+  ) => Promise<AuditLogPage>;
+  lookupStore?: LookupStoreApi | null;
+  audit?: EditorAuditBehavior;
+  effects?: EditorDocumentEffectsBehavior;
+  print?: EditorPrintBehavior;
+  resolveEntityProfile?: (context: EntityEditorContext) => EditorEntityProfile | null;
+  resolveDocumentActions?: (args: ResolveEditorDocumentActionsArgs) => EditorConfiguredDocumentAction[] | null;
+};
+
+let editorFrameworkConfig: EditorFrameworkConfig | null = null;
+
+function normalizePathSegment(value: string | null | undefined): string {
+  return String(value ?? '').trim();
+}
+
+function appendQuery(path: string, query: Record<string, string | null | undefined>): string {
+  const params = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(query)) {
+    const normalized = normalizePathSegment(value);
+    if (!normalized) continue;
+    params.set(key, normalized);
+  }
+
+  const serialized = params.toString();
+  return serialized ? `${path}?${serialized}` : path;
+}
+
+function defaultBuildCatalogListUrl(catalogType: string): string {
+  const type = encodeURIComponent(normalizePathSegment(catalogType));
+  return `/catalogs/${type}`;
+}
+
+function defaultBuildCatalogFullPageUrl(catalogType: string, id?: string | null): string {
+  const normalizedId = normalizePathSegment(id);
+  if (!normalizedId) return `${defaultBuildCatalogListUrl(catalogType)}/new`;
+  return `${defaultBuildCatalogListUrl(catalogType)}/${encodeURIComponent(normalizedId)}`;
+}
+
+function defaultBuildCatalogCompactPageUrl(catalogType: string, id?: string | null): string {
+  const normalizedId = normalizePathSegment(id);
+  if (!normalizedId) return appendQuery(defaultBuildCatalogListUrl(catalogType), { panel: 'new' });
+  return appendQuery(defaultBuildCatalogListUrl(catalogType), { panel: 'edit', id: normalizedId });
+}
+
+function defaultBuildDocumentFullPageUrl(documentType: string, id?: string | null): string {
+  const type = encodeURIComponent(normalizePathSegment(documentType));
+  const normalizedId = normalizePathSegment(id);
+  if (!normalizedId) return `/documents/${type}/new`;
+  return `/documents/${type}/${encodeURIComponent(normalizedId)}`;
+}
+
+function defaultBuildDocumentCompactPageUrl(documentType: string, id?: string | null): string {
+  const type = encodeURIComponent(normalizePathSegment(documentType));
+  const normalizedId = normalizePathSegment(id);
+  if (!normalizedId) return `/documents/${type}?panel=new`;
+  return appendQuery(`/documents/${type}`, { panel: 'edit', id: normalizedId });
+}
+
+function defaultBuildDocumentEffectsPageUrl(documentType: string, id: string): string {
+  const type = encodeURIComponent(normalizePathSegment(documentType));
+  return `/documents/${type}/${encodeURIComponent(normalizePathSegment(id))}/effects`;
+}
+
+function defaultBuildDocumentFlowPageUrl(documentType: string, id: string): string {
+  const type = encodeURIComponent(normalizePathSegment(documentType));
+  return `/documents/${type}/${encodeURIComponent(normalizePathSegment(id))}/flow`;
+}
+
+function defaultBuildDocumentPrintPageUrl(
+  documentType: string,
+  id: string,
+  options?: { autoPrint?: boolean },
+): string {
+  const type = encodeURIComponent(normalizePathSegment(documentType));
+  const base = `/documents/${type}/${encodeURIComponent(normalizePathSegment(id))}/print`;
+  return options?.autoPrint ? `${base}?autoprint=1` : base;
+}
+
+export function configureNgbEditor(config: EditorFrameworkConfig): void {
+  editorFrameworkConfig = config;
+}
+
+export function getConfiguredNgbEditor(): EditorFrameworkConfig {
+  if (!editorFrameworkConfig) {
+    throw new Error('NGB editor framework is not configured. Call configureNgbEditor(...) during app bootstrap.');
+  }
+
+  return editorFrameworkConfig;
+}
+
+export function maybeGetConfiguredNgbEditor(): EditorFrameworkConfig | null {
+  return editorFrameworkConfig;
+}
+
+export function resolveNgbEditorRouting(): Required<EditorRoutingConfig> {
+  return {
+    buildCatalogListUrl:
+      editorFrameworkConfig?.routing?.buildCatalogListUrl ?? defaultBuildCatalogListUrl,
+    buildCatalogFullPageUrl:
+      editorFrameworkConfig?.routing?.buildCatalogFullPageUrl ?? defaultBuildCatalogFullPageUrl,
+    buildCatalogCompactPageUrl:
+      editorFrameworkConfig?.routing?.buildCatalogCompactPageUrl ?? defaultBuildCatalogCompactPageUrl,
+    buildDocumentFullPageUrl:
+      editorFrameworkConfig?.routing?.buildDocumentFullPageUrl ?? defaultBuildDocumentFullPageUrl,
+    buildDocumentCompactPageUrl:
+      editorFrameworkConfig?.routing?.buildDocumentCompactPageUrl ?? defaultBuildDocumentCompactPageUrl,
+    buildDocumentEffectsPageUrl:
+      editorFrameworkConfig?.routing?.buildDocumentEffectsPageUrl ?? defaultBuildDocumentEffectsPageUrl,
+    buildDocumentFlowPageUrl:
+      editorFrameworkConfig?.routing?.buildDocumentFlowPageUrl ?? defaultBuildDocumentFlowPageUrl,
+    buildDocumentPrintPageUrl:
+      editorFrameworkConfig?.routing?.buildDocumentPrintPageUrl ?? defaultBuildDocumentPrintPageUrl,
+  };
+}
+
+export function resolveNgbEditorEntityProfile(context: EntityEditorContext): EditorEntityProfile {
+  return editorFrameworkConfig?.resolveEntityProfile?.(context) ?? {};
+}
+
+export function resolveNgbEditorDocumentActions(
+  args: ResolveEditorDocumentActionsArgs,
+): EditorConfiguredDocumentAction[] {
+  return editorFrameworkConfig?.resolveDocumentActions?.(args) ?? [];
+}
+
+export function sanitizeNgbEditorModelForEditing(
+  context: EntityEditorContext,
+  model: EntityFormModel,
+): void {
+  resolveNgbEditorEntityProfile(context).sanitizeModelForEditing?.({ context, model });
+}
+
+export function syncNgbEditorComputedDisplay(
+  context: EntityEditorContext,
+  model: EntityFormModel,
+): void {
+  resolveNgbEditorEntityProfile(context).syncComputedDisplay?.({ context, model });
+}
+
+export function resolveNgbEditorAuditBehavior(override?: EditorAuditBehavior): EditorAuditBehavior {
+  const defaultHiddenFieldNames = [
+    'created_at_utc',
+    'updated_at_utc',
+    'deleted_at_utc',
+    'marked_for_deletion_at_utc',
+  ];
+
+  return {
+    hiddenFieldNames: [
+      ...defaultHiddenFieldNames,
+      ...(editorFrameworkConfig?.audit?.hiddenFieldNames ?? []),
+      ...(override?.hiddenFieldNames ?? []),
+    ],
+    explicitFieldLabels: {
+      ...(editorFrameworkConfig?.audit?.explicitFieldLabels ?? {}),
+      ...(override?.explicitFieldLabels ?? {}),
+    },
+    actionTitles: {
+      ...(editorFrameworkConfig?.audit?.actionTitles ?? {}),
+      ...(override?.actionTitles ?? {}),
+    },
+  };
+}
+
+export function resolveNgbEditorEffectsBehavior(
+  override?: EditorDocumentEffectsBehavior,
+): EditorDocumentEffectsBehavior {
+  return {
+    ...(editorFrameworkConfig?.effects ?? {}),
+    ...(override ?? {}),
+  };
+}
+
+export function resolveNgbEditorPrintBehavior(override?: EditorPrintBehavior): EditorPrintBehavior {
+  return {
+    ...(editorFrameworkConfig?.print ?? {}),
+    ...(override ?? {}),
+  };
+}

package/src/ngb/editor/documentCopyDraft.ts

@@ -0,0 +1,245 @@
+import {
+  canUseStorage,
+  listStorageKeys,
+  readStorageString,
+  removeStorageItem,
+  writeStorageString,
+} from '../utils/storage';
+import type { JsonObject, JsonValue, RecordFields, RecordParts } from '../metadata/types';
+
+const STORAGE_KEY_PREFIX = 'ngb:document-copy-draft:';
+const SNAPSHOT_VERSION = 1;
+const MAX_SNAPSHOT_AGE_MS = 6 * 60 * 60 * 1000;
+
+type StoredDocumentCopyDraft = {
+  version: number;
+  documentType: string;
+  fields: RecordFields;
+  parts?: RecordParts | null;
+  createdAtUtc: string;
+};
+
+export type DocumentCopyDraftSnapshot = {
+  documentType: string;
+  fields: RecordFields;
+  parts?: RecordParts | null;
+};
+
+type CopyDraftStore = {
+  kind: 'session' | 'local' | 'memory';
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+  keys(): string[];
+};
+
+type GlobalWithCopyDraftStore = typeof globalThis & {
+  __ngbDocumentCopyDraftMemoryStore?: Map<string, string>;
+};
+
+function getMemoryStore(): Map<string, string> {
+  const root = globalThis as GlobalWithCopyDraftStore;
+  if (!root.__ngbDocumentCopyDraftMemoryStore) {
+    root.__ngbDocumentCopyDraftMemoryStore = new Map<string, string>();
+  }
+  return root.__ngbDocumentCopyDraftMemoryStore;
+}
+
+function getStores(): CopyDraftStore[] {
+  const stores: CopyDraftStore[] = [];
+  if (canUseStorage('session')) {
+    stores.push({
+      kind: 'session',
+      getItem: (key) => readStorageString('session', key),
+      setItem: (key, value) => {
+        void writeStorageString('session', key, value);
+      },
+      removeItem: (key) => removeStorageItem('session', key),
+      keys: () => listStorageKeys('session'),
+    });
+  }
+
+  if (canUseStorage('local')) {
+    stores.push({
+      kind: 'local',
+      getItem: (key) => readStorageString('local', key),
+      setItem: (key, value) => {
+        void writeStorageString('local', key, value);
+      },
+      removeItem: (key) => removeStorageItem('local', key),
+      keys: () => listStorageKeys('local'),
+    });
+  }
+
+  const memory = getMemoryStore();
+  stores.push({
+    kind: 'memory',
+    getItem: (key) => memory.get(key) ?? null,
+    setItem: (key, value) => {
+      memory.set(key, value);
+    },
+    removeItem: (key) => {
+      memory.delete(key);
+    },
+    keys: () => Array.from(memory.keys()),
+  });
+
+  return stores;
+}
+
+function buildStorageKey(token: string): string {
+  return `${STORAGE_KEY_PREFIX}${token}`;
+}
+
+function createToken(): string {
+  const random = Math.random().toString(36).slice(2, 10);
+  return `${Date.now().toString(36)}-${random}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cleanupExpiredSnapshots(store: CopyDraftStore): void {
+  const now = Date.now();
+
+  for (const key of store.keys()) {
+    if (!key || !key.startsWith(STORAGE_KEY_PREFIX)) continue;
+
+    const raw = store.getItem(key);
+    if (!raw) {
+      store.removeItem(key);
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(raw) as Partial<StoredDocumentCopyDraft>;
+      const createdAtMs = Date.parse(String(parsed.createdAtUtc ?? ''));
+      if (!Number.isFinite(createdAtMs) || now - createdAtMs > MAX_SNAPSHOT_AGE_MS) {
+        store.removeItem(key);
+      }
+    } catch {
+      store.removeItem(key);
+    }
+  }
+}
+
+function parseSnapshot(raw: string | null): StoredDocumentCopyDraft | null {
+  if (!raw) return null;
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredDocumentCopyDraft>;
+    if (parsed.version !== SNAPSHOT_VERSION) return null;
+    if (typeof parsed.documentType !== 'string' || !parsed.documentType.trim()) return null;
+    if (!isRecord(parsed.fields)) return null;
+    if (parsed.parts != null && !isRecord(parsed.parts)) return null;
+    if (typeof parsed.createdAtUtc !== 'string' || !parsed.createdAtUtc.trim()) return null;
+    return {
+      version: SNAPSHOT_VERSION,
+      documentType: parsed.documentType,
+      fields: parsed.fields as RecordFields,
+      parts: (parsed.parts ?? null) as RecordParts | null,
+      createdAtUtc: parsed.createdAtUtc,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function sanitizeForStorage(value: unknown, seen: WeakSet<object> = new WeakSet()): JsonValue {
+  if (value == null) return null;
+
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'bigint') return value.toString();
+  if (typeof value === 'function' || typeof value === 'symbol') return null;
+
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeForStorage(item, seen));
+  }
+
+  if (typeof value === 'object') {
+    if (seen.has(value)) return null;
+    seen.add(value);
+
+    const out: JsonObject = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item === undefined) continue;
+      out[key] = sanitizeForStorage(item, seen);
+    }
+    return out;
+  }
+
+  return null;
+}
+
+function buildPayload(snapshot: DocumentCopyDraftSnapshot): StoredDocumentCopyDraft {
+  return {
+    version: SNAPSHOT_VERSION,
+    documentType: snapshot.documentType,
+    fields: (sanitizeForStorage(snapshot.fields ?? {}) ?? {}) as RecordFields,
+    parts: sanitizeForStorage(snapshot.parts ?? null) as RecordParts | null,
+    createdAtUtc: new Date().toISOString(),
+  };
+}
+
+function writeToStore(store: CopyDraftStore, key: string, value: string): boolean {
+  try {
+    store.setItem(key, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function saveDocumentCopyDraft(snapshot: DocumentCopyDraftSnapshot): string | null {
+  const token = createToken();
+  const stores = getStores();
+  const payload = buildPayload(snapshot);
+  const serialized = JSON.stringify(payload);
+  const key = buildStorageKey(token);
+
+  for (const store of stores) {
+    cleanupExpiredSnapshots(store);
+    if (writeToStore(store, key, serialized)) return token;
+  }
+
+  return null;
+}
+
+export function readDocumentCopyDraft(
+  token: string | null | undefined,
+  expectedDocumentType?: string | null,
+): DocumentCopyDraftSnapshot | null {
+  const normalizedToken = String(token ?? '').trim();
+  if (!normalizedToken) return null;
+
+  const key = buildStorageKey(normalizedToken);
+  for (const store of getStores()) {
+    cleanupExpiredSnapshots(store);
+
+    const parsed = parseSnapshot(store.getItem(key));
+    if (!parsed) continue;
+    if (expectedDocumentType && parsed.documentType !== expectedDocumentType) return null;
+
+    return {
+      documentType: parsed.documentType,
+      fields: parsed.fields,
+      parts: parsed.parts ?? null,
+    };
+  }
+
+  return null;
+}
+
+export function clearDocumentCopyDraft(token: string | null | undefined): void {
+  const normalizedToken = String(token ?? '').trim();
+  if (!normalizedToken) return;
+
+  const key = buildStorageKey(normalizedToken);
+  for (const store of getStores()) {
+    store.removeItem(key);
+  }
+}

package/src/ngb/editor/documentEffects.ts

@@ -0,0 +1,43 @@
+import { isEmptyGuid, isNonEmptyGuid, shortGuid } from '../utils/guid';
+import type { DocumentEffects, EffectAccount } from './types';
+
+type CoaLabelResolver = (id: unknown) => string;
+
+export function resolveEffectAccountLabel(
+  account: EffectAccount | null | undefined,
+  accountId: string | null | undefined,
+  resolveCoaLabel?: CoaLabelResolver | null,
+): string {
+  const code = String(account?.code ?? '').trim();
+  const name = String(account?.name ?? '').trim();
+  if (code && name) return `${code} — ${name}`;
+  if (code) return code;
+  if (name) return name;
+  if (resolveCoaLabel && isNonEmptyGuid(accountId) && !isEmptyGuid(accountId)) return resolveCoaLabel(accountId);
+  return '—';
+}
+
+export function finalizeEffectDimensionSummary(
+  items: string[],
+  fallbackDimensionSetId?: string | null,
+): string | string[] {
+  const visibleItems = items.filter((item) => !!item && item !== '—');
+  if (visibleItems.length > 0) return visibleItems;
+  if (isNonEmptyGuid(fallbackDimensionSetId) && !isEmptyGuid(fallbackDimensionSetId)) return shortGuid(fallbackDimensionSetId);
+  return '—';
+}
+
+export function collectAccountingEntryAccountIds(snapshot: DocumentEffects | null | undefined): string[] {
+  const ids = new Set<string>();
+
+  for (const entry of snapshot?.accountingEntries ?? []) {
+    if (!entry.debitAccount && isNonEmptyGuid(entry.debitAccountId) && !isEmptyGuid(entry.debitAccountId)) {
+      ids.add(entry.debitAccountId);
+    }
+    if (!entry.creditAccount && isNonEmptyGuid(entry.creditAccountId) && !isEmptyGuid(entry.creditAccountId)) {
+      ids.add(entry.creditAccountId);
+    }
+  }
+
+  return Array.from(ids);
+}

package/src/ngb/editor/documentEffectsDateFormatting.ts

@@ -0,0 +1,18 @@
+export function formatOccurredAtUtcValue(value: string, locales?: Intl.LocalesArgument): string {
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return value
+
+  const isUtcMidnight =
+    date.getUTCHours() === 0 &&
+    date.getUTCMinutes() === 0 &&
+    date.getUTCSeconds() === 0 &&
+    date.getUTCMilliseconds() === 0
+
+  if (isUtcMidnight) {
+    return date.toLocaleDateString(locales, {
+      timeZone: 'UTC',
+    })
+  }
+
+  return date.toLocaleString(locales)
+}