@ethersphere/bee-js 6.0.0-pre.0 → 6.0.0-pre.10

package/dist/{src/utils/collection-browser.js → mjs/utils/collection.browser.js}

@@ -13,7 +13,6 @@ export async function makeCollectionFromFS(dir) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-
 export async function getFolderSize(dir) {
   throw new Error('Creating Collection from File System is not supported in browsers!');
 }

package/dist/{src → mjs}/utils/collection.js

@@ -5,7 +5,6 @@ export function isCollection(data) {
   if (!Array.isArray(data)) {
     return false;
   }
-
   return data.every(entry => typeof entry === 'object' && entry.data && entry.path && isUint8Array(entry.data));
 }
 export function assertCollection(data) {
@@ -13,25 +12,19 @@ export function assertCollection(data) {
     throw new BeeArgumentError('invalid collection', data);
   }
 }
-
 function makeFilePath(file) {
   if (file.webkitRelativePath && file.webkitRelativePath !== '') {
     return file.webkitRelativePath.replace(/.*?\//i, '');
   }
-
   if (file.name) {
     return file.name;
   }
-
   throw new TypeError('file is not valid File object');
 }
-
 export async function makeCollectionFromFileList(fileList) {
   const collection = [];
-
   for (let i = 0; i < fileList.length; i++) {
     const file = fileList[i];
-
     if (file) {
       collection.push({
         path: makeFilePath(file),
@@ -39,7 +32,6 @@ export async function makeCollectionFromFileList(fileList) {
       });
     }
   }
-
   return collection;
 }
 /**
@@ -48,17 +40,13 @@ export async function makeCollectionFromFileList(fileList) {
  * @param fileList list of files to check
  * @returns size in bytes
  */
-
 export function getCollectionSize(fileList) {
   let sum = 0;
-
   for (let i = 0; i < fileList.length; i++) {
     const file = fileList[i];
-
     if (file) {
       sum += file.size;
     }
   }
-
   return sum;
 }

package/dist/{src/utils/collection-node.js → mjs/utils/collection.node.js}

@@ -6,29 +6,23 @@ import path from 'path';
  *
  * @param dir path to the directory
  */
-
 export async function makeCollectionFromFS(dir) {
   if (typeof dir !== 'string') {
     throw new TypeError('dir has to be string!');
   }
-
   if (dir === '') {
     throw new TypeError('dir must not be empty string!');
   }
-
   return buildCollectionRelative(dir, '');
 }
-
 async function buildCollectionRelative(dir, relativePath) {
   // Handles case when the dir is not existing or it is a file ==> throws an error
   const dirname = path.join(dir, relativePath);
   const entries = await fs.promises.opendir(dirname);
   let collection = [];
-
   for await (const entry of entries) {
     const fullPath = path.join(dir, relativePath, entry.name);
     const entryPath = path.join(relativePath, entry.name);
-
     if (entry.isFile()) {
       collection.push({
         path: entryPath,
@@ -38,7 +32,6 @@ async function buildCollectionRelative(dir, relativePath) {
       collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
     }
   }
-
   return collection;
 }
 /**
@@ -47,20 +40,15 @@ async function buildCollectionRelative(dir, relativePath) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-
-
 export async function getFolderSize(dir) {
   if (typeof dir !== 'string') {
     throw new TypeError('dir has to be string!');
   }
-
   if (dir === '') {
     throw new TypeError('dir must not be empty string!');
   }
-
   const entries = await fs.promises.opendir(dir);
   let size = 0;
-
   for await (const entry of entries) {
     if (entry.isFile()) {
       const stats = await fs.promises.stat(path.join(dir, entry.name));
@@ -69,6 +57,5 @@ export async function getFolderSize(dir) {
       size += await getFolderSize(path.join(dir, entry.name));
     }
   }
-
   return size;
 }

package/dist/{src → mjs}/utils/data.browser.js

@@ -4,26 +4,22 @@ import { isNodeReadable, isReadableStream } from "./stream.js";
  *
  * @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'
     });
   }
-
   if (data instanceof Blob) {
     return data;
-  } // Currently it is not possible to stream requests from browsers
+  }
+  // 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 = [];
@@ -37,31 +33,26 @@ export async function prepareData(data) {
       });
     });
   }
-
   if (isReadableStream(data)) {
     return new Promise(async resolve => {
       const reader = data.getReader();
       const buffers = [];
       let done, value;
-
       do {
         ;
         ({
           done,
           value
         } = await reader.read());
-
         if (!done) {
           buffers.push(value);
         }
       } while (!done);
-
       resolve(new Blob(buffers, {
         type: 'application/octet-stream'
       }));
     });
   }
-
   throw new TypeError('unknown data type');
 }
 export async function prepareWebsocketData(data) {

package/dist/{src → mjs}/utils/data.js

@@ -8,31 +8,24 @@ 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 BlobPolyfill([data], {
     type: 'text/plain'
   });
-
   if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
     return new BlobPolyfill([data], {
       type: 'application/octet-stream'
     });
   }
-
   if (data instanceof BlobPolyfill || isNodeReadable(data)) return data;
-
   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);

package/dist/mjs/utils/error.js

@@ -0,0 +1,11 @@
+export class BeeError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+export class BeeArgumentError extends BeeError {
+  constructor(message, value) {
+    super(message);
+    this.value = value;
+  }
+}

package/dist/{src → mjs}/utils/eth.js

@@ -18,7 +18,6 @@ export function makeEthAddress(address) {
     assertBytes(address, ETH_ADDR_BYTES_LENGTH);
     return address;
   }
-
   throw new TypeError('Invalid EthAddress');
 }
 export function makeHexEthAddress(address) {
@@ -28,7 +27,6 @@ export function makeHexEthAddress(address) {
     if (e instanceof TypeError) {
       e.message = `Invalid HexEthAddress: ${e.message}`;
     }
-
     throw e;
   }
 }
@@ -37,7 +35,6 @@ export function makeHexEthAddress(address) {
  *
  * @param address Ethereum address as hex string
  */
-
 function isEthAddrCaseIns(address) {
   // Check it's string, all small caps or all all caps hex and 40 chars long without the `0x` prefix
   return typeof address === 'string' && (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address));
@@ -47,28 +44,23 @@ function isEthAddrCaseIns(address) {
  *
  * @param address Ethereum address as hex string
  */
-
-
 function isValidChecksummedEthAddress(address) {
   try {
     // Check for valid case insensitive hex type string, 40 chars
-    const addr = makeHexString(address, ETH_ADDR_HEX_LENGTH); // Check the checksum
-
+    const addr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
+    // Check the checksum
     const addressHash = keccak256(addr.toLowerCase());
-
     for (let i = 0; i < 40; i += 1) {
       // the nth letter should be uppercase if the nth digit of casemap is 1
       if (parseInt(addressHash[i], 16) > 7 && addr[i].toUpperCase() !== addr[i] || parseInt(addressHash[i], 16) <= 7 && addr[i].toLowerCase() !== addr[i]) {
         return false;
       }
     }
-
     return true;
   } catch (e) {
     if (e instanceof TypeError) {
       return false;
     }
-
     throw e;
   }
 }
@@ -82,8 +74,6 @@ function isValidChecksummedEthAddress(address) {
  *
  * @return True if is valid eth address
  */
-
-
 export function isHexEthAddress(address) {
   return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
 }
@@ -96,18 +86,16 @@ export function isHexEthAddress(address) {
  *
  * @return little-endian encoded hexstring
  */
-
 export function toLittleEndian(bigEndian, pad = 2) {
   if (!(Number.isInteger(pad) && pad >= 2 && pad % 2 === 0)) {
     throw new TypeError('minimal padding for conversion needs to be positive even integer');
   }
-
   let hexRep;
   if (typeof bigEndian === 'string') hexRep = makeHexString(bigEndian);else if (typeof bigEndian === 'number') hexRep = intToHex(bigEndian);else throw new TypeError('incorrect input type');
-  hexRep = hexRep.padStart(pad, '0'); // Extend to an even length hexstring
-
-  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
-
+  hexRep = hexRep.padStart(pad, '0');
+  // Extend to an even length hexstring
+  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('');
   if (littleEndian) return littleEndian;
   throw new Error('failed to convert');
@@ -121,16 +109,13 @@ export function toLittleEndian(bigEndian, pad = 2) {
  *
  * @return big-endian encoded hexstring
  */
-
 export function fromLittleEndian(littleEndian, pad = 2) {
   // It's a reversible function
   return toLittleEndian(littleEndian, pad);
 }
-
 function assertEthAddress(ethAddress) {
   if (!isHexEthAddress(ethAddress)) throw new TypeError('invalid ETH address');
 }
-
 function assertSwarmNetworkId(networkId) {
   if (Number.isInteger(networkId && networkId > 0 && networkId < Number.MAX_SAFE_INTEGER)) {
     throw new TypeError('swarm network id must be positive integer');
@@ -144,8 +129,6 @@ function assertSwarmNetworkId(networkId) {
  *
  * @return Swarm overlay address
  */
-
-
 export function ethToSwarmAddress(ethAddress, networkId = 1) {
   assertEthAddress(ethAddress);
   assertSwarmNetworkId(networkId);
@@ -161,14 +144,11 @@ export function ethToSwarmAddress(ethAddress, networkId = 1) {
  * @param provider Injected web3 provider like window.ethereum or other compatible with EIP-1193
  * @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!');
   }
-
   if (provider.request) {
     executorFnc = provider.request;
   } else if (provider.sendAsync) {
@@ -176,13 +156,11 @@ export async function makeEthereumWalletSigner(provider, ethAddress) {
   } else {
     throw new Error('Incompatible interface of given provider!');
   }
-
   if (!ethAddress) {
     ethAddress = (await executorFnc({
       method: 'eth_requestAccounts'
     }))[0];
   }
-
   const bytesEthAddress = makeEthAddress(ethAddress);
   const hexEthAddress = makeHexEthAddress(ethAddress);
   return {

package/dist/{src → mjs}/utils/expose.js

@@ -1,5 +1,5 @@
 export { getCollectionSize } from "./collection.js";
-export { getFolderSize } from "./collection-node.js";
+export { getFolderSize } from "./collection.node.js";
 export { isBytes, assertBytes, isFlexBytes, assertFlexBytes, bytesAtOffset, flexBytesAtOffset, bytesEqual } from "./bytes.js";
 export { makeHexString, hexToBytes, bytesToHex, intToHex, isHexString, assertHexString, assertPrefixedHexString } from "./hex.js";
 export { makeEthAddress, makeHexEthAddress, isHexEthAddress, ethToSwarmAddress, toLittleEndian, fromLittleEndian, makeEthereumWalletSigner } from "./eth.js";

package/dist/{src → mjs}/utils/file.js

@@ -7,9 +7,8 @@ export function isFile(file) {
   // browser
   if (typeof File === 'function') {
     return file instanceof File;
-  } // node.js
-
-
+  }
+  // node.js
   const f = file;
   return typeof f === 'object' && typeof f.name === 'string' && (typeof f.stream === 'function' || typeof f.arrayBuffer === 'function');
 }
@@ -19,18 +18,14 @@ 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
-
-
+  }
+  // workaround for Safari where arrayBuffer is not supported on Files
   return new Promise(resolve => {
     const fr = new FileReader();
-
     fr.onload = () => resolve(fr.result);
-
     fr.readAsArrayBuffer(file);
   });
 }

package/dist/{src → mjs}/utils/hash.js

@@ -9,7 +9,6 @@ const {
  *
  * @param messages Any number of messages (strings, byte arrays etc.)
  */
-
 export function keccak256Hash(...messages) {
   const hasher = keccak256.create();
   messages.forEach(bytes => hasher.update(bytes));

package/dist/{src → mjs}/utils/headers.js

@@ -7,35 +7,28 @@ import { BeeError } from "./error.js";
  *
  * @returns the filename
  */
-
 function readContentDispositionFilename(header) {
   if (!header) {
     throw new BeeError('missing content-disposition header');
-  } // Regex was found here
+  }
+  // Regex was found here
   // https://stackoverflow.com/questions/23054475/javascript-regex-for-extracting-filename-from-content-disposition-header
-
-
   const dispositionMatch = header.match(/filename\*?=['"]?(?:UTF-\d['"]*)?([^;\r\n"']*)['"]?;?/i);
-
   if (dispositionMatch && dispositionMatch.length > 0) {
     return dispositionMatch[1];
   }
-
   throw new BeeError('invalid content-disposition header');
 }
-
 function readTagUid(header) {
   if (!header) {
     return undefined;
   }
-
   return parseInt(header, 10);
 }
-
 export function readFileHeaders(headers) {
-  const name = readContentDispositionFilename(headers.get('content-disposition'));
-  const tagUid = readTagUid(headers.get('swarm-tag-uid'));
-  const contentType = headers.get('content-type') || undefined;
+  const name = readContentDispositionFilename(headers['content-disposition']);
+  const tagUid = readTagUid(headers['swarm-tag-uid']);
+  const contentType = headers['content-type'] || undefined;
   return {
     name,
     tagUid,
@@ -46,7 +39,6 @@ export function extractUploadHeaders(postageBatchId, options) {
   if (!postageBatchId) {
     throw new BeeError('Postage BatchID has to be specified!');
   }
-
   const headers = {
     'swarm-postage-batch-id': postageBatchId
   };

package/dist/{src → 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

@@ -0,0 +1,34 @@
+import axios from 'axios';
+import { Objects, Strings } from 'cafe-utility';
+export const DEFAULT_HTTP_CONFIG = {
+  headers: {
+    accept: 'application/json, text/plain, */*'
+  }
+};
+/**
+ * Main function to make HTTP requests.
+ * @param options User defined settings
+ * @param config Internal settings and/or Bee settings
+ */
+export async function http(options, config) {
+  try {
+    const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
+    maybeRunOnRequestHook(options, requestConfig);
+    const response = await axios(requestConfig);
+    return response;
+  } catch (e) {
+    throw e;
+  }
+}
+function maybeRunOnRequestHook(options, requestConfig) {
+  if (options.onRequest) {
+    options.onRequest({
+      method: requestConfig.method || 'GET',
+      url: Strings.joinUrl(requestConfig.baseURL, requestConfig.url),
+      headers: {
+        ...requestConfig.headers
+      },
+      params: requestConfig.params
+    });
+  }
+}

package/dist/{src → 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/{src → 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');
 }