@ethersphere/bee-js 5.1.1 → 5.1.2

package/dist/mjs/utils/hex.js

@@ -7,24 +7,19 @@ import { makeBytes } from "./bytes.js";
  * @param input
  * @param len of the resulting HexString WITHOUT prefix!
  */
-
 export function makeHexString(input, len) {
   if (typeof input === 'number') {
     return intToHex(input, len);
   }
-
   if (input instanceof Uint8Array) {
     return bytesToHex(input, len);
   }
-
   if (typeof input === 'string') {
     if (isPrefixedHexString(input)) {
       const hex = input.slice(2);
-
       if (len && hex.length !== len) {
         throw new TypeError(`Length mismatch for valid hex string. Expecting length ${len}: ${hex}`);
       }
-
       return hex;
     } else {
       // We use assertHexString() as there might be more reasons why a string is not valid hex string
@@ -34,7 +29,6 @@ export function makeHexString(input, len) {
       return input;
     }
   }
-
   throw new TypeError('Not HexString compatible type!');
 }
 /**
@@ -42,16 +36,13 @@ export function makeHexString(input, len) {
  *
  * @param hex string input without 0x prefix!
  */
-
 export function hexToBytes(hex) {
   assertHexString(hex);
   const bytes = makeBytes(hex.length / 2);
-
   for (let i = 0; i < bytes.length; i++) {
     const hexByte = hex.substr(i * 2, 2);
     bytes[i] = parseInt(hexByte, 16);
   }
-
   return bytes;
 }
 /**
@@ -60,16 +51,13 @@ export function hexToBytes(hex) {
  * @param bytes   The input array
  * @param len     The length of the non prefixed HexString
  */
-
 export function bytesToHex(bytes, len) {
   const hexByte = n => n.toString(16).padStart(2, '0');
-
-  const hex = Array.from(bytes, hexByte).join(''); // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
-
+  const hex = Array.from(bytes, hexByte).join('');
+  // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
   if (len && hex.length !== len) {
     throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
   }
-
   return hex;
 }
 /**
@@ -80,17 +68,15 @@ export function bytesToHex(bytes, len) {
  * @param int         The positive integer to be converted
  * @param len     The length of the non prefixed HexString
  */
-
 export function intToHex(int, len) {
   if (!Number.isInteger(int)) throw new TypeError('the value provided is not integer');
   if (int > Number.MAX_SAFE_INTEGER) throw new TypeError('the value provided exceeds safe integer');
   if (int < 0) throw new TypeError('the value provided is a negative integer');
-  const hex = int.toString(16); // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
-
+  const hex = int.toString(16);
+  // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
   if (len && hex.length !== len) {
     throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
   }
-
   return hex;
 }
 /**
@@ -102,7 +88,6 @@ export function intToHex(int, len) {
  * @param s string input
  * @param len expected length of the HexString
  */
-
 export function isHexString(s, len) {
   return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
 }
@@ -112,7 +97,6 @@ export function isHexString(s, len) {
  *
  * @param s string input
  */
-
 export function isPrefixedHexString(s) {
   return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
 }
@@ -126,14 +110,12 @@ export function isPrefixedHexString(s) {
  * @param name optional name for the asserted value
  * @returns HexString or throws error
  */
-
 export function assertHexString(s, len, name = 'value') {
   if (!isHexString(s, len)) {
     if (isPrefixedHexString(s)) {
       throw new TypeError(`${name} not valid non prefixed hex string (has 0x prefix): ${s}`);
-    } // Don't display length error if no length specified in order not to confuse user
-
-
+    }
+    // Don't display length error if no length specified in order not to confuse user
     const lengthMsg = len ? ` of length ${len}` : '';
     throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
   }
@@ -146,7 +128,6 @@ export function assertHexString(s, len, name = 'value') {
  * @param name optional name for the asserted value
  * @returns HexString or throws error
  */
-
 export function assertPrefixedHexString(s, name = 'value') {
   if (!isPrefixedHexString(s)) {
     throw new TypeError(`${name} not valid prefixed hex string: ${s}`);

package/dist/mjs/utils/http.js

@@ -1,73 +1,25 @@
-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());
-  });
-};
-
-var __rest = this && this.__rest || function (s, e) {
-  var t = {};
-
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
-};
-
 import { BeeError, BeeNotAJsonError, BeeRequestError, BeeResponseError } from "./error.js";
-import kyFactory from 'ky-universal';
 import { normalizeToReadableStream } from "./stream.js";
-import { deepMerge } from "./merge.js";
 import { isObject, isStrictlyObject } from "./type.js";
-const DEFAULT_KY_CONFIG = {
+import { deepMerge } from "./merge.js";
+export const DEFAULT_KY_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*',
     'user-agent': `bee-js`
   }
 };
-
 function isHttpError(e) {
   return isObject(e) && typeof e.response !== 'undefined';
 }
-
 function isHttpRequestError(e) {
   return isObject(e) && typeof e.request !== 'undefined';
 }
-
 function headersToObject(header) {
   return [...header.entries()].reduce((obj, [key, val]) => {
     obj[key] = val;
     return obj;
   }, {});
 }
-
 function wrapRequest(request) {
   return {
     url: request.url,
@@ -75,21 +27,20 @@ function wrapRequest(request) {
     headers: headersToObject(request.headers)
   };
 }
-
 export function wrapRequestClosure(cb) {
-  return request => __awaiter(this, void 0, void 0, function* () {
-    yield cb(wrapRequest(request));
-  });
+  return async request => {
+    await cb(wrapRequest(request));
+  };
 }
 export function wrapResponseClosure(cb) {
-  return (request, options, response) => __awaiter(this, void 0, void 0, function* () {
-    yield cb({
+  return async (request, options, response) => {
+    await cb({
       headers: headersToObject(response.headers),
       status: response.status,
       statusText: response.statusText,
       request: wrapRequest(request)
     });
-  });
+  };
 }
 /**
  * Filters out entries that has undefined value from headers object.
@@ -98,111 +49,102 @@ export function wrapResponseClosure(cb) {
  * @param obj
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
-
 export function filterHeaders(obj) {
   if (obj === undefined) {
     return undefined;
   }
-
   isStrictlyObject(obj);
   const typedObj = obj;
-
   for (const key in typedObj) {
     if (typedObj[key] === undefined) {
       delete typedObj[key];
     }
   }
-
   if (Object.keys(typedObj).length === 0) {
     return undefined;
   }
-
   return typedObj;
 }
 /**
  * Main utility function to make HTTP requests.
- * @param ky
+ * @param kyOptions
  * @param config
  */
-
-export function http(ky, config) {
-  return __awaiter(this, void 0, void 0, function* () {
-    try {
-      const {
-        path,
-        responseType
-      } = config,
-            kyConfig = __rest(config, ["path", "responseType"]);
-
-      const response = yield ky(path, Object.assign(Object.assign({}, kyConfig), {
-        searchParams: filterHeaders(kyConfig.searchParams)
-      }));
-
-      switch (responseType) {
-        case 'stream':
-          if (!response.body) {
-            throw new BeeError('Response was expected to get data but did not get any!');
-          }
-
-          response.data = normalizeToReadableStream(response.body);
-          break;
-
-        case 'arraybuffer':
-          response.data = yield response.arrayBuffer();
-          break;
-
-        case 'json':
-          try {
-            response.data = yield response.json();
-          } catch (e) {
-            throw new BeeNotAJsonError();
-          }
-
-          break;
-
-        default:
-          break;
-        // If responseType is not set, then no data are expected
-      }
-
-      return response;
-    } catch (e) {
-      // Passthrough thrown errors
-      if (e instanceof BeeNotAJsonError) {
-        throw e;
-      }
-
-      if (isHttpError(e)) {
-        let message; // We store the response body here as it can be read only once in Response's lifecycle so to make it exposed
-        // to the user in the BeeResponseError, for further analysis.
-
-        const body = yield e.response.text();
-
-        try {
-          // The response can be Bee's JSON with structure `{code, message}` lets try to parse it
-          message = JSON.parse(body).message;
-        } catch (e) {}
-
-        if (message) {
-          throw new BeeResponseError(e.response.status, e.response, body, config, `${e.response.statusText}: ${message}`);
-        } else {
-          throw new BeeResponseError(e.response.status, e.response, body, config, e.response.statusText);
+export async function http(kyOptions, config) {
+  try {
+    const ky = await getKy();
+    const {
+      path,
+      responseType,
+      ...kyConfig
+    } = deepMerge(kyOptions, config);
+    const response = await ky(path, {
+      ...kyConfig,
+      searchParams: filterHeaders(kyConfig.searchParams)
+    });
+    switch (responseType) {
+      case 'stream':
+        if (!response.body) {
+          throw new BeeError('Response was expected to get data but did not get any!');
         }
-      } else if (isHttpRequestError(e)) {
-        throw new BeeRequestError(e.message, config);
-      } else {
-        // Node 18 has native `fetch` implementation called Undici. Errors from this implementation have top level generic
-        // message "fetch failed" with the more specific error placed into `cause` property. Instead of "fetch failed" we
-        // expose the underlying problem.
-        if (e.cause) {
-          throw new BeeError(e.cause.message);
+        response.parsedData = normalizeToReadableStream(response.body);
+        break;
+      case 'arraybuffer':
+        response.parsedData = await response.arrayBuffer();
+        break;
+      case 'json':
+        try {
+          response.parsedData = await response.json();
+        } catch (e) {
+          throw new BeeNotAJsonError();
         }
+        break;
+      default:
+        break;
+      // If responseType is not set, then no data are expected
+    }
 
-        throw new BeeError(e.message);
+    return response;
+  } catch (e) {
+    // Passthrough thrown errors
+    if (e instanceof BeeNotAJsonError) {
+      throw e;
+    }
+    if (isHttpError(e)) {
+      let message;
+      // We store the response body here as it can be read only once in Response's lifecycle so to make it exposed
+      // to the user in the BeeResponseError, for further analysis.
+      const body = await e.response.text();
+      try {
+        // The response can be Bee's JSON with structure `{code, message}` lets try to parse it
+        message = JSON.parse(body).message;
+      } catch (e) {}
+      if (message) {
+        throw new BeeResponseError(e.response.status, e.response, body, config, `${e.response.statusText}: ${message}`);
+      } else {
+        throw new BeeResponseError(e.response.status, e.response, body, config, e.response.statusText);
+      }
+    } else if (isHttpRequestError(e)) {
+      throw new BeeRequestError(e.message, config);
+    } else {
+      // Node 18 has native `fetch` implementation called Undici. Errors from this implementation have top level generic
+      // message "fetch failed" with the more specific error placed into `cause` property. Instead of "fetch failed" we
+      // expose the underlying problem.
+      if (e.cause) {
+        throw new BeeError(e.cause.message);
       }
+      throw new BeeError(e.message);
     }
-  });
+  }
 }
-export function makeDefaultKy(kyConfig) {
-  return kyFactory.create(deepMerge(DEFAULT_KY_CONFIG, kyConfig));
+let ky;
+async function getKy() {
+  if (ky) {
+    return ky;
+  }
+  ky = (await import('ky-universal')).default;
+  if (!ky) {
+    throw new Error('Ky was not found while it should have been!');
+  }
+  return ky;
 }

package/dist/mjs/utils/merge.js

@@ -6,17 +6,14 @@ import { isObject } from "./type.js";
  * @licence MIT
  * @param sources
  */
-
 export function deepMerge(...sources) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let returnValue = {};
-
   for (const source of sources) {
     if (Array.isArray(source)) {
       if (!Array.isArray(returnValue)) {
         returnValue = [];
       }
-
       returnValue = [...returnValue, ...source];
     } else if (isObject(source)) {
       // eslint-disable-next-line prefer-const
@@ -24,13 +21,12 @@ export function deepMerge(...sources) {
         if (isObject(value) && key in returnValue) {
           value = deepMerge(returnValue[key], value);
         }
-
-        returnValue = Object.assign(Object.assign({}, returnValue), {
+        returnValue = {
+          ...returnValue,
           [key]: value
-        });
+        };
       }
     }
   }
-
   return returnValue;
 }

package/dist/mjs/utils/pss.js

@@ -6,11 +6,9 @@ import { PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
  * @param target is a non-prefixed hex string Bee address
  * @see [Bee docs - PSS](https://docs.ethswarm.org/docs/dapps-on-swarm/pss)
  */
-
 export function makeMaxTarget(target) {
   if (typeof target !== 'string') {
     throw new TypeError('target has to be an string!');
   }
-
   return target.slice(0, PSS_TARGET_HEX_LENGTH_MAX);
 }

package/dist/mjs/utils/reference.js

@@ -6,7 +6,6 @@ export function makeBytesReference(reference, offset = 0) {
     if (offset) {
       throw new Error('Offset property can be set only for UintArray reference!');
     }
-
     try {
       // Non-encrypted chunk hex string reference
       const hexReference = makeHexString(reference, REFERENCE_HEX_LENGTH);
@@ -14,9 +13,8 @@ export function makeBytesReference(reference, offset = 0) {
     } catch (e) {
       if (!(e instanceof TypeError)) {
         throw e;
-      } // Encrypted chunk hex string reference
-
-
+      }
+      // Encrypted chunk hex string reference
       const hexReference = makeHexString(reference, ENCRYPTED_REFERENCE_HEX_LENGTH);
       return hexToBytes(hexReference);
     }
@@ -27,6 +25,5 @@ export function makeBytesReference(reference, offset = 0) {
       return bytesAtOffset(reference, offset, REFERENCE_BYTES_LENGTH);
     }
   }
-
   throw new TypeError('invalid chunk reference');
 }

package/dist/mjs/utils/sleep.js

@@ -1,43 +1,8 @@
-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());
-  });
-};
 /**
  * Sleep for N miliseconds
  *
  * @param ms Number of miliseconds to sleep
  */
-
-
-export function sleep(ms) {
-  return __awaiter(this, void 0, void 0, function* () {
-    return new Promise(resolve => setTimeout(() => resolve(), ms));
-  });
+export async function sleep(ms) {
+  return new Promise(resolve => setTimeout(() => resolve(), ms));
 }

package/dist/mjs/utils/stream.js

@@ -8,7 +8,6 @@ const NodeReadable = NodeReadableNative || class {};
  *
  * @param entry
  */
-
 export function isReadable(entry) {
   return isReadableStream(entry) || isNodeReadable(entry);
 }
@@ -16,26 +15,20 @@ export function isReadableStream(entry) {
   if (!isStrictlyObject(entry)) {
     return false;
   }
-
   const browserReadable = entry;
-
   if (typeof browserReadable.getReader === 'function' && browserReadable.locked !== undefined && typeof browserReadable.cancel === 'function' && typeof browserReadable.pipeTo === 'function' && typeof browserReadable.pipeThrough === 'function') {
     return true;
   }
-
   return false;
 }
 export function isNodeReadable(entry) {
   if (!isStrictlyObject(entry)) {
     return false;
   }
-
   const nodeReadable = entry;
-
   if (typeof nodeReadable.pipe === 'function' && nodeReadable.readable && typeof nodeReadable._read === 'function') {
     return true;
   }
-
   return false;
 }
 /**
@@ -48,7 +41,6 @@ export function isNodeReadable(entry) {
  * @licence Apache License 2.0 https://github.com/gwicke/node-web-streams/blob/master/LICENSE
  * @param nodeStream
  */
-
 export function readableNodeToWeb(nodeStream) {
   return new ReadableStream({
     start(controller) {
@@ -59,21 +51,17 @@ export function readableNodeToWeb(nodeStream) {
         } else {
           controller.enqueue(chunk);
         }
-
         nodeStream.pause();
       });
       nodeStream.on('end', () => controller.close());
       nodeStream.on('error', e => controller.error(e));
     },
-
     pull() {
       nodeStream.resume();
     },
-
     cancel() {
       nodeStream.pause();
     }
-
   });
 }
 /**
@@ -83,7 +71,6 @@ export function readableNodeToWeb(nodeStream) {
  * @author https://github.com/gwicke
  * @licence Apache License 2.0 https://github.com/gwicke/node-web-streams/blob/master/LICENSE
  */
-
 class NodeReadableWrapper extends NodeReadable {
   constructor(webStream, options) {
     super(options);
@@ -91,21 +78,17 @@ class NodeReadableWrapper extends NodeReadable {
     this._reader = webStream.getReader();
     this._reading = false;
   }
-
   _read() {
     if (this._reading) {
       return;
     }
-
     this._reading = true;
-
     const doRead = () => {
       this._reader.read().then(res => {
         if (res.done) {
           this.push(null);
           return;
         }
-
         if (this.push(res.value)) {
           return doRead();
         } else {
@@ -113,10 +96,8 @@ class NodeReadableWrapper extends NodeReadable {
         }
       });
     };
-
     doRead();
   }
-
 }
 /**
  * Function that converts WHATWG ReadableStream into Node's Readable
@@ -132,13 +113,10 @@ class NodeReadableWrapper extends NodeReadable {
  * @param webStream
  * @param options
  */
-
-
 export function readableWebToNode(webStream, options) {
   if (!NodeReadableNative) {
     throw new Error("The Node's Readable is not available! If you are running this in browser you have to polyfill 'stream' package!");
   }
-
   return new NodeReadableWrapper(webStream, options);
 }
 export function normalizeToReadableStream(stream) {
@@ -147,6 +125,5 @@ export function normalizeToReadableStream(stream) {
   } else if (isReadableStream(stream)) {
     return stream;
   }
-
   throw new TypeError('Passed stream is not Node Readable nor ReadableStream!');
 }

package/dist/mjs/utils/tar.js

@@ -1,6 +1,6 @@
-import Tar from 'tar-js'; // converts a string to utf8 Uint8Array and returns it as a string-like
+import Tar from 'tar-js';
+// converts a string to utf8 Uint8Array and returns it as a string-like
 // object that `tar.append` accepts as path
-
 function fixUnicodePath(path) {
   const codes = new TextEncoder().encode(path);
   return {
@@ -8,14 +8,11 @@ function fixUnicodePath(path) {
     charCodeAt: index => codes[index]
   };
 }
-
 export function makeTar(data) {
   const tar = new Tar();
-
   for (const entry of data) {
     const path = fixUnicodePath(entry.path);
     tar.append(path, entry.data);
   }
-
   return tar.out;
 }