typedapi-client-helpers 0.1.16 → 0.2.0

package/dist/index.cjs

@@ -20,56 +20,252 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ContentType: () => ContentType,
+  abortRequest: () => abortRequest,
   buildQuery: () => buildQuery,
+  configureApiClient: () => configureApiClient,
+  createApiClient: () => createApiClient,
+  defaultApiClient: () => defaultApiClient,
   extractArgsCallbacksAndParams: () => extractArgsCallbacksAndParams,
   extractArgsToastsAndParams: () => extractArgsToastsAndParams,
   getSortDirectionFromSortType: () => getSortDirectionFromSortType,
   getSortTypeFromSortDirection: () => getSortTypeFromSortDirection,
   handleApiResponse: () => handleApiResponse,
+  request: () => request,
+  setSecurityData: () => setSecurityData,
   sortTypes: () => sortTypes,
   toFormData: () => toFormData
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/httpClient.ts
+var ContentType = {
+  Json: "application/json",
+  JsonApi: "application/vnd.api+json",
+  FormData: "multipart/form-data",
+  UrlEncoded: "application/x-www-form-urlencoded",
+  Text: "text/plain"
+};
+function createApiClient(apiConfig = {}) {
+  const state = {
+    baseUrl: apiConfig.baseUrl ?? "",
+    securityData: null,
+    securityWorker: apiConfig.securityWorker,
+    customFetch: apiConfig.customFetch ?? ((...fetchParams) => fetch(...fetchParams)),
+    baseApiParams: {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer",
+      ...apiConfig.baseApiParams ?? {}
+    },
+    abortControllers: /* @__PURE__ */ new Map()
+  };
+  function configureApiClient2(nextConfig = {}) {
+    if (typeof nextConfig.baseUrl === "string") {
+      state.baseUrl = nextConfig.baseUrl;
+    }
+    if (nextConfig.securityWorker) {
+      state.securityWorker = nextConfig.securityWorker;
+    }
+    if (nextConfig.customFetch) {
+      state.customFetch = nextConfig.customFetch;
+    }
+    if (nextConfig.baseApiParams) {
+      state.baseApiParams = mergeRequestParams(
+        state.baseApiParams,
+        nextConfig.baseApiParams
+      );
+    }
+  }
+  function setSecurityData2(data) {
+    state.securityData = data;
+  }
+  function encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    const normalizedValue = value instanceof Date ? value.toISOString() : value;
+    return `${encodedKey}=${encodeURIComponent(String(normalizedValue))}`;
+  }
+  function addArrayQueryParam(key, value) {
+    return value.map((item) => encodeQueryParam(key, item)).join("&");
+  }
+  function toQueryString(rawQuery) {
+    if (!rawQuery) {
+      return "";
+    }
+    return Object.entries(rawQuery).filter(([, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => Array.isArray(value) ? addArrayQueryParam(key, value) : encodeQueryParam(key, value)
+    ).join("&");
+  }
+  function contentFormatter(type, input) {
+    if (input === void 0 || input === null) {
+      return null;
+    }
+    if (input instanceof FormData || input instanceof Blob) {
+      return input;
+    }
+    switch (type ?? ContentType.Json) {
+      case ContentType.Json:
+      case ContentType.JsonApi:
+        return JSON.stringify(input);
+      case ContentType.Text:
+        return typeof input === "string" ? input : JSON.stringify(input);
+      case ContentType.FormData:
+        return toFormData2(input);
+      case ContentType.UrlEncoded:
+        return toQueryString(input);
+      default:
+        return input;
+    }
+  }
+  function toFormData2(input) {
+    if (input instanceof FormData) {
+      return input;
+    }
+    const formData = new FormData();
+    for (const [key, value] of Object.entries(
+      input ?? {}
+    )) {
+      appendFormDataValue2(formData, key, value);
+    }
+    return formData;
+  }
+  function appendFormDataValue2(formData, key, value) {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        appendFormDataValue2(formData, key, item);
+      }
+      return;
+    }
+    if (value instanceof File) {
+      formData.append(key, value, value.name);
+      return;
+    }
+    if (value instanceof Blob) {
+      formData.append(key, value);
+      return;
+    }
+    if (typeof value === "object") {
+      formData.append(key, JSON.stringify(value));
+      return;
+    }
+    formData.append(key, String(value));
+  }
+  function mergeRequestParams(params1, params2) {
+    return {
+      ...params1,
+      ...params2 ?? {},
+      headers: {
+        ...params1.headers ?? {},
+        ...params2?.headers ?? {}
+      }
+    };
+  }
+  function createAbortSignal(cancelToken) {
+    const existingAbortController = state.abortControllers.get(cancelToken);
+    if (existingAbortController) {
+      return existingAbortController.signal;
+    }
+    const abortController = new AbortController();
+    state.abortControllers.set(cancelToken, abortController);
+    return abortController.signal;
+  }
+  function abortRequest2(cancelToken) {
+    const abortController = state.abortControllers.get(cancelToken);
+    if (!abortController) {
+      return;
+    }
+    abortController.abort();
+    state.abortControllers.delete(cancelToken);
+  }
+  async function request2({
+    body,
+    secure,
+    path,
+    type,
+    query,
+    baseUrl,
+    cancelToken,
+    ...params
+  }) {
+    const secureParams = (typeof secure === "boolean" ? secure : state.baseApiParams.secure) && state.securityWorker && await state.securityWorker(state.securityData) || {};
+    const requestParams = mergeRequestParams(
+      mergeRequestParams(state.baseApiParams, params),
+      secureParams
+    );
+    const queryString = query ? toQueryString(query) : "";
+    const url = `${baseUrl ?? state.baseUrl}${path}${queryString ? `?${queryString}` : ""}`;
+    const requestInit = {
+      ...requestParams,
+      headers: {
+        ...requestParams.headers ?? {},
+        ...type && type !== ContentType.FormData ? { "Content-Type": type } : {}
+      },
+      signal: cancelToken ? createAbortSignal(cancelToken) : requestParams.signal
+    };
+    if (body !== void 0 && body !== null) {
+      requestInit.body = contentFormatter(type, body);
+    }
+    const response = await state.customFetch(url, requestInit);
+    const typedResponse = response;
+    typedResponse.data = null;
+    typedResponse.error = null;
+    if (cancelToken) {
+      state.abortControllers.delete(cancelToken);
+    }
+    if (!response.ok) {
+      throw typedResponse;
+    }
+    return typedResponse;
+  }
+  return {
+    configureApiClient: configureApiClient2,
+    setSecurityData: setSecurityData2,
+    abortRequest: abortRequest2,
+    request: request2,
+    toQueryString
+  };
+}
+var defaultApiClient = createApiClient();
+var configureApiClient = defaultApiClient.configureApiClient;
+var setSecurityData = defaultApiClient.setSecurityData;
+var abortRequest = defaultApiClient.abortRequest;
+var request = defaultApiClient.request;
+
 // src/utils/buildQuery.ts
 function buildQuery(filters, page = 1, pageSize = 100, sortBy = null, sortDirection) {
-  let isPageSizeSet = pageSize > 0;
   const query = filters.reduce((queryResult, filter) => {
     const { filterName, filterNameMax, type, value, maxValue, isAList } = filter;
-    if ((value === null || value === void 0 || value === "") && (maxValue === null || maxValue === void 0 || maxValue === "")) {
+    if (isEmptyValue(value) && isEmptyValue(maxValue)) {
       return queryResult;
     }
     if (isAList && Array.isArray(value)) {
-      if (isOptionValueArray(value)) {
-        queryResult[filterName] = value.map(
-          (item) => convertType(type, item.value)
-        );
-        return queryResult;
+      const convertedValues = value.map(
+        (item) => convertType(type, isOptionValue(item) ? item.value : item)
+      ).filter((item) => item !== null);
+      if (convertedValues.length > 0) {
+        queryResult[filterName] = convertedValues;
       }
-      queryResult[filterName] = value.map(
-        (item) => convertType(type, item)
-      );
       return queryResult;
     }
-    if (value !== "null" && value !== "undefined" && value !== null && value !== void 0 && value !== "") {
-      const convertedValue = convertType(type, value);
-      if (convertedValue !== null) {
-        queryResult[filterName] = convertedValue;
-      }
+    const rawValue = isOptionValue(value) ? value.value : value;
+    const convertedValue = convertType(type, rawValue);
+    if (convertedValue !== null) {
+      queryResult[filterName] = convertedValue;
     }
-    if (filterNameMax && maxValue !== null && maxValue !== void 0 && maxValue !== "") {
+    if (filterNameMax && !isEmptyValue(maxValue)) {
       const convertedMaxValue = convertType(type, maxValue);
       if (convertedMaxValue !== null) {
         queryResult[filterNameMax] = convertedMaxValue;
       }
     }
-    if (String(filterName) === "pageSize" && !isPageSizeSet) {
-      isPageSizeSet = true;
-    }
     return queryResult;
   }, {});
   query.pageNumber = page;
-  if (isPageSizeSet) {
+  if (pageSize > 0) {
     query.pageSize = pageSize;
   }
   if (sortBy) {
@@ -80,20 +276,43 @@ function buildQuery(filters, page = 1, pageSize = 100, sortBy = null, sortDirect
   }
   return query;
 }
+function isEmptyValue(value) {
+  return value === null || value === void 0 || value === "" || value === "null" || value === "undefined";
+}
 function isOptionValue(value) {
   return typeof value === "object" && value !== null && "value" in value;
 }
-function isOptionValueArray(value) {
-  return value.every(isOptionValue);
-}
 function convertType(type, value) {
+  if (isEmptyValue(value)) {
+    return null;
+  }
   switch (type) {
-    case "date":
-      return value instanceof Date ? value.toISOString() : value;
-    case "number":
-      return Number(value);
+    case "date": {
+      if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? null : value.toISOString();
+      }
+      return value;
+    }
+    case "number": {
+      const numberValue = Number(value);
+      return Number.isNaN(numberValue) ? null : numberValue;
+    }
     case "boolean":
+    case "boolean-button": {
+      if (typeof value === "boolean") {
+        return value;
+      }
+      if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["true", "1", "yes", "on"].includes(normalized)) {
+          return true;
+        }
+        if (["false", "0", "no", "off"].includes(normalized)) {
+          return false;
+        }
+      }
       return Boolean(value);
+    }
     default:
       return value;
   }
@@ -171,15 +390,18 @@ function extractArgsCallbacksAndParams(argsWithCallbacks) {
 
 // src/utils/handleApiResponse.ts
 async function readResponseBody(response) {
-  if (response.status === 204) {
+  if (response.status === 204 || response.status === 205) {
     return void 0;
   }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/octet-stream")) {
+    return response.blob();
+  }
   const text = await response.text();
   if (!text) {
     return void 0;
   }
-  const contentType = response.headers.get("content-type");
-  if (contentType?.includes("application/json")) {
+  if (contentType.includes("json") || contentType.includes("+json")) {
     try {
       return JSON.parse(text);
     } catch {
@@ -188,30 +410,23 @@ async function readResponseBody(response) {
   }
   return text;
 }
+function isResponseLike(value) {
+  return typeof value === "object" && value !== null && "status" in value && "ok" in value && "headers" in value && typeof value.text === "function";
+}
 async function handleApiResponse(call, options) {
   let response;
   try {
     response = await call();
-    const data = await readResponseBody(response);
-    if (response.ok) {
-      const result2 = {
-        ok: true,
-        status: response.status,
-        response: data
-      };
-      await options?.onSuccess?.(result2);
-      return result2;
-    }
+    const data = await readResponseBody(response.clone());
     const result = {
-      ok: false,
+      ok: true,
       status: response.status,
-      response: void 0,
-      error: data
+      response: data
     };
-    await options?.onError?.(result);
+    await options?.onSuccess?.(result);
     return result;
   } catch (error) {
-    if (error instanceof Response) {
+    if (isResponseLike(error)) {
       const errorData = await readResponseBody(error.clone());
       const result2 = {
         ok: false,
@@ -242,10 +457,14 @@ var sortTypes = [
 ];
 function getSortTypeFromSortDirection(sortDirection) {
   switch (sortDirection) {
+    case "Asc":
     case "Ascending":
       return "Ascending";
+    case "Desc":
     case "Descending":
       return "Descending";
+    case "Neutral":
+      return "Neutral";
     case "Default":
     default:
       return "Default";
@@ -254,10 +473,11 @@ function getSortTypeFromSortDirection(sortDirection) {
 function getSortDirectionFromSortType(sortType) {
   switch (sortType) {
     case "Ascending":
-      return "Ascending";
+      return "Asc";
     case "Descending":
-      return "Descending";
+      return "Desc";
     case "Neutral":
+      return "Neutral";
     case "Default":
     default:
       return "Default";
@@ -298,12 +518,19 @@ function appendFormDataValue(formData, key, value) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ContentType,
+  abortRequest,
   buildQuery,
+  configureApiClient,
+  createApiClient,
+  defaultApiClient,
   extractArgsCallbacksAndParams,
   extractArgsToastsAndParams,
   getSortDirectionFromSortType,
   getSortTypeFromSortDirection,
   handleApiResponse,
+  request,
+  setSecurityData,
   sortTypes,
   toFormData
 });