@cavuno/board 1.25.0 → 1.27.0

package/dist/format.mjs

@@ -0,0 +1,430 @@
+// src/format/dates.ts
+var rtfNarrowCache = /* @__PURE__ */ new Map();
+var dtfCache = /* @__PURE__ */ new Map();
+function getNarrowRelativeTimeFormat(language) {
+  const key = language ?? "en";
+  let rtf = rtfNarrowCache.get(key);
+  if (!rtf) {
+    rtf = new Intl.RelativeTimeFormat(key, {
+      numeric: "always",
+      style: "narrow"
+    });
+    rtfNarrowCache.set(key, rtf);
+  }
+  return rtf;
+}
+function getDateTimeFormat(language) {
+  const key = language ?? "en";
+  let dtf = dtfCache.get(key);
+  if (!dtf) {
+    dtf = new Intl.DateTimeFormat(key, {
+      dateStyle: "medium",
+      timeZone: "UTC"
+    });
+    dtfCache.set(key, dtf);
+  }
+  return dtf;
+}
+function formatNarrow(value, unit, language) {
+  try {
+    return getNarrowRelativeTimeFormat(language).format(value, unit);
+  } catch {
+    const shortMap = {
+      year: "y",
+      month: "mo",
+      week: "w",
+      day: "d",
+      hour: "h",
+      minute: "m",
+      second: "s"
+    };
+    return `${Math.abs(value)}${shortMap[unit] ?? unit}`;
+  }
+}
+function formatDate(locale, value) {
+  if (!value) return null;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return null;
+  try {
+    return getDateTimeFormat(locale).format(parsed);
+  } catch {
+    return parsed.toISOString().split("T")[0];
+  }
+}
+function formatPublishedRelativeDate(locale, value, referenceNowMs = Date.now()) {
+  if (!value) return null;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return null;
+  const diff = referenceNowMs - parsed.getTime();
+  const absDiff = Math.abs(diff);
+  const minute = 60 * 1e3;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  const week = 7 * day;
+  const month = 30 * day;
+  const year = 365 * day;
+  if (absDiff < minute) {
+    return "now";
+  }
+  const units = [
+    { unit: "year", ms: year },
+    { unit: "month", ms: month },
+    { unit: "week", ms: week },
+    { unit: "day", ms: day },
+    { unit: "hour", ms: hour },
+    { unit: "minute", ms: minute }
+  ];
+  for (const candidate of units) {
+    if (absDiff >= candidate.ms) {
+      const valueInUnit = Math.round(absDiff / candidate.ms);
+      const direction2 = diff >= 0 ? -valueInUnit : valueInUnit;
+      return formatNarrow(direction2, candidate.unit, locale);
+    }
+  }
+  const seconds = Math.round(absDiff / 1e3);
+  const direction = diff >= 0 ? -seconds : seconds;
+  return formatNarrow(direction, "second", locale);
+}
+function formatMonthYear(locale, dateStr) {
+  const date = /* @__PURE__ */ new Date(dateStr + "T00:00:00");
+  return date.toLocaleDateString(locale, {
+    month: "short",
+    year: "numeric"
+  });
+}
+
+// src/format/salary-lexicon.ts
+var EN = {
+  timeframe: {
+    per_year: "Yearly",
+    per_month: "Monthly",
+    per_week: "Weekly",
+    per_day: "Daily",
+    per_hour: "Hourly"
+  },
+  rangePrefix: { from: "From", upTo: "Up to" },
+  seniority: {
+    entry_level: "Entry level",
+    associate: "Associate",
+    mid_level: "Mid-level",
+    senior: "Senior",
+    lead: "Lead",
+    principal: "Principal",
+    director: "Director",
+    executive: "Executive"
+  },
+  frames: {
+    entitySalariesTitle: ({ entity, range }) => `${entity} Salaries (${range}/yr)`,
+    salariesInPlaceTitle: ({ place, range }) => `Salaries in ${place} (${range}/yr)`,
+    salariesInPlaceTitleNoRange: ({ place }) => `Salaries in ${place}`,
+    entitySalariesInPlaceTitle: ({ entity, place, range }) => `${entity} Salaries in ${place} (${range}/yr)`,
+    companySalariesTitle: ({ company, range }) => `${company} Salaries${range ? ` (${range}/yr)` : ""}`,
+    companyCategorySalariesTitle: ({ company, category, range }) => `${company} ${category} Salaries${range ? ` (${range}/yr)` : ""}`,
+    professionalsEarn: ({ entity, range, count }) => `${entity} professionals earn ${range}/yr on average across ${count} job postings.`,
+    rolesPay: ({ entity, range, count }) => `${entity} roles pay ${range}/yr on average across ${count} job postings.`,
+    professionalsInLocationEarn: ({ entity, place, range, count }) => `${entity} professionals in ${place} earn ${range}/yr on average across ${count} job postings.`,
+    seniorityRange: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel} roles start at ${lowAmount}, ${highLabel} roles reach ${highAmount}.`,
+    seniorityRangeWhile: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel} salaries start at ${lowAmount}, while ${highLabel} roles reach ${highAmount}.`,
+    compareAcrossTopPaying: ({ count }) => `Compare across ${count} top-paying ${count === 1 ? "company" : "companies"}.`,
+    compareAcrossTop: ({ count }) => `Compare across ${count} top ${count === 1 ? "company" : "companies"}.`,
+    boardWideAverage: ({ entity, range }) => `Board-wide ${entity} average: ${range}/yr.`,
+    averageSalaryInCity: ({ place, range, count }) => `Average salary in ${place} is ${range}/yr across ${count} jobs. Browse salary data by title and skill.`,
+    browseLocationsInRegion: ({ count, place }) => `Browse salary data across ${count} locations in ${place}. Compare salaries by title, skill, and company.`,
+    companyPays: ({ company, range, count }) => `${company} pays ${range}/yr on average across ${count} job postings.`,
+    breakdownAcrossCategories: ({ count }) => `Breakdown across ${count} job ${count === 1 ? "category" : "categories"}.`,
+    compareWithSimilar: ({ count }) => `Compare with ${count} similar ${count === 1 ? "company" : "companies"}.`,
+    salaryInfoFor: ({ company, board }) => `Salary information for ${company} on ${board}.`,
+    categoryRolesAtCompanyPay: ({ category, company, range, count }) => `${category} roles at ${company} pay ${range}/yr based on ${count} job postings.`,
+    categorySalaryDataFor: ({ category, company, board }) => `${category} salary data for ${company} on ${board}.`
+  }
+};
+var DE = {
+  timeframe: {
+    per_year: "pro Jahr",
+    per_month: "pro Monat",
+    per_week: "pro Woche",
+    per_day: "pro Tag",
+    per_hour: "pro Stunde"
+  },
+  rangePrefix: { from: "ab", upTo: "bis zu" },
+  seniority: {
+    entry_level: "Entry-Level",
+    associate: "Associate",
+    mid_level: "Mid-Level",
+    senior: "Senior",
+    lead: "Lead",
+    principal: "Principal",
+    director: "Director",
+    executive: "F\xFChrungskraft"
+  },
+  frames: {
+    entitySalariesTitle: ({ entity, range }) => `${entity} Geh\xE4lter (${range}/Jahr)`,
+    salariesInPlaceTitle: ({ place, range }) => `Geh\xE4lter in ${place} (${range}/Jahr)`,
+    salariesInPlaceTitleNoRange: ({ place }) => `Geh\xE4lter in ${place}`,
+    entitySalariesInPlaceTitle: ({ entity, place, range }) => `${entity} Geh\xE4lter in ${place} (${range}/Jahr)`,
+    companySalariesTitle: ({ company, range }) => `${company} Geh\xE4lter${range ? ` (${range}/Jahr)` : ""}`,
+    companyCategorySalariesTitle: ({ company, category, range }) => `${company} ${category} Geh\xE4lter${range ? ` (${range}/Jahr)` : ""}`,
+    professionalsEarn: ({ entity, range, count }) => `${entity}-Fachkr\xE4fte verdienen durchschnittlich ${range}/Jahr, basierend auf ${count} Stellenanzeigen.`,
+    rolesPay: ({ entity, range, count }) => `${entity}-Positionen werden mit durchschnittlich ${range}/Jahr verg\xFCtet, basierend auf ${count} Stellenanzeigen.`,
+    professionalsInLocationEarn: ({ entity, place, range, count }) => `${entity}-Fachkr\xE4fte in ${place} verdienen durchschnittlich ${range}/Jahr, basierend auf ${count} Stellenanzeigen.`,
+    seniorityRange: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel}-Positionen beginnen bei ${lowAmount}, ${highLabel}-Positionen erreichen ${highAmount}.`,
+    seniorityRangeWhile: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel}-Geh\xE4lter beginnen bei ${lowAmount}, w\xE4hrend ${highLabel}-Positionen ${highAmount} erreichen.`,
+    compareAcrossTopPaying: ({ count }) => `Vergleichen Sie ${count} ${count === 1 ? "bestzahlendes" : "bestzahlende"} Unternehmen.`,
+    compareAcrossTop: ({ count }) => `Vergleichen Sie ${count} Top-Unternehmen.`,
+    boardWideAverage: ({ entity, range }) => `Gesamtdurchschnitt ${entity}: ${range}/Jahr.`,
+    averageSalaryInCity: ({ place, range, count }) => `Das Durchschnittsgehalt in ${place} betr\xE4gt ${range}/Jahr, basierend auf ${count} Stellen. Gehaltsdaten nach Titel und F\xE4higkeiten durchsuchen.`,
+    browseLocationsInRegion: ({ count, place }) => `Gehaltsdaten f\xFCr ${count} Standorte in ${place} durchsuchen. Geh\xE4lter nach Titel, F\xE4higkeiten und Unternehmen vergleichen.`,
+    companyPays: ({ company, range, count }) => `${company} zahlt durchschnittlich ${range}/Jahr, basierend auf ${count} Stellenanzeigen.`,
+    breakdownAcrossCategories: ({ count }) => `Aufschl\xFCsselung \xFCber ${count} Job-${count === 1 ? "Kategorie" : "Kategorien"}.`,
+    compareWithSimilar: ({ count }) => `Vergleichen Sie mit ${count} \xE4hnlichen Unternehmen.`,
+    salaryInfoFor: ({ company, board }) => `Gehaltsinformationen f\xFCr ${company} auf ${board}.`,
+    categoryRolesAtCompanyPay: ({ category, company, range, count }) => `${category}-Positionen bei ${company} werden mit ${range}/Jahr verg\xFCtet, basierend auf ${count} Stellenanzeigen.`,
+    categorySalaryDataFor: ({ category, company, board }) => `${category}-Gehaltsdaten f\xFCr ${company} auf ${board}.`
+  }
+};
+var LEXICONS = { en: EN, de: DE };
+function getSalaryLexicon(locale) {
+  return locale && LEXICONS[locale] || EN;
+}
+
+// src/format/labels.ts
+var EN_LABELS = {
+  // remoteOption
+  on_site: "On-site",
+  hybrid: "Hybrid",
+  remote: "Remote",
+  // employmentType
+  full_time: "Full-time",
+  part_time: "Part-time",
+  contract: "Contract",
+  internship: "Internship",
+  temporary: "Temporary",
+  volunteer: "Volunteer",
+  other: "Other"
+};
+var SENIORITY_KEYS = /* @__PURE__ */ new Set([
+  "entry_level",
+  "associate",
+  "mid_level",
+  "senior",
+  "lead",
+  "principal",
+  "director",
+  "executive"
+]);
+function fieldLabel(locale, value) {
+  if (!value) return null;
+  if (SENIORITY_KEYS.has(value)) {
+    return getSalaryLexicon(locale).seniority[value];
+  }
+  return EN_LABELS[value] ?? value;
+}
+
+// src/format/location.ts
+function locationLabel(locale, job) {
+  const office = job.officeLocations[0];
+  const place = office ? office.displayName ?? [office.city ?? office.locality, office.country].filter(Boolean).join(", ") : null;
+  if (job.remoteOption === "remote") {
+    return job.remoteWorldwide ? "Remote (worldwide)" : "Remote";
+  }
+  if (!place) return fieldLabel(locale, job.remoteOption) ?? "";
+  return job.remoteOption === "hybrid" ? `${place} (hybrid)` : place;
+}
+function cardLocationLabel(locale, job) {
+  if (job.remoteOption === "remote") {
+    return job.remoteLocationLabel ? `Remote \xB7 ${job.remoteLocationLabel}` : "Remote";
+  }
+  return job.locationLabel ?? fieldLabel(locale, job.remoteOption) ?? "";
+}
+
+// src/format/job-card.ts
+function fullJobToCard(locale, job) {
+  return {
+    id: job.id,
+    object: "job_card",
+    slug: job.slug ?? "",
+    title: job.title,
+    publishedAt: job.publishedAt,
+    employmentType: job.employmentType,
+    remoteOption: job.remoteOption,
+    remoteLocationLabel: job.remoteWorldwide ? "Worldwide" : null,
+    salaryMin: job.salaryMin,
+    salaryMax: job.salaryMax,
+    salaryCurrency: job.salaryCurrency,
+    salaryTimeframe: job.salaryTimeframe,
+    isFeatured: job.isFeatured,
+    locationLabel: locationLabel(locale, job),
+    company: job.company?.slug ? {
+      slug: job.company.slug,
+      name: job.company.name ?? "",
+      logoUrl: job.company.logoUrl
+    } : null,
+    categories: job.categories,
+    skills: job.skills,
+    links: job.links
+  };
+}
+
+// src/format/salary-range.ts
+var CURRENCY_SYMBOLS = {
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  JPY: "\xA5",
+  CNY: "\xA5",
+  KRW: "\u20A9",
+  INR: "\u20B9",
+  RUB: "\u20BD",
+  BRL: "R$",
+  CAD: "C$",
+  AUD: "A$",
+  CHF: "CHF ",
+  SEK: "kr ",
+  NOK: "kr ",
+  DKK: "kr ",
+  PLN: "z\u0142 ",
+  MXN: "MX$",
+  SGD: "S$",
+  HKD: "HK$",
+  NZD: "NZ$",
+  ZAR: "R ",
+  THB: "\u0E3F",
+  PHP: "\u20B1",
+  IDR: "Rp ",
+  MYR: "RM ",
+  VND: "\u20AB",
+  AED: "AED ",
+  SAR: "SAR ",
+  ILS: "\u20AA",
+  TRY: "\u20BA",
+  CZK: "K\u010D ",
+  HUF: "Ft ",
+  RON: "lei ",
+  BGN: "\u043B\u0432 ",
+  HRK: "kn ",
+  ISK: "kr ",
+  CLP: "CLP$",
+  COP: "COP$",
+  PEN: "S/",
+  ARS: "ARS$",
+  TWD: "NT$",
+  NGN: "\u20A6",
+  EGP: "E\xA3",
+  PKR: "\u20A8",
+  BDT: "\u09F3",
+  UAH: "\u20B4",
+  KZT: "\u20B8"
+};
+function getCurrencySymbol(currency) {
+  if (!currency) {
+    return "$";
+  }
+  const normalized = currency.trim().toUpperCase();
+  return CURRENCY_SYMBOLS[normalized] ?? `${normalized} `;
+}
+var compactFormatCache = /* @__PURE__ */ new Map();
+function getCompactFormatter(language) {
+  const cached = compactFormatCache.get(language);
+  if (cached) return cached;
+  const formatter = new Intl.NumberFormat(language, {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: 1
+  });
+  compactFormatCache.set(language, formatter);
+  return formatter;
+}
+function formatCompactNumber(value, language) {
+  try {
+    return getCompactFormatter(language ?? "en").format(value);
+  } catch {
+    if (value >= 1e6) {
+      const millions = value / 1e6;
+      return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+    }
+    if (value >= 1e3) {
+      const thousands = value / 1e3;
+      return thousands % 1 === 0 ? `${thousands}k` : `${thousands.toFixed(1)}k`;
+    }
+    return value.toString();
+  }
+}
+var compactCurrencyCache = /* @__PURE__ */ new Map();
+function formatCompactCurrency(value, language, currency) {
+  const currencyCode = (currency ?? "USD").trim().toUpperCase();
+  const cacheKey = `${language}:${currencyCode}`;
+  let formatter = compactCurrencyCache.get(cacheKey);
+  if (formatter === void 0) {
+    try {
+      formatter = new Intl.NumberFormat(language, {
+        style: "currency",
+        currency: currencyCode,
+        notation: "compact",
+        compactDisplay: "short",
+        maximumFractionDigits: 1
+      });
+    } catch {
+      formatter = null;
+    }
+    compactCurrencyCache.set(cacheKey, formatter);
+  }
+  if (!formatter) {
+    return `${getCurrencySymbol(currency)}${formatCompactNumber(value, language)}`;
+  }
+  return formatter.format(value);
+}
+function appendTimeframe(value, timeframeLabel) {
+  if (!value) {
+    return null;
+  }
+  if (!timeframeLabel) {
+    return value;
+  }
+  return `${value} ${timeframeLabel}`;
+}
+function formatSalaryRange(language, min, max, timeframe, currency = null, timeframeOverrides) {
+  if (min == null && max == null) {
+    return null;
+  }
+  const locale = language ?? "en";
+  const lexicon = getSalaryLexicon(locale);
+  const overrideMap = {
+    per_year: timeframeOverrides?.yearlyLabel,
+    per_month: timeframeOverrides?.monthlyLabel,
+    per_week: timeframeOverrides?.weeklyLabel,
+    per_day: timeframeOverrides?.dailyLabel,
+    per_hour: timeframeOverrides?.hourlyLabel
+  };
+  const rawOverride = timeframe ? overrideMap[timeframe] : void 0;
+  const enSourceWord = timeframe ? getSalaryLexicon("en").timeframe[timeframe] : void 0;
+  const lexiconTimeframe = timeframe ? lexicon.timeframe[timeframe] ?? null : null;
+  const timeframeLabel = rawOverride && rawOverride !== enSourceWord ? rawOverride : lexiconTimeframe;
+  const formatAmount = locale === "en" ? (value) => `${getCurrencySymbol(currency)}${formatCompactNumber(value, locale)}` : (value) => formatCompactCurrency(value, locale, currency);
+  if (min != null && max != null) {
+    return appendTimeframe(
+      `${formatAmount(min)} \u2013 ${formatAmount(max)}`,
+      timeframeLabel
+    );
+  }
+  if (min != null) {
+    return appendTimeframe(
+      `${lexicon.rangePrefix.from} ${formatAmount(min)}`,
+      timeframeLabel
+    );
+  }
+  return appendTimeframe(
+    `${lexicon.rangePrefix.upTo} ${formatAmount(max)}`,
+    timeframeLabel
+  );
+}
+export {
+  cardLocationLabel,
+  fieldLabel,
+  formatDate,
+  formatMonthYear,
+  formatPublishedRelativeDate,
+  formatSalaryRange,
+  fullJobToCard,
+  getSalaryLexicon,
+  locationLabel
+};