@cavuno/board 1.41.0 → 1.43.0

package/dist/well-known.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/well-known/index.ts
+var well_known_exports = {};
+__export(well_known_exports, {
+  WELL_KNOWN_CACHE_CONTROL: () => WELL_KNOWN_CACHE_CONTROL,
+  WELL_KNOWN_CONTENT_TYPE: () => WELL_KNOWN_CONTENT_TYPE,
+  WELL_KNOWN_MANIFEST_PATH: () => WELL_KNOWN_MANIFEST_PATH,
+  createWellKnownHandler: () => createWellKnownHandler,
+  emitWellKnownManifest: () => emitWellKnownManifest,
+  routeEntriesFromTanStackRouteTree: () => routeEntriesFromTanStackRouteTree,
+  serializeManifest: () => serializeManifest,
+  tanStackPathToUrlPattern: () => tanStackPathToUrlPattern
+});
+module.exports = __toCommonJS(well_known_exports);
+
+// src/paths/index.ts
+function jobDetailPath(companySlug, jobSlug) {
+  return `/companies/${companySlug}/jobs/${jobSlug}`;
+}
+function jobsCategoryPath(categorySlug) {
+  return `/jobs/${categorySlug}`;
+}
+function jobsSkillPath(skillSlug) {
+  return `/jobs/skills/${skillSlug}`;
+}
+function jobsLocationPath(placeSlug) {
+  return `/jobs/locations/${placeSlug}`;
+}
+function companyPath(companySlug) {
+  return `/companies/${companySlug}`;
+}
+function companyMarketPath(marketSlug) {
+  return `/companies/markets/${marketSlug}`;
+}
+function companySalaryPath(companySlug) {
+  return `/companies/${companySlug}/salaries`;
+}
+function salaryTitlePath(titleSlug) {
+  return `/salaries/titles/${titleSlug}`;
+}
+function salarySkillPath(skillSlug) {
+  return `/salaries/skills/${skillSlug}`;
+}
+function salaryLocationPath(placeSlug) {
+  return `/salaries/locations/${placeSlug}`;
+}
+function blogPostPath(postSlug) {
+  return `/blog/${postSlug}`;
+}
+function blogTagPath(tagSlug) {
+  return `/blog/tag/${tagSlug}`;
+}
+function blogAuthorPath(authorSlug) {
+  return `/blog/author/${authorSlug}`;
+}
+var BOARD_PATHS = {
+  home: "/",
+  jobs: "/jobs",
+  companies: "/companies",
+  salaries: "/salaries",
+  salaryCompanies: "/salaries/companies",
+  salaryTitles: "/salaries/titles",
+  salarySkills: "/salaries/skills",
+  salaryLocations: "/salaries/locations",
+  blog: "/blog",
+  about: "/about",
+  privacyPolicy: "/privacy-policy",
+  termsOfService: "/terms-of-service",
+  cookiePolicy: "/cookie-policy",
+  impressum: "/impressum",
+  talent: "/talent",
+  employers: "/employers",
+  /**
+   * Alert-email surfaces (ADR-0090 D1/D4). Promoted out of raw literals in
+   * the job-alerts composer so /go indirection and email composition share
+   * one definition.
+   */
+  alertsManage: "/alerts/manage",
+  alertsConfirm: "/alerts/confirm"
+};
+
+// src/route-contract/roles.ts
+var ROLE_PARAM_REGISTRY = {
+  jobDetail: ["companySlug", "jobSlug"],
+  jobsCategory: ["categorySlug"],
+  jobsSkill: ["skillSlug"],
+  jobsLocation: ["placeSlug"],
+  company: ["companySlug"],
+  companyMarket: ["marketSlug"],
+  companySalary: ["companySlug"],
+  salaryTitle: ["titleSlug"],
+  salarySkill: ["skillSlug"],
+  salaryLocation: ["placeSlug"],
+  blogPost: ["postSlug"],
+  blogTag: ["tagSlug"],
+  blogAuthor: ["authorSlug"],
+  home: [],
+  jobs: [],
+  companies: [],
+  salaries: [],
+  salaryCompanies: [],
+  salaryTitles: [],
+  salarySkills: [],
+  salaryLocations: [],
+  blog: [],
+  about: [],
+  privacyPolicy: [],
+  termsOfService: [],
+  cookiePolicy: [],
+  impressum: [],
+  talent: [],
+  employers: [],
+  alertsManage: [],
+  alertsConfirm: []
+};
+var REQUIRED_ROLES = [
+  "jobDetail",
+  "alertsManage",
+  "alertsConfirm"
+];
+var ALL_ROLES = Object.keys(
+  ROLE_PARAM_REGISTRY
+);
+var ROLE_SET = new Set(ALL_ROLES);
+var CANONICAL_MANIFEST = {
+  version: 1,
+  roles: {
+    jobDetail: jobDetailPath(":companySlug", ":jobSlug"),
+    jobsCategory: jobsCategoryPath(":categorySlug"),
+    jobsSkill: jobsSkillPath(":skillSlug"),
+    jobsLocation: jobsLocationPath(":placeSlug"),
+    company: companyPath(":companySlug"),
+    companyMarket: companyMarketPath(":marketSlug"),
+    companySalary: companySalaryPath(":companySlug"),
+    salaryTitle: salaryTitlePath(":titleSlug"),
+    salarySkill: salarySkillPath(":skillSlug"),
+    salaryLocation: salaryLocationPath(":placeSlug"),
+    blogPost: blogPostPath(":postSlug"),
+    blogTag: blogTagPath(":tagSlug"),
+    blogAuthor: blogAuthorPath(":authorSlug"),
+    home: BOARD_PATHS.home,
+    jobs: BOARD_PATHS.jobs,
+    companies: BOARD_PATHS.companies,
+    salaries: BOARD_PATHS.salaries,
+    salaryCompanies: BOARD_PATHS.salaryCompanies,
+    salaryTitles: BOARD_PATHS.salaryTitles,
+    salarySkills: BOARD_PATHS.salarySkills,
+    salaryLocations: BOARD_PATHS.salaryLocations,
+    blog: BOARD_PATHS.blog,
+    about: BOARD_PATHS.about,
+    privacyPolicy: BOARD_PATHS.privacyPolicy,
+    termsOfService: BOARD_PATHS.termsOfService,
+    cookiePolicy: BOARD_PATHS.cookiePolicy,
+    impressum: BOARD_PATHS.impressum,
+    talent: BOARD_PATHS.talent,
+    employers: BOARD_PATHS.employers,
+    alertsManage: "/alerts/manage",
+    alertsConfirm: "/alerts/confirm"
+  }
+};
+
+// src/route-contract/params.ts
+function extractParamNames(template) {
+  const names = [];
+  const re = /:([A-Za-z_][A-Za-z0-9_]*)/g;
+  let match;
+  while ((match = re.exec(template)) !== null) {
+    const name = match[1];
+    if (name !== void 0) names.push(name);
+  }
+  return names;
+}
+function sameParamSet(a, b) {
+  if (a.length !== b.length) return false;
+  const sortedA = [...a].sort();
+  const sortedB = [...b].sort();
+  for (let i = 0; i < sortedA.length; i++) {
+    if (sortedA[i] !== sortedB[i]) return false;
+  }
+  return true;
+}
+function paramSetKey(params) {
+  return [...params].sort().join("\0");
+}
+
+// src/route-contract/classify.ts
+var SHARED_SIGNATURE_COUNTS = (() => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const role of ALL_ROLES) {
+    const params = ROLE_PARAM_REGISTRY[role];
+    if (params.length === 0) continue;
+    const key = paramSetKey(params);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+})();
+function isSignatureCandidate(route, role) {
+  const registry = ROLE_PARAM_REGISTRY[role];
+  const routeParams = extractParamNames(route.template);
+  if (registry.length === 0) {
+    return route.template === CANONICAL_MANIFEST.roles[role];
+  }
+  if (!sameParamSet(routeParams, registry)) return false;
+  const shareCount = SHARED_SIGNATURE_COUNTS.get(paramSetKey(registry)) ?? 0;
+  if (shareCount > 1) {
+    return route.template === CANONICAL_MANIFEST.roles[role];
+  }
+  return true;
+}
+function classifyRoutes(routes, markers) {
+  const assignments = {};
+  const ambiguities = [];
+  const claimed = /* @__PURE__ */ new Set();
+  if (markers && markers.size > 0) {
+    const claimsByRole = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      if (route.sourcePath === void 0) continue;
+      const role = markers.get(route.sourcePath);
+      if (role === void 0) continue;
+      const list = claimsByRole.get(role);
+      if (list) list.push(route);
+      else claimsByRole.set(role, [route]);
+    }
+    for (const [role, candidates] of claimsByRole) {
+      for (const c of candidates) claimed.add(c);
+      if (candidates.length === 1) {
+        assignments[role] = candidates[0];
+      } else {
+        ambiguities.push({ role, candidates: [...candidates] });
+      }
+    }
+  }
+  const pool = routes.filter((r) => !claimed.has(r));
+  for (const role of ALL_ROLES) {
+    if (assignments[role] !== void 0) continue;
+    if (ambiguities.some((a) => a.role === role)) continue;
+    const candidates = pool.filter((r) => isSignatureCandidate(r, role));
+    if (candidates.length === 0) continue;
+    if (candidates.length === 1) {
+      const only = candidates[0];
+      if (claimed.has(only)) {
+        continue;
+      }
+      assignments[role] = only;
+      claimed.add(only);
+      continue;
+    }
+    ambiguities.push({ role, candidates: [...candidates] });
+  }
+  const missingRequired = REQUIRED_ROLES.filter(
+    (role) => assignments[role] === void 0
+  );
+  return { assignments, ambiguities, missingRequired };
+}
+
+// src/route-contract/validate.ts
+var TEMPLATE_CHARSET_RE = /^[A-Za-z0-9/_.:-]+$/;
+function checkRoleTemplate(role, template) {
+  const errors = [];
+  if (typeof template !== "string" || template.length === 0) {
+    errors.push({
+      code: "invalid_template",
+      message: `role '${role}' template must be a non-empty string`,
+      role
+    });
+    return errors;
+  }
+  if (!template.startsWith("/")) {
+    errors.push({
+      code: "invalid_template",
+      message: `role '${role}' template must start with '/', got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  if (/\s/.test(template)) {
+    errors.push({
+      code: "invalid_template",
+      message: `role '${role}' template must not contain whitespace, got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  if (template.includes("?") || template.includes("#")) {
+    errors.push({
+      code: "template_query_or_fragment",
+      message: `role '${role}' template must not contain '?' or '#', got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  if (template.startsWith("//") || template.includes("//")) {
+    errors.push({
+      code: "template_double_slash",
+      message: `role '${role}' template must not contain '//', got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  for (const seg of template.split("/")) {
+    if (seg === "." || seg === "..") {
+      errors.push({
+        code: "template_dot_segment",
+        message: `role '${role}' template must not contain '.' or '..' segments, got ${JSON.stringify(template)}`,
+        role
+      });
+      return errors;
+    }
+  }
+  if (!TEMPLATE_CHARSET_RE.test(template)) {
+    errors.push({
+      code: "template_illegal_charset",
+      message: `role '${role}' template contains illegal characters, got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  const registry = ROLE_PARAM_REGISTRY[role];
+  const tokens = extractParamNames(template);
+  if (registry.length === 0) {
+    if (tokens.length > 0) {
+      errors.push({
+        code: "static_has_params",
+        message: `static role '${role}' template must not contain ':' tokens, got ${template}`,
+        role,
+        token: tokens[0]
+      });
+    }
+  } else {
+    const registrySet = new Set(registry);
+    for (const token of tokens) {
+      if (!registrySet.has(token)) {
+        errors.push({
+          code: "unregistered_param",
+          message: `role '${role}' template references unregistered param ':${token}'`,
+          role,
+          token
+        });
+      }
+    }
+    const retained = tokens.filter((t) => registrySet.has(t));
+    if (retained.length === 0) {
+      errors.push({
+        code: "missing_entity_param",
+        message: `role '${role}' template must contain at least one registry param (${registry.join(", ")})`,
+        role
+      });
+    }
+  }
+  return errors;
+}
+
+// src/route-contract/compile.ts
+var REQUIRED_SET = new Set(REQUIRED_ROLES);
+function compileManifest(routes, markers) {
+  const { assignments, ambiguities, missingRequired } = classifyRoutes(
+    routes,
+    markers
+  );
+  const roles = {};
+  const warnings = [];
+  const blocking = new Set(missingRequired);
+  for (const role of ALL_ROLES) {
+    const entry = assignments[role];
+    if (entry === void 0) continue;
+    const templateErrors = checkRoleTemplate(role, entry.template);
+    if (templateErrors.length > 0) {
+      const exact = templateErrors.map((e) => e.message).join("; ");
+      warnings.push(
+        `role '${role}' template rejected: ${exact} \u2014 add export const cavunoPage = '${role}' on the correct page or fix the template`
+      );
+      if (REQUIRED_SET.has(role)) {
+        blocking.add(role);
+      }
+      continue;
+    }
+    roles[role] = entry.template;
+  }
+  for (const amb of ambiguities) {
+    const kind = REQUIRED_SET.has(amb.role) ? "required" : "optional";
+    warnings.push(
+      `${kind} role '${amb.role}' is ambiguous \u2014 add export const cavunoPage = '${amb.role}' to disambiguate`
+    );
+  }
+  for (const role of ALL_ROLES) {
+    if (REQUIRED_SET.has(role)) continue;
+    if (roles[role] !== void 0) continue;
+    if (assignments[role] !== void 0) continue;
+    if (ambiguities.some((a) => a.role === role)) continue;
+    warnings.push(`optional role '${role}' is unassigned`);
+  }
+  return {
+    manifest: { version: 1, roles },
+    blockingMissing: REQUIRED_ROLES.filter((r) => blocking.has(r)),
+    warnings,
+    ambiguities
+  };
+}
+
+// src/route-contract/resolve-links.ts
+var REQUIRED_SET2 = new Set(REQUIRED_ROLES);
+
+// src/route-contract/match-history.ts
+var ROLE_INDEX_PATHS = {
+  jobDetail: BOARD_PATHS.jobs,
+  jobsCategory: BOARD_PATHS.jobs,
+  jobsSkill: BOARD_PATHS.jobs,
+  jobsLocation: BOARD_PATHS.jobs,
+  company: BOARD_PATHS.companies,
+  companyMarket: BOARD_PATHS.companies,
+  companySalary: BOARD_PATHS.companies,
+  salaryTitle: BOARD_PATHS.salaries,
+  salarySkill: BOARD_PATHS.salaries,
+  salaryLocation: BOARD_PATHS.salaries,
+  salaryCompanies: BOARD_PATHS.salaries,
+  salaryTitles: BOARD_PATHS.salaries,
+  salarySkills: BOARD_PATHS.salaries,
+  salaryLocations: BOARD_PATHS.salaries,
+  salaries: BOARD_PATHS.salaries,
+  blogPost: BOARD_PATHS.blog,
+  blogTag: BOARD_PATHS.blog,
+  blogAuthor: BOARD_PATHS.blog,
+  blog: BOARD_PATHS.blog,
+  home: BOARD_PATHS.home,
+  jobs: BOARD_PATHS.jobs,
+  companies: BOARD_PATHS.companies,
+  about: BOARD_PATHS.about,
+  privacyPolicy: BOARD_PATHS.privacyPolicy,
+  termsOfService: BOARD_PATHS.termsOfService,
+  cookiePolicy: BOARD_PATHS.cookiePolicy,
+  impressum: BOARD_PATHS.impressum,
+  talent: BOARD_PATHS.talent,
+  employers: BOARD_PATHS.employers,
+  alertsManage: BOARD_PATHS.home,
+  alertsConfirm: BOARD_PATHS.home
+};
+
+// src/well-known/handler.ts
+var WELL_KNOWN_CACHE_CONTROL = "public, max-age=300";
+var WELL_KNOWN_CONTENT_TYPE = "application/json";
+function createWellKnownHandler(config) {
+  return async (_request) => {
+    try {
+      const routes = await resolveRoutes(config.routes);
+      const { manifest } = compileManifest(routes, config.markers);
+      const body = serializeManifest(manifest);
+      return new Response(body, {
+        status: 200,
+        headers: {
+          "content-type": WELL_KNOWN_CONTENT_TYPE,
+          "cache-control": WELL_KNOWN_CACHE_CONTROL
+        }
+      });
+    } catch {
+      return new Response("", { status: 500 });
+    }
+  };
+}
+async function resolveRoutes(routes) {
+  if (typeof routes === "function") {
+    return await routes();
+  }
+  return routes;
+}
+function serializeManifest(manifest) {
+  return JSON.stringify(manifest);
+}
+
+// src/well-known/emit.ts
+var WELL_KNOWN_MANIFEST_PATH = ".well-known/cavuno.json";
+function emitWellKnownManifest(config) {
+  const { manifest } = compileManifest(config.routes, config.markers);
+  const contents = serializeManifest(manifest);
+  return { path: WELL_KNOWN_MANIFEST_PATH, contents };
+}
+
+// src/well-known/tanstack.ts
+function routeEntriesFromTanStackRouteTree(routeTree) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node, isRoot) {
+    if (!isTechnicalNode(node, isRoot)) {
+      const template = templateFromNode(node);
+      if (template !== null && !seen.has(template)) {
+        seen.add(template);
+        out.push({ template });
+      }
+    }
+    for (const child of childrenOf(node)) {
+      visit(child, false);
+    }
+  }
+  visit(routeTree, true);
+  return out;
+}
+function childrenOf(node) {
+  const kids = node.children;
+  if (kids === void 0 || kids === null) return [];
+  if (Array.isArray(kids)) return kids;
+  return Object.values(kids);
+}
+function isTechnicalNode(node, isRoot) {
+  if (isRoot) return true;
+  const id = node.id ?? "";
+  if (id === "__root__" || id === "root") return true;
+  const path = node.path ?? "";
+  if (path === "" && !node.fullPath) return true;
+  if (hasUnderscoreSegment(path) || hasUnderscoreSegment(id)) {
+    const full = node.fullPath ?? "";
+    if (full === "" || hasUnderscoreSegment(full)) return true;
+  }
+  return false;
+}
+function hasUnderscoreSegment(value) {
+  if (!value) return false;
+  return value.split("/").some((seg) => seg.startsWith("_") && seg.length > 1);
+}
+function templateFromNode(node) {
+  const raw = typeof node.fullPath === "string" && node.fullPath.length > 0 ? node.fullPath : typeof node.path === "string" && node.path.length > 0 ? node.path.startsWith("/") ? node.path : `/${node.path}` : null;
+  if (raw === null) return null;
+  if (hasUnderscoreSegment(raw)) return null;
+  return tanStackPathToUrlPattern(raw);
+}
+function tanStackPathToUrlPattern(path) {
+  if (path === "/" || path === "") return "/";
+  const segments = path.split("/");
+  const converted = segments.map((seg) => {
+    if (seg === "") return seg;
+    if (seg === "$") return "*";
+    if (seg.startsWith("$") && seg.endsWith("?")) {
+      return `:${seg.slice(1, -1)}`;
+    }
+    if (seg.startsWith("$")) return `:${seg.slice(1)}`;
+    return seg;
+  });
+  let result = converted.join("/");
+  result = result.replace(/\/{2,}/g, "/");
+  if (!result.startsWith("/")) result = `/${result}`;
+  if (result.length > 1 && result.endsWith("/")) {
+    result = result.slice(0, -1);
+  }
+  return result;
+}