@ngbplatform/ui 1.3.0

package/src/ngb/editor/useEntityEditorBusinessContext.ts

@@ -0,0 +1,97 @@
+import { computed, watch, type ComputedRef, type Ref } from 'vue';
+
+import type { EntityFormModel } from '../metadata/types';
+import {
+  resolveNgbEditorEntityProfile,
+  sanitizeNgbEditorModelForEditing,
+  syncNgbEditorComputedDisplay,
+} from './config';
+import type { EntityEditorContext, EditorKind } from './types';
+
+type DocumentMetaWithParts = {
+  parts?: unknown[] | null;
+};
+
+export type UseEntityEditorBusinessContextArgs<
+  TDocumentMeta extends DocumentMetaWithParts | null = DocumentMetaWithParts | null,
+> = {
+  kind: ComputedRef<EditorKind>;
+  typeCode: ComputedRef<string>;
+  model: Ref<EntityFormModel>;
+  docMeta: Ref<TDocumentMeta>;
+  loading: Ref<boolean>;
+  isNew: ComputedRef<boolean>;
+  isDraft: ComputedRef<boolean>;
+  isMarkedForDeletion: ComputedRef<boolean>;
+};
+
+function watchedFieldValues(model: EntityFormModel, fieldKeys: string[] | undefined): unknown[] {
+  return (fieldKeys ?? []).map((fieldKey) => model[fieldKey]);
+}
+
+export function useEntityEditorBusinessContext<
+  TDocumentMeta extends DocumentMetaWithParts | null = DocumentMetaWithParts | null,
+>(args: UseEntityEditorBusinessContextArgs<TDocumentMeta>) {
+  const currentContext = computed<EntityEditorContext>(() => ({
+    kind: args.kind.value,
+    typeCode: args.typeCode.value,
+  }));
+
+  const entityProfile = computed(() => resolveNgbEditorEntityProfile(currentContext.value));
+  const tags = computed(() => Array.from(new Set(entityProfile.value.tags ?? [])));
+
+  const hasDocumentTables = computed(() =>
+    args.kind.value === 'document' && (args.docMeta.value?.parts?.length ?? 0) > 0,
+  );
+
+  function currentEditorContext(): EntityEditorContext {
+    return currentContext.value;
+  }
+
+  function hasTag(tag: string): boolean {
+    const normalized = String(tag ?? '').trim();
+    if (!normalized) return false;
+    return tags.value.includes(normalized);
+  }
+
+  watch(
+    () => [
+      args.kind.value,
+      args.typeCode.value,
+      ...watchedFieldValues(args.model.value, entityProfile.value.sanitizeWatchFields),
+    ],
+    () => {
+      if (!entityProfile.value.sanitizeModelForEditing) return;
+      sanitizeNgbEditorModelForEditing(currentContext.value, args.model.value);
+    },
+    { deep: false },
+  );
+
+  watch(
+    () => [
+      args.kind.value,
+      args.typeCode.value,
+      args.loading.value,
+      args.isNew.value,
+      args.isDraft.value,
+      args.isMarkedForDeletion.value,
+      ...watchedFieldValues(args.model.value, entityProfile.value.computedDisplayWatchFields),
+    ],
+    () => {
+      if (!entityProfile.value.syncComputedDisplay) return;
+      if (args.loading.value) return;
+      if (args.isMarkedForDeletion.value) return;
+      if (entityProfile.value.computedDisplayMode === 'new_or_draft' && !args.isNew.value && !args.isDraft.value) return;
+      syncNgbEditorComputedDisplay(currentContext.value, args.model.value);
+    },
+    { deep: false },
+  );
+
+  return {
+    currentEditorContext,
+    entityProfile,
+    tags,
+    hasTag,
+    hasDocumentTables,
+  };
+}

package/src/ngb/editor/useEntityEditorCapabilities.ts

@@ -0,0 +1,190 @@
+import { computed, type ComputedRef, type Ref } from 'vue';
+
+import type { EntityFormModel, DocumentStatusValue } from '../metadata/types';
+import { documentStatusLabel, documentStatusTone } from './documentStatus';
+import type { EditorKind } from './types';
+
+type EntityEditorCapabilitiesMetadata = {
+  displayName?: string | null;
+  form?: unknown | null;
+  capabilities?: {
+    canCreate?: boolean;
+    canEdit?: boolean;
+    canEditDraft?: boolean;
+    canDelete?: boolean;
+    canDeleteDraft?: boolean;
+    canPost?: boolean;
+    canUnpost?: boolean;
+    canMarkForDeletion?: boolean;
+    canViewEffects?: boolean;
+    canViewFlow?: boolean;
+  } | null;
+};
+
+export type UseEntityEditorCapabilitiesArgs<
+  TMetadata extends EntityEditorCapabilitiesMetadata = EntityEditorCapabilitiesMetadata,
+> = {
+  kind: ComputedRef<EditorKind>;
+  currentId: Ref<string | null>;
+  metadata: ComputedRef<TMetadata | null>;
+  model: Ref<EntityFormModel>;
+  loading: Ref<boolean>;
+  saving: Ref<boolean>;
+  isNew: ComputedRef<boolean>;
+  isDraft: ComputedRef<boolean>;
+  isMarkedForDeletion: ComputedRef<boolean>;
+  status: ComputedRef<DocumentStatusValue>;
+};
+
+export function useEntityEditorCapabilities<
+  TMetadata extends EntityEditorCapabilitiesMetadata = EntityEditorCapabilitiesMetadata,
+>(args: UseEntityEditorCapabilitiesArgs<TMetadata>) {
+  const capabilities = computed(() => args.metadata.value?.capabilities ?? null);
+  const canOpenAudit = computed(() => !args.isNew.value && !!args.currentId.value);
+  const canShareLink = computed(() => !args.isNew.value && !!args.currentId.value);
+
+  const canOpenEffectsPage = computed(() =>
+    args.kind.value === 'document'
+    && capabilities.value?.canViewEffects !== false
+    && !args.isNew.value
+    && !!args.currentId.value
+    && !args.loading.value
+    && !args.saving.value,
+  );
+
+  const canOpenDocumentFlowPage = computed(() =>
+    args.kind.value === 'document'
+    && capabilities.value?.canViewFlow !== false
+    && !args.isNew.value
+    && !!args.currentId.value
+    && !args.loading.value
+    && !args.saving.value,
+  );
+
+  const canPrintDocument = computed(() =>
+    args.kind.value === 'document' && !args.isNew.value && !!args.currentId.value && !args.loading.value && !args.saving.value,
+  );
+
+  const canMarkForDeletion = computed(() => {
+    if (args.isNew.value) return false;
+    if (args.loading.value || args.saving.value) return false;
+    if (args.isMarkedForDeletion.value) return false;
+    if (capabilities.value?.canMarkForDeletion === false) return false;
+    if (args.kind.value === 'document' && !args.isDraft.value) return false;
+    return true;
+  });
+
+  const canUnmarkForDeletion = computed(() => {
+    if (args.isNew.value) return false;
+    if (args.loading.value || args.saving.value) return false;
+    if (!args.isMarkedForDeletion.value) return false;
+    if (capabilities.value?.canMarkForDeletion === false) return false;
+    return true;
+  });
+
+  const canDelete = computed(() =>
+    args.kind.value === 'catalog'
+    && capabilities.value?.canDelete !== false
+    && !args.isNew.value
+    && !args.loading.value
+    && !args.saving.value
+    && !args.isMarkedForDeletion.value,
+  );
+
+  const canPost = computed(() => {
+    if (args.kind.value !== 'document') return false;
+    if (capabilities.value?.canPost === false) return false;
+    if (args.isNew.value) return false;
+    if (args.loading.value || args.saving.value) return false;
+    return args.isDraft.value && !args.isMarkedForDeletion.value;
+  });
+
+  const canUnpost = computed(() => {
+    if (args.kind.value !== 'document') return false;
+    if (capabilities.value?.canUnpost === false) return false;
+    if (args.isNew.value) return false;
+    if (args.loading.value || args.saving.value) return false;
+    return args.status.value === 2;
+  });
+
+  const canSave = computed(() => {
+    if (!args.metadata.value?.form) return false;
+    if (!args.isNew.value && args.isMarkedForDeletion.value) return false;
+    if (args.kind.value !== 'document') {
+      return args.isNew.value
+        ? capabilities.value?.canCreate !== false
+        : capabilities.value?.canEdit !== false;
+    }
+    if (args.isNew.value) return capabilities.value?.canCreate !== false;
+    if (capabilities.value?.canEditDraft === false) return false;
+    return args.isDraft.value;
+  });
+
+  const documentDisplayTitle = computed(() => {
+    if (args.kind.value !== 'document') return '';
+
+    const display = String(args.model.value.display ?? '').trim();
+    if (display) return display;
+
+    const base = args.metadata.value?.displayName ?? 'Document';
+    return args.isNew.value ? `New ${base}` : base;
+  });
+
+  const resolvedDocumentStatusLabel = computed(() => {
+    if (args.kind.value !== 'document') return 'Draft';
+    if (args.isNew.value) return 'Draft';
+    return documentStatusLabel(args.status.value);
+  });
+
+  const resolvedDocumentStatusTone = computed(() => {
+    if (args.isNew.value) return 'neutral' as const;
+    return documentStatusTone(args.status.value);
+  });
+
+  const title = computed(() => {
+    if (args.kind.value === 'document') return documentDisplayTitle.value;
+
+    const base = args.metadata.value?.displayName ?? 'Catalog record';
+    return args.isNew.value ? `New ${base}` : base;
+  });
+
+  const subtitle = computed(() => {
+    if (args.kind.value === 'document') return resolvedDocumentStatusLabel.value;
+
+    const display = String(args.model.value.display ?? '').trim();
+    if (display) return display;
+
+    return args.isNew.value ? 'New record' : undefined;
+  });
+
+  const auditEntityKind = computed(() => (args.kind.value === 'catalog' ? 2 : 1));
+  const auditEntityId = computed(() => args.currentId.value);
+  const auditEntityTitle = computed(() => String(args.model.value.display ?? title.value ?? '').trim());
+
+  const isReadOnly = computed(() =>
+    (!args.isNew.value && args.isMarkedForDeletion.value)
+    || (args.kind.value === 'document' && !args.isNew.value && !args.isDraft.value),
+  );
+
+  return {
+    canOpenAudit,
+    canShareLink,
+    canOpenEffectsPage,
+    canOpenDocumentFlowPage,
+    canPrintDocument,
+    canMarkForDeletion,
+    canUnmarkForDeletion,
+    canDelete,
+    canPost,
+    canUnpost,
+    canSave,
+    documentStatusLabel: resolvedDocumentStatusLabel,
+    documentStatusTone: resolvedDocumentStatusTone,
+    title,
+    subtitle,
+    auditEntityKind,
+    auditEntityId,
+    auditEntityTitle,
+    isReadOnly,
+  };
+}

package/src/ngb/editor/useEntityEditorCommandPalette.ts

@@ -0,0 +1,154 @@
+import { computed, type ComputedRef } from 'vue';
+
+import { useCommandPalettePageContext } from '../command-palette/useCommandPalettePageContext';
+import type { CommandPaletteItemSeed } from '../command-palette/types';
+import type { EditorKind, EditorMode } from './types';
+
+type UseEntityEditorCommandPaletteArgs = {
+  mode: ComputedRef<EditorMode>;
+  kind: ComputedRef<EditorKind>;
+  typeCode: ComputedRef<string>;
+  currentId: ComputedRef<string | null>;
+  title: ComputedRef<string>;
+  canOpenDocumentFlowPage: ComputedRef<boolean>;
+  canOpenEffectsPage: ComputedRef<boolean>;
+  canPrintDocument: ComputedRef<boolean>;
+  canPost: ComputedRef<boolean>;
+  canUnpost: ComputedRef<boolean>;
+  openDocumentFlowPage: () => void;
+  openDocumentEffectsPage: () => void;
+  openDocumentPrintPage: () => void;
+  post: () => Promise<void>;
+  unpost: () => Promise<void>;
+};
+
+export function useEntityEditorCommandPalette(args: UseEntityEditorCommandPaletteArgs) {
+  const commandPaletteActions = computed<CommandPaletteItemSeed[]>(() => {
+    if (args.mode.value !== 'page') return [];
+
+    const actions: CommandPaletteItemSeed[] = [];
+
+    if (args.kind.value === 'document' && args.currentId.value && args.canOpenDocumentFlowPage.value) {
+      actions.push({
+        key: `current:flow:${args.typeCode.value}:${args.currentId.value}`,
+        group: 'actions',
+        kind: 'command',
+        scope: 'commands',
+        title: 'Open document flow',
+        subtitle: 'Open workflow for this document',
+        icon: 'document-flow',
+        badge: 'Flow',
+        hint: null,
+        route: null,
+        commandCode: 'document-flow',
+        status: null,
+        openInNewTabSupported: false,
+        keywords: ['flow', 'document flow'],
+        defaultRank: 988,
+        isCurrentContext: true,
+        perform: args.openDocumentFlowPage,
+      });
+    }
+
+    if (args.kind.value === 'document' && args.currentId.value && args.canOpenEffectsPage.value) {
+      actions.push({
+        key: `current:effects:${args.typeCode.value}:${args.currentId.value}`,
+        group: 'actions',
+        kind: 'command',
+        scope: 'commands',
+        title: 'Open accounting effects',
+        subtitle: 'Review ledger impact for this document',
+        icon: 'effects-flow',
+        badge: 'Effects',
+        hint: null,
+        route: null,
+        commandCode: 'accounting-effects',
+        status: null,
+        openInNewTabSupported: false,
+        keywords: ['effects', 'accounting effects', 'posting'],
+        defaultRank: 986,
+        isCurrentContext: true,
+        perform: args.openDocumentEffectsPage,
+      });
+    }
+
+    if (args.kind.value === 'document' && args.currentId.value && args.canPrintDocument.value) {
+      actions.push({
+        key: `current:print:${args.typeCode.value}:${args.currentId.value}`,
+        group: 'actions',
+        kind: 'command',
+        scope: 'commands',
+        title: 'Print document',
+        subtitle: 'Open a print-friendly version of this document',
+        icon: 'printer',
+        badge: 'Print',
+        hint: null,
+        route: null,
+        commandCode: 'print-document',
+        status: null,
+        openInNewTabSupported: false,
+        keywords: ['print', 'print document', 'paper'],
+        defaultRank: 985,
+        isCurrentContext: true,
+        perform: args.openDocumentPrintPage,
+      });
+    }
+
+    if (args.kind.value === 'document' && args.canPost.value) {
+      actions.push({
+        key: `current:post:${args.typeCode.value}:${args.currentId.value ?? 'new'}`,
+        group: 'actions',
+        kind: 'command',
+        scope: 'commands',
+        title: 'Post document',
+        subtitle: 'Post this document to the ledger',
+        icon: 'check',
+        badge: 'Post',
+        hint: null,
+        route: null,
+        commandCode: 'post-document',
+        status: null,
+        openInNewTabSupported: false,
+        keywords: ['post', 'post document'],
+        defaultRank: 984,
+        isCurrentContext: true,
+        perform: args.post,
+      });
+    } else if (args.kind.value === 'document' && args.canUnpost.value) {
+      actions.push({
+        key: `current:unpost:${args.typeCode.value}:${args.currentId.value ?? 'new'}`,
+        group: 'actions',
+        kind: 'command',
+        scope: 'commands',
+        title: 'Unpost document',
+        subtitle: 'Reverse the posted ledger impact',
+        icon: 'undo',
+        badge: 'Unpost',
+        hint: null,
+        route: null,
+        commandCode: 'unpost-document',
+        status: null,
+        openInNewTabSupported: false,
+        keywords: ['unpost', 'unpost document'],
+        defaultRank: 984,
+        isCurrentContext: true,
+        perform: args.unpost,
+      });
+    }
+
+    return actions;
+  });
+
+  useCommandPalettePageContext(() => {
+    if (args.mode.value !== 'page') return null;
+
+    return {
+      entityType: args.kind.value,
+      documentType: args.kind.value === 'document' ? args.typeCode.value : null,
+      catalogType: args.kind.value === 'catalog' ? args.typeCode.value : null,
+      entityId: args.currentId.value,
+      title: args.title.value,
+      actions: commandPaletteActions.value,
+    };
+  });
+}

package/src/ngb/editor/useEntityEditorCommitHandlers.ts

@@ -0,0 +1,102 @@
+import type { Awaitable } from '../metadata/types';
+import type { EditorChangeReason } from './types';
+
+export type EntityEditorCommitContext = {
+  reloadSucceeded: boolean;
+};
+
+export type EntityEditorCreatedContext = EntityEditorCommitContext & {
+  id: string;
+};
+
+export type EntityEditorChangedContext = EntityEditorCommitContext & {
+  reason?: EditorChangeReason | (string & {});
+};
+
+type EntityEditorCommitDecision<TContext> =
+  | boolean
+  | ((context: TContext) => boolean);
+
+export type UseEntityEditorCommitHandlersArgs = {
+  reload: () => Awaitable<boolean | void>;
+  closeDrawer?: () => Awaitable<void>;
+  onCreated?: (context: EntityEditorCreatedContext) => Awaitable<void>;
+  onSaved?: (context: EntityEditorCommitContext) => Awaitable<void>;
+  onChanged?: (context: EntityEditorChangedContext) => Awaitable<void>;
+  onDeleted?: (context: EntityEditorCommitContext) => Awaitable<void>;
+  closeOnCreated?: EntityEditorCommitDecision<EntityEditorCreatedContext>;
+  closeOnSaved?: EntityEditorCommitDecision<EntityEditorCommitContext>;
+  closeOnChanged?: EntityEditorCommitDecision<EntityEditorChangedContext>;
+  closeOnDeleted?: EntityEditorCommitDecision<EntityEditorCommitContext>;
+};
+
+function shouldClose<TContext>(
+  decision: EntityEditorCommitDecision<TContext> | undefined,
+  context: TContext,
+): boolean {
+  if (typeof decision === 'function') return decision(context);
+  return decision ?? true;
+}
+
+async function reloadWithStatus(
+  reload: UseEntityEditorCommitHandlersArgs['reload'],
+): Promise<boolean> {
+  return await reload() !== false;
+}
+
+export function useEntityEditorCommitHandlers(
+  args: UseEntityEditorCommitHandlersArgs,
+) {
+  async function closeIfRequested<TContext>(
+    decision: EntityEditorCommitDecision<TContext> | undefined,
+    context: TContext,
+  ) {
+    if (!args.closeDrawer || !shouldClose(decision, context)) return;
+    await args.closeDrawer();
+  }
+
+  async function handleCreated(id: string) {
+    const context: EntityEditorCreatedContext = {
+      id,
+      reloadSucceeded: await reloadWithStatus(args.reload),
+    };
+
+    await args.onCreated?.(context);
+    await closeIfRequested(args.closeOnCreated, context);
+  }
+
+  async function handleSaved() {
+    const context: EntityEditorCommitContext = {
+      reloadSucceeded: await reloadWithStatus(args.reload),
+    };
+
+    await args.onSaved?.(context);
+    await closeIfRequested(args.closeOnSaved, context);
+  }
+
+  async function handleChanged(reason?: EditorChangeReason | (string & {})) {
+    const context: EntityEditorChangedContext = {
+      reason,
+      reloadSucceeded: await reloadWithStatus(args.reload),
+    };
+
+    await args.onChanged?.(context);
+    await closeIfRequested(args.closeOnChanged, context);
+  }
+
+  async function handleDeleted() {
+    const context: EntityEditorCommitContext = {
+      reloadSucceeded: await reloadWithStatus(args.reload),
+    };
+
+    await args.onDeleted?.(context);
+    await closeIfRequested(args.closeOnDeleted, context);
+  }
+
+  return {
+    handleCreated,
+    handleSaved,
+    handleChanged,
+    handleDeleted,
+  };
+}