@localazy/cdn-client 1.1.2 → 1.2.1

package/dist/index.d.ts

@@ -1,23 +1,15 @@
-import { AxiosInstance } from 'axios';
-import { AxiosRequestConfig } from 'axios';
-import { AxiosResponse } from 'axios';
-import { CreateAxiosDefaults } from 'axios';
-
 export declare class Api {
     protected context: Context;
     constructor(context: Context);
-    fetchLocale(options: ApiLocaleRequest): Promise<AxiosResponse>;
-    fetchMetafile(config?: AxiosRequestConfig): Promise<AxiosResponse<IMetafile>>;
+    fetchLocale(options: ApiLocaleRequest): Promise<object | string>;
+    fetchMetafile(): Promise<IMetafile>;
 }
 
 export declare type ApiLocaleRequest = ILocalesCacheItem;
 
-export declare class AxiosHttpAdapter implements IHttpAdapter {
-    client: AxiosInstance;
-    constructor(baseUrl: string, config?: CreateAxiosDefaults);
-    protected static clientFactory(baseURL: string, config?: CreateAxiosDefaults): AxiosInstance;
-    get<T = unknown, D = unknown>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
-}
+export declare type ApiRequestConfig = object & {
+    reference: ApiLocaleRequest;
+};
 
 export declare type CacheGetLocalesRequest = ILocalesCacheItem;
 
@@ -42,9 +34,9 @@ export declare class CdnClient {
     metafile: CdnMetafile;
     cache: CdnCache;
     protected context: Context;
-    protected constructor(options: CdnClientOptions, config?: CreateAxiosDefaults);
+    protected constructor(options: CdnClientOptions);
     fetch: (options?: CdnFetchOptions) => Promise<CdnResponse>;
-    static create(options: CdnClientOptions, config?: CreateAxiosDefaults): Promise<CdnClient>;
+    static create(options: CdnClientOptions): Promise<CdnClient>;
 }
 
 export declare type CdnClientOptions = {
@@ -182,8 +174,8 @@ export declare class CdnMetafile extends CdnBase {
     get baseLocale(): CdnLocale;
     get url(): string;
     locales: (options?: CdnLocalesOptions) => CdnLocale[];
-    refresh: (config?: AxiosRequestConfig) => Promise<void>;
-    switch: (options: CdnClientOptions, config?: AxiosRequestConfig) => Promise<void>;
+    refresh: () => Promise<void>;
+    switch: (options: CdnClientOptions) => Promise<void>;
 }
 
 export declare class CdnMetafileFiles extends CdnBase {
@@ -241,6 +233,12 @@ export declare type ExcludeBaseLocale = {
     excludeBaseLocale?: boolean;
 };
 
+export declare class FetchHttpAdapter implements IHttpAdapter {
+    protected baseUrl: string;
+    constructor(baseUrl: string);
+    get(url: string): Promise<string | object>;
+}
+
 export declare type FileResponse = {
     [fileId: string]: LocaleResponse;
 };
@@ -256,8 +254,8 @@ export declare interface ICacheAdapter<K, V> {
     flush: () => void;
 }
 
-export declare interface IHttpAdapter {
-    get<T = unknown, D = unknown>(url: string, config?: AxiosRequestConfig<D>): Promise<T>;
+export declare interface IHttpAdapter<T = object> {
+    get: (url: string, config?: T) => Promise<object | string>;
 }
 
 export declare interface ILocalesCacheItem {
@@ -433,7 +431,7 @@ declare class Request_2 {
     protected context: Context;
     constructor(context: Context);
     execute(): Promise<CdnResponse>;
-    protected getPromises(): Promise<AxiosResponse<CdnResponse>>[];
+    protected getPromises(): [Promise<string | object>, ApiLocaleRequest][];
 }
 export { Request_2 as Request }
 
@@ -450,13 +448,13 @@ export declare class ResponseFactory {
     protected context: Context;
     constructor(context: Context);
     createCdnResponse(options: ResponseFactoryOptions): CdnResponse;
-    protected cacheResponses(responses: AxiosResponse<CdnResponse>[]): void;
-    protected static transformResponsesToOutput(options: ResponseFactoryOptions): CdnResponse;
-    protected static extractReference(response: AxiosResponse<CdnResponse>): Partial<CacheStoreLocalesRequest>;
+    protected cacheResponses(requests: ApiLocaleRequest[], responses: (object | string)[]): void;
+    protected static transformResponses(options: ResponseFactoryOptions): CdnResponse;
 }
 
 export declare type ResponseFactoryOptions = {
-    responses: AxiosResponse<CdnResponse>[];
+    requests: ApiLocaleRequest[];
+    responses: (string | object)[];
     localesMap: LocalesMap;
     hasSingleFileResponse: boolean;
     hasSingleLocaleResponse: boolean;

package/dist/localazy-cdn-client.js

@@ -4,33 +4,25 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-/* @localazy/cdn-client@1.1.2
+/* @localazy/cdn-client@1.2.1
  * (c) 2024 Localazy <team@localazy.com>
  * @license MIT */
-import axios from "axios";
+import "isomorphic-fetch";
 class Api {
   constructor(context) {
     __publicField(this, "context");
     this.context = context;
   }
   async fetchLocale(options) {
-    const config = { reference: options };
     if (this.context.cache.has(options)) {
       return new Promise((resolve) => {
-        resolve({
-          data: this.context.cache.get(options),
-          config
-        });
+        resolve(this.context.cache.get(options));
       });
     }
-    const responseType = /\.(json|json5)$/.test(options.metafileFile.file) ? "json" : "text";
-    return this.context.client.get(options.metafileLocale.uri, { ...config, responseType });
+    return this.context.client.get(options.metafileLocale.uri);
   }
-  async fetchMetafile(config) {
-    return this.context.client.get(
-      this.context.metafile.params.jsonPath,
-      config
-    );
+  async fetchMetafile() {
+    return await this.context.client.get(this.context.metafile.params.jsonPath);
   }
 }
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
@@ -1582,40 +1574,45 @@ class ResponseFactory {
     this.context = context;
   }
   createCdnResponse(options) {
-    const { responses, hasSingleFileResponse, hasSingleLocaleResponse } = options;
+    const {
+      requests,
+      responses,
+      hasSingleFileResponse,
+      hasSingleLocaleResponse
+    } = options;
     if (responses.length === 0) {
       return {};
     }
-    this.cacheResponses(responses);
-    return hasSingleFileResponse && hasSingleLocaleResponse ? responses[0].data : ResponseFactory.transformResponsesToOutput(options);
+    this.cacheResponses(requests, responses);
+    return hasSingleFileResponse && hasSingleLocaleResponse ? responses[0] : ResponseFactory.transformResponses(options);
   }
-  cacheResponses(responses) {
-    responses.forEach((response) => {
+  cacheResponses(requests, responses) {
+    responses.forEach((response, index) => {
       const {
         metafileFile,
         metafileLocale
-      } = ResponseFactory.extractReference(response);
+      } = requests[index];
       if (metafileFile && metafileLocale) {
-        this.context.cache.setIfMissed({ metafileFile, metafileLocale, data: response.data });
+        this.context.cache.setIfMissed({ metafileFile, metafileLocale, data: response });
       }
     });
   }
-  static transformResponsesToOutput(options) {
-    const { responses, hasSingleFileResponse } = options;
+  static transformResponses(options) {
+    const { requests, responses, hasSingleFileResponse } = options;
     return responses.reduce(
-      (acc, cur) => {
+      (acc, cur, index) => {
         const {
           metafileFile,
           metafileLocale
-        } = ResponseFactory.extractReference(cur);
+        } = requests[index];
         if (metafileFile && metafileLocale) {
           if (hasSingleFileResponse) {
-            acc[metafileLocale.locale] = cur.data;
+            acc[metafileLocale.locale] = cur;
           } else {
             if (!acc[metafileFile.id]) {
               acc[metafileFile.id] = {};
             }
-            acc[metafileFile.id][metafileLocale.locale] = cur.data;
+            acc[metafileFile.id][metafileLocale.locale] = cur;
           }
         }
         return acc;
@@ -1623,17 +1620,6 @@ class ResponseFactory {
       {}
     );
   }
-  static extractReference(response) {
-    var _a, _b;
-    const metafileFile = (_a = response.config.reference) == null ? void 0 : _a.metafileFile;
-    const metafileLocale = (_b = response.config.reference) == null ? void 0 : _b.metafileLocale;
-    const { data } = response;
-    return {
-      metafileFile,
-      metafileLocale,
-      data
-    };
-  }
 }
 class Context {
   constructor(options) {
@@ -2237,13 +2223,13 @@ class CdnMetafile extends CdnBase {
       const { locales } = this.context.metafile.data;
       return excludeBaseLocale ? locales.filter((cdnLocale) => !cdnLocale.isBaseLocale) : locales;
     });
-    __publicField(this, "refresh", async (config) => {
-      const response = await this.context.api.fetchMetafile(config);
-      this.context.metafile.setMetafile(response.data);
+    __publicField(this, "refresh", async () => {
+      const response = await this.context.api.fetchMetafile();
+      this.context.metafile.setMetafile(response);
     });
-    __publicField(this, "switch", async (options, config) => {
+    __publicField(this, "switch", async (options) => {
       this.context.metafile.params = new MetafileParams(options.metafile);
-      await this.refresh(config);
+      await this.refresh();
     });
     this.files = new CdnMetafileFiles(context);
   }
@@ -2284,8 +2270,17 @@ class Request {
     this.context = context;
   }
   async execute() {
+    const payload = this.getPromises();
+    const promises = payload.map(
+      (item) => item[0]
+    );
+    const requests = payload.map(
+      (item) => item[1]
+    );
+    const responses = await Promise.all(promises);
     return this.context.responseFactory.createCdnResponse({
-      responses: await Promise.all(this.getPromises()),
+      requests,
+      responses,
       localesMap: this.localesMap,
       hasSingleFileResponse: this.hasSingleFileResponse,
       hasSingleLocaleResponse: this.hasSingleLocaleResponse
@@ -2297,10 +2292,16 @@ class Request {
         if (this.localesMap.data[cur.id]) {
           acc.push(
             ...this.localesMap.data[cur.id].map(
-              (metafileLocale) => this.context.api.fetchLocale({
-                metafileFile: cur,
-                metafileLocale
-              })
+              (metafileLocale) => {
+                const request = {
+                  metafileFile: cur,
+                  metafileLocale
+                };
+                return [
+                  this.context.api.fetchLocale(request),
+                  request
+                ];
+              }
             )
           );
         }
@@ -2422,21 +2423,40 @@ class RequestBuilder {
     return result;
   }
 }
-class AxiosHttpAdapter {
-  constructor(baseUrl, config) {
-    __publicField(this, "client");
-    this.client = AxiosHttpAdapter.clientFactory(baseUrl, config);
-  }
-  static clientFactory(baseURL, config) {
-    const clientConfig = { baseURL, ...config };
-    return axios.create(clientConfig);
-  }
-  get(url, config) {
-    return this.client.get(url, config);
+class FetchHttpAdapter {
+  constructor(baseUrl) {
+    __publicField(this, "baseUrl");
+    this.baseUrl = baseUrl;
+  }
+  async get(url) {
+    const response = await fetch(`${this.baseUrl}${url}`);
+    const contentType = response.headers.get("content-type") || "";
+    const isJson = [
+      "application/json5",
+      "application/json"
+    ].includes(contentType);
+    if (response.status >= 400) {
+      throw new Error(`Request failed with status code ${response.status}`);
+    }
+    let result = "";
+    if (isJson) {
+      try {
+        result = await response.json();
+      } catch (error) {
+        result = {};
+      }
+    } else {
+      try {
+        result = await response.text();
+      } catch (error) {
+        result = "";
+      }
+    }
+    return result;
   }
 }
 class CdnClient {
-  constructor(options, config) {
+  constructor(options) {
     __publicField(this, "metafile");
     __publicField(this, "cache");
     __publicField(this, "context");
@@ -2446,32 +2466,32 @@ class CdnClient {
       return requestBuilder.getCdnRequest().execute();
     });
     const metafileContext = new MetafileContext(options);
-    const client = new AxiosHttpAdapter(metafileContext.params.baseUrl, config);
+    const client = new FetchHttpAdapter(metafileContext.params.baseUrl);
     this.context = new Context({ metafileContext, cdn: this, client });
     this.metafile = new CdnMetafile(this.context);
     this.cache = new CdnCache(this.context);
   }
-  static async create(options, config) {
+  static async create(options) {
     if (!options) {
       throw new Error('Invalid param: missing required "options" parameter.');
     }
     if (!isString$1(options.metafile)) {
       throw new Error('Invalid param: "options.metafile" must be string.');
     }
-    const cdn = new CdnClient(options, config);
-    await cdn.metafile.refresh(config);
+    const cdn = new CdnClient(options);
+    await cdn.metafile.refresh();
     return cdn;
   }
 }
 export {
   Api,
-  AxiosHttpAdapter,
   CdnBase,
   CdnCache,
   CdnClient,
   CdnMetafile,
   CdnMetafileFiles,
   Context,
+  FetchHttpAdapter,
   LocalesCache,
   LocalesMap,
   MemoryCacheAdapter,