@sia-ui/api 0.1.0

package/dist/index.cjs

@@ -0,0 +1,928 @@
+'use strict';
+
+var async = require('@sia-ui/utils/async');
+var query = require('@sia-ui/utils/query');
+
+// src/http-error.ts
+var HttpError = class _HttpError extends Error {
+  status;
+  body;
+  headers;
+  /** Les erreurs par champ, quand le serveur en renvoie. */
+  fields;
+  constructor(status, body = null, message, headers = {}) {
+    super(message ?? _HttpError.extractMessage(body) ?? `HTTP ${status}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.fields = _HttpError.extractFields(body);
+    Object.setPrototypeOf(this, _HttpError.prototype);
+  }
+  static async fromResponse(response) {
+    const headers = _HttpError.normalizeHeaders(response.headers);
+    const contentType = headers["content-type"] ?? "";
+    const body = contentType.includes("application/json") ? await response.json().catch(() => null) : await response.text().catch(() => null);
+    return new _HttpError(response.status, body, void 0, headers);
+  }
+  /**
+   * Retrouve les erreurs par champ dans un corps d'erreur.
+   *
+   * Trois formes couvertes, parce que trois serveurs sur quatre en utilisent
+   * une : la liste (`errors: [{ field, message }]`), la carte
+   * (`errors: { email: "…" }`) et la carte de listes, que produit Laravel.
+   */
+  static extractFields(body) {
+    if (!body || typeof body !== "object") return [];
+    const record = body;
+    const source = record.errors ?? record.fieldErrors ?? record.violations;
+    if (!source) return [];
+    if (Array.isArray(source)) {
+      return source.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") return [];
+        const item = entry;
+        const field = item.field ?? item.property ?? item.path ?? item.name;
+        const message = item.message ?? item.error ?? item.detail;
+        if (typeof field !== "string" || typeof message !== "string") return [];
+        return [
+          {
+            field,
+            message,
+            ...typeof item.code === "string" ? { code: item.code } : {}
+          }
+        ];
+      });
+    }
+    if (typeof source === "object") {
+      return Object.entries(source).flatMap(
+        ([field, value]) => {
+          const message = Array.isArray(value) ? value[0] : value;
+          return typeof message === "string" ? [{ field, message }] : [];
+        }
+      );
+    }
+    return [];
+  }
+  /** Le message rattaché à ce champ, s'il y en a un. */
+  fieldError(field) {
+    return this.fields.find((entry) => entry.field === field)?.message;
+  }
+  static normalizeHeaders(headers) {
+    if (!headers) return {};
+    if (typeof headers.forEach === "function") {
+      const normalized = {};
+      headers.forEach((value, key) => {
+        normalized[String(key).toLowerCase()] = String(value);
+      });
+      return normalized;
+    }
+    if (typeof headers === "object") {
+      return Object.fromEntries(
+        Object.entries(headers).map(
+          ([key, value]) => [key.toLowerCase(), String(value ?? "")]
+        )
+      );
+    }
+    return {};
+  }
+  static extractMessage(body) {
+    if (!body || typeof body !== "object") return null;
+    const record = body;
+    const directMessage = record.message;
+    if (Array.isArray(directMessage)) {
+      const values = directMessage.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+      return values.length > 0 ? values.join(" ") : null;
+    }
+    if (typeof directMessage === "string" && directMessage.trim().length > 0) {
+      return directMessage.trim();
+    }
+    if (Array.isArray(record.errors)) {
+      const nestedMessage = record.errors.map((entry) => {
+        if (!entry || typeof entry !== "object") return "";
+        const message = entry.message;
+        return typeof message === "string" ? message.trim() : "";
+      }).filter(Boolean)[0];
+      if (nestedMessage) return nestedMessage;
+    }
+    return null;
+  }
+  isClientError() {
+    return this.status >= 400 && this.status < 500;
+  }
+  isServerError() {
+    return this.status >= 500;
+  }
+};
+function buildQueryString(params) {
+  return query.toQueryString(params);
+}
+
+// src/response-handler.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+var ResponseHandler = class {
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  extractData(raw) {
+    if (this.config.extractData) return this.config.extractData(raw);
+    const record = asRecord(raw);
+    if (record && record.data !== void 0) return record.data;
+    return raw;
+  }
+  extractPaginated(raw) {
+    if (this.config.extractPaginated) {
+      return this.config.extractPaginated(raw);
+    }
+    const record = asRecord(raw);
+    if (!record) return null;
+    const data = record.data;
+    const meta = asRecord(record.meta);
+    const pagination = asRecord(meta?.pagination);
+    if (Array.isArray(data) && pagination) {
+      return {
+        items: data,
+        meta: {
+          page: Number(pagination.currentPage ?? pagination.page ?? 1),
+          limit: Number(pagination.pageSize ?? pagination.limit ?? data.length),
+          total: pagination.total === void 0 ? void 0 : Number(pagination.total),
+          totalPages: pagination.totalPages === void 0 ? void 0 : Number(pagination.totalPages)
+        }
+      };
+    }
+    if (Array.isArray(data) && meta) {
+      return { items: data, meta };
+    }
+    if (Array.isArray(record.items)) {
+      const limit = Number(record.limit ?? record.items.length);
+      const total = record.total === void 0 ? void 0 : Number(record.total);
+      return {
+        items: record.items,
+        meta: {
+          page: Number(record.page ?? 1),
+          limit,
+          total,
+          totalPages: record.totalPages === void 0 && total !== void 0 && limit > 0 ? Math.ceil(total / limit) : record.totalPages === void 0 ? void 0 : Number(record.totalPages)
+        }
+      };
+    }
+    return null;
+  }
+  extractCursor(raw) {
+    if (this.config.extractCursor) {
+      return this.config.extractCursor(raw);
+    }
+    const record = asRecord(raw);
+    if (!record) return null;
+    const items = record.data ?? record.items;
+    if (!Array.isArray(items)) return null;
+    const meta = asRecord(record.meta);
+    return {
+      items,
+      meta: {
+        nextCursor: String(
+          meta?.nextCursor ?? record.nextCursor ?? record.cursor ?? ""
+        ) || null,
+        prevCursor: String(meta?.prevCursor ?? record.prevCursor ?? "") || null
+      }
+    };
+  }
+};
+
+// src/transports.ts
+function isBodyInit(value) {
+  return typeof value === "string" || value instanceof Blob || value instanceof FormData || value instanceof URLSearchParams || value instanceof ArrayBuffer;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function removeContentType(headers) {
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === "content-type") delete headers[key];
+  }
+}
+function serializeBody(body, headers) {
+  if (body === void 0 || body === null) return null;
+  if (isBodyInit(body)) {
+    if (isFormData(body)) removeContentType(headers);
+    return body;
+  }
+  const contentTypeKey = Object.keys(headers).find(
+    (key) => key.toLowerCase() === "content-type"
+  );
+  if (!contentTypeKey) headers["Content-Type"] = "application/json";
+  return JSON.stringify(body);
+}
+function withTimeout(signal, timeoutMs) {
+  if (!timeoutMs)
+    return { signal: signal ?? void 0, cleanup: () => void 0 };
+  const controller = new AbortController();
+  const timeout = globalThis.setTimeout(() => controller.abort(), timeoutMs);
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      globalThis.clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    }
+  };
+}
+function createFetchTransport(fetcher = fetch) {
+  return {
+    async request(request) {
+      const headers = { ...request.headers };
+      const { signal, cleanup } = withTimeout(
+        request.signal,
+        request.timeoutMs
+      );
+      try {
+        const init = {
+          method: request.method,
+          headers,
+          body: serializeBody(request.body, headers)
+        };
+        if (signal) init.signal = signal;
+        const response = await fetcher(request.url, init);
+        const normalizedHeaders = HttpError.normalizeHeaders(response.headers);
+        const contentType = normalizedHeaders["content-type"] ?? "";
+        const data = contentType.includes("application/json") ? await response.json().catch(() => null) : await response.text().catch(() => null);
+        return {
+          status: response.status,
+          statusText: response.statusText,
+          headers: normalizedHeaders,
+          data
+        };
+      } finally {
+        cleanup();
+      }
+    }
+  };
+}
+function createAxiosTransport(axios) {
+  return {
+    async request(request) {
+      const headers = { ...request.headers };
+      if (isFormData(request.body)) removeContentType(headers);
+      try {
+        const response = await axios.request({
+          url: request.url,
+          method: request.method,
+          headers,
+          data: request.body,
+          signal: request.signal ?? void 0,
+          timeout: request.timeoutMs,
+          onUploadProgress: request.onUploadProgress ? (event) => {
+            if (!event.total) return;
+            request.onUploadProgress?.(
+              Math.round(event.loaded * 100 / event.total)
+            );
+          } : void 0
+        });
+        return {
+          status: response.status,
+          statusText: response.statusText,
+          headers: HttpError.normalizeHeaders(response.headers),
+          data: response.data
+        };
+      } catch (error) {
+        const record = error;
+        if (record.response) {
+          return {
+            status: record.response.status,
+            statusText: record.response.statusText ?? "",
+            headers: HttpError.normalizeHeaders(record.response.headers),
+            data: record.response.data
+          };
+        }
+        throw new HttpError(0, null, record.message ?? String(error));
+      }
+    }
+  };
+}
+
+// src/client.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
+function isAbsoluteUrl(path) {
+  return /^https?:\/\//i.test(path);
+}
+function normalizeMethod(method) {
+  return method.toUpperCase();
+}
+function normalizeRequestInput(input) {
+  return typeof input === "string" ? { path: input } : input;
+}
+var ApiClient = class {
+  baseURL;
+  transport;
+  getToken;
+  getLanguage;
+  defaultHeaders;
+  defaultRetry;
+  defaultTimeoutMs;
+  plugins;
+  responseHandler;
+  constructor(options) {
+    this.baseURL = options.baseURL.replace(/\/+$/, "");
+    this.transport = options.transport ?? createFetchTransport();
+    this.getToken = options.getToken;
+    this.getLanguage = options.getLanguage;
+    this.defaultHeaders = options.defaultHeaders ?? {
+      "Content-Type": "application/json"
+    };
+    this.defaultRetry = options.defaultRetry ?? 2;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 3e4;
+    this.plugins = options.plugins ?? [];
+    this.responseHandler = new ResponseHandler(options.responseHandler);
+  }
+  addPlugin(plugin) {
+    this.plugins.push(plugin);
+  }
+  /**
+   * Monte un greffon et renvoie le client.
+   *
+   * Le chaînage rend l'assemblage lisible d'un coup d'œil — c'est là qu'on
+   * relit l'ordre des greffons, et l'ordre compte : le premier qui renvoie une
+   * valeur court-circuite les suivants.
+   */
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  buildURL(path, params) {
+    const queryString = buildQueryString(params);
+    if (isAbsoluteUrl(path)) return `${path}${queryString}`;
+    const trimmed = path.startsWith("/") ? path : `/${path}`;
+    return `${this.baseURL}${trimmed}${queryString}`;
+  }
+  async runPlugins(hook, ...args) {
+    for (const plugin of this.plugins) {
+      const handler = plugin[hook];
+      if (!handler) continue;
+      const result = await handler(...args);
+      if (result !== void 0) return result;
+    }
+    return void 0;
+  }
+  async buildHeaders(custom) {
+    const token = this.getToken ? await this.getToken() : null;
+    const language = this.getLanguage ? await this.getLanguage() : null;
+    const headers = {
+      ...this.defaultHeaders,
+      ...custom ?? {}
+    };
+    if (token && !headers.Authorization)
+      headers.Authorization = `Bearer ${token}`;
+    if (language && !headers["Accept-Language"])
+      headers["Accept-Language"] = language;
+    return headers;
+  }
+  shouldRetry(error, attempt, maxRetries) {
+    if (attempt >= maxRetries) return false;
+    if (error instanceof DOMException && error.name === "AbortError")
+      return false;
+    if (error instanceof HttpError) {
+      return RETRYABLE_STATUSES.has(error.status);
+    }
+    return true;
+  }
+  async requestRaw(method, path, config = {}) {
+    const ctx = {
+      ...config,
+      url: this.buildURL(path, config.queryParams),
+      method: normalizeMethod(method),
+      headers: await this.buildHeaders(config.headers)
+    };
+    const onRequestResult = await this.runPlugins("onRequest", ctx);
+    if (onRequestResult !== void 0) return onRequestResult;
+    const maxRetries = config.retry ?? this.defaultRetry;
+    let attempt = 0;
+    while (true) {
+      try {
+        const response = await this.transport.request({
+          url: ctx.url,
+          method: ctx.method,
+          headers: ctx.headers,
+          body: ctx.body,
+          signal: ctx.signal,
+          timeoutMs: ctx.timeoutMs ?? this.defaultTimeoutMs,
+          onUploadProgress: ctx.onUploadProgress
+        });
+        const pluginResult = await this.runPlugins(
+          "onResponse",
+          response,
+          ctx
+        );
+        if (pluginResult !== void 0) return pluginResult;
+        if (response.status >= 400) {
+          throw new HttpError(
+            response.status,
+            response.data,
+            void 0,
+            response.headers
+          );
+        }
+        if (response.status === 204) return null;
+        return response.data;
+      } catch (error) {
+        const pluginResult = await this.runPlugins("onError", error, ctx);
+        if (pluginResult !== void 0) return pluginResult;
+        if (!this.shouldRetry(error, attempt, maxRetries)) throw error;
+        attempt += 1;
+        const baseDelay = Math.min(1e3 * 2 ** attempt, 3e4);
+        await async.sleep(baseDelay + Math.random() * 0.1 * baseDelay);
+      }
+    }
+  }
+  async request(method, path, config) {
+    const raw = await this.requestRaw(method, path, config);
+    if (raw === null || typeof raw === "string") return raw;
+    return this.responseHandler.extractData(raw);
+  }
+  replay(ctx) {
+    return this.request(ctx.method, ctx.url, {
+      headers: ctx.headers,
+      body: ctx.body,
+      signal: ctx.signal,
+      timeoutMs: ctx.timeoutMs,
+      retry: 0,
+      onUploadProgress: ctx.onUploadProgress
+    });
+  }
+  get(path, config) {
+    return this.request("GET", path, config);
+  }
+  post(path, config) {
+    return this.request("POST", path, config);
+  }
+  put(path, config) {
+    return this.request("PUT", path, config);
+  }
+  patch(path, config) {
+    return this.request("PATCH", path, config);
+  }
+  delete(path, config) {
+    return this.request("DELETE", path, config);
+  }
+  /** Sans corps de réponse : sert à tester l'existence ou lire des en-têtes. */
+  head(path, config) {
+    return this.request("HEAD", path, config);
+  }
+  /**
+   * Une liste, qu'elle soit paginée ou non.
+   *
+   * Beaucoup d'points d'entrée renvoient un tableau nu quand il n'y a pas de
+   * pagination. Les appelants ne devraient pas avoir à deviner lequel : la
+   * méthode normalise les deux en `{ items, meta }`.
+   */
+  async getList(path, config) {
+    const raw = await this.requestRaw("GET", path, config);
+    const parsed = this.responseHandler.extractPaginated(raw);
+    if (parsed) return parsed;
+    const fallback = raw;
+    const items = Array.isArray(raw) ? raw : fallback.data ?? fallback.items ?? [];
+    return { items, meta: { page: 1, limit: items.length, total: items.length } };
+  }
+  async getPaginated(path, options = {}) {
+    const page = options.page ?? 1;
+    const limit = options.limit ?? 20;
+    const raw = await this.requestRaw("GET", path, {
+      ...options.config,
+      queryParams: { ...options.query ?? {}, page, limit }
+    });
+    const parsed = this.responseHandler.extractPaginated(raw);
+    if (parsed) return parsed;
+    const fallback = raw;
+    return {
+      items: fallback.data ?? fallback.items ?? [],
+      meta: {
+        page,
+        limit,
+        total: fallback.total,
+        totalPages: fallback.totalPages
+      }
+    };
+  }
+  async getCursorPage(path, options = {}) {
+    const cursorParamName = options.cursorParamName ?? "cursor";
+    const raw = await this.requestRaw("GET", path, {
+      ...options.config,
+      queryParams: {
+        ...options.query ?? {},
+        [cursorParamName]: options.cursor ?? null,
+        limit: options.limit ?? 20
+      }
+    });
+    const parsed = this.responseHandler.extractCursor(raw);
+    if (parsed) return parsed;
+    const fallback = raw;
+    return {
+      items: fallback.data ?? fallback.items ?? [],
+      meta: { nextCursor: fallback.nextCursor ?? null }
+    };
+  }
+  query(loader) {
+    return loader;
+  }
+  swrFetcher(config) {
+    return (path) => this.get(path, config);
+  }
+  rtkBaseQuery() {
+    return async (input) => {
+      const { path, config } = normalizeRequestInput(input);
+      try {
+        return { data: await this.get(path, config) };
+      } catch (error) {
+        if (error instanceof HttpError) {
+          return {
+            error: {
+              status: error.status,
+              data: error.body,
+              message: error.message
+            }
+          };
+        }
+        return {
+          error: {
+            status: "FETCH_ERROR",
+            data: error,
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    };
+  }
+};
+function createApiClient(options) {
+  return new ApiClient(options);
+}
+
+// src/plugins.ts
+function createAuthPlugin(options) {
+  return {
+    name: "auth",
+    onRequest: async (ctx) => {
+      const token = await options.getToken();
+      if (!token) return void 0;
+      const scheme = options.scheme ?? "Bearer";
+      ctx.headers.Authorization = scheme ? `${scheme} ${token}` : token;
+      return void 0;
+    }
+  };
+}
+function createUnauthorizedPlugin(options) {
+  return {
+    name: "unauthorized",
+    onError: (error, ctx) => {
+      if (!(error instanceof HttpError) || error.status !== 401)
+        return void 0;
+      if (options.shouldIgnore?.(ctx)) return void 0;
+      options.onUnauthorized(error, ctx);
+      return void 0;
+    }
+  };
+}
+function unwrapTokenResponse(data) {
+  if (!data || typeof data !== "object") return {};
+  const record = data;
+  const nested = record.data;
+  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+    return nested;
+  }
+  return record;
+}
+function extractAccessToken(data) {
+  const record = unwrapTokenResponse(data);
+  const token = record.accessToken ?? record.access_token;
+  return typeof token === "string" ? token : null;
+}
+function extractRefreshToken(data) {
+  const record = unwrapTokenResponse(data);
+  const token = record.refreshToken ?? record.refresh_token;
+  return typeof token === "string" ? token : void 0;
+}
+function createRefreshTokenPlugin(config, replayRequest) {
+  if (!config.enabled) return { name: "refresh-token" };
+  let isRefreshing = false;
+  let queue = [];
+  const processQueueSuccess = async () => {
+    const items = queue.slice();
+    queue = [];
+    for (const item of items) {
+      try {
+        item.resolve(await replayRequest(item.ctx));
+      } catch (error) {
+        item.reject(error);
+      }
+    }
+  };
+  const processQueueFailure = (error) => {
+    const items = queue.slice();
+    queue = [];
+    for (const item of items) item.reject(error);
+  };
+  return {
+    name: "refresh-token",
+    onError: async (error, ctx) => {
+      if (!(error instanceof HttpError) || error.status !== 401)
+        return void 0;
+      if (ctx.url.includes(config.refreshEndpoint)) {
+        config.onRefreshFailure?.(error);
+        return void 0;
+      }
+      if (isRefreshing) {
+        return new Promise((resolve, reject) => {
+          queue.push({ resolve, reject, ctx });
+        });
+      }
+      isRefreshing = true;
+      try {
+        const refreshToken = await config.getRefreshToken?.();
+        if (!refreshToken) throw error;
+        const response = await fetch(config.refreshEndpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ refreshToken })
+        });
+        if (!response.ok) throw await HttpError.fromResponse(response);
+        const data = await response.json().catch(() => null);
+        const accessToken = extractAccessToken(data);
+        if (!accessToken)
+          throw new Error("No access token in refresh response.");
+        await config.saveTokens(accessToken, extractRefreshToken(data));
+        isRefreshing = false;
+        await processQueueSuccess();
+        return replayRequest(ctx);
+      } catch (refreshError) {
+        isRefreshing = false;
+        processQueueFailure(refreshError);
+        config.onRefreshFailure?.(refreshError);
+        return void 0;
+      }
+    }
+  };
+}
+function createLoggerPlugin(options = {}) {
+  const log = options.log ?? ((message) => console.debug(message));
+  const started = /* @__PURE__ */ new WeakMap();
+  return {
+    name: "logger",
+    onRequest: (ctx) => {
+      started.set(ctx, Date.now());
+      log(`[api \u2192] ${ctx.method} ${ctx.url}`);
+      return void 0;
+    },
+    onResponse: (response, ctx) => {
+      const ms = Date.now() - (started.get(ctx) ?? Date.now());
+      log(`[api \u2190] ${ctx.method} ${ctx.url} ${response.status} (${ms}ms)`);
+      return void 0;
+    },
+    onError: (error, ctx) => {
+      const ms = Date.now() - (started.get(ctx) ?? Date.now());
+      log(`[api \u2715] ${ctx.method} ${ctx.url} (${ms}ms)`, error);
+      return void 0;
+    }
+  };
+}
+function createIdempotencyPlugin(options = {}) {
+  const header = options.header ?? "Idempotency-Key";
+  const newKey = options.newKey ?? (() => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(16).slice(2)}`);
+  const WRITES = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+  return {
+    name: "idempotency",
+    onRequest: (ctx) => {
+      if (!WRITES.has(ctx.method)) return void 0;
+      const existing = Object.keys(ctx.headers).some(
+        (key) => key.toLowerCase() === header.toLowerCase()
+      );
+      if (!existing) ctx.headers[header] = newKey();
+      return void 0;
+    }
+  };
+}
+function createReadOnlyPlugin(message = "Cette action est d\xE9sactiv\xE9e en lecture seule.") {
+  const SAFE = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+  return {
+    name: "read-only",
+    onRequest: (ctx) => {
+      if (SAFE.has(ctx.method)) return void 0;
+      throw new HttpError(403, { message }, message);
+    }
+  };
+}
+function createHeaderSignalPlugin(options) {
+  const header = options.header.toLowerCase();
+  const expect = options.expect ?? ((value) => value.toLowerCase() === "true");
+  let pending = null;
+  const react = async (value, ctx) => {
+    if (pending) return pending;
+    pending = Promise.resolve(options.onSignal(value, ctx)).finally(() => {
+      pending = null;
+    });
+    return pending;
+  };
+  const read = (headers) => {
+    if (!headers || typeof headers !== "object") return void 0;
+    const record = headers;
+    const value = record[header] ?? record[options.header];
+    return typeof value === "string" ? value : void 0;
+  };
+  return {
+    name: `header-signal:${options.header}`,
+    onResponse: async (response, ctx) => {
+      const value = read(response.headers);
+      if (value && expect(value)) await react(value, ctx);
+      return void 0;
+    },
+    onError: async (error, ctx) => {
+      if (!(error instanceof HttpError)) return void 0;
+      const value = read(error.headers);
+      if (value && expect(value)) await react(value, ctx);
+      return void 0;
+    }
+  };
+}
+
+// src/storage.ts
+var ACCESS_TOKEN_KEY = "sia.accessToken";
+var REFRESH_TOKEN_KEY = "sia.refreshToken";
+function createMemoryTokenStorage() {
+  let access = null;
+  let refresh = null;
+  return {
+    getAccessToken: () => access,
+    getRefreshToken: () => refresh,
+    saveTokens: (accessToken, refreshToken) => {
+      access = accessToken;
+      refresh = refreshToken ?? null;
+    },
+    clear: () => {
+      access = null;
+      refresh = null;
+    }
+  };
+}
+function createBrowserTokenStorage(storage, options = {}) {
+  const accessKey = options.accessKey ?? ACCESS_TOKEN_KEY;
+  const refreshKey = options.refreshKey ?? REFRESH_TOKEN_KEY;
+  const read = (key) => {
+    try {
+      return storage.getItem(key);
+    } catch {
+      return null;
+    }
+  };
+  const write = (key, value) => {
+    try {
+      if (value === null) storage.removeItem(key);
+      else storage.setItem(key, value);
+    } catch {
+    }
+  };
+  return {
+    getAccessToken: () => read(accessKey),
+    getRefreshToken: () => read(refreshKey),
+    saveTokens: (accessToken, refreshToken) => {
+      write(accessKey, accessToken);
+      write(refreshKey, refreshToken ?? null);
+    },
+    clear: () => {
+      write(accessKey, null);
+      write(refreshKey, null);
+    }
+  };
+}
+
+// src/filters.ts
+function isGroup(filters) {
+  return "$and" in filters || "$or" in filters;
+}
+function normalizeFilters(filters) {
+  if (!filters || typeof filters !== "object") return void 0;
+  if (isGroup(filters)) return filters;
+  if (Object.keys(filters).length === 0) return void 0;
+  return { $and: [filters] };
+}
+var FILTERS_HEADER = "X-Filters";
+function filtersHeader(filters, header = FILTERS_HEADER) {
+  const normalized = normalizeFilters(filters);
+  if (!normalized) return {};
+  return { [header]: JSON.stringify(normalized) };
+}
+
+// src/service.ts
+var BaseService = class {
+  client;
+  resource;
+  constructor(client, resource) {
+    this.client = client;
+    this.resource = resource;
+  }
+  normalizeQueryParams(params) {
+    if (!params || typeof params !== "object") return params;
+    const normalized = { ...params };
+    for (const key of ["relations", "select"]) {
+      const value = normalized[key];
+      if (Array.isArray(value)) {
+        normalized[key] = value.map((item) => String(item).trim()).filter(Boolean).join(",");
+      }
+    }
+    return normalized;
+  }
+  list(params, config) {
+    return this.client.get(this.resource, {
+      ...config,
+      queryParams: this.normalizeQueryParams(params)
+    });
+  }
+  getById(id, config) {
+    return this.client.get(`${this.resource}/${id}`, config);
+  }
+  create(payload, config) {
+    return this.client.post(this.resource, {
+      ...config,
+      body: payload
+    });
+  }
+  update(id, payload, config) {
+    return this.client.put(`${this.resource}/${id}`, {
+      ...config,
+      body: payload
+    });
+  }
+  patch(id, payload, config) {
+    return this.client.patch(`${this.resource}/${id}`, {
+      ...config,
+      body: payload
+    });
+  }
+  remove(id, config) {
+    return this.client.delete(`${this.resource}/${id}`, config);
+  }
+  /**
+   * Suppression en lot.
+   *
+   * Un `POST` plutôt que N `DELETE` : le serveur décide en une transaction,
+   * et l'interface n'a pas à gérer une suppression à moitié réussie.
+   */
+  removeMany(ids, options = {}, config) {
+    return this.client.post(`${this.resource}/manydelete`, {
+      ...config,
+      body: { ids, hardDelete: options.hardDelete ?? false }
+    });
+  }
+  /**
+   * Une liste filtrée, la forme composée passant par un en-tête.
+   *
+   * Voir `filters.ts` : une recherche à plusieurs critères tient mal dans une
+   * URL.
+   */
+  search(filters, params, config) {
+    return this.client.getList(this.resource, {
+      ...config,
+      headers: { ...config?.headers, ...filtersHeader(filters) },
+      queryParams: this.normalizeQueryParams(params)
+    });
+  }
+  paginated(options = {}) {
+    return this.client.getPaginated(this.resource, {
+      ...options,
+      query: this.normalizeQueryParams(options.query)
+    });
+  }
+  cursorPage(options = {}) {
+    return this.client.getCursorPage(this.resource, {
+      ...options,
+      query: this.normalizeQueryParams(options.query)
+    });
+  }
+};
+function createResourceService(client, resourcePath) {
+  return new BaseService(client, resourcePath);
+}
+
+exports.ACCESS_TOKEN_KEY = ACCESS_TOKEN_KEY;
+exports.ApiClient = ApiClient;
+exports.BaseService = BaseService;
+exports.FILTERS_HEADER = FILTERS_HEADER;
+exports.HttpError = HttpError;
+exports.REFRESH_TOKEN_KEY = REFRESH_TOKEN_KEY;
+exports.ResponseHandler = ResponseHandler;
+exports.buildQueryString = buildQueryString;
+exports.createApiClient = createApiClient;
+exports.createAuthPlugin = createAuthPlugin;
+exports.createAxiosTransport = createAxiosTransport;
+exports.createBrowserTokenStorage = createBrowserTokenStorage;
+exports.createFetchTransport = createFetchTransport;
+exports.createHeaderSignalPlugin = createHeaderSignalPlugin;
+exports.createIdempotencyPlugin = createIdempotencyPlugin;
+exports.createLoggerPlugin = createLoggerPlugin;
+exports.createMemoryTokenStorage = createMemoryTokenStorage;
+exports.createReadOnlyPlugin = createReadOnlyPlugin;
+exports.createRefreshTokenPlugin = createRefreshTokenPlugin;
+exports.createResourceService = createResourceService;
+exports.createUnauthorizedPlugin = createUnauthorizedPlugin;
+exports.filtersHeader = filtersHeader;
+exports.normalizeFilters = normalizeFilters;