@alexisapp/leave-core 0.0.1-beta.1

package/dist/hooks/index.d.ts

@@ -0,0 +1,50 @@
+import { D as DisplayStatus } from '../leaveStatusUtils-C26heVdh.js';
+
+/**
+ * Resolves the current user's employeeId from the Gateway `me` query.
+ */
+declare function useCurrentEmployeeId(): string;
+
+interface LeaveListItem {
+    id: string;
+    typeName: string;
+    displayStatus: DisplayStatus;
+    localStartDate: string;
+    localEndDate: string | null;
+}
+/**
+ * Fetches and merges all leave data sources into a unified list
+ * split into upcoming and history sections.
+ *
+ * Resolves the current employee internally — no args needed.
+ *
+ * Data sources:
+ * 1. Standard leaves (HR Core) — has type.name directly
+ * 2. Self-certified leaves (Gateway) — needs typeId→typeName join
+ * 3. Leave changes (Gateway) — for status overrides (pending change/revoke)
+ * 4. Employee leave types (HR Core) — provides typeId→typeName mapping
+ */
+declare function useLeaveList(): {
+    upcoming: LeaveListItem[];
+    history: LeaveListItem[];
+};
+
+interface BalanceData {
+    remaining: number;
+    spent: number;
+    saved: number | null;
+    unpaid: number | null;
+}
+/**
+ * Fetches the current employee's vacation balance and policy,
+ * returning normalized tile values.
+ *
+ * Returns `null` when no balance data exists.
+ *
+ * Norwegian policies (`includeUnusedDaysInNewBalance`) use
+ * `balanceAmountPlusUnpaidLeft` for remaining and omit saved/unpaid
+ * (returned as `null`).
+ */
+declare function useBalance(): BalanceData | null;
+
+export { type BalanceData, type LeaveListItem, useBalance, useCurrentEmployeeId, useLeaveList };

package/dist/hooks/index.mjs

@@ -0,0 +1,106 @@
+import {
+  getLocalToday,
+  isDefined,
+  resolveDisplayStatus,
+  splitLeaveSections
+} from "../chunk-R7NHFDIU.mjs";
+import {
+  leaveQueries,
+  policyQueries,
+  userQueries
+} from "../chunk-P5WZALLT.mjs";
+import "../chunk-TUQKZ7GW.mjs";
+
+// src/hooks/useCurrentEmployeeId.ts
+import { useSuspenseQuery } from "@tanstack/react-query";
+function useCurrentEmployeeId() {
+  const { data } = useSuspenseQuery(userQueries.me());
+  const employeeId = data.me.membership?.employeeId;
+  if (!employeeId) {
+    throw new Error("Current user has no employeeId");
+  }
+  return employeeId;
+}
+
+// src/hooks/useLeaveList.ts
+import { useSuspenseQuery as useSuspenseQuery2 } from "@tanstack/react-query";
+import { useMemo } from "react";
+function useLeaveList() {
+  const employeeId = useCurrentEmployeeId();
+  const { data: standardData } = useSuspenseQuery2(leaveQueries.listVisible());
+  const { data: selfCertifiedData } = useSuspenseQuery2(leaveQueries.selfCertifiedListVisible());
+  const { data: changesData } = useSuspenseQuery2(
+    leaveQueries.approvalQueue({ filters: { status: { eq: "PENDING" } } })
+  );
+  const { data: leaveTypesData } = useSuspenseQuery2(policyQueries.employeeLeaveTypes(employeeId));
+  return useMemo(() => {
+    const typeMap = /* @__PURE__ */ new Map();
+    for (const lt of leaveTypesData.employeeLeaveTypeList) {
+      if (lt?.id) {
+        typeMap.set(lt.id, lt.name);
+      }
+    }
+    const changeMap = /* @__PURE__ */ new Map();
+    for (const change of changesData.leaveChangeList.data) {
+      const changeType = change.type;
+      if (changeType === "UPDATE" || changeType === "REVOKE") {
+        for (const leaveId of change.leaveIds) {
+          changeMap.set(leaveId, changeType);
+        }
+      }
+    }
+    const standardItems = standardData.leaveListVisible.filter(isDefined).map((item) => ({
+      id: item.id ?? "",
+      typeName: item.type.name,
+      displayStatus: resolveDisplayStatus(item.id ?? "", item.status, changeMap),
+      localStartDate: item.localStartDate,
+      localEndDate: item.localEndDate
+    }));
+    const selfCertifiedItems = selfCertifiedData.leaveSelfCertifiedListVisible.data.filter((item) => item.status !== "MIGRATED").map((item) => ({
+      id: item.id,
+      typeName: typeMap.get(item.typeId) ?? item.typeId,
+      displayStatus: resolveDisplayStatus(item.id, item.status, changeMap),
+      localStartDate: item.localStartDate,
+      localEndDate: item.localEndDate ?? null
+    }));
+    const allItems = [...standardItems, ...selfCertifiedItems];
+    const today = getLocalToday();
+    return splitLeaveSections(allItems, today);
+  }, [standardData, selfCertifiedData, changesData, leaveTypesData]);
+}
+
+// src/hooks/useBalance.ts
+import { useSuspenseQuery as useSuspenseQuery3 } from "@tanstack/react-query";
+function useBalance() {
+  const employeeId = useCurrentEmployeeId();
+  const { data: balanceData } = useSuspenseQuery3(
+    leaveQueries.balanceList({
+      filters: { employeeId: { eq: employeeId } }
+    })
+  );
+  const rows = (balanceData.employeeVacationBalanceList?.rows ?? []).filter(isDefined);
+  const balance = rows[0];
+  const leavePolicyId = balance?.leavePolicyId ?? "";
+  const { data: policyData } = useSuspenseQuery3(policyQueries.detail(leavePolicyId));
+  if (!balance) return null;
+  const isNorwegian = policyData.leavePolicy?.allowance?.includeUnusedDaysInNewBalance === true;
+  if (isNorwegian) {
+    return {
+      remaining: balance.balanceAmountPlusUnpaidLeft ?? 0,
+      spent: balance.spentAmount ?? 0,
+      saved: null,
+      unpaid: null
+    };
+  }
+  return {
+    remaining: balance.balanceAmount ?? 0,
+    spent: balance.spentAmount ?? 0,
+    saved: balance.savedDaysLeft ?? 0,
+    unpaid: balance.balanceAmountUnpaidLeft ?? 0
+  };
+}
+export {
+  useBalance,
+  useCurrentEmployeeId,
+  useLeaveList
+};

package/dist/i18n/index.d.ts

@@ -0,0 +1,18 @@
+import { i18n } from 'i18next';
+
+declare function initLeaveI18n(locale?: string): Promise<i18n>;
+declare function getLeaveI18n(): i18n;
+declare function resetLeaveI18n(): void;
+
+declare const Locale: {
+    readonly EN: "en-GB";
+    readonly SV: "sv-SE";
+    readonly NB: "nb-NO";
+    readonly DA: "da-DK";
+    readonly FI: "fi-FI";
+};
+type Locale = (typeof Locale)[keyof typeof Locale];
+declare const supportedLocales: readonly Locale[];
+declare function resolveLocale(input: string): Locale;
+
+export { Locale, getLeaveI18n, initLeaveI18n, resetLeaveI18n, resolveLocale, supportedLocales };

package/dist/i18n/index.mjs

@@ -0,0 +1,16 @@
+import {
+  Locale,
+  getLeaveI18n,
+  initLeaveI18n,
+  resetLeaveI18n,
+  resolveLocale,
+  supportedLocales
+} from "../chunk-VS74AXZ6.mjs";
+export {
+  Locale,
+  getLeaveI18n,
+  initLeaveI18n,
+  resetLeaveI18n,
+  resolveLocale,
+  supportedLocales
+};

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { ag as TypedDocumentString, ah as TypedDocumentString$1 } from './graphql-BI4OTV8N.js';
+export { Locale, getLeaveI18n, initLeaveI18n, resetLeaveI18n, resolveLocale, supportedLocales } from './i18n/index.js';
+import { HTTPError } from 'ky';
+import '@graphql-typed-document-node/core';
+import 'i18next';
+
+interface ClientConfig {
+    /** Base proxy URL. Core appends /v2/graphql (gateway) and /graphql (hrCore) internally. */
+    endpoint: string;
+    /** Override base URL for gateway only (local dev with split services). Falls back to `endpoint`. */
+    gatewayEndpoint?: string | undefined;
+    /** Mobile only — returns Auth0 JWT. Web BFF handles auth transparently. */
+    getToken?: (() => Promise<string | null>) | undefined;
+    /** Mobile only — called on 401/403 before throwing. Shell handles 401 redirect on web. */
+    onAuthError?: (() => void) | undefined;
+    /** Hardcoded Alexis token for dev. Platform reads from env, core never touches process.env. */
+    devToken?: string | undefined;
+}
+
+/**
+ * Creates a fresh ky instance. Throws if called twice without resetClient().
+ * Called in useEffect with resetClient() in cleanup.
+ */
+declare function initializeClient(config: ClientConfig): void;
+
+/**
+ * Resets module-scoped singleton. Used in:
+ * - useEffect cleanup on unmount (prevents stale closure on MF remount)
+ * - afterEach() in tests (prevents cross-test state pollution)
+ */
+declare function resetClient(): void;
+
+interface ExecuteProps<TQuery, TVariables> {
+    query: TQuery;
+    variables: TVariables extends Record<string, never> ? unknown : TVariables | undefined;
+    signal?: AbortSignal | undefined;
+}
+type ExecuteGatewayProps<TResult, TVariables> = ExecuteProps<TypedDocumentString<TResult, TVariables>, TVariables>;
+type ExecuteHrCoreProps<TResult, TVariables> = ExecuteProps<TypedDocumentString$1<TResult, TVariables>, TVariables>;
+/**
+ * Typed GraphQL executors. Classifies all errors at this boundary (§12).
+ * Auth errors (401/403): zero retry, immediate onAuthError() callback (§4).
+ *
+ * - execute.gateway() — new leave service (default for most operations)
+ * - execute.hrCore()  — legacy HR Core (employee/policy lookups)
+ */
+declare const execute: {
+    readonly gateway: <TResult, TVariables>({ query, variables, signal, }: ExecuteGatewayProps<TResult, TVariables>) => Promise<TResult>;
+    readonly hrCore: <TResult, TVariables>({ query, variables, signal, }: ExecuteHrCoreProps<TResult, TVariables>) => Promise<TResult>;
+};
+
+/**
+ * Base error class for all leave management errors.
+ * All domain-specific errors extend this class.
+ */
+declare class LeaveError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+
+/**
+ * Authentication/authorization error — 401 or 403.
+ * Never retried. Immediately escalated via onAuthError() callback.
+ */
+declare class AuthError extends LeaveError {
+    readonly statusCode: 401 | 403;
+    constructor(statusCode: 401 | 403);
+}
+
+/**
+ * Server returned errors[] in the GraphQL response body.
+ */
+declare class GraphQLError extends LeaveError {
+    readonly errors: Array<{
+        message: string;
+        extensions?: Record<string, unknown>;
+    }>;
+    constructor(errors: Array<{
+        message: string;
+        extensions?: Record<string, unknown>;
+    }>);
+}
+
+/**
+ * Fetch failed, timeout, or no connectivity.
+ * Also used for non-auth HTTP errors that reach classifyError after ky retries are exhausted.
+ */
+declare class NetworkError extends LeaveError {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+
+/**
+ * Business rule violation returned by the server
+ * (e.g., insufficient leave balance, blackout period).
+ */
+declare class DomainError extends LeaveError {
+    readonly domainCode: string;
+    constructor(domainCode: string, message: string);
+}
+
+/**
+ * Classifies an unknown error into a LeaveError subclass.
+ * Idempotent — if the error is already a LeaveError, passes through unchanged.
+ *
+ * Classification order:
+ * 1. LeaveError passthrough (idempotent)
+ * 2. AbortError → ABORT_ERROR (no-op in UI — no toast, no error boundary)
+ * 3. ky HTTPError 401/403 → AuthError
+ * 4. ky HTTPError other → NetworkError (retries already exhausted by ky)
+ * 5. TypeError → NetworkError (fetch throws TypeError on DNS failure, CORS, network-down)
+ * 6. Fallback → UNKNOWN_ERROR
+ */
+declare function classifyError(error: unknown): LeaveError;
+
+declare enum ErrorCode {
+    UNEXPECTED_ERROR = "UNEXPECTED_ERROR",
+    CONNECTION_FAILURE = "CONNECTION_FAILURE",
+    BAD_REQUEST = "BAD_REQUEST",
+    NOT_FOUND = "NOT_FOUND",
+    SYSTEM_FAILURE = "SYSTEM_FAILURE",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN"
+}
+declare function getErrorCode(error: unknown): ErrorCode;
+declare function isHttpError(error: unknown): error is HTTPError;
+declare function isRetryable(error: unknown): boolean;
+declare function getErrorMessage(error: unknown): {
+    title: string;
+    description: string;
+};
+
+export { AuthError, type ClientConfig, DomainError, ErrorCode, GraphQLError, LeaveError, NetworkError, classifyError, execute, getErrorCode, getErrorMessage, initializeClient, isHttpError, isRetryable, resetClient };

package/dist/index.mjs

@@ -0,0 +1,109 @@
+import {
+  AuthError,
+  GraphQLError,
+  LeaveError,
+  NetworkError,
+  classifyError,
+  execute,
+  initializeClient,
+  resetClient
+} from "./chunk-TUQKZ7GW.mjs";
+import {
+  Locale,
+  getLeaveI18n,
+  initLeaveI18n,
+  resetLeaveI18n,
+  resolveLocale,
+  supportedLocales
+} from "./chunk-VS74AXZ6.mjs";
+
+// src/errors/DomainError.ts
+var DomainError = class extends LeaveError {
+  constructor(domainCode, message) {
+    super("DOMAIN_ERROR", message);
+    this.domainCode = domainCode;
+    this.name = "DomainError";
+  }
+};
+
+// src/errors/errorMessages.ts
+import { HTTPError } from "ky";
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["UNEXPECTED_ERROR"] = "UNEXPECTED_ERROR";
+  ErrorCode2["CONNECTION_FAILURE"] = "CONNECTION_FAILURE";
+  ErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  ErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ErrorCode2["SYSTEM_FAILURE"] = "SYSTEM_FAILURE";
+  ErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  return ErrorCode2;
+})(ErrorCode || {});
+var httpStatusToErrorCode = {
+  400: "BAD_REQUEST" /* BAD_REQUEST */,
+  401: "UNAUTHORIZED" /* UNAUTHORIZED */,
+  403: "FORBIDDEN" /* FORBIDDEN */,
+  404: "NOT_FOUND" /* NOT_FOUND */
+};
+function getErrorCode(error) {
+  if (error instanceof AuthError) {
+    return error.statusCode === 401 ? "UNAUTHORIZED" /* UNAUTHORIZED */ : "FORBIDDEN" /* FORBIDDEN */;
+  }
+  if (error instanceof NetworkError) {
+    return "CONNECTION_FAILURE" /* CONNECTION_FAILURE */;
+  }
+  if (error instanceof GraphQLError) {
+    return "SYSTEM_FAILURE" /* SYSTEM_FAILURE */;
+  }
+  if (error instanceof Error && "response" in error) {
+    const status = error.response?.status;
+    if (status != null) {
+      const mapped = httpStatusToErrorCode[status];
+      if (mapped != null) return mapped;
+      if (status >= 500) return "SYSTEM_FAILURE" /* SYSTEM_FAILURE */;
+    }
+  }
+  return "UNEXPECTED_ERROR" /* UNEXPECTED_ERROR */;
+}
+function isHttpError(error) {
+  return error instanceof HTTPError;
+}
+function isRetryable(error) {
+  if (error instanceof NetworkError) return true;
+  if (error instanceof GraphQLError) return true;
+  if (error instanceof AuthError) return false;
+  if (error instanceof DomainError) return false;
+  if (error instanceof HTTPError) {
+    return error.response.status >= 500;
+  }
+  return false;
+}
+function getErrorMessage(error) {
+  const code = getErrorCode(error);
+  const t = getLeaveI18n().t;
+  return {
+    title: t(`errors.${code}.title`),
+    description: t(`errors.${code}.description`)
+  };
+}
+export {
+  AuthError,
+  DomainError,
+  ErrorCode,
+  GraphQLError,
+  LeaveError,
+  Locale,
+  NetworkError,
+  classifyError,
+  execute,
+  getErrorCode,
+  getErrorMessage,
+  getLeaveI18n,
+  initLeaveI18n,
+  initializeClient,
+  isHttpError,
+  isRetryable,
+  resetClient,
+  resetLeaveI18n,
+  resolveLocale,
+  supportedLocales
+};

package/dist/leaveStatusUtils-C26heVdh.d.ts

@@ -0,0 +1,11 @@
+type DisplayStatus = 'APPROVED' | 'PENDING' | 'DENIED' | 'CANCELLED' | 'PENDING_CHANGES' | 'PENDING_REVOKE';
+type LeaveChangeType = 'UPDATE' | 'REVOKE';
+/**
+ * Resolves the display status for a leave item, applying change overrides.
+ *
+ * If the leave has a pending change (UPDATE or REVOKE), the display status
+ * is overridden to reflect the pending change instead of the leave's own status.
+ */
+declare function resolveDisplayStatus(leaveId: string, leaveStatus: string, changeMap: ReadonlyMap<string, LeaveChangeType>): DisplayStatus;
+
+export { type DisplayStatus as D, type LeaveChangeType as L, resolveDisplayStatus as r };

package/dist/mutations/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }