@ethersphere/bee-js 3.3.0 → 3.3.1

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

@@ -1,57 +1,73 @@
-import { isNodeReadable, isReadableStream } from './stream';
+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' });
-    }
-    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 (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');
+  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
+  // 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 (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) {
-    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');
-}
+  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');
+}

package/dist/mjs/utils/data.js

@@ -1,5 +1,5 @@
 import Blob from 'cross-blob';
-import { isNodeReadable, isReadableStream, readableWebToNode } from './stream';
+import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js";
 /**
  * Prepare data for valid input for node-fetch.
  *
@@ -8,32 +8,36 @@ import { isNodeReadable, isReadableStream, readableWebToNode } from './stream';
  *
  * @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' });
-    }
-    if (data instanceof Blob || isNodeReadable(data))
-        return data;
-    if (isReadableStream(data)) {
-        return readableWebToNode(data);
-    }
-    throw new TypeError('unknown data type');
+  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 || 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);
+  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');
-}
+  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');
+}

package/dist/mjs/utils/error.js

@@ -1,48 +1,56 @@
 export class BeeError extends Error {
-    constructor(message) {
-        super(message);
-    }
+  constructor(message) {
+    super(message);
+  }
+
 }
 export class BeeArgumentError extends BeeError {
-    value;
-    constructor(message, value) {
-        super(message);
-        this.value = value;
-    }
+  value;
+
+  constructor(message, value) {
+    super(message);
+    this.value = value;
+  }
+
 }
 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;
-    }
+  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;
+  }
+
 }
 export class BeeResponseError extends BeeError {
-    status;
-    response;
-    responseBody;
-    requestOptions;
-    /**
-     * @param status HTTP status code number
-     * @param response Response returned from the server
-     * @param responseBody Response body as string which is returned from response.text() call
-     * @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;
-        this.response = response;
-        this.responseBody = responseBody;
-        this.requestOptions = requestOptions;
-    }
+  status;
+  response;
+  responseBody;
+  requestOptions;
+  /**
+   * @param status HTTP status code number
+   * @param response Response returned from the server
+   * @param responseBody Response body as string which is returned from response.text() call
+   * @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;
+    this.response = response;
+    this.responseBody = responseBody;
+    this.requestOptions = requestOptions;
+  }
+
 }
 export class BeeNotAJsonError extends BeeError {
-    constructor() {
-        super(`Received response is not valid JSON.`);
-    }
-}
+  constructor() {
+    super(`Received response is not valid JSON.`);
+  }
+
+}

package/dist/mjs/utils/eth.js

@@ -1,67 +1,76 @@
-import { keccak256, sha3_256 } from 'js-sha3';
-import { hexToBytes, intToHex, makeHexString, assertHexString } from './hex';
-import { assertBytes } from './bytes';
+// For ESM compatibility
+import pkg from 'js-sha3';
+const {
+  keccak256,
+  sha3_256
+} = pkg;
+import { hexToBytes, intToHex, makeHexString, assertHexString } from "./hex.js";
+import { assertBytes } from "./bytes.js";
 const ETH_ADDR_BYTES_LENGTH = 20;
 const ETH_ADDR_HEX_LENGTH = 40;
 export function makeEthAddress(address) {
-    if (typeof address === 'string') {
-        const hexAddr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
-        const ownerBytes = hexToBytes(hexAddr);
-        assertBytes(ownerBytes, ETH_ADDR_BYTES_LENGTH);
-        return ownerBytes;
-    }
-    else if (address instanceof Uint8Array) {
-        assertBytes(address, ETH_ADDR_BYTES_LENGTH);
-        return address;
-    }
-    throw new TypeError('Invalid EthAddress');
+  if (typeof address === 'string') {
+    const hexAddr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
+    const ownerBytes = hexToBytes(hexAddr);
+    assertBytes(ownerBytes, ETH_ADDR_BYTES_LENGTH);
+    return ownerBytes;
+  } else if (address instanceof Uint8Array) {
+    assertBytes(address, ETH_ADDR_BYTES_LENGTH);
+    return address;
+  }
+
+  throw new TypeError('Invalid EthAddress');
 }
 export function makeHexEthAddress(address) {
-    try {
-        return makeHexString(address, ETH_ADDR_HEX_LENGTH);
-    }
-    catch (e) {
-        if (e instanceof TypeError) {
-            e.message = `Invalid HexEthAddress: ${e.message}`;
-        }
-        throw e;
+  try {
+    return makeHexString(address, ETH_ADDR_HEX_LENGTH);
+  } catch (e) {
+    if (e instanceof TypeError) {
+      e.message = `Invalid HexEthAddress: ${e.message}`;
     }
+
+    throw e;
+  }
 }
 /**
  * Check if this is all caps or small caps eth address (=address without checksum)
  *
  * @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)));
+  // 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));
 }
 /**
  * Check if this is checksummed ethereum 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 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;
+  try {
+    // Check for valid case insensitive hex type string, 40 chars
+    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;
+      }
     }
-    catch (e) {
-        if (e instanceof TypeError) {
-            return false;
-        }
-        throw e;
+
+    return true;
+  } catch (e) {
+    if (e instanceof TypeError) {
+      return false;
     }
+
+    throw e;
+  }
 }
 /**
  * Check if is valid ethereum address
@@ -73,8 +82,10 @@ function isValidChecksummedEthAddress(address) {
  *
  * @return True if is valid eth address
  */
+
+
 export function isHexEthAddress(address) {
-    return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
+  return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
 }
 /**
  * Convert big-endian hex or number to little-endian.
@@ -85,26 +96,21 @@ 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
-    const littleEndian = hexRep.match(/../g)?.reverse().join('');
-    if (littleEndian)
-        return littleEndian;
-    throw new Error('failed to convert');
+  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
+
+  const littleEndian = hexRep.match(/../g)?.reverse().join('');
+  if (littleEndian) return littleEndian;
+  throw new Error('failed to convert');
 }
 /**
  * Convert little-endian hex or number to big-endian
@@ -115,18 +121,20 @@ 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);
+  // It's a reversible function
+  return toLittleEndian(littleEndian, pad);
 }
+
 function assertEthAddress(ethAddress) {
-    if (!isHexEthAddress(ethAddress))
-        throw new TypeError('invalid ETH address');
+  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');
-    }
+  if (Number.isInteger(networkId && networkId > 0 && networkId < Number.MAX_SAFE_INTEGER)) {
+    throw new TypeError('swarm network id must be positive integer');
+  }
 }
 /**
  * Get swarm overlay address from public ethereum address and swarm network id
@@ -136,13 +144,15 @@ function assertSwarmNetworkId(networkId) {
  *
  * @return Swarm overlay address
  */
+
+
 export function ethToSwarmAddress(ethAddress, networkId = 1) {
-    assertEthAddress(ethAddress);
-    assertSwarmNetworkId(networkId);
-    const hex = `${makeHexString(ethAddress)}${toLittleEndian(networkId, 16)}`;
-    assertHexString(hex);
-    const overlayAddress = sha3_256(hexToBytes(hex));
-    return overlayAddress;
+  assertEthAddress(ethAddress);
+  assertSwarmNetworkId(networkId);
+  const hex = `${makeHexString(ethAddress)}${toLittleEndian(networkId, 16)}`;
+  assertHexString(hex);
+  const overlayAddress = sha3_256(hexToBytes(hex));
+  return overlayAddress;
 }
 /**
  * Function that takes Ethereum EIP-1193 compatible provider and create an Signer instance that
@@ -151,34 +161,39 @@ 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!');
+  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) {
+    executorFnc = provider.sendAsync;
+  } 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 {
+    address: bytesEthAddress,
+    sign: async data => {
+      const result = await executorFnc({
+        jsonrpc: '2.0',
+        method: 'personal_sign',
+        params: ['0x' + data.hex(), '0x' + hexEthAddress]
+      });
+      return result;
     }
-    if (provider.request) {
-        executorFnc = provider.request;
-    }
-    else if (provider.sendAsync) {
-        executorFnc = provider.sendAsync;
-    }
-    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 {
-        address: bytesEthAddress,
-        sign: async (data) => {
-            const result = await executorFnc({
-                jsonrpc: '2.0',
-                method: 'personal_sign',
-                params: ['0x' + data.hex(), '0x' + hexEthAddress],
-            });
-            return result;
-        },
-    };
-}
+  };
+}

package/dist/mjs/utils/expose.js

@@ -1,9 +1,9 @@
-export { getCollectionSize } from './collection';
-export { getFolderSize } from './collection.node';
-export { isBytes, assertBytes, isFlexBytes, assertFlexBytes, bytesAtOffset, flexBytesAtOffset, bytesEqual, } from './bytes';
-export { makeHexString, hexToBytes, bytesToHex, intToHex, isHexString, assertHexString, assertPrefixedHexString, } from './hex';
-export { makeEthAddress, makeHexEthAddress, isHexEthAddress, ethToSwarmAddress, toLittleEndian, fromLittleEndian, makeEthereumWalletSigner, } from './eth';
-export { readableWebToNode, readableNodeToWeb, isReadableStream, isNodeReadable, normalizeToReadableStream, isReadable, } from './stream';
-export { keccak256Hash } from './hash';
-export { makeMaxTarget } from './pss';
-export { getStampUsage } from './stamps';
+export { getCollectionSize } from "./collection.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";
+export { readableWebToNode, readableNodeToWeb, isReadableStream, isNodeReadable, normalizeToReadableStream, isReadable } from "./stream.js";
+export { keccak256Hash } from "./hash.js";
+export { makeMaxTarget } from "./pss.js";
+export { getStampUsage } from "./stamps.js";

package/dist/mjs/utils/file.js

@@ -4,15 +4,14 @@
  * https://developer.mozilla.org/en-US/docs/Web/API/File
  */
 export function isFile(file) {
-    // browser
-    if (typeof File === 'function') {
-        return file instanceof File;
-    }
-    // node.js
-    const f = file;
-    return (typeof f === 'object' &&
-        typeof f.name === 'string' &&
-        (typeof f.stream === 'function' || typeof f.arrayBuffer === 'function'));
+  // browser
+  if (typeof File === 'function') {
+    return file instanceof File;
+  } // node.js
+
+
+  const f = file;
+  return typeof f === 'object' && typeof f.name === 'string' && (typeof f.stream === 'function' || typeof f.arrayBuffer === 'function');
 }
 /**
  * Compatibility helper for browsers where the `arrayBuffer function is
@@ -20,14 +19,18 @@ 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
-    return new Promise(resolve => {
-        const fr = new FileReader();
-        fr.onload = () => resolve(fr.result);
-        fr.readAsArrayBuffer(file);
-    });
-}
+  if (file.arrayBuffer) {
+    return file.arrayBuffer();
+  } // 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);
+  });
+}