@ngbplatform/ui 1.3.0

package/src/ngb/metadata/NgbRegisterPageLayout.vue

@@ -0,0 +1,143 @@
+<script setup lang="ts">
+import { useSlots } from 'vue'
+import NgbDrawer from '../components/NgbDrawer.vue'
+import NgbRegisterGrid from '../components/register/NgbRegisterGrid.vue'
+import type { RegisterColumn, RegisterDataRow } from '../components/register/registerTypes'
+import NgbEntityListPageHeader from './NgbEntityListPageHeader.vue'
+
+const props = withDefaults(defineProps<{
+  title: string
+  canBack?: boolean
+  itemsCount?: number | null
+  total?: number | null
+  loading?: boolean
+  error?: string | null
+  warning?: string | null
+  disableCreate?: boolean
+  showFilter?: boolean
+  disableFilter?: boolean
+  filterActive?: boolean
+  disablePrev?: boolean
+  disableNext?: boolean
+  columns: RegisterColumn[]
+  rows: RegisterDataRow[]
+  storageKey: string
+  drawerOpen?: boolean
+  drawerTitle?: string
+  drawerSubtitle?: string
+  drawerHideHeader?: boolean
+  drawerFlushBody?: boolean
+  beforeClose?: (() => boolean | Promise<boolean>) | null
+}>(), {
+  canBack: true,
+  loading: false,
+  error: null,
+  warning: null,
+  showFilter: true,
+  disableCreate: false,
+  disableFilter: false,
+  filterActive: false,
+  disablePrev: false,
+  disableNext: false,
+  drawerOpen: undefined,
+  drawerTitle: '',
+  drawerSubtitle: '',
+  drawerHideHeader: false,
+  drawerFlushBody: false,
+  beforeClose: null,
+})
+
+const emit = defineEmits<{
+  (e: 'back'): void
+  (e: 'refresh'): void
+  (e: 'create'): void
+  (e: 'filter'): void
+  (e: 'prev'): void
+  (e: 'next'): void
+  (e: 'rowActivate', id: string): void
+  (e: 'update:drawerOpen', value: boolean): void
+}>()
+
+const slots = useSlots()
+</script>
+
+<template>
+  <div class="h-full min-h-0 flex flex-col">
+    <NgbEntityListPageHeader
+      :title="title"
+      :can-back="canBack"
+      :items-count="itemsCount"
+      :total="total"
+      :loading="loading"
+      :disable-create="disableCreate"
+      :show-filter="showFilter"
+      :disable-filter="disableFilter"
+      :filter-active="filterActive"
+      :disable-prev="disablePrev"
+      :disable-next="disableNext"
+      @back="emit('back')"
+      @refresh="emit('refresh')"
+      @create="emit('create')"
+      @filter="emit('filter')"
+      @prev="emit('prev')"
+      @next="emit('next')"
+    >
+      <template #filters>
+        <slot name="filters" />
+      </template>
+    </NgbEntityListPageHeader>
+
+    <div class="p-6 flex-1 min-h-0 flex flex-col">
+      <div
+        v-if="error"
+        class="mb-4 rounded-[var(--ngb-radius)] border border-red-200 bg-red-50 p-3 text-sm text-red-900 dark:border-red-900/50 dark:bg-red-950/30 dark:text-red-100"
+      >
+        {{ error }}
+      </div>
+
+      <div
+        v-if="warning"
+        class="mb-4 rounded-[var(--ngb-radius)] border border-amber-200 bg-amber-50 p-3 text-sm text-amber-900 dark:border-amber-900/50 dark:bg-amber-950/20 dark:text-amber-100"
+      >
+        {{ warning }}
+      </div>
+
+      <slot name="beforeGrid" />
+
+      <slot name="grid">
+        <NgbRegisterGrid
+          class="flex-1 min-h-0"
+          fill-height
+          :show-panel="false"
+          :columns="columns"
+          :rows="rows"
+          :show-totals="false"
+          :storage-key="storageKey"
+          :activate-on-row-click="true"
+          @rowActivate="emit('rowActivate', String($event))"
+        />
+      </slot>
+
+      <div v-if="loading" class="mt-3 text-sm text-ngb-muted">Loading…</div>
+    </div>
+
+    <slot name="filterDrawer" />
+
+    <NgbDrawer
+      v-if="drawerOpen !== undefined && slots.drawerContent"
+      :open="drawerOpen"
+      :title="drawerTitle"
+      :subtitle="drawerSubtitle"
+      :hide-header="drawerHideHeader"
+      :flush-body="drawerFlushBody"
+      :before-close="beforeClose ?? undefined"
+      @update:open="emit('update:drawerOpen', $event)"
+    >
+      <template v-if="slots.drawerActions" #actions>
+        <slot name="drawerActions" />
+      </template>
+
+      <slot name="drawerContent" />
+    </NgbDrawer>
+  </div>
+</template>

package/src/ngb/metadata/config.ts

@@ -0,0 +1,28 @@
+import type { CatalogTypeMetadata, DocumentTypeMetadata, MetadataFormBehavior } from './types'
+
+export type MetadataFrameworkConfig = {
+  loadCatalogTypeMetadata: (catalogType: string) => Promise<CatalogTypeMetadata>
+  loadDocumentTypeMetadata: (documentType: string) => Promise<DocumentTypeMetadata>
+  formBehavior?: MetadataFormBehavior
+}
+
+let metadataFrameworkConfig: MetadataFrameworkConfig | null = null
+
+export function configureNgbMetadata(config: MetadataFrameworkConfig): void {
+  metadataFrameworkConfig = config
+}
+
+export function getConfiguredNgbMetadata(): MetadataFrameworkConfig {
+  if (!metadataFrameworkConfig) {
+    throw new Error('NGB metadata framework is not configured. Call configureNgbMetadata(...) during app bootstrap.')
+  }
+
+  return metadataFrameworkConfig
+}
+
+export function resolveNgbMetadataFormBehavior(override?: MetadataFormBehavior): MetadataFormBehavior {
+  return {
+    ...(metadataFrameworkConfig?.formBehavior ?? {}),
+    ...(override ?? {}),
+  }
+}

package/src/ngb/metadata/dataTypes.ts

@@ -0,0 +1,27 @@
+export function dataTypeKind(dataType: unknown): string {
+  const normalized = String(dataType ?? '').trim()
+  return normalized || 'Unknown'
+}
+
+export function isGuidType(dataType: unknown): boolean {
+  return dataTypeKind(dataType) === 'Guid'
+}
+
+export function isBooleanType(dataType: unknown): boolean {
+  return dataTypeKind(dataType) === 'Boolean'
+}
+
+export function isNumberType(dataType: unknown): boolean {
+  const kind = dataTypeKind(dataType)
+  return kind === 'Int32' || kind === 'Decimal' || kind === 'Money'
+}
+
+export function isDateType(dataType: unknown): boolean {
+  const kind = dataTypeKind(dataType)
+  return kind === 'Date' || kind === 'DateOnly'
+}
+
+export function isDateTimeType(dataType: unknown): boolean {
+  const kind = dataTypeKind(dataType)
+  return kind === 'DateTime' || kind === 'DateTimeOffset'
+}

package/src/ngb/metadata/entityForm.ts

@@ -0,0 +1,114 @@
+import { dataTypeKind } from './dataTypes'
+import { resolveNgbMetadataFormBehavior } from './config'
+import { tryExtractReferenceId } from './entityModel'
+import type { EntityFormModel, FieldHiddenArgs, FieldMetadata, FieldReadonlyArgs, FormMetadata, JsonValue, MetadataFormBehavior, RecordFields } from './types'
+
+export function flattenFormFields(form?: FormMetadata | null): FieldMetadata[] {
+  if (!form?.sections) return []
+
+  const out: FieldMetadata[] = []
+  for (const section of form.sections) {
+    for (const row of section.rows ?? []) {
+      for (const field of row.fields ?? []) out.push(field)
+    }
+  }
+
+  return out
+}
+
+export function defaultFindDisplayField(form: FormMetadata): FieldMetadata | null {
+  for (const field of flattenFormFields(form)) {
+    if (field.key === 'display') return field
+  }
+
+  return null
+}
+
+export function defaultIsFieldReadonly(args: FieldReadonlyArgs): boolean {
+  if (args.forceReadonly) return true
+  if (args.field.isReadOnly) return true
+  if (args.status !== undefined && args.field.readOnlyWhenStatusIn?.includes(args.status)) return true
+  return false
+}
+
+export function defaultIsFieldHidden(_args: FieldHiddenArgs): boolean {
+  return false
+}
+
+function tryFlattenRef(value: unknown): unknown {
+  const referenceId = tryExtractReferenceId(value)
+  return referenceId ?? value
+}
+
+export function ensureModelKeys(form: FormMetadata | null | undefined, model: EntityFormModel): void {
+  for (const field of flattenFormFields(form)) {
+    if (!(field.key in model) || model[field.key] === undefined) {
+      model[field.key] = dataTypeKind(field.dataType) === 'Boolean' || field.uiControl === 5 ? false : null
+    }
+  }
+}
+
+function normalizeValue(field: FieldMetadata, value: unknown): JsonValue {
+  let normalized = value
+  if (normalized === '') normalized = null
+  if (normalized === undefined) normalized = null
+
+  normalized = tryFlattenRef(normalized)
+
+  if (normalized === null) return null
+
+  switch (field.uiControl) {
+    case 5:
+      return !!normalized
+    case 3:
+    case 4:
+      if (typeof normalized === 'number') return normalized
+      if (typeof normalized === 'string') {
+        const number = Number(normalized)
+        return Number.isFinite(number) ? number : normalized
+      }
+      return normalized as JsonValue
+    case 6:
+    case 7:
+      return normalized as JsonValue
+  }
+
+  switch (dataTypeKind(field.dataType)) {
+    case 'Int32': {
+      if (typeof normalized === 'number') return Math.trunc(normalized)
+      if (typeof normalized === 'string') {
+        const number = Number.parseInt(normalized, 10)
+        return Number.isFinite(number) ? number : normalized
+      }
+      return normalized as JsonValue
+    }
+    case 'Decimal':
+    case 'Money': {
+      if (typeof normalized === 'number') return normalized
+      if (typeof normalized === 'string') {
+        const number = Number(normalized)
+        return Number.isFinite(number) ? number : normalized
+      }
+      return normalized as JsonValue
+    }
+    case 'Boolean':
+      return !!normalized
+    default:
+      return normalized as JsonValue
+  }
+}
+
+export function buildFieldsPayload(form: FormMetadata | null | undefined, model: EntityFormModel): RecordFields {
+  const fields = flattenFormFields(form)
+  const payload: RecordFields = {}
+
+  for (const field of fields) {
+    payload[field.key] = normalizeValue(field, model[field.key])
+  }
+
+  return payload
+}
+
+export function resolveMetadataFormBehavior(override?: MetadataFormBehavior): MetadataFormBehavior {
+  return resolveNgbMetadataFormBehavior(override)
+}

package/src/ngb/metadata/entityModel.ts

@@ -0,0 +1,34 @@
+import type { ReferenceValue } from './types'
+
+export type { EntityFormModel, ReferenceValue } from './types'
+
+export function isReferenceValue(value: unknown): value is ReferenceValue {
+  return !!value
+    && typeof value === 'object'
+    && typeof (value as ReferenceValue).id === 'string'
+    && typeof (value as ReferenceValue).display === 'string'
+}
+
+export function tryExtractReferenceId(value: unknown): string | null {
+  if (typeof value === 'string') {
+    const normalized = value.trim()
+    return normalized || null
+  }
+
+  if (isReferenceValue(value)) {
+    const normalized = value.id.trim()
+    return normalized || null
+  }
+
+  return null
+}
+
+export function tryExtractReferenceDisplay(value: unknown): string | null {
+  if (!isReferenceValue(value)) return null
+  const normalized = value.display.trim()
+  return normalized || null
+}
+
+export function asTrimmedString(value: unknown): string {
+  return value == null ? '' : String(value).trim()
+}

package/src/ngb/metadata/entityValueFormatting.ts

@@ -0,0 +1,83 @@
+import { dataTypeKind } from './dataTypes'
+import { isReferenceValue } from './entityModel'
+
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/
+
+export function formatDateOnlyValue(value: string): string {
+  if (!DATE_ONLY_RE.test(value)) return value
+
+  const [year, month, day] = value.split('-').map((part) => Number(part))
+  const date = new Date(year, month - 1, day, 12, 0, 0)
+  if (Number.isNaN(date.getTime())) return value
+  return date.toLocaleDateString()
+}
+
+export function formatDateTimeValue(value: string): string {
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return value
+  return date.toLocaleString()
+}
+
+export function formatNumberValue(kind: string, value: unknown): string {
+  const numeric = typeof value === 'number' ? value : Number(value)
+  if (!Number.isFinite(numeric)) return String(value ?? '—')
+
+  if (kind === 'Int32') {
+    return Math.trunc(numeric).toLocaleString()
+  }
+
+  if (kind === 'Money') {
+    return numeric.toLocaleString(undefined, {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+    })
+  }
+
+  return numeric.toLocaleString(undefined, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 4,
+  })
+}
+
+function formatObjectValue(value: Record<string, unknown>): string {
+  const entries = Object.entries(value)
+    .filter(([, item]) => item !== undefined)
+    .map(([key, item]) => `${humanizeEntityKey(key)}: ${formatLooseEntityValue(item)}`)
+    .filter((item) => item.length > 0)
+
+  return entries.length > 0 ? entries.join(' · ') : '—'
+}
+
+export function formatLooseEntityValue(value: unknown): string {
+  if (value == null) return '—'
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No'
+  if (typeof value === 'number') return Number.isFinite(value) ? value.toLocaleString() : String(value)
+  if (typeof value === 'string') return value.trim() || '—'
+  if (Array.isArray(value)) return value.map((item) => formatLooseEntityValue(item)).join(' · ')
+  if (isReferenceValue(value)) return value.display.trim() || value.id
+  if (typeof value === 'object') return formatObjectValue(value as Record<string, unknown>)
+  return String(value)
+}
+
+export function formatTypedEntityValue(dataType: unknown, value: unknown): string {
+  if (value == null) return '—'
+
+  const kind = dataTypeKind(dataType)
+  if (kind === 'Boolean') return !!value ? 'Yes' : 'No'
+  if (kind === 'Date' && typeof value === 'string') return formatDateOnlyValue(value)
+  if (kind === 'DateTime' && typeof value === 'string') return formatDateTimeValue(value)
+  if (kind === 'Money' || kind === 'Decimal' || kind === 'Int32') return formatNumberValue(kind, value)
+
+  return formatLooseEntityValue(value)
+}
+
+export function humanizeEntityKey(value: string): string {
+  const normalized = String(value ?? '').trim().replace(/[._]/g, ' ')
+  if (!normalized) return 'Field'
+
+  return normalized
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ')
+}

package/src/ngb/metadata/fieldRendererState.ts

@@ -0,0 +1,84 @@
+import { resolveNgbMetadataFormBehavior } from './config'
+import { dataTypeKind } from './dataTypes'
+import { isReferenceValue } from './entityModel'
+import { resolveLookupHint } from './lookup'
+import type { EntityFormModel, FieldMetadata, FieldOption, LookupHint, MetadataFormBehavior } from './types'
+
+export type FieldRenderMode =
+  | 'select'
+  | 'lookup'
+  | 'checkbox'
+  | 'textarea'
+  | 'reference-display'
+  | 'date'
+  | 'input'
+
+export type FieldInputType = 'text' | 'number' | 'datetime-local'
+
+export type FieldRendererState = {
+  mode: FieldRenderMode
+  inputType: FieldInputType
+  fieldOptions: FieldOption[] | null
+  hint: LookupHint | null
+}
+
+export function resolveFieldRendererState(args: {
+  entityTypeCode: string
+  model: EntityFormModel
+  field: FieldMetadata
+  modelValue: unknown
+  behavior?: MetadataFormBehavior
+}): FieldRendererState {
+  const behavior = resolveNgbMetadataFormBehavior(args.behavior)
+  const fieldOptions = behavior.resolveFieldOptions?.({
+    entityTypeCode: args.entityTypeCode,
+    model: args.model,
+    field: args.field,
+  }) ?? args.field.options ?? null
+  const hint = resolveLookupHint({
+    entityTypeCode: args.entityTypeCode,
+    model: args.model,
+    field: args.field,
+    behavior,
+  })
+  const dataType = dataTypeKind(args.field.dataType)
+
+  const isLookup = !!hint || dataType === 'Lookup'
+  const isCheckbox = args.field.uiControl === 5 || dataType === 'Boolean'
+  const isTextArea = args.field.uiControl === 2
+  const isDate = args.field.uiControl === 6 || dataType === 'Date'
+  const isDateTime = args.field.uiControl === 7 || dataType === 'DateTime'
+  const isNumber = args.field.uiControl === 3 || dataType === 'Int32' || dataType === 'Decimal'
+  const isMoney = args.field.uiControl === 4 || dataType === 'Money'
+
+  if (fieldOptions) {
+    return { mode: 'select', inputType: 'text', fieldOptions, hint }
+  }
+
+  if (isLookup && hint) {
+    return { mode: 'lookup', inputType: 'text', fieldOptions, hint }
+  }
+
+  if (isCheckbox) {
+    return { mode: 'checkbox', inputType: 'text', fieldOptions, hint }
+  }
+
+  if (isTextArea) {
+    return { mode: 'textarea', inputType: 'text', fieldOptions, hint }
+  }
+
+  if (isReferenceValue(args.modelValue) && !hint) {
+    return { mode: 'reference-display', inputType: 'text', fieldOptions, hint }
+  }
+
+  if (isDate) {
+    return { mode: 'date', inputType: 'text', fieldOptions, hint }
+  }
+
+  return {
+    mode: 'input',
+    inputType: isDateTime ? 'datetime-local' : (isNumber || isMoney ? 'number' : 'text'),
+    fieldOptions,
+    hint,
+  }
+}

package/src/ngb/metadata/filtering.ts

@@ -0,0 +1,153 @@
+import { isNonEmptyGuid } from '../utils/guid'
+import type { FilterFieldLike, FilterFieldOption, FilterFieldState, FilterLookupItem, LookupStoreApi, ResolvedLookupSource } from './types'
+
+export type {
+  FilterFieldLike,
+  FilterFieldOption,
+  FilterFieldState,
+  FilterLookupItem,
+  LookupStoreApi,
+  ResolvedLookupSource,
+} from './types'
+
+export function splitFilterValues(raw: string): string[] {
+  return raw
+    .split(',')
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0)
+}
+
+export function joinFilterValues(values: string[]): string {
+  return values
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0)
+    .join(',')
+}
+
+export function summarizeFilterValues(values: string[]): string | null {
+  if (values.length === 0) return null
+  const first = values[0]
+  const remaining = values.length - 1
+  return remaining > 0 ? `${first} (+${remaining})` : first
+}
+
+export function optionLabelForFilter(field: Pick<FilterFieldLike, 'options'>, rawValue: string): string {
+  const normalized = rawValue.trim()
+  if (!normalized) return ''
+  const option = (field.options ?? []).find((entry) => String(entry.value ?? '').trim() === normalized)
+  return String(option?.label ?? normalized).trim()
+}
+
+type FilterOptionLabelField = {
+  key: string
+  options?: readonly FilterFieldOption[] | null
+}
+
+export function buildFilterOptionLabelsByKey<TField extends FilterOptionLabelField>(
+  fields: readonly TField[],
+): Record<string, Map<string, string>> {
+  const result: Record<string, Map<string, string>> = {}
+
+  for (const field of fields) {
+    if (!field.key || !field.options?.length) continue
+
+    const options = new Map<string, string>()
+    for (const option of field.options) {
+      const value = String(option?.value ?? '').trim()
+      const label = String(option?.label ?? '').trim()
+      if (!value || !label) continue
+      options.set(value, label)
+    }
+
+    if (options.size > 0) result[field.key] = options
+  }
+
+  return result
+}
+
+export function filterInputType(dataType: unknown): 'number' | 'text' {
+  const normalized = String(dataType ?? '').trim().toLowerCase()
+  if (normalized === 'decimal' || normalized === 'money' || normalized === 'int32' || normalized === '2' || normalized === '3') {
+    return 'number'
+  }
+  if (normalized.includes('decimal') || normalized.includes('number') || normalized.includes('int')) return 'number'
+  return 'text'
+}
+
+export function filterPlaceholder(field: Pick<FilterFieldLike, 'label' | 'lookup' | 'isMulti'>): string {
+  if (field.lookup) return `Type ${field.label.toLowerCase()}…`
+  if (field.isMulti) return 'Comma-separated values…'
+  return field.label
+}
+
+export function filterSelectOptions(
+  field: Pick<FilterFieldLike, 'options'>,
+  emptyLabel = 'Any',
+): FilterFieldOption[] {
+  return [{ value: '', label: emptyLabel }, ...((field.options ?? []) as FilterFieldOption[])]
+}
+
+export function extractLookupIds(value: unknown): string[] {
+  if (Array.isArray(value)) return value.filter(isNonEmptyGuid)
+  return isNonEmptyGuid(value) ? [value] : []
+}
+
+export function labelForResolvedLookup(
+  lookupStore: LookupStoreApi,
+  lookup: ResolvedLookupSource,
+  id: string,
+): string {
+  if (lookup.kind === 'catalog') return lookupStore.labelForCatalog(lookup.catalogType, id)
+  if (lookup.kind === 'coa') return lookupStore.labelForCoa(id)
+  return lookupStore.labelForAnyDocument(lookup.documentTypes, id)
+}
+
+export async function ensureResolvedLookupLabels(
+  lookupStore: LookupStoreApi,
+  lookup: ResolvedLookupSource,
+  ids: string[],
+): Promise<void> {
+  if (lookup.kind === 'catalog') {
+    await lookupStore.ensureCatalogLabels(lookup.catalogType, ids)
+    return
+  }
+
+  if (lookup.kind === 'coa') {
+    await lookupStore.ensureCoaLabels(ids)
+    return
+  }
+
+  await lookupStore.ensureAnyDocumentLabels(lookup.documentTypes, ids)
+}
+
+export async function searchResolvedLookupItems<TItem extends FilterLookupItem>(
+  lookupStore: LookupStoreApi<TItem>,
+  lookup: ResolvedLookupSource,
+  query: string,
+): Promise<TItem[]> {
+  if (lookup.kind === 'catalog') {
+    return await lookupStore.searchCatalog(
+      lookup.catalogType,
+      query,
+      'filters' in lookup && lookup.filters ? { filters: lookup.filters } : undefined,
+    )
+  }
+
+  if (lookup.kind === 'coa') return await lookupStore.searchCoa(query)
+  return await lookupStore.searchDocuments(lookup.documentTypes, query)
+}
+
+export async function hydrateResolvedLookupItems<TItem extends FilterLookupItem>(
+  lookupStore: LookupStoreApi<TItem>,
+  lookup: ResolvedLookupSource,
+  ids: string[],
+): Promise<TItem[]> {
+  if (ids.length === 0) return []
+
+  await ensureResolvedLookupLabels(lookupStore, lookup, ids)
+
+  return ids.map((id) => ({
+    id,
+    label: labelForResolvedLookup(lookupStore, lookup, id),
+  }) as TItem)
+}

package/src/ngb/metadata/lookup.ts

@@ -0,0 +1,25 @@
+import { resolveNgbMetadataFormBehavior } from './config'
+import type { EntityFormModel, FieldMetadata, LookupHint, LookupSource, MetadataFormBehavior } from './types'
+
+export function lookupHintFromSource(source?: LookupSource | null): LookupHint | null {
+  if (!source) return null
+
+  if (source.kind === 'catalog') return { kind: 'catalog', catalogType: source.catalogType }
+  if (source.kind === 'document') return { kind: 'document', documentTypes: [...source.documentTypes] }
+  return { kind: 'coa' }
+}
+
+export function resolveLookupHint(args: {
+  entityTypeCode: string
+  model: EntityFormModel
+  field: FieldMetadata
+  behavior?: MetadataFormBehavior
+}): LookupHint | null {
+  const behavior = resolveNgbMetadataFormBehavior(args.behavior)
+
+  return behavior.resolveLookupHint?.({
+    entityTypeCode: args.entityTypeCode,
+    model: args.model,
+    field: args.field,
+  }) ?? lookupHintFromSource(args.field.lookup)
+}