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

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

@@ -1,36 +1,4 @@
-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
-
-
+// For ESM compatibility
 import pkg from 'js-sha3';
 const {
   keccak256,
@@ -130,8 +98,6 @@ 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');
   }
@@ -142,7 +108,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 = (_a = hexRep.match(/../g)) === null || _a === void 0 ? void 0 : _a.reverse().join('');
+  const littleEndian = hexRep.match(/../g)?.reverse().join('');
   if (littleEndian) return littleEndian;
   throw new Error('failed to convert');
 }
@@ -196,40 +162,38 @@ 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 function makeEthereumWalletSigner(provider, ethAddress) {
-  return __awaiter(this, void 0, void 0, function* () {
-    let executorFnc;
+export async function makeEthereumWalletSigner(provider, ethAddress) {
+  let executorFnc;
 
-    if (typeof provider !== 'object' || provider === null) {
-      throw new TypeError('We need JsonRPC provider object!');
-    }
+  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 (provider.request) {
+    executorFnc = provider.request;
+  } else if (provider.sendAsync) {
+    executorFnc = provider.sendAsync;
+  } else {
+    throw new Error('Incompatible interface of given provider!');
+  }
 
-    if (!ethAddress) {
-      ethAddress = (yield executorFnc({
-        method: 'eth_requestAccounts'
-      }))[0];
-    }
+  if (!ethAddress) {
+    ethAddress = (await 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;
-      })
-    };
-  });
+  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 → src}/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/utils/file.js

@@ -0,0 +1,36 @@
+/**
+ * Compatibility functions for working with File API objects
+ *
+ * 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');
+}
+/**
+ * Compatibility helper for browsers where the `arrayBuffer function is
+ * missing from `File` objects.
+ *
+ * @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);
+  });
+}

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

@@ -50,9 +50,9 @@ export function extractUploadHeaders(postageBatchId, options) {
   const headers = {
     'swarm-postage-batch-id': postageBatchId
   };
-  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();
+  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/src/utils/http.js

@@ -0,0 +1,162 @@
+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 = {
+  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,
+    method: request.method.toUpperCase(),
+    headers: headersToObject(request.headers)
+  };
+}
+
+export function wrapRequestClosure(cb) {
+  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)
+    });
+  };
+}
+/**
+ * Filters out entries that has undefined value from headers object.
+ * Modifies the original object!
+ *
+ * @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 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.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
+    }
+
+    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));
+}

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

@@ -25,9 +25,9 @@ export function deepMerge(...sources) {
           value = deepMerge(returnValue[key], value);
         }
 
-        returnValue = Object.assign(Object.assign({}, returnValue), {
+        returnValue = { ...returnValue,
           [key]: value
-        });
+        };
       }
     }
   }

package/dist/src/utils/sleep.js

@@ -0,0 +1,8 @@
+/**
+ * Sleep for N miliseconds
+ *
+ * @param ms Number of miliseconds to sleep
+ */
+export async function sleep(ms) {
+  return new Promise(resolve => setTimeout(() => resolve(), ms));
+}

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

@@ -1,7 +1,7 @@
-import { Readable as NodeReadableNative } from 'stream';
+import * as streamPackage from 'stream';
 import { isStrictlyObject } from "./type.js";
 import { ReadableStream } from 'web-streams-polyfill';
-const NodeReadable = NodeReadableNative || class {};
+const NodeReadable = streamPackage?.Readable || class {};
 /**
  * Validates if passed object is either browser's ReadableStream
  * or Node's Readable.
@@ -135,7 +135,7 @@ class NodeReadableWrapper extends NodeReadable {
 
 
 export function readableWebToNode(webStream, options) {
-  if (!NodeReadableNative) {
+  if (!streamPackage?.Readable) {
     throw new Error("The Node's Readable is not available! If you are running this in browser you have to polyfill 'stream' package!");
   }
 

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

@@ -122,8 +122,6 @@ export function assertReferenceOrEns(value) {
  */
 
 export function makeReferenceOrEns(value, expectedCidType) {
-  var _a;
-
   if (typeof value !== 'string') {
     throw new TypeError('ReferenceCidOrEns has to be a string!');
   }
@@ -132,7 +130,7 @@ export function makeReferenceOrEns(value, expectedCidType) {
     const result = decodeCid(value);
 
     if (result.type !== expectedCidType) {
-      throw new BeeError(`CID was expected to be of type ${expectedCidType}, but got instead ${(_a = result.type) !== null && _a !== void 0 ? _a : 'non-Swarm CID'}`);
+      throw new BeeError(`CID was expected to be of type ${expectedCidType}, but got instead ${result.type ?? 'non-Swarm CID'}`);
     }
 
     return result.reference;
@@ -150,12 +148,13 @@ export function makeReferenceOrEns(value, expectedCidType) {
  */
 
 export function addCidConversionFunction(result, cidType) {
-  return Object.assign(Object.assign({}, result), {
+  return { ...result,
+
     cid() {
       return encodeReference(result.reference, cidType).toString();
     }
 
-  });
+  };
 }
 export function assertAddress(value) {
   assertHexString(value, ADDRESS_HEX_LENGTH, 'Address');
@@ -313,19 +312,19 @@ export function assertPostageBatchOptions(value) {
   const options = value;
   assertRequestOptions(options, 'PostageBatchOptions');
 
-  if (options === null || options === void 0 ? void 0 : options.gasPrice) {
+  if (options?.gasPrice) {
     assertNonNegativeInteger(options.gasPrice);
   }
 
-  if ((options === null || options === void 0 ? void 0 : options.immutableFlag) !== undefined) {
+  if (options?.immutableFlag !== undefined) {
     assertBoolean(options.immutableFlag);
   }
 
-  if ((options === null || options === void 0 ? void 0 : options.waitForUsable) !== undefined) {
+  if (options?.waitForUsable !== undefined) {
     assertBoolean(options.waitForUsable);
   }
 
-  if ((options === null || options === void 0 ? void 0 : options.waitForUsableTimeout) !== undefined) {
+  if (options?.waitForUsableTimeout !== undefined) {
     assertNonNegativeInteger(options.waitForUsableTimeout, 'options.waitForUsableTimeout');
   }
 }
@@ -338,11 +337,11 @@ export function assertCashoutOptions(value) {
   const options = value;
   assertRequestOptions(options, 'PostageBatchOptions');
 
-  if (options === null || options === void 0 ? void 0 : options.gasLimit) {
+  if (options?.gasLimit) {
     assertNonNegativeInteger(options.gasLimit);
   }
 
-  if (options === null || options === void 0 ? void 0 : options.gasPrice) {
+  if (options?.gasPrice) {
     assertNonNegativeInteger(options.gasPrice);
   }
 }
@@ -381,7 +380,7 @@ export function assertAllTagsOptions(entry) {
   assertRequestOptions(entry, 'AllTagsOptions');
   const options = entry;
 
-  if ((options === null || options === void 0 ? void 0 : options.limit) !== undefined) {
+  if (options?.limit !== undefined) {
     if (typeof options.limit !== 'number') {
       throw new TypeError('AllTagsOptions.limit has to be a number or undefined!');
     }
@@ -395,7 +394,7 @@ export function assertAllTagsOptions(entry) {
     }
   }
 
-  if ((options === null || options === void 0 ? void 0 : options.offset) !== undefined) {
+  if (options?.offset !== undefined) {
     assertNonNegativeInteger(options.offset, 'AllTagsOptions.offset');
   }
 }

package/dist/types/chunk/bmt.d.ts

@@ -1,4 +1,4 @@
-import { Bytes } from '../utils/bytes';
+import type { Bytes } from '../utils/bytes';
 /**
  * Calculate a Binary Merkle Tree hash for a chunk
  *

package/dist/types/chunk/soc.d.ts

@@ -1,7 +1,7 @@
-import { Bytes } from '../utils/bytes';
 import { Chunk } from './cac';
 import { UploadOptions, Signature, Signer, BatchId, Reference, Ky, PlainBytesReference } from '../types';
 import { EthAddress } from '../utils/eth';
+import type { Bytes } from '../utils/bytes';
 export declare type Identifier = Bytes<32>;
 /**
  * With single owner chunks, a user can assign arbitrary data to an

package/dist/types/chunk/span.d.ts

@@ -1,4 +1,4 @@
-import { Bytes } from '../utils/bytes';
+import type { Bytes } from '../utils/bytes';
 export declare const SPAN_SIZE = 8;
 /**
  * Create a span for storing the length of the chunk

package/dist/types/feed/index.d.ts

@@ -1,8 +1,8 @@
 import { FeedUpdateOptions } from '../modules/feed';
 import { BatchId, BytesReference, FEED_INDEX_HEX_LENGTH, FeedReader, FeedWriter, Ky, PlainBytesReference, Reference, Signer, Topic, UploadOptions } from '../types';
-import { Bytes } from '../utils/bytes';
 import { HexString } from '../utils/hex';
 import { EthAddress, HexEthAddress } from '../utils/eth';
+import type { Bytes } from '../utils/bytes';
 import type { FeedType } from './type';
 export interface Epoch {
     time: number;

package/dist/types/index.d.ts

@@ -5,16 +5,3 @@ export * from './types';
 export * from './utils/error';
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
 export { Bee, BeeDebug };
-declare global {
-    interface Window {
-        BeeJs: {
-            Bee: typeof import('./bee').Bee;
-            BeeDebug: typeof import('./bee-debug').BeeDebug;
-            Utils: typeof import('./utils/expose');
-            BeeError: typeof import('./utils/error').BeeError;
-            BeeRequestError: typeof import('./utils/error').BeeRequestError;
-            BeeResponseError: typeof import('./utils/error').BeeResponseError;
-            BeeArgumentError: typeof import('./utils/error').BeeArgumentError;
-        };
-    }
-}

package/dist/types/modules/bzz.d.ts

@@ -1,4 +1,4 @@
-import { BatchId, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Ky, Readable, ReferenceOrEns, UploadResult } from '../types';
+import type { BatchId, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Ky, Readable, ReferenceOrEns, UploadResult } from '../types';
 /**
  * Upload single file
  *

package/dist/types/types/index.d.ts

@@ -8,10 +8,10 @@ import type { BeeError } from '../utils/error';
 import type { EthAddress, HexEthAddress } from '../utils/eth';
 import type { HexString } from '../utils/hex';
 import type ky from 'ky-universal';
+import type { Options as KyOptions } from 'ky';
 import type { Readable as NativeReadable } from 'stream';
 import type { Readable as CompatibilityReadable } from 'readable-stream';
 import type { ReadableStream as ReadableStreamPonyfill } from 'web-streams-polyfill';
-import { Options as KyOptions } from './ky-options';
 export * from './debug';
 export declare type Ky = typeof ky;
 export interface Dictionary<T> {
@@ -266,13 +266,13 @@ export interface Pin {
     reference: string;
 }
 /**
- * Helper interface that adds utility functions
- * to work more conveniently with bytes in normal
- * user scenarios.
- *
- * Concretely: text(), hex(), json()
+ * Interface that represents Data passed from Bee and that allows accessing it in different forms..
  */
-export interface Data extends Uint8Array {
+export interface Data {
+    /**
+     * The raw binary data in form of Uint8Array
+     */
+    bytes(): Uint8Array;
     /**
      * Converts the binary data using UTF-8 decoding into string.
      */
@@ -548,4 +548,4 @@ interface JsonMap {
     [key: string]: AnyJson;
 }
 declare type JsonArray = Array<AnyJson>;
-declare type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+export declare type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;

package/dist/types/utils/error.d.ts

@@ -1,4 +1,4 @@
-import { KyRequestOptions } from '../types';
+import type { KyRequestOptions } from '../types';
 export declare class BeeError extends Error {
     constructor(message: string);
 }

package/dist/types/utils/eth.d.ts

@@ -1,6 +1,6 @@
-import { BrandedString, Signer } from '../types';
-import { HexString } from './hex';
-import { Bytes } from './bytes';
+import type { HexString } from './hex';
+import type { Bytes } from '../utils/bytes';
+import type { BrandedString, Signer } from '../types';
 export declare type OverlayAddress = BrandedString<'OverlayAddress'>;
 export declare type EthAddress = Bytes<20>;
 export declare type HexEthAddress = HexString<40>;

package/dist/types/utils/expose.d.ts

@@ -1,8 +1,11 @@
 export { getCollectionSize } from './collection';
-export { getFolderSize } from './collection.node';
-export { Bytes, FlexBytes, isBytes, assertBytes, isFlexBytes, assertFlexBytes, bytesAtOffset, flexBytesAtOffset, bytesEqual, } from './bytes';
-export { HexString, PrefixedHexString, makeHexString, hexToBytes, bytesToHex, intToHex, isHexString, assertHexString, assertPrefixedHexString, } from './hex';
-export { EthAddress, makeEthAddress, makeHexEthAddress, isHexEthAddress, ethToSwarmAddress, toLittleEndian, fromLittleEndian, makeEthereumWalletSigner, } from './eth';
+export { getFolderSize } from './collection-node';
+export type { Bytes, FlexBytes } from './bytes';
+export { isBytes, assertBytes, isFlexBytes, assertFlexBytes, bytesAtOffset, flexBytesAtOffset, bytesEqual, } from './bytes';
+export type { HexString, PrefixedHexString } from './hex';
+export { makeHexString, hexToBytes, bytesToHex, intToHex, isHexString, assertHexString, assertPrefixedHexString, } from './hex';
+export type { EthAddress } from './eth';
+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';

package/dist/types/utils/hash.d.ts

@@ -1,5 +1,5 @@
 import { Message } from 'js-sha3';
-import { Bytes } from './bytes';
+import type { Bytes } from './bytes';
 /**
  * Helper function for calculating the keccak256 hash with
  * correct types.

package/dist/types/utils/hex.d.ts

@@ -1,5 +1,5 @@
-import { Bytes } from './bytes';
-import { BrandedType, FlavoredType } from '../types';
+import type { Bytes } from '../utils/bytes';
+import type { BrandedType, FlavoredType } from '../types';
 /**
  * Nominal type to represent hex strings WITHOUT '0x' prefix.
  * For example for 32 bytes hex representation you have to use 64 length.