@alexisapp/leave-core 0.0.1-beta.1

package/dist/chunk-R7NHFDIU.mjs

@@ -0,0 +1,53 @@
+// src/utils/leaveStatusUtils.ts
+function resolveDisplayStatus(leaveId, leaveStatus, changeMap) {
+  const changeType = changeMap.get(leaveId);
+  if (changeType === "UPDATE") return "PENDING_CHANGES";
+  if (changeType === "REVOKE") return "PENDING_REVOKE";
+  switch (leaveStatus) {
+    case "APPROVED":
+      return "APPROVED";
+    case "PENDING":
+      return "PENDING";
+    case "DENIED":
+      return "DENIED";
+    case "CANCELLED":
+      return "CANCELLED";
+    default:
+      return "PENDING";
+  }
+}
+
+// src/utils/splitLeaveSectionsUtils.ts
+function splitLeaveSections(items, today) {
+  const upcoming = [];
+  const history = [];
+  for (const item of items) {
+    if (item.localEndDate == null || item.localEndDate >= today) {
+      upcoming.push(item);
+    } else {
+      history.push(item);
+    }
+  }
+  upcoming.sort((a, b) => a.localStartDate.localeCompare(b.localStartDate));
+  history.sort((a, b) => b.localStartDate.localeCompare(a.localStartDate));
+  return { upcoming, history };
+}
+function getLocalToday() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/utils/typeSafeUtils.ts
+var isDefined = (value) => {
+  return value !== null && value !== void 0;
+};
+
+export {
+  resolveDisplayStatus,
+  splitLeaveSections,
+  getLocalToday,
+  isDefined
+};

package/dist/chunk-TUQKZ7GW.mjs

@@ -0,0 +1,207 @@
+// src/client/createKyInstance.ts
+import ky from "ky";
+function createKyInstance(config) {
+  return ky.create({
+    hooks: {
+      beforeRequest: [
+        async (request) => {
+          if (config.devToken) {
+            request.headers.set("Authorization", `Bearer ${config.devToken}`);
+            return;
+          }
+          if (config.getToken) {
+            const token = await config.getToken();
+            if (token) {
+              request.headers.set("Authorization", `Bearer ${token}`);
+            }
+          }
+        }
+      ]
+    },
+    timeout: 3e4,
+    retry: { limit: 2, statusCodes: [408, 429, 500, 502, 503, 504] }
+  });
+}
+
+// src/client/initializeClient.ts
+var kyInstance = null;
+var clientConfig = null;
+function initializeClient(config) {
+  if (kyInstance !== null) {
+    throw new Error(
+      "[LeavePackage] initializeClient() called but client already exists. Call resetClient() first. If this error appears in production, it likely means two MF remotes are consuming @leave/core simultaneously \u2014 see ADR-011."
+    );
+  }
+  clientConfig = config;
+  kyInstance = createKyInstance(config);
+}
+function getKyInstance() {
+  return kyInstance;
+}
+function getClientConfig() {
+  return clientConfig;
+}
+function _resetInternal() {
+  kyInstance = null;
+  clientConfig = null;
+}
+
+// src/client/resetClient.ts
+function resetClient() {
+  _resetInternal();
+}
+
+// src/errors/LeaveError.ts
+var LeaveError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LeaveError";
+  }
+};
+
+// src/errors/AuthError.ts
+var AuthError = class extends LeaveError {
+  constructor(statusCode) {
+    super("AUTH_ERROR", statusCode === 401 ? "Session expired" : "Access denied");
+    this.statusCode = statusCode;
+    this.name = "AuthError";
+  }
+};
+
+// src/errors/NetworkError.ts
+var NetworkError = class extends LeaveError {
+  constructor(cause) {
+    super("NETWORK_ERROR", "Unable to reach the server");
+    this.cause = cause;
+    this.name = "NetworkError";
+  }
+};
+
+// src/errors/classifyError.ts
+import { HTTPError } from "ky";
+function classifyError(error) {
+  if (error instanceof LeaveError) {
+    return error;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return new LeaveError("ABORT_ERROR", "Request aborted");
+  }
+  if (error instanceof HTTPError) {
+    const status = error.response.status;
+    if (status === 401 || status === 403) {
+      return new AuthError(status);
+    }
+    return new NetworkError(error);
+  }
+  if (error instanceof TypeError) {
+    return new NetworkError(error);
+  }
+  const message = error instanceof Error ? error.message : "An unexpected error occurred";
+  return new LeaveError("UNKNOWN_ERROR", message);
+}
+
+// src/errors/GraphQLError.ts
+var GraphQLError = class extends LeaveError {
+  constructor(errors) {
+    super("GRAPHQL_ERROR", errors[0]?.message ?? "Unknown server error");
+    this.errors = errors;
+    this.name = "GraphQLError";
+  }
+};
+
+// src/client/execute.ts
+async function executeBase({
+  url,
+  query,
+  variables,
+  signal
+}) {
+  const kyInstance2 = getKyInstance();
+  if (!kyInstance2) {
+    throw new Error("GraphQL client not initialized. Call initializeClient() first.");
+  }
+  const response = await kyInstance2.post(url, {
+    json: { query, variables },
+    ...signal != null && { signal }
+  }).json();
+  if (response.errors?.length) {
+    throw new GraphQLError(response.errors);
+  }
+  return response.data;
+}
+var GATEWAY_PATH = "/v2/graphql";
+var HR_CORE_PATH = "/graphql";
+function getGatewayUrl() {
+  const config = getClientConfig();
+  if (!config) {
+    throw new Error("GraphQL client not initialized. Call initializeClient() first.");
+  }
+  const base = config.gatewayEndpoint ?? config.endpoint;
+  return `${base}${GATEWAY_PATH}`;
+}
+function getHrCoreUrl() {
+  const config = getClientConfig();
+  if (!config) {
+    throw new Error("GraphQL client not initialized. Call initializeClient() first.");
+  }
+  return `${config.endpoint}${HR_CORE_PATH}`;
+}
+async function executeWithErrorHandling(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    const classified = classifyError(error);
+    if (classified instanceof AuthError) {
+      const config = getClientConfig();
+      config?.onAuthError?.();
+      throw classified;
+    }
+    throw classified;
+  }
+}
+var executeGateway = async ({
+  query,
+  variables,
+  signal
+}) => {
+  const url = getGatewayUrl();
+  return executeWithErrorHandling(
+    () => executeBase({
+      url,
+      query,
+      variables,
+      signal
+    })
+  );
+};
+var executeHrCore = async ({
+  query,
+  variables,
+  signal
+}) => {
+  const url = getHrCoreUrl();
+  return executeWithErrorHandling(
+    () => executeBase({
+      url,
+      query,
+      variables,
+      signal
+    })
+  );
+};
+var execute = {
+  gateway: executeGateway,
+  hrCore: executeHrCore
+};
+
+export {
+  initializeClient,
+  resetClient,
+  LeaveError,
+  AuthError,
+  NetworkError,
+  classifyError,
+  GraphQLError,
+  execute
+};

package/dist/chunk-VS74AXZ6.mjs

@@ -0,0 +1,70 @@
+// src/i18n/instance.ts
+import i18next from "i18next";
+
+// src/i18n/locale.ts
+var Locale = {
+  EN: "en-GB",
+  SV: "sv-SE",
+  NB: "nb-NO",
+  DA: "da-DK",
+  FI: "fi-FI"
+};
+var supportedLocales = Object.values(Locale);
+var LanguageCodeToLocale = {
+  en: Locale.EN,
+  sv: Locale.SV,
+  nb: Locale.NB,
+  da: Locale.DA,
+  fi: Locale.FI
+};
+function resolveLocale(input) {
+  return LanguageCodeToLocale[input] ?? Locale.EN;
+}
+
+// src/i18n/instance.ts
+var instance = null;
+async function initLeaveI18n(locale = Locale.EN) {
+  if (instance) {
+    if (instance.language !== locale) {
+      await instance.changeLanguage(locale);
+    }
+    return instance;
+  }
+  instance = i18next.createInstance();
+  await instance.init({
+    compatibilityJSON: "v4",
+    lng: locale,
+    fallbackLng: Locale.EN,
+    supportedLngs: supportedLocales,
+    load: "currentOnly",
+    interpolation: { escapeValue: false },
+    resources: {
+      "en-GB": {
+        translation: (await import("./en-GB-TSTNTOGN.mjs")).default
+      }
+      // Phase 2: uncomment when sv translations are complete
+      // sv: {
+      //   translation: (await import('./translations/sv.json')).default,
+      // },
+    }
+  });
+  return instance;
+}
+function getLeaveI18n() {
+  if (!instance) {
+    throw new Error("[LeavePackage] Leave i18n not initialized. Call initLeaveI18n() first.");
+  }
+  return instance;
+}
+function resetLeaveI18n() {
+  instance = null;
+}
+
+export {
+  Locale,
+  supportedLocales,
+  resolveLocale,
+  initLeaveI18n,
+  getLeaveI18n,
+  resetLeaveI18n
+};

package/dist/components/index.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode, JSX } from 'react';
+import { ErrorBoundaryProps } from 'react-error-boundary';
+
+interface AsyncBoundaryProps {
+    suspenseFallback?: ReactNode;
+    errorBoundaryProps: ErrorBoundaryProps;
+    children?: ReactNode;
+}
+declare const AsyncBoundary: ({ suspenseFallback, errorBoundaryProps, children, }: AsyncBoundaryProps) => JSX.Element;
+
+export { AsyncBoundary };

package/dist/components/index.mjs

@@ -0,0 +1,23 @@
+// src/components/AsyncBoundary.tsx
+import { QueryErrorResetBoundary } from "@tanstack/react-query";
+import { Suspense } from "react";
+import { ErrorBoundary } from "react-error-boundary";
+import { jsx } from "react/jsx-runtime";
+var AsyncBoundary = ({
+  suspenseFallback,
+  errorBoundaryProps,
+  children
+}) => /* @__PURE__ */ jsx(QueryErrorResetBoundary, { children: ({ reset }) => /* @__PURE__ */ jsx(
+  ErrorBoundary,
+  {
+    ...errorBoundaryProps,
+    onReset: (...args) => {
+      reset();
+      errorBoundaryProps.onReset?.(...args);
+    },
+    children: /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children })
+  }
+) });
+export {
+  AsyncBoundary
+};

package/dist/domain/index.d.ts

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

package/dist/en-GB-TSTNTOGN.mjs

@@ -0,0 +1,81 @@
+// src/i18n/translations/en-GB.json
+var errors = {
+  UNEXPECTED_ERROR: {
+    title: "Something went wrong",
+    description: "An unexpected error occurred. Please try again."
+  },
+  CONNECTION_FAILURE: {
+    title: "Connection failed",
+    description: "Unable to reach the server. Check your connection and try again."
+  },
+  BAD_REQUEST: {
+    title: "Invalid request",
+    description: "The request could not be processed."
+  },
+  NOT_FOUND: {
+    title: "Not found",
+    description: "The requested resource was not found."
+  },
+  SYSTEM_FAILURE: {
+    title: "Server error",
+    description: "A server error occurred. Please try again later."
+  },
+  UNAUTHORIZED: {
+    title: "Session expired",
+    description: "Your session has expired. Please sign in again."
+  },
+  FORBIDDEN: {
+    title: "Access denied",
+    description: "You do not have permission to access this resource."
+  }
+};
+var retry = "Retry";
+var close = "Close";
+var balance = {
+  remaining: {
+    label: "Remaining",
+    subtitle: "vacation days"
+  },
+  spent: {
+    label: "Spent",
+    subtitle: "vacation days"
+  },
+  saved: {
+    label: "Saved",
+    subtitle: "vacation days"
+  },
+  unpaid: {
+    label: "Unpaid",
+    subtitle: "days left"
+  }
+};
+var leave = {
+  upcoming: "Upcoming",
+  history: "History",
+  emptyTitle: "No leave requests",
+  emptyDescription: "Your leave requests will appear here",
+  ongoing: "ongoing",
+  status: {
+    APPROVED: "Approved",
+    PENDING: "Pending",
+    DENIED: "Denied",
+    CANCELLED: "Cancelled",
+    PENDING_CHANGES: "Pending changes",
+    PENDING_REVOKE: "Pending revoke"
+  }
+};
+var en_GB_default = {
+  errors,
+  retry,
+  close,
+  balance,
+  leave
+};
+export {
+  balance,
+  close,
+  en_GB_default as default,
+  errors,
+  leave,
+  retry
+};

package/dist/forms/index.d.ts

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