@ethersphere/bee-js 3.3.2 → 3.3.4

package/dist/mjs/utils/data.browser.js

@@ -1,73 +1,108 @@
+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 { isNodeReadable, isReadableStream } from "./stream.js";
-import Blob from 'cross-blob';
 /**
  * Validates input and converts to Uint8Array
  *
  * @param data any string, ArrayBuffer or Uint8Array
  */
 
-export async function prepareData(data) {
-  if (typeof data === 'string') return new Blob([data], {
-    type: 'text/plain'
-  });
-
-  if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
-    return new Blob([data], {
-      type: 'application/octet-stream'
+export function prepareData(data) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof data === 'string') return new Blob([data], {
+      type: 'text/plain'
     });
-  }
 
-  if (data instanceof Blob) {
-    return data;
-  } // Currently it is not possible to stream requests from browsers
-  // there are already first experiments on this field (Chromium)
-  // but till it is fully implemented across browsers-land we have to
-  // buffer the data before sending the requests.
+    if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+      return new Blob([data], {
+        type: 'application/octet-stream'
+      });
+    }
 
+    if (data instanceof Blob) {
+      return data;
+    } // Currently it is not possible to stream requests from browsers
+    // there are already first experiments on this field (Chromium)
+    // but till it is fully implemented across browsers-land we have to
+    // buffer the data before sending the requests.
 
-  if (isNodeReadable(data)) {
-    return new Promise(resolve => {
-      const buffers = [];
-      data.on('data', d => {
-        buffers.push(d);
-      });
-      data.on('end', () => {
-        resolve(new Blob(buffers, {
-          type: 'application/octet-stream'
-        }));
+
+    if (isNodeReadable(data)) {
+      return new Promise(resolve => {
+        const buffers = [];
+        data.on('data', d => {
+          buffers.push(d);
+        });
+        data.on('end', () => {
+          resolve(new Blob(buffers, {
+            type: 'application/octet-stream'
+          }));
+        });
       });
-    });
-  }
+    }
 
-  if (isReadableStream(data)) {
-    return new Promise(async resolve => {
-      const reader = data.getReader();
-      const buffers = [];
-      let done, value;
+    if (isReadableStream(data)) {
+      return new Promise(resolve => __awaiter(this, void 0, void 0, function* () {
+        const reader = data.getReader();
+        const buffers = [];
+        let done, value;
 
-      do {
-        ;
-        ({
-          done,
-          value
-        } = await reader.read());
+        do {
+          ;
+          ({
+            done,
+            value
+          } = yield reader.read());
 
-        if (!done) {
-          buffers.push(value);
-        }
-      } while (!done);
+          if (!done) {
+            buffers.push(value);
+          }
+        } while (!done);
 
-      resolve(new Blob(buffers, {
-        type: 'application/octet-stream'
+        resolve(new Blob(buffers, {
+          type: 'application/octet-stream'
+        }));
       }));
-    });
-  }
+    }
 
-  throw new TypeError('unknown data type');
+    throw new TypeError('unknown data type');
+  });
 }
-export async function prepareWebsocketData(data) {
-  if (typeof data === 'string') return new TextEncoder().encode(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (data instanceof Blob) return new Uint8Array(await new Response(data).arrayBuffer());
-  throw new TypeError('unknown websocket data type');
+export function prepareWebsocketData(data) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof data === 'string') return new TextEncoder().encode(data);
+    if (data instanceof ArrayBuffer) return new Uint8Array(data);
+    if (data instanceof Blob) return new Uint8Array(yield new Response(data).arrayBuffer());
+    throw new TypeError('unknown websocket data type');
+  });
 }

package/dist/mjs/utils/data.js

@@ -1,4 +1,36 @@
-import Blob from 'cross-blob';
+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 BlobPolyfill from 'fetch-blob';
 import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js";
 /**
  * Prepare data for valid input for node-fetch.
@@ -9,35 +41,38 @@ import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js
  * @param data any string, ArrayBuffer, Uint8Array or Readable
  */
 
-export async function prepareData(data) {
-  if (typeof data === 'string') return new Blob([data], {
-    type: 'text/plain'
-  });
-
-  if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
-    return new Blob([data], {
-      type: 'application/octet-stream'
+export function prepareData(data) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof data === 'string') return new BlobPolyfill([data], {
+      type: 'text/plain'
     });
-  }
 
-  if (data instanceof Blob || isNodeReadable(data)) return data;
+    if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+      return new BlobPolyfill([data], {
+        type: 'application/octet-stream'
+      });
+    }
 
-  if (isReadableStream(data)) {
-    return readableWebToNode(data);
-  }
+    if (data instanceof BlobPolyfill || isNodeReadable(data)) return data;
 
-  throw new TypeError('unknown data type');
+    if (isReadableStream(data)) {
+      return readableWebToNode(data);
+    }
+
+    throw new TypeError('unknown data type');
+  });
 }
 
 function isBufferArray(buffer) {
   return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
 }
 
-export async function prepareWebsocketData(data) {
-  if (typeof data === 'string') return new TextEncoder().encode(data);
-  if (data instanceof Buffer) return new Uint8Array(data);
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (data instanceof Blob) return new Uint8Array(await new Response(data).arrayBuffer());
-  if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data));
-  throw new TypeError('unknown websocket data type');
+export function prepareWebsocketData(data) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof data === 'string') return new TextEncoder().encode(data);
+    if (data instanceof Buffer) return new Uint8Array(data);
+    if (data instanceof ArrayBuffer) return new Uint8Array(data);
+    if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data));
+    throw new TypeError('unknown websocket data type');
+  });
 }

package/dist/mjs/utils/error.js

@@ -5,8 +5,6 @@ export class BeeError extends Error {
 
 }
 export class BeeArgumentError extends BeeError {
-  value;
-
   constructor(message, value) {
     super(message);
     this.value = value;
@@ -14,12 +12,10 @@ export class BeeArgumentError extends BeeError {
 
 }
 export class BeeRequestError extends BeeError {
-  requestOptions;
   /**
    * @param message
    * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
    */
-
   constructor(message, requestOptions) {
     super(message);
     this.requestOptions = requestOptions;
@@ -27,10 +23,6 @@ export class BeeRequestError extends BeeError {
 
 }
 export class BeeResponseError extends BeeError {
-  status;
-  response;
-  responseBody;
-  requestOptions;
   /**
    * @param status HTTP status code number
    * @param response Response returned from the server
@@ -38,7 +30,6 @@ export class BeeResponseError extends BeeError {
    * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
    * @param message
    */
-
   constructor(status, response, responseBody, requestOptions, message) {
     super(message);
     this.status = status;

package/dist/mjs/utils/eth.js

@@ -1,4 +1,36 @@
-// For ESM compatibility
+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());
+  });
+}; // For ESM compatibility
+
+
 import pkg from 'js-sha3';
 const {
   keccak256,
@@ -98,6 +130,8 @@ export function isHexEthAddress(address) {
  */
 
 export function toLittleEndian(bigEndian, pad = 2) {
+  var _a;
+
   if (!(Number.isInteger(pad) && pad >= 2 && pad % 2 === 0)) {
     throw new TypeError('minimal padding for conversion needs to be positive even integer');
   }
@@ -108,7 +142,7 @@ export function toLittleEndian(bigEndian, pad = 2) {
 
   if (hexRep.length % 2 !== 0) hexRep = hexRep.padStart(hexRep.length + 1, '0'); // Match all two pairs in the hexstring, reverse the pairs and join it again
 
-  const littleEndian = hexRep.match(/../g)?.reverse().join('');
+  const littleEndian = (_a = hexRep.match(/../g)) === null || _a === void 0 ? void 0 : _a.reverse().join('');
   if (littleEndian) return littleEndian;
   throw new Error('failed to convert');
 }
@@ -162,38 +196,40 @@ export function ethToSwarmAddress(ethAddress, networkId = 1) {
  * @param ethAddress Optional address of the account which the data should be signed with. If not specified `eth_requestAccounts` request is used to get the account address.
  */
 
-export async function makeEthereumWalletSigner(provider, ethAddress) {
-  let executorFnc;
-
-  if (typeof provider !== 'object' || provider === null) {
-    throw new TypeError('We need JsonRPC provider object!');
-  }
+export function makeEthereumWalletSigner(provider, ethAddress) {
+  return __awaiter(this, void 0, void 0, function* () {
+    let executorFnc;
 
-  if (provider.request) {
-    executorFnc = provider.request;
-  } else if (provider.sendAsync) {
-    executorFnc = provider.sendAsync;
-  } else {
-    throw new Error('Incompatible interface of given provider!');
-  }
+    if (typeof provider !== 'object' || provider === null) {
+      throw new TypeError('We need JsonRPC provider object!');
+    }
 
-  if (!ethAddress) {
-    ethAddress = (await executorFnc({
-      method: 'eth_requestAccounts'
-    }))[0];
-  }
+    if (provider.request) {
+      executorFnc = provider.request;
+    } else if (provider.sendAsync) {
+      executorFnc = provider.sendAsync;
+    } else {
+      throw new Error('Incompatible interface of given provider!');
+    }
 
-  const bytesEthAddress = makeEthAddress(ethAddress);
-  const hexEthAddress = makeHexEthAddress(ethAddress);
-  return {
-    address: bytesEthAddress,
-    sign: async data => {
-      const result = await executorFnc({
-        jsonrpc: '2.0',
-        method: 'personal_sign',
-        params: ['0x' + data.hex(), '0x' + hexEthAddress]
-      });
-      return result;
+    if (!ethAddress) {
+      ethAddress = (yield executorFnc({
+        method: 'eth_requestAccounts'
+      }))[0];
     }
-  };
+
+    const bytesEthAddress = makeEthAddress(ethAddress);
+    const hexEthAddress = makeHexEthAddress(ethAddress);
+    return {
+      address: bytesEthAddress,
+      sign: data => __awaiter(this, void 0, void 0, function* () {
+        const result = yield executorFnc({
+          jsonrpc: '2.0',
+          method: 'personal_sign',
+          params: ['0x' + data.hex(), '0x' + hexEthAddress]
+        });
+        return result;
+      })
+    };
+  });
 }

package/dist/mjs/utils/file.js

@@ -3,6 +3,38 @@
  *
  * https://developer.mozilla.org/en-US/docs/Web/API/File
  */
+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());
+  });
+};
+
 export function isFile(file) {
   // browser
   if (typeof File === 'function') {
@@ -20,17 +52,19 @@ export function isFile(file) {
  * @param file A File object
  */
 
-export async function fileArrayBuffer(file) {
-  if (file.arrayBuffer) {
-    return file.arrayBuffer();
-  } // workaround for Safari where arrayBuffer is not supported on Files
+export function fileArrayBuffer(file) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (file.arrayBuffer) {
+      return file.arrayBuffer();
+    } // workaround for Safari where arrayBuffer is not supported on Files
 
 
-  return new Promise(resolve => {
-    const fr = new FileReader();
+    return new Promise(resolve => {
+      const fr = new FileReader();
 
-    fr.onload = () => resolve(fr.result);
+      fr.onload = () => resolve(fr.result);
 
-    fr.readAsArrayBuffer(file);
+      fr.readAsArrayBuffer(file);
+    });
   });
 }

package/dist/mjs/utils/headers.js

@@ -50,9 +50,9 @@ export function extractUploadHeaders(postageBatchId, options) {
   const headers = {
     'swarm-postage-batch-id': postageBatchId
   };
-  if (options?.pin) headers['swarm-pin'] = String(options.pin);
-  if (options?.encrypt) headers['swarm-encrypt'] = String(options.encrypt);
-  if (options?.tag) headers['swarm-tag'] = String(options.tag);
-  if (typeof options?.deferred === 'boolean') headers['swarm-deferred-upload'] = options.deferred.toString();
+  if (options === null || options === void 0 ? void 0 : options.pin) headers['swarm-pin'] = String(options.pin);
+  if (options === null || options === void 0 ? void 0 : options.encrypt) headers['swarm-encrypt'] = String(options.encrypt);
+  if (options === null || options === void 0 ? void 0 : options.tag) headers['swarm-tag'] = String(options.tag);
+  if (typeof (options === null || options === void 0 ? void 0 : options.deferred) === 'boolean') headers['swarm-deferred-upload'] = options.deferred.toString();
   return headers;
 }