@cavuno/board 3.1.0 → 3.2.0

package/dist/chunk-2ETP5UH4.mjs

@@ -0,0 +1,271 @@
+// src/errors.ts
+var BOARD_API_ERROR_CODES = [
+  // Cross-cutting envelope
+  "internal_error",
+  "validation_bad_request",
+  "validation_payload_too_large",
+  "rate_limited",
+  "rate_limit_unavailable",
+  "search_unavailable",
+  "too_many_filter_values",
+  "pagination_invalid_cursor",
+  "pagination_offset_too_large",
+  "auth_unauthenticated",
+  "auth_forbidden",
+  "plan_upgrade_required",
+  "unknown_error",
+  // Board resolution + custom pages
+  "boards_not_found",
+  "board_page_not_found",
+  // Board-user auth
+  "board_auth_email_taken",
+  "board_auth_invalid_credentials",
+  "board_auth_invalid_token",
+  "board_auth_registration_disabled",
+  "board_auth_token_expired",
+  // Board password gate
+  "board_password_required",
+  "board_password_invalid",
+  // Jobs browse
+  "jobs_not_found",
+  "jobs_invalid_filter",
+  // Taxonomy
+  "categories_not_found",
+  "skills_not_found",
+  "places_not_found",
+  // Companies (public reads)
+  "companies_not_found",
+  "company_markets_not_found",
+  "company_salary_not_found",
+  "company_category_salary_not_found",
+  // Salaries
+  "salaries_title_not_found",
+  "salaries_skill_not_found",
+  "salaries_location_not_found",
+  "salaries_title_location_not_found",
+  "salaries_skill_location_not_found",
+  // Blog (public reads)
+  "blog_post_not_found",
+  "blog_author_not_found",
+  "blog_tag_not_found",
+  // Talent directory
+  "talent_not_found",
+  "talent_directory_not_found",
+  "talent_directory_restricted",
+  // Job alerts (anonymous + authenticated)
+  "job_alert_not_found",
+  "job_alerts_disabled",
+  "candidate_alert_limit_reached",
+  "candidate_alert_not_found",
+  // Candidate account
+  "candidate_entry_not_found",
+  "candidate_handle_taken",
+  "candidate_job_not_found",
+  "resume_invalid_file",
+  "resume_upload_forbidden",
+  // Applications
+  "applications_external_apply_only",
+  "applications_guest_not_allowed",
+  "applications_job_not_found",
+  "applications_not_found",
+  "applications_resume_invalid_file",
+  "applications_unprocessable",
+  // Messaging
+  "messaging_application_not_found",
+  "messaging_application_not_linked",
+  "messaging_blocked",
+  "messaging_cannot_block_self",
+  "messaging_cold_rule",
+  "messaging_conversation_not_found",
+  "messaging_disabled",
+  "messaging_edit_window_expired",
+  "messaging_message_deleted",
+  "messaging_message_not_found",
+  "messaging_not_author",
+  "messaging_not_participant",
+  "messaging_not_permitted",
+  "messaging_not_recipient",
+  "messaging_rate_limited",
+  "messaging_recipient_not_found",
+  "messaging_recipient_not_open",
+  "messaging_unsend_window_expired",
+  // Employer self-service
+  "employer_applicant_not_found",
+  "employer_ats_unprocessable",
+  "employer_checkout_failed",
+  "employer_company_exists",
+  "employer_company_name_taken",
+  "employer_company_not_found",
+  "employer_job_not_found",
+  "employer_job_slug_taken",
+  "employer_jobs_quota_exceeded",
+  "employer_not_member",
+  "employer_payment_required",
+  "employer_pipeline_stage_not_found",
+  // Candidate job-access paywall
+  "paywall_already_active",
+  "paywall_disabled",
+  "paywall_invalid_checkout_session",
+  "paywall_no_candidate_profile",
+  "paywall_no_recurring_subscription",
+  "paywall_offer_not_found",
+  // Public job posting
+  "job_posting_logo_lookup_unavailable",
+  "job_posting_logo_not_found",
+  "job_posting_rejected"
+];
+var BoardApiError = class extends Error {
+  status;
+  /** `<domain>_<snake_reason>` code from the v1 error envelope. */
+  code;
+  /** Structured, per-code details — shape varies by `code`. */
+  details;
+  requestId;
+  /** The parsed response body, untouched. */
+  raw;
+  constructor(input) {
+    super(input.message);
+    this.name = "BoardApiError";
+    this.status = input.status;
+    this.code = input.code;
+    this.details = input.details;
+    this.requestId = input.requestId;
+    this.raw = input.raw;
+  }
+};
+function isBoardApiError(e) {
+  return e instanceof Error && e.name === "BoardApiError" && typeof e.status === "number" && typeof e.code === "string";
+}
+function isNotFound(e) {
+  return isBoardApiError(e) && e.status === 404;
+}
+function isUnauthorized(e) {
+  return isBoardApiError(e) && e.status === 401;
+}
+function isBoardPasswordRequired(e) {
+  return isBoardApiError(e) && e.status === 401 && e.code === "board_password_required";
+}
+function isForbidden(e) {
+  return isBoardApiError(e) && e.status === 403;
+}
+function isValidationError(e) {
+  return isBoardApiError(e) && e.status === 400 && e.code === "validation_bad_request";
+}
+function isRateLimited(e) {
+  return isBoardApiError(e) && e.status === 429;
+}
+function isConflict(e) {
+  return isBoardApiError(e) && e.status === 409;
+}
+
+// src/scope.ts
+function scopeToken(board) {
+  let hash = 5381;
+  for (let i = 0; i < board.length; i++) {
+    hash = (hash << 5) + hash + board.charCodeAt(i) >>> 0;
+  }
+  const sanitized = board.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `${sanitized}-${hash.toString(36)}`;
+}
+
+// src/storage.ts
+var ACCESS_TOKEN_KEY = "cavuno_board_access_token";
+var REFRESH_TOKEN_KEY = "cavuno_board_refresh_token";
+var BOARD_ACCESS_GRANT_KEY = "cavuno_board_access_grant";
+function isBrowser() {
+  return typeof globalThis.document !== "undefined";
+}
+function memoryStorage() {
+  const backing = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => backing.get(key) ?? null,
+    setItem: (key, value) => {
+      backing.set(key, value);
+    },
+    removeItem: (key) => {
+      backing.delete(key);
+    }
+  };
+}
+function browserStorage(mode, scope) {
+  if (!isBrowser()) {
+    throw new Error(
+      `storage mode '${mode}' is browser-only \u2014 use 'nostore' + per-call headers on the server`
+    );
+  }
+  let backing;
+  try {
+    backing = mode === "local" ? globalThis.localStorage : globalThis.sessionStorage;
+    if (!backing) throw new Error("unavailable");
+  } catch {
+    throw new Error(
+      `storage mode '${mode}' is unavailable in this browsing context (storage access is blocked \u2014 e.g. a sandboxed or third-party iframe). Use 'memory', or 'nostore' + per-call headers.`
+    );
+  }
+  const suffix = scope ? `:${scopeToken(scope)}` : "";
+  return {
+    getItem: (key) => backing.getItem(`${key}${suffix}`),
+    setItem: (key, value) => {
+      backing.setItem(`${key}${suffix}`, value);
+    },
+    removeItem: (key) => {
+      backing.removeItem(`${key}${suffix}`);
+    }
+  };
+}
+var NOSTORE_BRAND = /* @__PURE__ */ Symbol.for("@cavuno/board:nostore");
+function isNoStore(storage) {
+  return storage[NOSTORE_BRAND] === true;
+}
+var NOSTORE = {
+  [NOSTORE_BRAND]: true,
+  getItem: () => null,
+  setItem: () => {
+  },
+  removeItem: () => {
+  }
+};
+function resolveStorage(mode, scope) {
+  const resolved = mode ?? (isBrowser() ? "memory" : "nostore");
+  if (typeof resolved === "object") return resolved;
+  switch (resolved) {
+    case "memory":
+      return memoryStorage();
+    case "nostore":
+      return NOSTORE;
+    case "local":
+    case "session":
+      return browserStorage(resolved, scope);
+    default:
+      throw new Error(`Unknown storage mode '${String(resolved)}'`);
+  }
+}
+async function writeSession(storage, session) {
+  await storage.setItem(ACCESS_TOKEN_KEY, session.accessToken);
+  await storage.setItem(REFRESH_TOKEN_KEY, session.refreshToken);
+}
+async function clearSession(storage) {
+  await storage.removeItem(ACCESS_TOKEN_KEY);
+  await storage.removeItem(REFRESH_TOKEN_KEY);
+}
+
+export {
+  BOARD_API_ERROR_CODES,
+  BoardApiError,
+  isBoardApiError,
+  isNotFound,
+  isUnauthorized,
+  isBoardPasswordRequired,
+  isForbidden,
+  isValidationError,
+  isRateLimited,
+  isConflict,
+  scopeToken,
+  ACCESS_TOKEN_KEY,
+  REFRESH_TOKEN_KEY,
+  BOARD_ACCESS_GRANT_KEY,
+  isNoStore,
+  resolveStorage,
+  writeSession,
+  clearSession
+};

package/dist/chunk-DLSO6XXY.mjs

@@ -0,0 +1,33 @@
+// src/pagination.ts
+function paginate(listFn, query, options) {
+  async function* pages() {
+    let current = query;
+    for (; ; ) {
+      const page = await listFn(current, options);
+      yield page;
+      if (!page.hasMore || page.nextCursor === null) return;
+      const { offset: _offset, ...rest } = current ?? {};
+      current = { ...rest, cursor: page.nextCursor };
+    }
+  }
+  return {
+    pages,
+    async *[Symbol.asyncIterator]() {
+      for await (const page of pages()) {
+        yield* page.data;
+      }
+    },
+    async toArray({ limit }) {
+      const items = [];
+      for await (const page of pages()) {
+        items.push(...page.data);
+        if (items.length >= limit) break;
+      }
+      return items.slice(0, limit);
+    }
+  };
+}
+
+export {
+  paginate
+};