@localazy/cdn-client 1.1.2 → 1.2.1

package/dist/node/localazy-cdn-client.cjs

@@ -5,34 +5,26 @@ 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 */
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const axios = require("axios");
+require("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 : {};
@@ -1584,40 +1576,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;
@@ -1625,17 +1622,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) {
@@ -2239,13 +2225,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);
   }
@@ -2286,8 +2272,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
@@ -2299,10 +2294,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
+                ];
+              }
             )
           );
         }
@@ -2424,21 +2425,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");
@@ -2448,31 +2468,31 @@ 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;
   }
 }
 exports.Api = Api;
-exports.AxiosHttpAdapter = AxiosHttpAdapter;
 exports.CdnBase = CdnBase;
 exports.CdnCache = CdnCache;
 exports.CdnClient = CdnClient;
 exports.CdnMetafile = CdnMetafile;
 exports.CdnMetafileFiles = CdnMetafileFiles;
 exports.Context = Context;
+exports.FetchHttpAdapter = FetchHttpAdapter;
 exports.LocalesCache = LocalesCache;
 exports.LocalesMap = LocalesMap;
 exports.MemoryCacheAdapter = MemoryCacheAdapter;