@zairakai/js-http-client 1.0.0

package/dist/index.js

@@ -0,0 +1,139 @@
+import {
+  createAuthInterceptor,
+  createCSRFInterceptor,
+  createErrorLoggerInterceptor,
+  createRetryInterceptor,
+  createTimeoutInterceptor,
+  createTrackingInterceptors
+} from "./chunk-SSH6WKEL.js";
+
+// src/client.ts
+import axios from "axios";
+
+// src/request-tracker.ts
+var createRequestTracker = () => {
+  let nbrInternal = 0;
+  return {
+    get count() {
+      return nbrInternal;
+    },
+    set count(val) {
+      nbrInternal = Math.max(0, val);
+    },
+    get isActive() {
+      return 0 < nbrInternal;
+    },
+    increment() {
+      nbrInternal++;
+    },
+    decrement() {
+      nbrInternal = Math.max(0, nbrInternal - 1);
+    },
+    reset() {
+      nbrInternal = 0;
+    }
+  };
+};
+var globalRequestTracker = createRequestTracker();
+
+// src/client.ts
+var DEFAULT_CONFIG = {
+  baseURL: "",
+  timeout: 1e4,
+  withCredentials: false,
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }
+};
+var createHttpClient = (options = {}) => {
+  const config = { ...DEFAULT_CONFIG, ...options };
+  const client = axios.create({
+    baseURL: config.baseURL,
+    timeout: config.timeout,
+    withCredentials: config.withCredentials,
+    headers: { ...DEFAULT_CONFIG.headers, ...config.headers }
+  });
+  const tracker = false !== config.trackRequests ? createRequestTracker() : null;
+  if (tracker) {
+    const trackingInterceptors = createTrackingInterceptors(tracker);
+    client.interceptors.request.use(trackingInterceptors.request, trackingInterceptors.requestError);
+    client.interceptors.response.use(trackingInterceptors.response, trackingInterceptors.responseError);
+  }
+  if (config.csrfToken) {
+    client.interceptors.request.use(createCSRFInterceptor(config.csrfToken));
+  }
+  if (config.authToken) {
+    client.interceptors.request.use(createAuthInterceptor(config.authToken, config.authType));
+  }
+  if (config.timeout !== DEFAULT_CONFIG.timeout) {
+    client.interceptors.request.use(createTimeoutInterceptor(config.timeout));
+  }
+  if (false !== config.enableErrorLogging) {
+    client.interceptors.response.use((response) => response, createErrorLoggerInterceptor(config.logger));
+  }
+  if (config.retries && 0 < config.retries) {
+    client.interceptors.request.use((reqConfig) => {
+      ;
+      reqConfig._axios = client;
+      return reqConfig;
+    });
+    client.interceptors.response.use(
+      (response) => response,
+      createRetryInterceptor(config.retries, config.retryDelay, config.shouldRetry)
+    );
+  }
+  if (false !== config.laravel) {
+    client.defaults.headers.common["X-Requested-With"] = "XMLHttpRequest";
+  }
+  return {
+    client,
+    tracker,
+    // Convenience methods
+    get: (url, config2) => client.get(url, config2),
+    post: (url, data, config2) => client.post(url, data, config2),
+    put: (url, data, config2) => client.put(url, data, config2),
+    patch: (url, data, config2) => client.patch(url, data, config2),
+    delete: (url, config2) => client.delete(url, config2),
+    // Request status
+    get isLoading() {
+      return tracker ? tracker.isActive : false;
+    },
+    get requestCount() {
+      return tracker ? tracker.count : 0;
+    }
+  };
+};
+var createLaravelClient = (options = {}) => {
+  return createHttpClient({
+    withCredentials: true,
+    headers: {
+      "X-Requested-With": "XMLHttpRequest"
+    },
+    ...options
+  });
+};
+var createApiClient = (options = {}) => {
+  return createHttpClient({
+    withCredentials: false,
+    laravel: false,
+    ...options
+  });
+};
+
+// src/index.ts
+import { default as default2 } from "axios";
+export {
+  default2 as axios,
+  createApiClient,
+  createAuthInterceptor,
+  createCSRFInterceptor,
+  createErrorLoggerInterceptor,
+  createHttpClient,
+  createLaravelClient,
+  createRequestTracker,
+  createRetryInterceptor,
+  createTimeoutInterceptor,
+  createTrackingInterceptors,
+  globalRequestTracker
+};

package/dist/interceptors-Pv-t9Hbf.d.cts

@@ -0,0 +1,93 @@
+import { AxiosError, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
+
+/**
+ * Request tracking utility for monitoring ongoing HTTP requests
+ */
+/**
+ * Interface for request tracker instance
+ */
+interface RequestTracker {
+    /** Current number of active requests */
+    readonly count: number;
+    /** Whether there are any active requests */
+    readonly isActive: boolean;
+    /** Increment the request counter */
+    increment(): void;
+    /** Decrement the request counter */
+    decrement(): void;
+    /** Reset the counter to zero */
+    reset(): void;
+}
+/**
+ * Creates a request tracker instance
+ * @returns Request tracker with counter and methods
+ */
+declare const createRequestTracker: () => RequestTracker;
+declare const globalRequestTracker: RequestTracker;
+
+/**
+ * Common interceptors for HTTP clients
+ */
+
+/**
+ * Token source type - either a string or a function that returns a string
+ */
+type TokenSource = string | (() => string);
+/**
+ * Logger function type
+ */
+type Logger = (message: string, data?: unknown) => void;
+/**
+ * Retry condition function type
+ */
+type ShouldRetryFunction = (error: AxiosError) => boolean;
+/**
+ * Tracking interceptors interface
+ */
+interface TrackingInterceptors {
+    request: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+    requestError: (error: Error) => Promise<never>;
+    response: (response: AxiosResponse) => AxiosResponse;
+    responseError: (error: Error) => Promise<never>;
+}
+/**
+ * Creates request tracking interceptors
+ * @param tracker - Request tracker instance
+ * @returns Request and response interceptors
+ */
+declare const createTrackingInterceptors: (tracker: RequestTracker) => TrackingInterceptors;
+/**
+ * Creates Laravel CSRF token interceptor
+ * @param tokenSource - CSRF token or function that returns token
+ * @returns Request interceptor
+ */
+declare const createCSRFInterceptor: (tokenSource: TokenSource) => (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+/**
+ * Creates authentication interceptor
+ * @param tokenSource - Auth token or function that returns token
+ * @param type - Token type ('Bearer', 'Token', etc.)
+ * @returns Request interceptor
+ */
+declare const createAuthInterceptor: (tokenSource: TokenSource, type?: string) => (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+/**
+ * Creates error logging interceptor
+ * @param logger - Logging function
+ * @returns Response error interceptor
+ */
+declare const createErrorLoggerInterceptor: (logger?: Logger) => (error: AxiosError) => Promise<never>;
+/**
+ * Creates timeout interceptor
+ * @param timeout - Default timeout in milliseconds
+ * @returns Request interceptor
+ */
+declare const createTimeoutInterceptor: (timeout: number) => (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+/**
+ * Creates retry interceptor
+ * @param retries - Number of retries
+ * @param delay - Delay between retries in milliseconds
+ * @param shouldRetry - Function to determine if request should be retried
+ * @returns Response error interceptor
+ */
+declare const createRetryInterceptor: (retries?: number, delay?: number, shouldRetry?: ShouldRetryFunction) => (error: AxiosError) => Promise<any>;
+
+export { type Logger as L, type RequestTracker as R, type ShouldRetryFunction as S, type TokenSource as T, type TrackingInterceptors as a, createCSRFInterceptor as b, createAuthInterceptor as c, createErrorLoggerInterceptor as d, createRequestTracker as e, createRetryInterceptor as f, createTimeoutInterceptor as g, createTrackingInterceptors as h, globalRequestTracker as i };

package/dist/interceptors-Pv-t9Hbf.d.ts

@@ -0,0 +1,93 @@
+import { AxiosError, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
+
+/**
+ * Request tracking utility for monitoring ongoing HTTP requests
+ */
+/**
+ * Interface for request tracker instance
+ */
+interface RequestTracker {
+    /** Current number of active requests */
+    readonly count: number;
+    /** Whether there are any active requests */
+    readonly isActive: boolean;
+    /** Increment the request counter */
+    increment(): void;
+    /** Decrement the request counter */
+    decrement(): void;
+    /** Reset the counter to zero */
+    reset(): void;
+}
+/**
+ * Creates a request tracker instance
+ * @returns Request tracker with counter and methods
+ */
+declare const createRequestTracker: () => RequestTracker;
+declare const globalRequestTracker: RequestTracker;
+
+/**
+ * Common interceptors for HTTP clients
+ */
+
+/**
+ * Token source type - either a string or a function that returns a string
+ */
+type TokenSource = string | (() => string);
+/**
+ * Logger function type
+ */
+type Logger = (message: string, data?: unknown) => void;
+/**
+ * Retry condition function type
+ */
+type ShouldRetryFunction = (error: AxiosError) => boolean;
+/**
+ * Tracking interceptors interface
+ */
+interface TrackingInterceptors {
+    request: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+    requestError: (error: Error) => Promise<never>;
+    response: (response: AxiosResponse) => AxiosResponse;
+    responseError: (error: Error) => Promise<never>;
+}
+/**
+ * Creates request tracking interceptors
+ * @param tracker - Request tracker instance
+ * @returns Request and response interceptors
+ */
+declare const createTrackingInterceptors: (tracker: RequestTracker) => TrackingInterceptors;
+/**
+ * Creates Laravel CSRF token interceptor
+ * @param tokenSource - CSRF token or function that returns token
+ * @returns Request interceptor
+ */
+declare const createCSRFInterceptor: (tokenSource: TokenSource) => (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+/**
+ * Creates authentication interceptor
+ * @param tokenSource - Auth token or function that returns token
+ * @param type - Token type ('Bearer', 'Token', etc.)
+ * @returns Request interceptor
+ */
+declare const createAuthInterceptor: (tokenSource: TokenSource, type?: string) => (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+/**
+ * Creates error logging interceptor
+ * @param logger - Logging function
+ * @returns Response error interceptor
+ */
+declare const createErrorLoggerInterceptor: (logger?: Logger) => (error: AxiosError) => Promise<never>;
+/**
+ * Creates timeout interceptor
+ * @param timeout - Default timeout in milliseconds
+ * @returns Request interceptor
+ */
+declare const createTimeoutInterceptor: (timeout: number) => (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+/**
+ * Creates retry interceptor
+ * @param retries - Number of retries
+ * @param delay - Delay between retries in milliseconds
+ * @param shouldRetry - Function to determine if request should be retried
+ * @returns Response error interceptor
+ */
+declare const createRetryInterceptor: (retries?: number, delay?: number, shouldRetry?: ShouldRetryFunction) => (error: AxiosError) => Promise<any>;
+
+export { type Logger as L, type RequestTracker as R, type ShouldRetryFunction as S, type TokenSource as T, type TrackingInterceptors as a, createCSRFInterceptor as b, createAuthInterceptor as c, createErrorLoggerInterceptor as d, createRequestTracker as e, createRetryInterceptor as f, createTimeoutInterceptor as g, createTrackingInterceptors as h, globalRequestTracker as i };

package/dist/interceptors.cjs

@@ -0,0 +1,113 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interceptors.ts
+var interceptors_exports = {};
+__export(interceptors_exports, {
+  createAuthInterceptor: () => createAuthInterceptor,
+  createCSRFInterceptor: () => createCSRFInterceptor,
+  createErrorLoggerInterceptor: () => createErrorLoggerInterceptor,
+  createRetryInterceptor: () => createRetryInterceptor,
+  createTimeoutInterceptor: () => createTimeoutInterceptor,
+  createTrackingInterceptors: () => createTrackingInterceptors
+});
+module.exports = __toCommonJS(interceptors_exports);
+var import_axios = __toESM(require("axios"), 1);
+var createTrackingInterceptors = (tracker) => ({
+  request: (config) => {
+    tracker.increment();
+    return config;
+  },
+  requestError: (error) => {
+    return Promise.reject(error);
+  },
+  response: (response) => {
+    tracker.decrement();
+    return response;
+  },
+  responseError: (error) => {
+    tracker.decrement();
+    return Promise.reject(error);
+  }
+});
+var createCSRFInterceptor = (tokenSource) => (config) => {
+  const token = "function" === typeof tokenSource ? tokenSource() : tokenSource;
+  if (token) {
+    config.headers = config.headers ?? {};
+    config.headers["X-CSRF-TOKEN"] = token;
+  }
+  return config;
+};
+var createAuthInterceptor = (tokenSource, type = "Bearer") => (config) => {
+  const token = "function" === typeof tokenSource ? tokenSource() : tokenSource;
+  if (token) {
+    config.headers = config.headers ?? {};
+    config.headers["Authorization"] = `${type} ${token}`;
+  }
+  return config;
+};
+var createErrorLoggerInterceptor = (logger = console.error) => (error) => {
+  const logData = {
+    message: error.message,
+    status: error.response?.status,
+    statusText: error.response?.statusText,
+    url: error.config?.url,
+    method: error.config?.method?.toUpperCase()
+  };
+  logger("HTTP Error:", logData);
+  return Promise.reject(error);
+};
+var createTimeoutInterceptor = (timeout) => (config) => {
+  config.timeout = timeout;
+  return config;
+};
+var createRetryInterceptor = (retries = 3, delay = 1e3, shouldRetry = () => true) => {
+  return async (error) => {
+    const config = error.config;
+    if (!config || (config.__retryCount ?? 0) >= retries) {
+      return Promise.reject(error);
+    }
+    if (!shouldRetry(error)) {
+      return Promise.reject(error);
+    }
+    config.__retryCount = (config.__retryCount ?? 0) + 1;
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    const axiosInstance = config._axios ?? import_axios.default;
+    return axiosInstance.request(config);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAuthInterceptor,
+  createCSRFInterceptor,
+  createErrorLoggerInterceptor,
+  createRetryInterceptor,
+  createTimeoutInterceptor,
+  createTrackingInterceptors
+});

package/dist/interceptors.d.cts

@@ -0,0 +1,2 @@
+import 'axios';
+export { L as Logger, S as ShouldRetryFunction, T as TokenSource, a as TrackingInterceptors, c as createAuthInterceptor, b as createCSRFInterceptor, d as createErrorLoggerInterceptor, f as createRetryInterceptor, g as createTimeoutInterceptor, h as createTrackingInterceptors } from './interceptors-Pv-t9Hbf.cjs';

package/dist/interceptors.d.ts

@@ -0,0 +1,2 @@
+import 'axios';
+export { L as Logger, S as ShouldRetryFunction, T as TokenSource, a as TrackingInterceptors, c as createAuthInterceptor, b as createCSRFInterceptor, d as createErrorLoggerInterceptor, f as createRetryInterceptor, g as createTimeoutInterceptor, h as createTrackingInterceptors } from './interceptors-Pv-t9Hbf.js';

package/dist/interceptors.js

@@ -0,0 +1,16 @@
+import {
+  createAuthInterceptor,
+  createCSRFInterceptor,
+  createErrorLoggerInterceptor,
+  createRetryInterceptor,
+  createTimeoutInterceptor,
+  createTrackingInterceptors
+} from "./chunk-SSH6WKEL.js";
+export {
+  createAuthInterceptor,
+  createCSRFInterceptor,
+  createErrorLoggerInterceptor,
+  createRetryInterceptor,
+  createTimeoutInterceptor,
+  createTrackingInterceptors
+};

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@zairakai/js-http-client",
+  "version": "1.0.0",
+  "description": "Configurable HTTP client built on axios with request tracking, Laravel CSRF support, and interceptor management",
+  "keywords": [
+    "http",
+    "client",
+    "axios",
+    "laravel",
+    "csrf",
+    "interceptors",
+    "api"
+  ],
+  "homepage": "https://gitlab.com/zairakai/npm-packages/js-http-client",
+  "bugs": {
+    "url": "https://gitlab.com/zairakai/npm-packages/js-http-client/-/issues",
+    "email": "contact-project+zairakai-npm-packages-js-http-client-80189938-issue-@incoming.gitlab.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/zairakai/npm-packages/js-http-client.git"
+  },
+  "funding": [
+    {
+      "type": "patreon",
+      "url": "https://www.patreon.com/c/zairakai"
+    },
+    {
+      "type": "twitch",
+      "url": "https://www.twitch.tv/zairakai"
+    }
+  ],
+  "license": "MIT",
+  "author": "Stanislas Poisson <stanislas.p@the-white-rabbits.fr> (https://the-white-rabbits.fr)",
+  "contributors": [
+    {
+      "name": "Stanislas Poisson",
+      "url": "https://gitlab.com/zairakai",
+      "role": "Maintainer"
+    }
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./interceptors": {
+      "types": "./dist/interceptors.d.ts",
+      "import": "./dist/interceptors.js",
+      "require": "./dist/interceptors.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bash node_modules/@zairakai/js-dev-tools/scripts/build.sh",
+    "eslint": "bash node_modules/@zairakai/js-dev-tools/scripts/eslint.sh",
+    "eslint:fix": "bash node_modules/@zairakai/js-dev-tools/scripts/eslint-fix.sh",
+    "markdownlint": "bash node_modules/@zairakai/js-dev-tools/scripts/markdownlint.sh",
+    "markdownlint:fix": "bash node_modules/@zairakai/js-dev-tools/scripts/markdownlint-fix.sh",
+    "normalize": "make package-normalize",
+    "package:validate": "make package-validate",
+    "postinstall": "bash node_modules/@zairakai/js-dev-tools/scripts/setup-project.sh --silent || true",
+    "prettier": "bash node_modules/@zairakai/js-dev-tools/scripts/prettier.sh",
+    "prettier:fix": "bash node_modules/@zairakai/js-dev-tools/scripts/prettier-fix.sh",
+    "setup": "bash node_modules/@zairakai/js-dev-tools/scripts/setup-project.sh",
+    "test": "make test-all",
+    "typecheck": "tsc --noEmit",
+    "validate": "make quality"
+  },
+  "dependencies": {
+    "axios": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.0",
+    "@vitest/coverage-v8": "^4.0.0",
+    "@zairakai/js-dev-tools": "^1.0.0",
+    "knip": "^5.86.0",
+    "sort-package-json": "^3.6.1",
+    "tsup": "^8.0.0",
+    "typedoc": "^0.28.0",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.0"
+  },
+  "peerDependencies": {
+    "axios": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "axios": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}