@ethersphere/bee-js 3.3.0 → 3.3.1

package/dist/mjs/utils/hash.js

@@ -1,12 +1,17 @@
-import { keccak256 } from 'js-sha3';
+// For ESM compatibility
+import pkg from 'js-sha3';
+const {
+  keccak256
+} = pkg;
 /**
  * Helper function for calculating the keccak256 hash with
  * correct types.
  *
  * @param messages Any number of messages (strings, byte arrays etc.)
  */
+
 export function keccak256Hash(...messages) {
-    const hasher = keccak256.create();
-    messages.forEach(bytes => hasher.update(bytes));
-    return Uint8Array.from(hasher.digest());
-}
+  const hasher = keccak256.create();
+  messages.forEach(bytes => hasher.update(bytes));
+  return Uint8Array.from(hasher.digest());
+}

package/dist/mjs/utils/headers.js

@@ -1,4 +1,4 @@
-import { BeeError } from './error';
+import { BeeError } from "./error.js";
 /**
  * Read the filename from the content-disposition header
  * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
@@ -7,48 +7,52 @@ import { BeeError } from './error';
  *
  * @returns the filename
  */
+
 function readContentDispositionFilename(header) {
-    if (!header) {
-        throw new BeeError('missing content-disposition header');
-    }
-    // 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');
+  if (!header) {
+    throw new BeeError('missing content-disposition header');
+  } // 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);
+  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;
-    return {
-        name,
-        tagUid,
-        contentType,
-    };
+  const name = readContentDispositionFilename(headers.get('content-disposition'));
+  const tagUid = readTagUid(headers.get('swarm-tag-uid'));
+  const contentType = headers.get('content-type') || undefined;
+  return {
+    name,
+    tagUid,
+    contentType
+  };
 }
 export function extractUploadHeaders(postageBatchId, options) {
-    if (!postageBatchId) {
-        throw new BeeError('Postage BatchID has to be specified!');
-    }
-    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();
-    return headers;
-}
+  if (!postageBatchId) {
+    throw new BeeError('Postage BatchID has to be specified!');
+  }
+
+  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();
+  return headers;
+}

package/dist/mjs/utils/hex.js

@@ -1,4 +1,4 @@
-import { makeBytes } from './bytes';
+import { makeBytes } from "./bytes.js";
 /**
  * Creates unprefixed hex string from wide range of data.
  *
@@ -7,44 +7,52 @@ import { makeBytes } from './bytes';
  * @param input
  * @param len of the resulting HexString WITHOUT prefix!
  */
+
 export function makeHexString(input, len) {
-    if (typeof input === 'number') {
-        return intToHex(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
+      // and usage of isHexString() would not give enough information to the user on what is going
+      // wrong.
+      assertHexString(input, len);
+      return input;
     }
-    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
-            // and usage of isHexString() would not give enough information to the user on what is going
-            // wrong.
-            assertHexString(input, len);
-            return input;
-        }
-    }
-    throw new TypeError('Not HexString compatible type!');
+  }
+
+  throw new TypeError('Not HexString compatible type!');
 }
 /**
  * Converts a hex string to Uint8Array
  *
  * @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;
+  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;
 }
 /**
  * Converts array of number or Uint8Array to HexString without prefix.
@@ -52,14 +60,17 @@ 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
-    if (len && hex.length !== len) {
-        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
-    }
-    return hex;
+  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
+
+  if (len && hex.length !== len) {
+    throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+  }
+
+  return hex;
 }
 /**
  * Converts integer number to hex string.
@@ -69,19 +80,18 @@ 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
-    if (len && hex.length !== len) {
-        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
-    }
-    return hex;
+  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
+
+  if (len && hex.length !== len) {
+    throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+  }
+
+  return hex;
 }
 /**
  * Type guard for HexStrings.
@@ -92,8 +102,9 @@ 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);
+  return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
 }
 /**
  * Type guard for PrefixedHexStrings.
@@ -101,8 +112,9 @@ export function isHexString(s, len) {
  *
  * @param s string input
  */
+
 export function isPrefixedHexString(s) {
-    return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
+  return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
 }
 /**
  * Verifies if the provided input is a HexString.
@@ -114,15 +126,17 @@ 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
-        const lengthMsg = len ? ` of length ${len}` : '';
-        throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
-    }
+  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
+
+
+    const lengthMsg = len ? ` of length ${len}` : '';
+    throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
+  }
 }
 /**
  * Verifies if the provided input is a PrefixedHexString.
@@ -132,8 +146,9 @@ 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}`);
-    }
-}
+  if (!isPrefixedHexString(s)) {
+    throw new TypeError(`${name} not valid prefixed hex string: ${s}`);
+  }
+}

package/dist/mjs/utils/http.js

@@ -1,47 +1,52 @@
-import { BeeError, BeeNotAJsonError, BeeRequestError, BeeResponseError } from './error';
+import { BeeError, BeeNotAJsonError, BeeRequestError, BeeResponseError } from "./error.js";
 import kyFactory from 'ky-universal';
-import { normalizeToReadableStream } from './stream';
-import { deepMerge } from './merge';
-import { isObject, isStrictlyObject } from './type';
+import { normalizeToReadableStream } from "./stream.js";
+import { deepMerge } from "./merge.js";
+import { isObject, isStrictlyObject } from "./type.js";
 const DEFAULT_KY_CONFIG = {
-    headers: {
-        accept: 'application/json, text/plain, */*',
-        'user-agent': `bee-js`,
-    },
+  headers: {
+    accept: 'application/json, text/plain, */*',
+    'user-agent': `bee-js`
+  }
 };
+
 function isHttpError(e) {
-    return isObject(e) && typeof e.response !== 'undefined';
+  return isObject(e) && typeof e.response !== 'undefined';
 }
+
 function isHttpRequestError(e) {
-    return isObject(e) && typeof e.request !== 'undefined';
+  return isObject(e) && typeof e.request !== 'undefined';
 }
+
 function headersToObject(header) {
-    return [...header.entries()].reduce((obj, [key, val]) => {
-        obj[key] = val;
-        return obj;
-    }, {});
+  return [...header.entries()].reduce((obj, [key, val]) => {
+    obj[key] = val;
+    return obj;
+  }, {});
 }
+
 function wrapRequest(request) {
-    return {
-        url: request.url,
-        method: request.method.toUpperCase(),
-        headers: headersToObject(request.headers),
-    };
+  return {
+    url: request.url,
+    method: request.method.toUpperCase(),
+    headers: headersToObject(request.headers)
+  };
 }
+
 export function wrapRequestClosure(cb) {
-    return async (request) => {
-        await cb(wrapRequest(request));
-    };
+  return async request => {
+    await cb(wrapRequest(request));
+  };
 }
 export function wrapResponseClosure(cb) {
-    return async (request, options, response) => {
-        await cb({
-            headers: headersToObject(response.headers),
-            status: response.status,
-            statusText: response.statusText,
-            request: wrapRequest(request),
-        });
-    };
+  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.
@@ -50,87 +55,101 @@ export function wrapResponseClosure(cb) {
  * @param obj
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
+
 export function filterHeaders(obj) {
-    if (obj === undefined) {
-        return undefined;
+  if (obj === undefined) {
+    return undefined;
+  }
+
+  isStrictlyObject(obj);
+  const typedObj = obj;
+
+  for (const key in typedObj) {
+    if (typedObj[key] === undefined) {
+      delete typedObj[key];
     }
-    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;
+  }
+
+  if (Object.keys(typedObj).length === 0) {
+    return undefined;
+  }
+
+  return typedObj;
 }
 /**
  * Main utility function to make HTTP requests.
  * @param ky
  * @param config
  */
+
 export async function http(ky, config) {
-    try {
-        const { path, responseType, ...kyConfig } = 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!');
-                }
-                response.data = normalizeToReadableStream(response.body);
-                break;
-            case 'arraybuffer':
-                response.data = (await response.arrayBuffer());
-                break;
-            case 'json':
-                try {
-                    response.data = (await 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;
+  try {
+    const {
+      path,
+      responseType,
+      ...kyConfig
+    } = 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!');
         }
-        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 {
-            throw new BeeError(e.message);
+
+        response.data = normalizeToReadableStream(response.body);
+        break;
+
+      case 'arraybuffer':
+        response.data = await response.arrayBuffer();
+        break;
+
+      case 'json':
+        try {
+          response.data = await 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 = 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 {
+      throw new BeeError(e.message);
+    }
+  }
 }
 export function makeDefaultKy(kyConfig) {
-    return kyFactory.create(deepMerge(DEFAULT_KY_CONFIG, kyConfig));
-}
+  return kyFactory.create(deepMerge(DEFAULT_KY_CONFIG, kyConfig));
+}

package/dist/mjs/utils/merge.js

@@ -1,4 +1,4 @@
-import { isObject } from './type';
+import { isObject } from "./type.js";
 /**
  * Function that deep merges objects
  *
@@ -6,25 +6,31 @@ import { isObject } from './type';
  * @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
-            for (let [key, value] of Object.entries(source)) {
-                if (isObject(value) && key in returnValue) {
-                    value = deepMerge(returnValue[key], value);
-                }
-                returnValue = { ...returnValue, [key]: value };
-            }
+  // 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
+      for (let [key, value] of Object.entries(source)) {
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
         }
+
+        returnValue = { ...returnValue,
+          [key]: value
+        };
+      }
     }
-    return returnValue;
-}
+  }
+
+  return returnValue;
+}

package/dist/mjs/utils/pss.js

@@ -1,4 +1,4 @@
-import { PSS_TARGET_HEX_LENGTH_MAX } from '../types';
+import { PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
 /**
  * Utility function that for given strings/reference takes the most specific
  * target that Bee node will except.
@@ -6,9 +6,11 @@ import { PSS_TARGET_HEX_LENGTH_MAX } from '../types';
  * @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);
-}
+  if (typeof target !== 'string') {
+    throw new TypeError('target has to be an string!');
+  }
+
+  return target.slice(0, PSS_TARGET_HEX_LENGTH_MAX);
+}