@c-rex/services 0.1.18 → 0.1.20

package/dist/vcard/index.d.ts

@@ -0,0 +1,102 @@
+import { VCardInfoModel, ConfigInterface, VCardImageModel, OrganizationsGetByIdQueryParams, OrganizationsGetAllQueryParams, IndividualsGetByIdQueryParams, IndividualsGetAllQueryParams, VCardsGetByIdQueryParams, VCardsGetAllQueryParams } from '@c-rex/interfaces';
+
+type ContactEntry = {
+    label: string;
+    value: string;
+    href?: string;
+};
+type BaseVCardProfile = {
+    id?: string;
+    displayName: string;
+    logoSrc: string;
+    addressLines: string[];
+    email?: string;
+    telephoneEntries: ContactEntry[];
+    website?: string;
+};
+type ResolvedSocialLink = {
+    label: string;
+    href: string;
+    provider: string;
+};
+type VCardEntityLike = {
+    id?: string | null;
+    fullName?: string | null;
+    organizationName?: string | null;
+    logos?: VCardImageModel[] | null;
+    photos?: VCardImageModel[] | null;
+    emails?: VCardInfoModel[] | null;
+    telephones?: VCardInfoModel[] | null;
+    addresses?: VCardInfoModel[] | null;
+    urls?: VCardInfoModel[] | null;
+};
+declare const DEFAULT_LOGO_SRC = "/img/logo.png";
+declare const resolveLogoSource: (images?: VCardImageModel[]) => string | undefined;
+declare const normalizeHref: (value?: string | null) => string | undefined;
+declare const resolveSocialProviderLabel: (href: string) => string;
+declare const resolveTypedSocialLinks: (urls?: VCardInfoModel[]) => ResolvedSocialLink[];
+declare const normalizeEmail: (value?: string | null) => string | undefined;
+declare const buildTelephoneEntries: (telephones: VCardInfoModel[] | undefined, uiLanguage: string) => ContactEntry[];
+declare const resolveUiLanguage: () => string;
+declare const mapVCardEntityToBaseProfile: (entity: VCardEntityLike, options: {
+    uiLanguage: string;
+    displayNameFallback: string;
+    logoFallbackSrc?: string;
+}) => BaseVCardProfile;
+declare const decodeEncodedVcardId: (encodedId: string) => string | undefined;
+declare const getServerConfig: () => ConfigInterface;
+
+type OrganizationProfile = {
+    id?: string;
+    displayName: string;
+    organizationName: string;
+    logoSrc: string;
+    addressLines: string[];
+    email?: string;
+    telephoneEntries: ContactEntry[];
+    website?: string;
+    socialLinks: Array<{
+        label: string;
+        href: string;
+    }>;
+};
+declare const getOrganizationProfileById: (id: string, query?: Partial<OrganizationsGetByIdQueryParams>) => Promise<OrganizationProfile>;
+declare const getOrganizationsProfiles: (query?: Partial<OrganizationsGetAllQueryParams>) => Promise<OrganizationProfile[]>;
+/**
+ * Resolves organization profile data (VCARD + configured fallbacks) for shared branding.
+ */
+declare const getOrganizationProfile: () => Promise<OrganizationProfile>;
+/**
+ * Convenience projection for places that only need logo + organization title.
+ */
+declare const getOrganizationBranding: () => Promise<Pick<OrganizationProfile, "logoSrc" | "organizationName">>;
+
+type IndividualProfile = {
+    id?: string;
+    displayName: string;
+    fullName: string;
+    logoSrc: string;
+    addressLines: string[];
+    email?: string;
+    telephoneEntries: ContactEntry[];
+    website?: string;
+    title?: string;
+    role?: string;
+};
+declare const getIndividualProfileById: (id: string, query?: Partial<IndividualsGetByIdQueryParams>) => Promise<IndividualProfile>;
+declare const getIndividualsProfiles: (query?: Partial<IndividualsGetAllQueryParams>) => Promise<IndividualProfile[]>;
+
+type VCardProfile = {
+    id?: string;
+    displayName: string;
+    fullName: string;
+    logoSrc: string;
+    addressLines: string[];
+    email?: string;
+    telephoneEntries: ContactEntry[];
+    website?: string;
+};
+declare const getVCardProfileById: (id: string, query?: Partial<VCardsGetByIdQueryParams>) => Promise<VCardProfile>;
+declare const getVCardProfiles: (query?: Partial<VCardsGetAllQueryParams>) => Promise<VCardProfile[]>;
+
+export { type BaseVCardProfile, type ContactEntry, DEFAULT_LOGO_SRC, type IndividualProfile, type OrganizationProfile, type ResolvedSocialLink, type VCardProfile, buildTelephoneEntries, decodeEncodedVcardId, getIndividualProfileById, getIndividualsProfiles, getOrganizationBranding, getOrganizationProfile, getOrganizationProfileById, getOrganizationsProfiles, getServerConfig, getVCardProfileById, getVCardProfiles, mapVCardEntityToBaseProfile, normalizeEmail, normalizeHref, resolveLogoSource, resolveSocialProviderLabel, resolveTypedSocialLinks, resolveUiLanguage };

package/dist/vcard/index.js

@@ -0,0 +1,561 @@
+"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/vcard/index.ts
+var vcard_exports = {};
+__export(vcard_exports, {
+  DEFAULT_LOGO_SRC: () => DEFAULT_LOGO_SRC,
+  buildTelephoneEntries: () => buildTelephoneEntries,
+  decodeEncodedVcardId: () => decodeEncodedVcardId,
+  getIndividualProfileById: () => getIndividualProfileById,
+  getIndividualsProfiles: () => getIndividualsProfiles,
+  getOrganizationBranding: () => getOrganizationBranding,
+  getOrganizationProfile: () => getOrganizationProfile,
+  getOrganizationProfileById: () => getOrganizationProfileById,
+  getOrganizationsProfiles: () => getOrganizationsProfiles,
+  getServerConfig: () => getServerConfig,
+  getVCardProfileById: () => getVCardProfileById,
+  getVCardProfiles: () => getVCardProfiles,
+  mapVCardEntityToBaseProfile: () => mapVCardEntityToBaseProfile,
+  normalizeEmail: () => normalizeEmail,
+  normalizeHref: () => normalizeHref,
+  resolveLogoSource: () => resolveLogoSource,
+  resolveSocialProviderLabel: () => resolveSocialProviderLabel,
+  resolveTypedSocialLinks: () => resolveTypedSocialLinks,
+  resolveUiLanguage: () => resolveUiLanguage
+});
+module.exports = __toCommonJS(vcard_exports);
+
+// src/vcard/profile-utils.ts
+var import_sdk = require("@c-rex/core/sdk");
+var import_constants = require("@c-rex/constants");
+var import_headers = require("next/headers");
+var DEFAULT_LOGO_SRC = "/img/logo.png";
+var normalizePathLikeImageSource = (value) => {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("data:") || trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return `/${trimmed}`;
+};
+var resolveLogoSource = (images = []) => {
+  const sourceFirst = images.map((image) => normalizePathLikeImageSource(image.source)).find((value) => Boolean(value));
+  if (!sourceFirst) {
+    console.warn("[VCardProfile] No usable VCARD image source found. Ignoring 'value' until IDS provides absolute resource URLs.");
+  }
+  return sourceFirst;
+};
+var normalizeHref = (value) => {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("mailto:") || trimmed.startsWith("tel:")) {
+    return trimmed;
+  }
+  return `https://${trimmed}`;
+};
+var SOCIAL_MEDIA_TYPE_URI = "https://www.c-rex.net/ns/iirds/vcard#SocialMedia";
+var SOCIAL_MEDIA_TYPE_URI_NORMALIZED = SOCIAL_MEDIA_TYPE_URI.toLowerCase();
+var isSocialMediaType = (value) => {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === SOCIAL_MEDIA_TYPE_URI_NORMALIZED || normalized.endsWith("#socialmedia");
+};
+var isSocialMediaUrlEntry = (url) => {
+  const hasTypedMarker = Array.isArray(url.types) && url.types.some((type) => isSocialMediaType(type));
+  if (hasTypedMarker) return true;
+  const hasClassMarker = Array.isArray(url.classes) && url.classes.some((cls) => isSocialMediaType(cls?.id));
+  if (hasClassMarker) return true;
+  const hasClassLabelMarker = Array.isArray(url.classes) && url.classes.some(
+    (cls) => (cls?.labels || []).some((label) => (label.value || "").trim().toLowerCase() === "social media")
+  );
+  return hasClassLabelMarker;
+};
+var SOCIAL_PROVIDER_BY_HOST = [
+  { hostPattern: /(^|\.)x\.com$/i, label: "X" },
+  { hostPattern: /(^|\.)twitter\.com$/i, label: "Twitter" },
+  { hostPattern: /(^|\.)facebook\.com$/i, label: "Facebook" },
+  { hostPattern: /(^|\.)instagram\.com$/i, label: "Instagram" },
+  { hostPattern: /(^|\.)youtube\.com$/i, label: "YouTube" },
+  { hostPattern: /(^|\.)youtu\.be$/i, label: "YouTube" },
+  { hostPattern: /(^|\.)linkedin\.com$/i, label: "LinkedIn" },
+  { hostPattern: /(^|\.)xing\.com$/i, label: "Xing" }
+];
+var resolveSocialProviderLabel = (href) => {
+  try {
+    const hostname = new URL(href).hostname.toLowerCase();
+    const provider = SOCIAL_PROVIDER_BY_HOST.find((entry) => entry.hostPattern.test(hostname));
+    return provider?.label || hostname.replace(/^www\./i, "");
+  } catch {
+    return "Social";
+  }
+};
+var isKnownSocialProviderHref = (href) => {
+  try {
+    const hostname = new URL(href).hostname.toLowerCase();
+    return SOCIAL_PROVIDER_BY_HOST.some((entry) => entry.hostPattern.test(hostname));
+  } catch {
+    return false;
+  }
+};
+var resolveTypedSocialLinks = (urls = []) => {
+  const items = urls.filter((url) => {
+    if (isSocialMediaUrlEntry(url)) return true;
+    const href = normalizeHref(url.value);
+    return Boolean(href && isKnownSocialProviderHref(href));
+  }).map((url) => normalizeHref(url.value)).filter((value) => Boolean(value));
+  const byHref = /* @__PURE__ */ new Map();
+  items.forEach((href) => {
+    if (byHref.has(href)) return;
+    const label = resolveSocialProviderLabel(href);
+    byHref.set(href, {
+      href,
+      label,
+      provider: label
+    });
+  });
+  return Array.from(byHref.values());
+};
+var normalizePhone = (value) => {
+  if (!value) return void 0;
+  return value.replace(/^tel:/i, "").trim() || void 0;
+};
+var isDialablePhone = (value) => {
+  if (!value) return false;
+  const normalized = value.trim();
+  if (!normalized) return false;
+  if (!/\d/.test(normalized)) return false;
+  return /^[+\d()[\]\-./\s]+$/.test(normalized);
+};
+var normalizePhoneHref = (value) => {
+  if (!value) return void 0;
+  const normalizedPhone = normalizePhone(value);
+  if (!normalizedPhone || !isDialablePhone(normalizedPhone)) return void 0;
+  return `tel:${normalizedPhone}`;
+};
+var normalizeEmail = (value) => {
+  if (!value) return void 0;
+  return value.replace(/^mailto:/i, "").trim() || void 0;
+};
+var normalizeLanguage = (value) => {
+  return (value || "").trim().toLowerCase().replace("_", "-");
+};
+var getLiteralLanguage = (literal) => {
+  const language = literal.language || literal["xml:lang"] || "";
+  return normalizeLanguage(language);
+};
+var getLocalizedLiteral = (labels = [], uiLanguage) => {
+  const normalizedUiLanguage = normalizeLanguage(uiLanguage);
+  const normalizedUiBaseLanguage = normalizedUiLanguage.split("-")[0];
+  const exact = labels.find((item) => getLiteralLanguage(item) === normalizedUiLanguage)?.value?.trim();
+  if (exact) return exact;
+  const base = labels.find((item) => getLiteralLanguage(item).startsWith(`${normalizedUiBaseLanguage}`))?.value?.trim();
+  if (base) return base;
+  const fallback = labels.find((item) => (item.value || "").trim().length > 0)?.value?.trim();
+  return fallback || void 0;
+};
+var buildTelephoneEntries = (telephones = [], uiLanguage) => {
+  return telephones.reduce((entries, telephone) => {
+    const normalizedValue = normalizePhone(telephone.value);
+    if (!normalizedValue) return entries;
+    const classLabels = (telephone.classes || []).map((cls) => getLocalizedLiteral(cls.labels || [], uiLanguage)).filter((value) => Boolean(value));
+    const dedupedClassLabels = Array.from(
+      new Map(classLabels.map((value) => [value.toLowerCase(), value])).values()
+    );
+    entries.push({
+      label: dedupedClassLabels.length > 0 ? dedupedClassLabels.join(" ") : "",
+      value: normalizedValue,
+      href: normalizePhoneHref(telephone.value)
+    });
+    return entries;
+  }, []);
+};
+var resolveUiLanguage = () => {
+  const sdk = new import_sdk.CrexSDK();
+  const clientConfig = sdk.getClientConfig();
+  const defaultLanguage = normalizeLanguage(clientConfig.languageSwitcher.default || "en-us");
+  const uiLanguageFromCookie = (0, import_headers.cookies)().get(import_constants.UI_LANG_KEY)?.value;
+  return normalizeLanguage(uiLanguageFromCookie) || defaultLanguage;
+};
+var buildAddressLines = (address) => {
+  if (!address) return [];
+  const line1 = [address.streetAddress].filter(Boolean).join(" ").trim();
+  const line2 = [address.postalCode, address.locality].filter(Boolean).join(" ").trim();
+  const line3 = [address.countryName].filter(Boolean).join(" ").trim();
+  return [line1, line2, line3].filter((line) => line.length > 0);
+};
+var mapVCardEntityToBaseProfile = (entity, options) => {
+  const preferredAddress = entity.addresses?.[0];
+  const preferredEmail = entity.emails?.[0];
+  const preferredWebsite = entity.urls?.find((item) => normalizeHref(item.value));
+  const logoSrc = resolveLogoSource([...entity.logos || [], ...entity.photos || []]) || (options.logoFallbackSrc || DEFAULT_LOGO_SRC);
+  return {
+    id: entity.id || void 0,
+    displayName: entity.organizationName?.trim() || entity.fullName?.trim() || options.displayNameFallback,
+    logoSrc,
+    addressLines: buildAddressLines(preferredAddress),
+    email: normalizeEmail(preferredEmail?.value),
+    telephoneEntries: buildTelephoneEntries(entity.telephones || [], options.uiLanguage),
+    website: normalizeHref(preferredWebsite?.value)
+  };
+};
+var decodeEncodedVcardId = (encodedId) => {
+  try {
+    return decodeURIComponent(encodedId);
+  } catch (error) {
+    console.error(`[VCardProfile] Invalid encoded VCARD ID value: "${encodedId}".`, error);
+    return void 0;
+  }
+};
+var getServerConfig = () => {
+  const sdk = new import_sdk.CrexSDK();
+  return sdk.getServerConfig();
+};
+
+// src/vcard/organization-profile.ts
+var import_requests2 = require("@c-rex/core/requests");
+var import_cache = require("next/cache");
+
+// src/base-server-request.ts
+var import_requests = require("@c-rex/core/requests");
+
+// src/server-request-context.ts
+var import_node_async_hooks = require("async_hooks");
+var requestContextStorage = new import_node_async_hooks.AsyncLocalStorage();
+var withServerRequestContext = async (context, run) => {
+  return requestContextStorage.run(context, run);
+};
+var getServerRequestContext = () => {
+  return requestContextStorage.getStore();
+};
+
+// src/base-server-request.ts
+var baseServerRequest = async (endpoint, query) => {
+  const api = new import_requests.CrexApi();
+  const requestContext = getServerRequestContext();
+  const response = await api.execute({
+    url: endpoint,
+    method: "GET",
+    params: query,
+    skipCookieTokenLookup: requestContext?.skipCookieTokenLookup,
+    authToken: requestContext?.authToken
+  });
+  return response;
+};
+
+// src/generated/server-requests.ts
+var individualsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Individuals", query);
+};
+var individualsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Individuals/${encodeURIComponent(String(params.id))}`, query);
+};
+var organizationsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Organizations", query);
+};
+var organizationsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Organizations/${encodeURIComponent(String(params.id))}`, query);
+};
+var vCardsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/VCards", query);
+};
+var vCardsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/VCards/${encodeURIComponent(String(params.id))}`, query);
+};
+
+// src/read-models/cache-policy.ts
+var readPositiveInt = (rawValue, fallback) => {
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+};
+var READMODEL_CACHE_POLICY = {
+  metadataRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_METADATA_SECONDS,
+    2 * 60 * 60
+  ),
+  vcardRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_VCARD_SECONDS,
+    6 * 60 * 60
+  ),
+  requestsRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_REQUESTS_SECONDS,
+    15 * 60
+  )
+};
+
+// src/vcard/organization-profile.ts
+var toOrganizationProfile = (organization, options) => {
+  const base = mapVCardEntityToBaseProfile(organization, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    organizationName: base.displayName,
+    socialLinks: resolveTypedSocialLinks(organization.urls || []).map((item) => ({
+      label: item.label,
+      href: item.href
+    }))
+  };
+};
+var ORGANIZATION_PROFILE_REQUIRED_FIELDS = [
+  "organizationName",
+  "fullName",
+  "logos",
+  "photos",
+  "emails",
+  "telephones",
+  "addresses",
+  "urls"
+];
+var resolveOrganizationProfileQuery = (query) => {
+  if (!query) return void 0;
+  if (!Array.isArray(query.Fields) || query.Fields.length === 0) return query;
+  const mergedFields = Array.from(/* @__PURE__ */ new Set([...query.Fields, ...ORGANIZATION_PROFILE_REQUIRED_FIELDS]));
+  return {
+    ...query,
+    Fields: mergedFields
+  };
+};
+var fetchOrganizationProfileById = async (id, query, context) => {
+  try {
+    const organization = await organizationsGetByIdServer({ id }, resolveOrganizationProfileQuery(query));
+    return toOrganizationProfile(organization, {
+      uiLanguage: context.uiLanguage,
+      displayNameFallback: context.fallbackName,
+      logoFallbackSrc: context.logoFallbackSrc
+    });
+  } catch (error) {
+    console.error(`[OrganizationProfile] Failed to load VCARD organization "${id}".`, error);
+    return {
+      id,
+      logoSrc: context.logoFallbackSrc,
+      displayName: context.fallbackName,
+      organizationName: context.fallbackName,
+      addressLines: [],
+      telephoneEntries: [],
+      socialLinks: []
+    };
+  }
+};
+var getOrganizationProfileById = async (id, query) => {
+  const serverConfig = getServerConfig();
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  return fetchOrganizationProfileById(id, query, {
+    uiLanguage,
+    fallbackName,
+    logoFallbackSrc
+  });
+};
+var getOrganizationProfileByIdCached = (0, import_cache.unstable_cache)(
+  async (id, query, context) => withServerRequestContext(
+    { skipCookieTokenLookup: true },
+    () => fetchOrganizationProfileById(id, query, context)
+  ),
+  ["read-model", "organization-profile-v2"],
+  {
+    revalidate: READMODEL_CACHE_POLICY.vcardRevalidateSeconds,
+    tags: [
+      import_requests2.CREX_API_CACHE_TAG,
+      import_requests2.CREX_API_CACHE_VCARD_TAG,
+      import_requests2.CREX_READMODEL_CACHE_TAG,
+      import_requests2.CREX_READMODEL_CACHE_VCARD_TAG,
+      import_requests2.CREX_READMODEL_CACHE_ORGANIZATION_TAG
+    ]
+  }
+);
+var getOrganizationsProfiles = async (query) => {
+  const serverConfig = getServerConfig();
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  const result = await organizationsGetAllServer(query);
+  return result.items.map(
+    (organization) => toOrganizationProfile(organization, {
+      uiLanguage,
+      displayNameFallback: fallbackName,
+      logoFallbackSrc
+    })
+  );
+};
+var getOrganizationProfile = async () => {
+  const serverConfig = getServerConfig();
+  const rawVcardId = process.env.CREX_ORGANIZATION_VCARD_ID?.trim();
+  const encodedVcardId = process.env.CREX_ORGANIZATION_VCARD_ID_ENCODED?.trim();
+  const decodedEncodedVcardId = encodedVcardId ? decodeEncodedVcardId(encodedVcardId) : void 0;
+  const configuredVcardId = rawVcardId || decodedEncodedVcardId || serverConfig.organization?.vcardId?.trim();
+  if (!configuredVcardId) {
+    console.info("[OrganizationProfile] No VCARD organization ID configured. Using fallback branding.");
+    const logoFallbackSrc2 = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+    const fallbackName2 = serverConfig.projectName;
+    return {
+      logoSrc: logoFallbackSrc2,
+      displayName: fallbackName2,
+      organizationName: fallbackName2,
+      addressLines: [],
+      telephoneEntries: [],
+      socialLinks: []
+    };
+  }
+  if (rawVcardId && rawVcardId.startsWith("http") && !rawVcardId.includes("#")) {
+    console.warn(
+      `[OrganizationProfile] VCARD ID does not contain "#": "${rawVcardId}". If this value comes from .env, wrap it in quotes or use CREX_ORGANIZATION_VCARD_ID_ENCODED.`
+    );
+  }
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  const context = {
+    uiLanguage,
+    fallbackName,
+    logoFallbackSrc
+  };
+  if (process.env.NODE_ENV === "test") {
+    return fetchOrganizationProfileById(configuredVcardId, void 0, context);
+  }
+  return getOrganizationProfileByIdCached(configuredVcardId, void 0, context);
+};
+var getOrganizationBranding = async () => {
+  const profile = await getOrganizationProfile();
+  return {
+    logoSrc: profile.logoSrc,
+    organizationName: profile.organizationName
+  };
+};
+
+// src/vcard/individual-profile.ts
+var toIndividualProfile = (individual, options) => {
+  const base = mapVCardEntityToBaseProfile(individual, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    fullName: base.displayName,
+    title: individual.title?.trim() || void 0,
+    role: individual.role?.trim() || void 0
+  };
+};
+var getIndividualProfileById = async (id, query) => {
+  const uiLanguage = resolveUiLanguage();
+  try {
+    const individual = await individualsGetByIdServer({ id }, query);
+    return toIndividualProfile(individual, {
+      uiLanguage,
+      displayNameFallback: id,
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    });
+  } catch (error) {
+    console.error(`[IndividualProfile] Failed to load VCARD individual "${id}".`, error);
+    return {
+      id,
+      logoSrc: DEFAULT_LOGO_SRC,
+      displayName: id,
+      fullName: id,
+      addressLines: [],
+      telephoneEntries: []
+    };
+  }
+};
+var getIndividualsProfiles = async (query) => {
+  const uiLanguage = resolveUiLanguage();
+  const result = await individualsGetAllServer(query);
+  return result.items.map(
+    (individual) => toIndividualProfile(individual, {
+      uiLanguage,
+      displayNameFallback: individual.id || "Unknown individual",
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    })
+  );
+};
+
+// src/vcard/vcard-profile.ts
+var toVCardProfile = (vcard, options) => {
+  const base = mapVCardEntityToBaseProfile(vcard, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    fullName: base.displayName
+  };
+};
+var getVCardProfileById = async (id, query) => {
+  const uiLanguage = resolveUiLanguage();
+  try {
+    const vcard = await vCardsGetByIdServer({ id }, query);
+    return toVCardProfile(vcard, {
+      uiLanguage,
+      displayNameFallback: id,
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    });
+  } catch (error) {
+    console.error(`[VCardProfile] Failed to load VCARD "${id}".`, error);
+    return {
+      id,
+      logoSrc: DEFAULT_LOGO_SRC,
+      displayName: id,
+      fullName: id,
+      addressLines: [],
+      telephoneEntries: []
+    };
+  }
+};
+var getVCardProfiles = async (query) => {
+  const uiLanguage = resolveUiLanguage();
+  const result = await vCardsGetAllServer(query);
+  return result.items.map(
+    (vcard) => toVCardProfile(vcard, {
+      uiLanguage,
+      displayNameFallback: vcard.id || "Unknown vCard",
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_LOGO_SRC,
+  buildTelephoneEntries,
+  decodeEncodedVcardId,
+  getIndividualProfileById,
+  getIndividualsProfiles,
+  getOrganizationBranding,
+  getOrganizationProfile,
+  getOrganizationProfileById,
+  getOrganizationsProfiles,
+  getServerConfig,
+  getVCardProfileById,
+  getVCardProfiles,
+  mapVCardEntityToBaseProfile,
+  normalizeEmail,
+  normalizeHref,
+  resolveLogoSource,
+  resolveSocialProviderLabel,
+  resolveTypedSocialLinks,
+  resolveUiLanguage
+});
+//# sourceMappingURL=index.js.map