@c-rex/services 0.3.0-build.39 → 0.3.0-build.41

package/dist/read-models/metadata-display-builder.d.mts

@@ -0,0 +1,34 @@
+import { RenditionModel, InformationUnitModel, LiteralModel, ObjectRefModel } from '@c-rex/interfaces';
+import { InformationUnitPropertyKey } from './metadata-presentation-config.mjs';
+
+type MetadataFacetPresentationItem = {
+    label: string;
+    groupLabel?: string;
+    sectionLabel?: string;
+    hidden?: boolean;
+};
+type MetadataFacetPresentation = Partial<Record<InformationUnitPropertyKey, Record<string, MetadataFacetPresentationItem>>>;
+type MetadataFacetLabelOverride = MetadataFacetPresentationItem;
+type MetadataFacetLabelOverrides = MetadataFacetPresentation;
+type MetadataDisplayRow = {
+    key: InformationUnitPropertyKey;
+    label: string;
+    labelSource: "translationKey" | "direct";
+    values: string[];
+    valueType?: "text" | "language" | "rendition";
+    renditions?: RenditionModel[];
+};
+type BuildMetadataDisplayRowsOptions = {
+    uiLanguage: string;
+    includeProperties: InformationUnitPropertyKey[];
+    presentation?: MetadataFacetPresentation;
+    overrides?: MetadataFacetPresentation;
+};
+declare const resolveLiteralLabel: (labels?: LiteralModel[] | null, uiLanguage?: string) => string | undefined;
+declare const resolveObjectRefLabel: (item: ObjectRefModel, uiLanguage: string) => string | undefined;
+declare const resolveObjectRefClassLabel: (item: ObjectRefModel, uiLanguage: string) => string | undefined;
+declare const resolveFacetPresentationProperties: (includeProperties: InformationUnitPropertyKey[]) => InformationUnitPropertyKey[];
+declare const resolveOverrideProperties: (includeProperties: InformationUnitPropertyKey[]) => InformationUnitPropertyKey[];
+declare const buildMetadataDisplayRows: (data: InformationUnitModel, options: BuildMetadataDisplayRowsOptions) => MetadataDisplayRow[];
+
+export { type MetadataDisplayRow, type MetadataFacetLabelOverride, type MetadataFacetLabelOverrides, type MetadataFacetPresentation, type MetadataFacetPresentationItem, buildMetadataDisplayRows, resolveFacetPresentationProperties, resolveLiteralLabel, resolveObjectRefClassLabel, resolveObjectRefLabel, resolveOverrideProperties };

package/dist/read-models/metadata-display-builder.d.ts

@@ -0,0 +1,34 @@
+import { RenditionModel, InformationUnitModel, LiteralModel, ObjectRefModel } from '@c-rex/interfaces';
+import { InformationUnitPropertyKey } from './metadata-presentation-config.js';
+
+type MetadataFacetPresentationItem = {
+    label: string;
+    groupLabel?: string;
+    sectionLabel?: string;
+    hidden?: boolean;
+};
+type MetadataFacetPresentation = Partial<Record<InformationUnitPropertyKey, Record<string, MetadataFacetPresentationItem>>>;
+type MetadataFacetLabelOverride = MetadataFacetPresentationItem;
+type MetadataFacetLabelOverrides = MetadataFacetPresentation;
+type MetadataDisplayRow = {
+    key: InformationUnitPropertyKey;
+    label: string;
+    labelSource: "translationKey" | "direct";
+    values: string[];
+    valueType?: "text" | "language" | "rendition";
+    renditions?: RenditionModel[];
+};
+type BuildMetadataDisplayRowsOptions = {
+    uiLanguage: string;
+    includeProperties: InformationUnitPropertyKey[];
+    presentation?: MetadataFacetPresentation;
+    overrides?: MetadataFacetPresentation;
+};
+declare const resolveLiteralLabel: (labels?: LiteralModel[] | null, uiLanguage?: string) => string | undefined;
+declare const resolveObjectRefLabel: (item: ObjectRefModel, uiLanguage: string) => string | undefined;
+declare const resolveObjectRefClassLabel: (item: ObjectRefModel, uiLanguage: string) => string | undefined;
+declare const resolveFacetPresentationProperties: (includeProperties: InformationUnitPropertyKey[]) => InformationUnitPropertyKey[];
+declare const resolveOverrideProperties: (includeProperties: InformationUnitPropertyKey[]) => InformationUnitPropertyKey[];
+declare const buildMetadataDisplayRows: (data: InformationUnitModel, options: BuildMetadataDisplayRowsOptions) => MetadataDisplayRow[];
+
+export { type MetadataDisplayRow, type MetadataFacetLabelOverride, type MetadataFacetLabelOverrides, type MetadataFacetPresentation, type MetadataFacetPresentationItem, buildMetadataDisplayRows, resolveFacetPresentationProperties, resolveLiteralLabel, resolveObjectRefClassLabel, resolveObjectRefLabel, resolveOverrideProperties };

package/dist/read-models/metadata-display-builder.js

@@ -0,0 +1,521 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/read-models/metadata-display-builder.ts
+var metadata_display_builder_exports = {};
+__export(metadata_display_builder_exports, {
+  buildMetadataDisplayRows: () => buildMetadataDisplayRows,
+  resolveFacetPresentationProperties: () => resolveFacetPresentationProperties,
+  resolveLiteralLabel: () => resolveLiteralLabel,
+  resolveObjectRefClassLabel: () => resolveObjectRefClassLabel,
+  resolveObjectRefLabel: () => resolveObjectRefLabel,
+  resolveOverrideProperties: () => resolveOverrideProperties
+});
+module.exports = __toCommonJS(metadata_display_builder_exports);
+
+// src/read-models/metadata-presentation-config.ts
+var INFORMATION_UNIT_PROPERTY_PRESENTATION = {
+  id: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  shortId: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  score: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  class: {
+    valueKind: "objectRef",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "class" }
+  },
+  labels: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  comments: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  descriptions: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  synonyms: {
+    valueKind: "stringArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  packages: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  hasInformationUnits: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  links: {
+    valueKind: "resourceLinkArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  revision: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  created: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  modified: {
+    valueKind: "scalar",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  abstract: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  replaces: {
+    valueKind: "objectRef",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  versionOf: {
+    valueKind: "objectRef",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  titles: {
+    valueKind: "literalArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  languages: {
+    valueKind: "stringArray",
+    facet: { supported: true, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  parties: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "partyRole" },
+    metadataDisplay: { supported: true, sectionStrategy: "partyRole" }
+  },
+  renditions: {
+    valueKind: "renditionArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  identities: {
+    valueKind: "objectRefArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  components: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  informationSubjects: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  topicTypes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  documentTypes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  directoryNodes: {
+    valueKind: "objectRefArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  contentLifeCycleStatus: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  applicableForTypes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
+  },
+  planningTimes: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  events: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  functionalMetadata: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  informationUnits: {
+    valueKind: "objectRefArray",
+    facet: { supported: false, sectionStrategy: "none" },
+    metadataDisplay: { supported: false, sectionStrategy: "none" }
+  },
+  productFeatures: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  productLifeCyclePhases: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  productMetadata: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  productVariants: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  qualifications: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  },
+  supplies: {
+    valueKind: "objectRefArray",
+    facet: { supported: true, sectionStrategy: "class" },
+    metadataDisplay: { supported: true, sectionStrategy: "class" }
+  }
+};
+
+// src/read-models/metadata-visibility-policy.ts
+var CONTENT_LICENSE_CLASS_ID = "https://ids.c-crex.net/ns/iirds/ext#ContentLicense";
+var METADATA_VISIBILITY_POLICY = {
+  parties: {
+    cacheFamily: "parties"
+  },
+  components: {
+    cacheFamily: "components"
+  },
+  informationSubjects: {
+    cacheFamily: "informationSubjects"
+  },
+  topicTypes: {
+    cacheFamily: "topicTypes"
+  },
+  documentTypes: {
+    cacheFamily: "documentTypes"
+  },
+  contentLifeCycleStatus: {
+    cacheFamily: "contentLifeCycleStatus"
+  },
+  applicableForTypes: {
+    cacheFamily: "documentTypes"
+  },
+  planningTimes: {
+    cacheFamily: "planningTimes"
+  },
+  functionalMetadata: {
+    cacheFamily: "functionalMetadata"
+  },
+  productFeatures: {
+    cacheFamily: "productFeatures"
+  },
+  productLifeCyclePhases: {
+    cacheFamily: "productLifeCyclePhases"
+  },
+  productMetadata: {
+    cacheFamily: "productMetadata"
+  },
+  productVariants: {
+    cacheFamily: "productVariants"
+  },
+  qualifications: {
+    cacheFamily: "qualifications",
+    deniedClassIds: [CONTENT_LICENSE_CLASS_ID]
+  },
+  supplies: {
+    cacheFamily: "supplies"
+  }
+};
+var runtimeSuppressedFamilies = /* @__PURE__ */ new Map();
+var getMetadataCacheFamily = (property) => METADATA_VISIBILITY_POLICY[property]?.cacheFamily;
+var isMetadataGroupDenied = (property, options) => {
+  const policy = METADATA_VISIBILITY_POLICY[property];
+  const classId = options.classId?.trim();
+  const partyRoleId = options.partyRoleId?.trim();
+  if (classId && policy?.deniedClassIds?.includes(classId)) {
+    return true;
+  }
+  if (partyRoleId && policy?.deniedPartyRoleIds?.includes(partyRoleId)) {
+    return true;
+  }
+  return false;
+};
+var isMetadataPropertyRuntimeSuppressed = (property) => {
+  const family = getMetadataCacheFamily(property);
+  return family ? runtimeSuppressedFamilies.has(family) : false;
+};
+
+// src/read-models/metadata-display-builder.ts
+var DEFAULT_IGNORED_FORMATS = [
+  "application/xhtml+xml",
+  "application/json",
+  "application/llm+xml",
+  "text/html"
+];
+var normalizeLanguageCode = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+  const [rawLang, rawCountry, ...rest] = trimmed.split("-");
+  const lang = (rawLang || "").toLowerCase();
+  if (!rawCountry) return lang;
+  const country = rawCountry.toUpperCase();
+  const suffix = rest.length > 0 ? `-${rest.join("-")}` : "";
+  return `${lang}-${country}${suffix}`;
+};
+var sortAndDeduplicateLanguages = (languages) => {
+  const normalized = languages.map((item) => (item || "").trim()).filter((item) => item.length > 0).map((item) => normalizeLanguageCode(item));
+  return Array.from(new Set(normalized)).sort((a, b) => a.localeCompare(b));
+};
+var resolvePreferredLanguage = (languages, uiLanguage) => {
+  if (!languages || languages.length === 0) return void 0;
+  const normalizedUiLanguage = normalizeLanguageCode(uiLanguage);
+  const baseLanguage = normalizedUiLanguage.split("-")[0];
+  const normalized = sortAndDeduplicateLanguages(languages);
+  const exact = normalized.find((item) => item === normalizedUiLanguage);
+  if (exact) return exact;
+  const base = normalized.find((item) => item === baseLanguage || item.startsWith(`${baseLanguage}-`));
+  if (base) return base;
+  const english = normalized.find((item) => item === "en" || item === "en-US" || item.startsWith("en-"));
+  if (english) return english;
+  return normalized[0];
+};
+var getFirstLinkByRel = (item, rel) => item.links?.find((link) => link.rel === rel)?.href;
+var hasRenderableFileRenditions = (renditions) => {
+  if (!renditions || renditions.length === 0) return false;
+  return renditions.some((item) => {
+    if (!item.format || DEFAULT_IGNORED_FORMATS.includes(item.format)) return false;
+    return Boolean(getFirstLinkByRel(item, "download") || getFirstLinkByRel(item, "view"));
+  });
+};
+var resolveLiteralLabel = (labels, uiLanguage) => {
+  if (!labels || labels.length === 0) return void 0;
+  const language = uiLanguage || "en";
+  const preferred = resolvePreferredLanguage(
+    labels.map((item) => item.language || ""),
+    language
+  );
+  if (preferred) {
+    const exact = labels.find((item) => item.language === preferred)?.value;
+    if (exact) return exact;
+  }
+  return labels.find((item) => item.value)?.value || void 0;
+};
+var resolveObjectRefLabel = (item, uiLanguage) => {
+  return resolveLiteralLabel(item.labels || [], uiLanguage) || item.shortId || item.id || void 0;
+};
+var resolveObjectRefClassLabel = (item, uiLanguage) => {
+  return resolveLiteralLabel(item.class?.labels || [], uiLanguage) || item.class?.shortId || item.class?.id || void 0;
+};
+var asObjectRefArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => Boolean(item && typeof item === "object"));
+};
+var asLiteralArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => Boolean(item && typeof item === "object"));
+};
+var shouldUseFacetPresentation = (strategy) => {
+  return strategy === "class" || strategy === "partyRole";
+};
+var resolveFacetPresentationProperties = (includeProperties) => {
+  return includeProperties.filter((key) => {
+    const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
+    if (!config?.metadataDisplay?.supported) return false;
+    if (config.valueKind !== "objectRefArray" && config.valueKind !== "objectRef") return false;
+    return shouldUseFacetPresentation(config.metadataDisplay.sectionStrategy);
+  });
+};
+var resolveOverrideProperties = resolveFacetPresentationProperties;
+var buildMetadataDisplayRows = (data, options) => {
+  const uiLanguage = options.uiLanguage;
+  const preferredTitle = resolveLiteralLabel(data.titles || [], uiLanguage) || resolveLiteralLabel(data.labels || [], uiLanguage);
+  const rows = [];
+  for (const key of options.includeProperties) {
+    const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
+    if (!config?.metadataDisplay?.supported) continue;
+    if (isMetadataPropertyRuntimeSuppressed(key)) continue;
+    if (key === "labels") continue;
+    if (key === "titles") {
+      if (preferredTitle) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: [preferredTitle],
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    const value = data[key];
+    if (value === null || value === void 0) continue;
+    if (key === "languages") {
+      const languages = sortAndDeduplicateLanguages(value || []);
+      if (languages.length > 0) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: languages,
+          valueType: "language"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "scalar") {
+      rows.push({
+        key,
+        label: key,
+        labelSource: "translationKey",
+        values: [String(value)],
+        valueType: "text"
+      });
+      continue;
+    }
+    if (config.valueKind === "stringArray") {
+      const values = Array.from(new Set(value.map((item) => String(item)).filter(Boolean)));
+      if (values.length > 0) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values,
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "literalArray") {
+      const preferred = resolveLiteralLabel(asLiteralArray(value), uiLanguage);
+      if (preferred) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: [preferred],
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "objectRef") {
+      const label = resolveObjectRefLabel(value, uiLanguage);
+      if (label) {
+        rows.push({
+          key,
+          label: key,
+          labelSource: "translationKey",
+          values: [label],
+          valueType: "text"
+        });
+      }
+      continue;
+    }
+    if (config.valueKind === "objectRefArray") {
+      const refs = asObjectRefArray(value);
+      if (refs.length === 0) continue;
+      const groupedValues = /* @__PURE__ */ new Map();
+      refs.forEach((ref) => {
+        const shortId = ref.shortId || "";
+        const presentationMap = (options.presentation || options.overrides)?.[key];
+        const presentationItem = (shortId ? presentationMap?.[shortId] : void 0) || (ref.id ? presentationMap?.[ref.id] : void 0);
+        if (presentationItem?.hidden) return;
+        if (isMetadataGroupDenied(key, { classId: ref.class?.id })) return;
+        const valueLabel = presentationItem?.label || resolveObjectRefLabel(ref, uiLanguage);
+        if (!valueLabel) return;
+        const sectionLabel = config.metadataDisplay.sectionStrategy === "none" ? key : presentationItem?.sectionLabel || resolveObjectRefClassLabel(ref, uiLanguage) || key;
+        const existing = groupedValues.get(sectionLabel) || /* @__PURE__ */ new Set();
+        existing.add(valueLabel);
+        groupedValues.set(sectionLabel, existing);
+      });
+      Array.from(groupedValues.entries()).sort(([left], [right]) => left.localeCompare(right)).forEach(([sectionLabel, valueSet]) => {
+        const values = Array.from(valueSet).sort((a, b) => a.localeCompare(b));
+        if (values.length === 0) return;
+        rows.push({
+          key,
+          label: sectionLabel,
+          labelSource: sectionLabel === key ? "translationKey" : "direct",
+          values,
+          valueType: "text"
+        });
+      });
+      continue;
+    }
+    if (config.valueKind === "renditionArray") {
+      const renditions = Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object")) : [];
+      if (renditions.length === 0) continue;
+      if (!hasRenderableFileRenditions(renditions)) continue;
+      rows.push({
+        key,
+        label: "files",
+        labelSource: "translationKey",
+        values: [],
+        valueType: "rendition",
+        renditions
+      });
+    }
+  }
+  return rows;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildMetadataDisplayRows,
+  resolveFacetPresentationProperties,
+  resolveLiteralLabel,
+  resolveObjectRefClassLabel,
+  resolveObjectRefLabel,
+  resolveOverrideProperties
+});
+//# sourceMappingURL=metadata-display-builder.js.map