@cavuno/board 3.1.0 → 4.0.0

package/dist/chunk-YEAQ3JEI.mjs

@@ -0,0 +1,853 @@
+import {
+  BOARD_PATHS,
+  jobsCategoryPath,
+  jobsLocationCategoryPath,
+  jobsLocationPath
+} from "./chunk-BGKNXG4H.mjs";
+
+// src/format/locale.ts
+function normalizeLocale(language) {
+  const trimmed = language.trim();
+  if (!trimmed) return null;
+  try {
+    const candidate = trimmed.replace(/_/g, "-");
+    const [canonical] = Intl.getCanonicalLocales(candidate);
+    if (!canonical) return null;
+    const [supported] = Intl.NumberFormat.supportedLocalesOf([canonical]);
+    return supported ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/seo/salary.ts
+var currencyFormatterCache = /* @__PURE__ */ new Map();
+function notationForMagnitude(...values) {
+  let anyFinite = false;
+  for (const v of values) {
+    if (v == null || !Number.isFinite(v)) continue;
+    anyFinite = true;
+    if (Math.abs(v) >= 1e3) return "compact";
+  }
+  return anyFinite ? "standard" : "compact";
+}
+function getCurrencyFormatter(language, currencyCode, notation) {
+  const key = `${language}:${currencyCode}:${notation}`;
+  const cached = currencyFormatterCache.get(key);
+  if (cached !== void 0) return cached;
+  let formatter;
+  try {
+    const options = {
+      style: "currency",
+      currency: currencyCode,
+      notation
+    };
+    if (notation === "compact") {
+      options.compactDisplay = "short";
+      options.minimumFractionDigits = 0;
+      options.maximumFractionDigits = 1;
+    }
+    formatter = new Intl.NumberFormat(language, options);
+  } catch {
+    formatter = null;
+  }
+  currencyFormatterCache.set(key, formatter);
+  return formatter;
+}
+function formatSalaryStat(locale, value, currency, notation) {
+  if (!Number.isFinite(value)) return null;
+  const currencyCode = currency?.trim().toUpperCase() || null;
+  if (!currencyCode) return null;
+  const normalized = normalizeLocale(locale);
+  if (!normalized) return null;
+  const resolved = notation ?? notationForMagnitude(value);
+  const formatter = getCurrencyFormatter(normalized, currencyCode, resolved);
+  if (!formatter) return null;
+  return formatter.format(value);
+}
+function formatSalaryStatRange(locale, min, max, currency, notation) {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return null;
+  const currencyCode = currency?.trim().toUpperCase() || null;
+  if (!currencyCode) return null;
+  const normalized = normalizeLocale(locale);
+  if (!normalized) return null;
+  const resolved = notation ?? notationForMagnitude(min, max);
+  const formatter = getCurrencyFormatter(normalized, currencyCode, resolved);
+  if (!formatter) return null;
+  const low = Math.min(min, max);
+  const high = Math.max(min, max);
+  if (low === high) return formatter.format(low);
+  return formatter.formatRange(low, high);
+}
+var SENIORITY_ORDER = [
+  "entry_level",
+  "associate",
+  "mid_level",
+  "senior",
+  "lead",
+  "principal",
+  "director",
+  "executive"
+];
+function sortBySeniority(items) {
+  return [...items].sort((a, b) => {
+    const aIdx = SENIORITY_ORDER.indexOf(
+      a.seniority
+    );
+    const bIdx = SENIORITY_ORDER.indexOf(
+      b.seniority
+    );
+    return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
+  });
+}
+var yearly = {
+  unitText: "YEAR",
+  duration: "P1Y"
+};
+function distribution(name, currency, minValue, maxValue, stats = {}) {
+  return {
+    "@type": "MonetaryAmountDistribution",
+    ...name !== void 0 ? { name } : {},
+    currency,
+    minValue,
+    maxValue,
+    ...stats,
+    ...yearly
+  };
+}
+function seniorityDistributions(rows, currency, entity, options) {
+  return rows.map((row) => {
+    const name = options?.seniorityName?.({
+      seniority: row.seniority,
+      entity
+    });
+    return distribution(
+      name,
+      currency,
+      row.avgSalaryMin,
+      row.avgSalaryMax
+    );
+  });
+}
+function salaryEnvelope(type, name, extra, estimatedSalary) {
+  return {
+    "@context": "https://schema.org",
+    "@type": type,
+    name,
+    ...extra,
+    estimatedSalary
+  };
+}
+function buildSalaryFaq(locale, label, overall, currency) {
+  if (!overall) return [];
+  const range = formatSalaryStatRange(
+    locale,
+    overall.avgMin,
+    overall.avgMax,
+    currency
+  );
+  return [
+    {
+      kind: "average",
+      label,
+      range,
+      avgMin: overall.avgMin,
+      avgMax: overall.avgMax,
+      currency,
+      jobCount: overall.jobCount
+    },
+    {
+      kind: "methodology",
+      label
+    }
+  ];
+}
+function itemListJsonLd(items) {
+  if (items.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "ItemList",
+    numberOfItems: items.length,
+    itemListElement: items.map((it, i) => ({
+      "@type": "ListItem",
+      position: i + 1,
+      name: it.name,
+      url: it.url
+    }))
+  };
+}
+function faqJsonLd(faqs) {
+  if (faqs.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: faqs.map((f) => ({
+      "@type": "Question",
+      name: f.q,
+      acceptedAnswer: { "@type": "Answer", text: f.a }
+    }))
+  };
+}
+function titleSalaryJsonLd(d, options) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope("Occupation", d.categoryName, {}, [
+    distribution(
+      d.categoryName,
+      d.currency,
+      d.overallSalary.avgMin,
+      d.overallSalary.avgMax,
+      {
+        ...d.boardP25Min ? { percentile25: d.boardP25Min } : {},
+        ...d.boardP75Max ? { percentile75: d.boardP75Max } : {}
+      }
+    ),
+    ...seniorityDistributions(
+      d.bySeniority,
+      d.currency,
+      d.categoryName,
+      options
+    )
+  ]);
+}
+function skillSalaryJsonLd(d) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope("Occupation", d.skillName, {}, [
+    distribution(
+      d.skillName,
+      d.currency,
+      d.overallSalary.avgMin,
+      d.overallSalary.avgMax,
+      {
+        median: Math.round(
+          (d.overallSalary.medianMin + d.overallSalary.medianMax) / 2
+        )
+      }
+    )
+  ]);
+}
+function locationSalaryJsonLd(d, options) {
+  if (!options?.occupationUrl) return null;
+  const isCity = d.adminLevel === "city" || d.adminLevel === "locality";
+  if (!isCity) return null;
+  return itemListJsonLd(
+    d.topCategories.map((c) => ({
+      name: c.categoryName,
+      url: options.occupationUrl(c)
+    }))
+  );
+}
+function crossAxisSalaryJsonLd(args, options) {
+  if (!args.overall) return null;
+  return salaryEnvelope(
+    "Occupation",
+    args.name,
+    {
+      occupationLocation: {
+        "@type": "AdministrativeArea",
+        name: args.placeName,
+        address: {
+          "@type": "PostalAddress",
+          addressCountry: args.countryCode
+        }
+      }
+    },
+    [
+      distribution(
+        args.name,
+        args.currency,
+        args.overall.avgMin,
+        args.overall.avgMax,
+        {
+          ...args.overall.p25Min ? { percentile25: args.overall.p25Min } : {},
+          ...args.overall.p75Max ? { percentile75: args.overall.p75Max } : {}
+        }
+      ),
+      ...seniorityDistributions(
+        args.bySeniority,
+        args.currency,
+        args.name,
+        options
+      )
+    ]
+  );
+}
+function companySalaryJsonLd(d, options) {
+  if (!options?.occupationUrl) return null;
+  return itemListJsonLd(
+    d.byCategory.map((c) => ({
+      name: c.categoryName,
+      url: options.occupationUrl(c)
+    }))
+  );
+}
+function companyCategorySalaryJsonLd(d, options) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope(
+    "Occupation",
+    d.categoryName,
+    {
+      occupationalCategory: d.categoryName,
+      hiringOrganization: { "@type": "Organization", name: d.companyName }
+    },
+    [
+      distribution(
+        d.categoryName,
+        d.currency,
+        d.overallSalary.avgMin,
+        d.overallSalary.avgMax,
+        {
+          ...d.boardCategoryP25Min ? { percentile25: d.boardCategoryP25Min } : {},
+          ...d.boardCategoryP75Max ? { percentile75: d.boardCategoryP75Max } : {}
+        }
+      ),
+      ...seniorityDistributions(
+        d.bySeniority,
+        d.currency,
+        d.categoryName,
+        options
+      )
+    ]
+  );
+}
+
+// src/seo/job-posting.ts
+var EDUCATION_TO_CREDENTIAL = {
+  high_school: "high school",
+  associate_degree: "associate degree",
+  bachelor_degree: "bachelor degree",
+  professional_certificate: "professional certificate",
+  postgraduate_degree: "postgraduate degree"
+};
+var EMPLOYMENT_TYPE_TO_GOOGLE = {
+  full_time: "FULL_TIME",
+  part_time: "PART_TIME",
+  contract: "CONTRACTOR",
+  internship: "INTERN",
+  temporary: "TEMPORARY",
+  volunteer: "VOLUNTEER",
+  other: "OTHER"
+};
+var SALARY_TIMEFRAME_TO_UNIT = {
+  per_year: "YEAR",
+  per_month: "MONTH",
+  per_week: "WEEK",
+  per_day: "DAY",
+  per_hour: "HOUR"
+};
+var ALL_COUNTRY_CODES = [
+  "AF",
+  "AX",
+  "AL",
+  "DZ",
+  "AS",
+  "AD",
+  "AO",
+  "AI",
+  "AQ",
+  "AG",
+  "AR",
+  "AM",
+  "AW",
+  "AU",
+  "AT",
+  "AZ",
+  "BS",
+  "BH",
+  "BD",
+  "BB",
+  "BY",
+  "BE",
+  "BZ",
+  "BJ",
+  "BM",
+  "BT",
+  "BO",
+  "BA",
+  "BW",
+  "BV",
+  "BR",
+  "IO",
+  "VG",
+  "BN",
+  "BG",
+  "BF",
+  "BI",
+  "KH",
+  "CM",
+  "CA",
+  "CV",
+  "BQ",
+  "KY",
+  "CF",
+  "TD",
+  "CL",
+  "CN",
+  "CX",
+  "CC",
+  "CO",
+  "KM",
+  "CK",
+  "CR",
+  "HR",
+  "CU",
+  "CW",
+  "CY",
+  "CZ",
+  "DK",
+  "DJ",
+  "DM",
+  "DO",
+  "CD",
+  "EC",
+  "EG",
+  "SV",
+  "GQ",
+  "ER",
+  "EE",
+  "SZ",
+  "ET",
+  "FK",
+  "FO",
+  "FJ",
+  "FI",
+  "FR",
+  "GF",
+  "PF",
+  "TF",
+  "GA",
+  "GM",
+  "GE",
+  "DE",
+  "GH",
+  "GI",
+  "GR",
+  "GL",
+  "GD",
+  "GP",
+  "GU",
+  "GT",
+  "GG",
+  "GN",
+  "GW",
+  "GY",
+  "HT",
+  "HM",
+  "HN",
+  "HK",
+  "HU",
+  "IS",
+  "IN",
+  "ID",
+  "IR",
+  "IQ",
+  "IE",
+  "IM",
+  "IL",
+  "IT",
+  "CI",
+  "JM",
+  "JP",
+  "JE",
+  "JO",
+  "KZ",
+  "KE",
+  "KI",
+  "XK",
+  "KW",
+  "KG",
+  "LA",
+  "LV",
+  "LB",
+  "LS",
+  "LR",
+  "LY",
+  "LI",
+  "LT",
+  "LU",
+  "MO",
+  "MG",
+  "MW",
+  "MY",
+  "MV",
+  "ML",
+  "MT",
+  "MH",
+  "MQ",
+  "MR",
+  "MU",
+  "YT",
+  "MX",
+  "FM",
+  "MD",
+  "MC",
+  "MN",
+  "ME",
+  "MS",
+  "MA",
+  "MZ",
+  "MM",
+  "NA",
+  "NR",
+  "NP",
+  "NL",
+  "NC",
+  "NZ",
+  "NI",
+  "NE",
+  "NG",
+  "NU",
+  "NF",
+  "MK",
+  "MP",
+  "NO",
+  "OM",
+  "PK",
+  "PW",
+  "PS",
+  "PA",
+  "PG",
+  "PY",
+  "PE",
+  "PH",
+  "PN",
+  "PL",
+  "PT",
+  "PR",
+  "QA",
+  "CG",
+  "RE",
+  "RO",
+  "RU",
+  "RW",
+  "BL",
+  "SH",
+  "KN",
+  "LC",
+  "MF",
+  "PM",
+  "VC",
+  "WS",
+  "SM",
+  "ST",
+  "SA",
+  "SN",
+  "RS",
+  "SC",
+  "SL",
+  "SG",
+  "SX",
+  "SK",
+  "SI",
+  "SB",
+  "SO",
+  "ZA",
+  "GS",
+  "KR",
+  "SS",
+  "ES",
+  "LK",
+  "SD",
+  "SR",
+  "SJ",
+  "SE",
+  "CH",
+  "SY",
+  "TW",
+  "TJ",
+  "TZ",
+  "TH",
+  "TL",
+  "TG",
+  "TK",
+  "TO",
+  "TT",
+  "TN",
+  "TR",
+  "TM",
+  "TC",
+  "TV",
+  "UG",
+  "UA",
+  "AE",
+  "GB",
+  "US",
+  "UM",
+  "VI",
+  "UY",
+  "UZ",
+  "VU",
+  "VA",
+  "VE",
+  "VN",
+  "WF",
+  "EH",
+  "YE",
+  "ZM",
+  "ZW"
+];
+function createJobPostingJsonLd({
+  job,
+  board,
+  shareUrl
+}) {
+  const educationRequirements = createEducationRequirements(job);
+  const experienceRequirements = createExperienceRequirements(job);
+  const jsonLd = pruneJsonLd({
+    "@context": "https://schema.org/",
+    "@type": "JobPosting",
+    title: job.title,
+    description: job.description ?? "",
+    identifier: createIdentifier(job, board),
+    datePosted: toIsoDate(job.publishedAt),
+    validThrough: toIsoDate(job.expiresAt),
+    employmentType: job.employmentType ? EMPLOYMENT_TYPE_TO_GOOGLE[job.employmentType] ?? "OTHER" : "OTHER",
+    hiringOrganization: createHiringOrganization(job, board),
+    jobLocation: createJobLocation(job),
+    jobLocationType: job.remoteOption === "remote" ? "TELECOMMUTE" : void 0,
+    applicantLocationRequirements: job.remoteOption === "remote" ? createApplicantLocationRequirements(job) : null,
+    baseSalary: createBaseSalary(job),
+    educationRequirements,
+    experienceRequirements,
+    experienceInPlaceOfEducation: job.experienceInPlaceOfEducation === true && educationRequirements && experienceRequirements ? true : void 0,
+    url: shareUrl
+  });
+  if (!jsonLd || Array.isArray(jsonLd) || Object.keys(jsonLd).length === 0) {
+    return null;
+  }
+  return jsonLd;
+}
+function createIdentifier(job, board) {
+  const organizationName = job.company?.name ?? board.name ?? null;
+  const identifier = { "@type": "PropertyValue", value: job.id };
+  if (organizationName) identifier.name = organizationName;
+  return identifier;
+}
+function createHiringOrganization(job, board) {
+  const name = job.company?.name ?? board.name ?? null;
+  if (!name) return null;
+  const organization = { "@type": "Organization", name };
+  const website = job.company?.website ?? null;
+  const normalizedWebsite = website ? normalizeWebsiteUrl(website) : null;
+  if (normalizedWebsite) organization.sameAs = normalizedWebsite;
+  const logo = job.company?.logoUrl ?? board.logoUrl ?? null;
+  if (logo) organization.logo = logo;
+  return organization;
+}
+function normalizeWebsiteUrl(website) {
+  const trimmed = website.trim();
+  if (!trimmed) return null;
+  return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+function createBaseSalary(job) {
+  const currency = job.salaryCurrency?.trim();
+  const hasMin = typeof job.salaryMin === "number";
+  const hasMax = typeof job.salaryMax === "number";
+  if (!currency || !hasMin && !hasMax) return null;
+  const value = { "@type": "QuantitativeValue" };
+  if (hasMin) value.minValue = job.salaryMin;
+  if (hasMax) value.maxValue = job.salaryMax;
+  const unitText = job.salaryTimeframe ? SALARY_TIMEFRAME_TO_UNIT[job.salaryTimeframe] : void 0;
+  if (unitText) value.unitText = unitText;
+  if (!hasMin && hasMax && typeof job.salaryMax === "number") {
+    value.value = job.salaryMax;
+    value.minValue = job.salaryMax;
+  } else if (!hasMax && hasMin && typeof job.salaryMin === "number") {
+    value.value = job.salaryMin;
+    value.maxValue = job.salaryMin;
+  }
+  return { "@type": "MonetaryAmount", currency: currency.toUpperCase(), value };
+}
+function createJobLocation(job) {
+  const places = job.officeLocations.map(
+    (office) => createPlaceJsonLd({
+      countryCode: office.countryCode,
+      region: office.region,
+      locality: office.city ?? office.locality,
+      postalCode: office.postalCode,
+      name: office.displayName
+    })
+  ).filter((place) => place !== null);
+  if (places.length === 0) return null;
+  return places.length === 1 ? places[0] : places;
+}
+function createPlaceJsonLd({
+  countryCode,
+  region,
+  locality,
+  postalCode,
+  name
+}) {
+  const address = { "@type": "PostalAddress" };
+  const country = countryCode?.trim();
+  const reg = region?.trim();
+  const loc = locality?.trim();
+  const postal = postalCode?.trim();
+  const placeName = name?.trim();
+  if (country) address.addressCountry = country.toUpperCase();
+  if (reg) address.addressRegion = reg;
+  if (loc) address.addressLocality = loc;
+  if (postal) address.postalCode = postal;
+  const hasAddressDetails = Object.keys(address).length > 1;
+  if (!hasAddressDetails && !placeName) return null;
+  const place = { "@type": "Place" };
+  if (placeName) place.name = placeName;
+  if (hasAddressDetails) place.address = address;
+  return place;
+}
+function createApplicantLocationRequirements(job) {
+  if (job.remoteWorldwide) {
+    return ALL_COUNTRY_CODES.map((code) => ({
+      "@type": "Country",
+      name: code
+    }));
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const code of job.remoteWorkPermitCountryCodes ?? []) {
+    const normalized = code?.trim().toUpperCase();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    entries.push({ "@type": "Country", name: normalized });
+  }
+  for (const subdivision of job.remoteWorkPermitSubdivisionCodes ?? []) {
+    const countryCode = subdivision?.split("-")[0]?.trim().toUpperCase();
+    if (!countryCode || seen.has(countryCode)) continue;
+    seen.add(countryCode);
+    entries.push({ "@type": "Country", name: countryCode });
+  }
+  if (entries.length === 0) return null;
+  return entries.length === 1 ? entries[0] : entries;
+}
+function createEducationRequirements(job) {
+  const requirements = job.educationRequirements;
+  if (!requirements || requirements.length === 0) return null;
+  if (requirements.includes("no_requirements")) return "no requirements";
+  const credentials = requirements.filter((value) => value in EDUCATION_TO_CREDENTIAL).map((value) => ({
+    "@type": "EducationalOccupationalCredential",
+    credentialCategory: EDUCATION_TO_CREDENTIAL[value]
+  }));
+  return credentials.length > 0 ? credentials : null;
+}
+function createExperienceRequirements(job) {
+  const months = job.experienceMonths;
+  if (typeof months !== "number") return null;
+  if (months === 0) return "no requirements";
+  return {
+    "@type": "OccupationalExperienceRequirements",
+    monthsOfExperience: months
+  };
+}
+function toIsoDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  return date.toISOString();
+}
+function pruneJsonLd(value) {
+  const keep = (entry) => {
+    if (entry == null) return false;
+    if (Array.isArray(entry)) return entry.length > 0;
+    if (typeof entry === "object")
+      return Object.keys(entry).length > 0;
+    return true;
+  };
+  if (Array.isArray(value)) {
+    return value.map((entry) => pruneJsonLd(entry)).filter(keep);
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).map(([key, entry]) => [key, pruneJsonLd(entry)]).filter(([, entry]) => keep(entry));
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+
+// src/seo/breadcrumbs.ts
+function createBreadcrumbJsonLd(items, options = {}) {
+  const normalizedItems = items.map((item) => {
+    const name = item.label?.trim();
+    return name ? {
+      name,
+      href: item.href?.trim() ?? null
+    } : null;
+  }).filter((item) => !!item);
+  if (normalizedItems.length < 2) {
+    return null;
+  }
+  const listItems = normalizedItems.map((item, index) => {
+    const resolvedHref = item.href ? resolveBreadcrumbHref(item.href, options.origin ?? null) : null;
+    const listItem = {
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.name
+    };
+    if (resolvedHref) {
+      listItem.item = resolvedHref;
+    }
+    return listItem;
+  });
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: listItems
+  };
+}
+function resolveBreadcrumbHref(href, origin) {
+  if (isAbsoluteUrl(href)) {
+    return href;
+  }
+  if (!origin) {
+    return null;
+  }
+  const normalizedPath = href.startsWith("/") ? href : `/${href}`;
+  return `${origin}${normalizedPath}`;
+}
+function isAbsoluteUrl(href) {
+  return /^https?:\/\//i.test(href);
+}
+function buildJobBreadcrumbs(job) {
+  const crumbs = [
+    { kind: "home", path: BOARD_PATHS.home },
+    { kind: "jobs", path: BOARD_PATHS.jobs }
+  ];
+  let lastPlaceSlug = null;
+  for (const place of job.placeHierarchy) {
+    lastPlaceSlug = place.slug;
+    crumbs.push({
+      kind: "place",
+      name: place.name,
+      path: jobsLocationPath(place.slug)
+    });
+  }
+  const primaryCategory = job.categories[0];
+  if (primaryCategory) {
+    crumbs.push({
+      kind: "category",
+      name: primaryCategory.name,
+      path: lastPlaceSlug ? jobsLocationCategoryPath(lastPlaceSlug, primaryCategory.slug) : jobsCategoryPath(primaryCategory.slug)
+    });
+  }
+  crumbs.push({ kind: "job", name: job.title });
+  return crumbs;
+}
+
+export {
+  normalizeLocale,
+  formatSalaryStat,
+  formatSalaryStatRange,
+  SENIORITY_ORDER,
+  sortBySeniority,
+  buildSalaryFaq,
+  itemListJsonLd,
+  faqJsonLd,
+  titleSalaryJsonLd,
+  skillSalaryJsonLd,
+  locationSalaryJsonLd,
+  crossAxisSalaryJsonLd,
+  companySalaryJsonLd,
+  companyCategorySalaryJsonLd,
+  ALL_COUNTRY_CODES,
+  createJobPostingJsonLd,
+  normalizeWebsiteUrl,
+  createBreadcrumbJsonLd,
+  buildJobBreadcrumbs
+};