@bbn/bbn 1.0.476 → 1.0.477

package/dist/fn/ajax/ajax.js

@@ -1,11 +1,192 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import isObject from '../type/isObject.js';
 import replaceAll from '../string/replaceAll.js';
 import getRequestId from './getRequestId.js';
 import getLoader from './getLoader.js';
 import extend from '../object/extend.js';
+import numProperties from '../object/numProperties.js';
 import _deleteLoader from './_deleteLoader.js';
 import isFunction from '../type/isFunction.js';
 import _addLoader from './_addLoader.js';
+class Cancel extends Error {
+    constructor(message) {
+        super(message || 'Request canceled');
+        this.name = 'Cancel';
+        this.__BBN_CANCEL__ = true;
+    }
+}
+const isCancel = function (value) {
+    return !!(value && value.__BBN_CANCEL__ === true);
+};
+const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
+const buildURL = function (url, params) {
+    if (!params)
+        return url;
+    const usp = new URLSearchParams(params).toString();
+    return usp ? url + (url.includes('?') ? '&' : '?') + usp : url;
+};
+const normalizeDataAndHeaders = function (data, headersObj) {
+    const headers = new Headers(headersObj || {});
+    let body = data;
+    if (data != null && !(data instanceof FormData) && typeof data === 'object') {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(data);
+    }
+    return { body, headers };
+};
+const fetchRequest = function (method, url, config = {}, aborter) {
+};
+/*
+const xhrRequest = function(method, url, config: any = {}, aborter?: any) {
+  const xhr = new XMLHttpRequest();
+  const hasBody = methodsWithBody.includes(method);
+
+  const promise = new Promise((resolve, reject) => {
+    xhr.open(method, url, true);
+
+    // Set headers
+    const { body, headers } = normalizeDataAndHeaders(finalConfig.data, finalConfig.headers);
+    headers.forEach((value, key) => {
+      xhr.setRequestHeader(key, value);
+    });
+
+    // Upload progress
+    if (typeof finalConfig.onUploadProgress === 'function' && xhr.upload) {
+      xhr.upload.addEventListener('progress', (event) => {
+        const total = event.lengthComputable ? event.total : undefined;
+        finalConfig.onUploadProgress({
+          loaded: event.loaded,
+          total,
+          progress: total ? event.loaded / total : undefined
+        });
+      });
+    }
+
+    xhr.onreadystatechange = () => {
+      if (xhr.readyState !== 4) return;
+
+      const headersObj = parseXhrHeaders(xhr.getAllResponseHeaders());
+      const status = xhr.status === 1223 ? 204 : xhr.status; // IE fix, mostly irrelevant now
+      const statusText = xhr.statusText || '';
+
+      let data = xhr.responseText;
+      const contentType = headersObj['content-type'] || '';
+      if (contentType.includes('application/json')) {
+        try {
+          data = JSON.parse(xhr.responseText);
+        } catch (e) {
+          // leave as text if JSON parse fails
+        }
+      }
+
+      const response = {
+        data,
+        status,
+        statusText,
+        headers: headersObj,
+        config: finalConfig,
+        request: xhr
+      };
+
+      if (status >= 200 && status < 300) {
+        resolve(response);
+      } else {
+        const err = new Error('Request failed with status code ' + status);
+        err.response = response;
+        err.config = finalConfig;
+        err.request = xhr;
+        reject(err);
+      }
+    };
+
+    xhr.onerror = () => {
+      const err = new Error('Network Error');
+      err.config = finalConfig;
+      err.request = xhr;
+      reject(err);
+    };
+
+    xhr.onabort = () => {
+      reject(new Cancel('Request canceled'));
+    };
+
+    if (hasBody) {
+      xhr.send(body);
+    } else {
+      xhr.send();
+    }
+  });
+
+  promise.cancel = () => xhr.abort();
+  return promise;
+};
+*/
+const request = function (method, url, config = {}, aborter) {
+    const fetchConfig = {
+        method,
+        headers: new Headers(config.headers || {}),
+        signal: aborter === null || aborter === void 0 ? void 0 : aborter.signal,
+    };
+    if (config.data != null && method !== 'GET' && method !== 'HEAD') {
+        // You can get fancier here (JSON, FormData, etc.)
+        if (typeof config.data === 'object' && !(config.data instanceof FormData)) {
+            fetchConfig.headers.set('Content-Type', 'application/json');
+            fetchConfig.body = JSON.stringify(config.data);
+        }
+        else {
+            fetchConfig.body = config.data;
+        }
+    }
+    // Add query params support if needed
+    if (config.params) {
+        const usp = new URLSearchParams(config.params).toString();
+        url += (url.includes('?') ? '&' : '?') + usp;
+    }
+    const fetchPromise = fetch(url, fetchConfig).then((res) => __awaiter(this, void 0, void 0, function* () {
+        let data;
+        const contentType = res.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            data = yield res.json();
+        }
+        else {
+            data = yield res.text();
+        }
+        const response = {
+            data,
+            status: res.status,
+            statusText: res.statusText,
+            headers: Object.fromEntries(res.headers.entries()),
+            config,
+            request: res,
+        };
+        if (!res.ok) {
+            // axios rejects for 4xx/5xx
+            const error = new Error('Request failed with status code ' + res.status);
+            error.response = response;
+            error.config = config;
+            error.request = res;
+            throw error;
+        }
+        return response;
+    })).catch((err) => {
+        if (err.name === 'AbortError') {
+            throw new Cancel('Request canceled');
+        }
+        throw err;
+    });
+    // axios usually gives you the cancel token separately;
+    // here we return both for convenience.
+    fetchPromise.cancel = () => aborter.abort();
+    return fetchPromise;
+};
 /**
  * Creates an XHR object and returns the Promise.
  *
@@ -111,14 +292,14 @@ export default function ajax(url, datatype = null, data = null, success = null,
                 "Content-Type": "text/javascript",
             };
         }
-        let args = [url];
+        let method = "get";
         if (isObject(data)) {
-            args.push(data);
+            if (numProperties(data) > 0) {
+                options.data = data;
+                method = "post";
+            }
         }
-        args.push(options);
-        const axiosMethod = args.length === 2 ? "get" : "post";
-        let loader = axios[axiosMethod]
-            .apply(null, args)
+        let loader = request(method, url, options)
             .then(res => {
             _deleteLoader(requestId, res);
             bbn.fn.defaultEndLoadingFunction(url, tst, data, res);
@@ -141,7 +322,7 @@ export default function ajax(url, datatype = null, data = null, success = null,
             return res;
         })
             .catch((err) => {
-            let isAbort = axios.isCancel(err);
+            let isAbort = isCancel(err);
             _deleteLoader(requestId, err.message || err.response.data, isAbort);
             bbn.fn.defaultEndLoadingFunction(url, tst, data, err);
             if (isAbort) {

package/dist/fn/ajax/stream.js

@@ -23,6 +23,9 @@ import arrayBuffer2String from '../convert/arrayBuffer2String.js';
  * @returns  {Promise}  The Promise created by the generated XHR.
  */
 const boundary = '\n';
+const isCancel = function (value) {
+    return !!(value && value.__BBN_CANCEL__ === true);
+};
 export default function stream(url, success, data, failure, abort, finished) {
     const requestId = getRequestId(url, data, 'json');
     const loaderObj = getLoader(requestId);
@@ -111,7 +114,7 @@ export default function stream(url, success, data, failure, abort, finished) {
         }
     })
         .catch((err) => {
-        let isAbort = axios.isCancel(err);
+        let isAbort = isCancel(err);
         _deleteLoader(requestId, data, isAbort);
         defaultEndLoadingFunction(url, tst, data, err);
         if (isAbort) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "1.0.476",
+  "version": "1.0.477",
   "description": "Javascript toolkit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",