@ethersphere/bee-js 5.1.1 → 5.1.2

package/dist/mjs/modules/tag.js

@@ -1,35 +1,3 @@
-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 { http } from "../utils/http.js";
 const endpoint = 'tags';
 /**
@@ -37,16 +5,13 @@ const endpoint = 'tags';
  *
  * @param url Bee tag URL
  */
-
-export function createTag(ky) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const response = yield http(ky, {
-      method: 'post',
-      path: endpoint,
-      responseType: 'json'
-    });
-    return response.data;
+export async function createTag(kyOptions) {
+  const response = await http(kyOptions, {
+    method: 'post',
+    path: endpoint,
+    responseType: 'json'
   });
+  return response.parsedData;
 }
 /**
  * Retrieve tag information from Bee node
@@ -54,15 +19,12 @@ export function createTag(ky) {
  * @param url Bee tag URL
  * @param uid UID of tag to be retrieved
  */
-
-export function retrieveTag(ky, uid) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const response = yield http(ky, {
-      path: `${endpoint}/${uid}`,
-      responseType: 'json'
-    });
-    return response.data;
+export async function retrieveTag(kyOptions, uid) {
+  const response = await http(kyOptions, {
+    path: `${endpoint}/${uid}`,
+    responseType: 'json'
   });
+  return response.parsedData;
 }
 /**
  * Get limited listing of all tags.
@@ -71,32 +33,26 @@ export function retrieveTag(ky, uid) {
  * @param offset
  * @param limit
  */
-
-export function getAllTags(ky, offset, limit) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const response = yield http(ky, {
-      path: `${endpoint}`,
-      searchParams: {
-        offset,
-        limit
-      },
-      responseType: 'json'
-    });
-    return response.data.tags;
+export async function getAllTags(kyOptions, offset, limit) {
+  const response = await http(kyOptions, {
+    path: `${endpoint}`,
+    searchParams: {
+      offset,
+      limit
+    },
+    responseType: 'json'
   });
+  return response.parsedData.tags;
 }
 /**
  * Removes tag from the Bee node.
  * @param url
  * @param uid
  */
-
-export function deleteTag(ky, uid) {
-  return __awaiter(this, void 0, void 0, function* () {
-    yield http(ky, {
-      method: 'delete',
-      path: `${endpoint}/${uid}`
-    });
+export async function deleteTag(kyOptions, uid) {
+  await http(kyOptions, {
+    method: 'delete',
+    path: `${endpoint}/${uid}`
   });
 }
 /**
@@ -105,15 +61,12 @@ export function deleteTag(ky, uid) {
  * @param uid
  * @param reference
  */
-
-export function updateTag(ky, uid, reference) {
-  return __awaiter(this, void 0, void 0, function* () {
-    yield http(ky, {
-      method: 'patch',
-      path: `${endpoint}/${uid}`,
-      json: {
-        reference
-      }
-    });
+export async function updateTag(kyOptions, uid, reference) {
+  await http(kyOptions, {
+    method: 'patch',
+    path: `${endpoint}/${uid}`,
+    json: {
+      reference
+    }
   });
 }

package/dist/mjs/types/debug.js

@@ -1,5 +1,4 @@
 export var BeeModes;
-
 (function (BeeModes) {
   BeeModes["FULL"] = "full";
   BeeModes["LIGHT"] = "light";

package/dist/mjs/types/index.js

@@ -14,12 +14,10 @@ export const ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
 /**
  * Minimal depth that can be used for creation of postage batch
  */
-
 export const STAMPS_DEPTH_MIN = 17;
 /**
  * Maximal depth that can be used for creation of postage batch
  */
-
 export const STAMPS_DEPTH_MAX = 255;
 export const TAGS_LIMIT_MIN = 1;
 export const TAGS_LIMIT_MAX = 1000;
@@ -27,12 +25,10 @@ export const FEED_INDEX_HEX_LENGTH = 16;
 /*********************************************************
  * Writers and Readers interfaces
  */
-
 export const TOPIC_BYTES_LENGTH = 32;
 export const TOPIC_HEX_LENGTH = 64;
 /*********************************************************
  * Ethereum compatible signing interfaces and definitions
  */
-
 export const SIGNATURE_HEX_LENGTH = 130;
 export const SIGNATURE_BYTES_LENGTH = 65;

package/dist/mjs/utils/bytes.js

@@ -5,7 +5,6 @@ import { bytesToHex } from "./hex.js";
  * @param b       The byte array
  * @param length  The length of the byte array
  */
-
 export function isBytes(b, length) {
   return b instanceof Uint8Array && b.length === length;
 }
@@ -15,12 +14,10 @@ export function isBytes(b, length) {
  * @param offset
  * @param length
  */
-
 export function hasBytesAtOffset(data, offset, length) {
   if (!(data instanceof Uint8Array)) {
     throw new TypeError('Data has to an Uint8Array!');
   }
-
   const offsetBytes = data.slice(offset, offset + length);
   return isBytes(offsetBytes, length);
 }
@@ -30,7 +27,6 @@ export function hasBytesAtOffset(data, offset, length) {
  * @param b       The byte array
  * @param length  The specified length
  */
-
 export function assertBytes(b, length) {
   if (!isBytes(b, length)) {
     throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
@@ -43,7 +39,6 @@ export function assertBytes(b, length) {
  * @param min     Minimum size of the array
  * @param max     Maximum size of the array
  */
-
 export function isFlexBytes(b, min, max) {
   return b instanceof Uint8Array && b.length >= min && b.length <= max;
 }
@@ -54,7 +49,6 @@ export function isFlexBytes(b, min, max) {
  * @param min     Minimum size of the array
  * @param max     Maximum size of the array
  */
-
 export function assertFlexBytes(b, min, max) {
   if (!isFlexBytes(b, min, max)) {
     throw new TypeError(`Parameter is not valid FlexBytes of  min: ${min}, max: ${max}, length: ${b.length}`);
@@ -67,10 +61,9 @@ export function assertFlexBytes(b, min, max) {
  * @param offset The offset to start from
  * @param length The length of data to be returned
  */
-
 export function bytesAtOffset(data, offset, length) {
-  const offsetBytes = data.slice(offset, offset + length); // We are returning strongly typed Bytes so we have to verify that length is really what we claim
-
+  const offsetBytes = data.slice(offset, offset + length);
+  // We are returning strongly typed Bytes so we have to verify that length is really what we claim
   assertBytes(offsetBytes, length);
   return offsetBytes;
 }
@@ -82,9 +75,10 @@ export function bytesAtOffset(data, offset, length) {
  * @param _min   The minimum size of the data
  * @param _max   The maximum size of the data
  */
-
-export function flexBytesAtOffset(data, offset, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-_min, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function flexBytesAtOffset(data, offset,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_min,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 _max) {
   return data.slice(offset);
 }
@@ -94,7 +88,6 @@ _max) {
  * @param a Byte array to compare
  * @param b Byte array to compare
  */
-
 export function bytesEqual(a, b) {
   return a.length === b.length && a.every((value, index) => value === b[index]);
 }
@@ -103,7 +96,6 @@ export function bytesEqual(a, b) {
  *
  * @param length The length of data to be returned
  */
-
 export function makeBytes(length) {
   return new Uint8Array(length);
 }

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

@@ -1,46 +1,11 @@
-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());
-  });
-};
 /**
  * Creates array in the format of Collection with data loaded from directory on filesystem.
  * The function loads all the data into memory!
  *
  * @param dir path to the directory
  */
-
-
-export function makeCollectionFromFS(dir) {
-  return __awaiter(this, void 0, void 0, function* () {
-    throw new Error('Creating Collection from File System is not supported in browsers!');
-  });
+export async function makeCollectionFromFS(dir) {
+  throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 /**
  * Calculate folder size recursively
@@ -48,9 +13,6 @@ export function makeCollectionFromFS(dir) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-
-export function getFolderSize(dir) {
-  return __awaiter(this, void 0, void 0, function* () {
-    throw new Error('Creating Collection from File System is not supported in browsers!');
-  });
+export async function getFolderSize(dir) {
+  throw new Error('Creating Collection from File System is not supported in browsers!');
 }

package/dist/mjs/utils/collection.js

@@ -1,35 +1,3 @@
-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 { BeeArgumentError } from "./error.js";
 import { fileArrayBuffer } from "./file.js";
 import { isUint8Array } from "./type.js";
@@ -37,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) {
@@ -45,36 +12,27 @@ 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 function makeCollectionFromFileList(fileList) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const collection = [];
-
-    for (let i = 0; i < fileList.length; i++) {
-      const file = fileList[i];
-
-      if (file) {
-        collection.push({
-          path: makeFilePath(file),
-          data: new Uint8Array(yield fileArrayBuffer(file))
-        });
-      }
+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),
+        data: new Uint8Array(await fileArrayBuffer(file))
+      });
     }
-
-    return collection;
-  });
+  }
+  return collection;
 }
 /**
  * Calculate cumulative size of files
@@ -82,17 +40,13 @@ export 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/mjs/utils/collection.node.js

@@ -1,61 +1,3 @@
-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());
-  });
-};
-
-var __asyncValues = this && this.__asyncValues || function (o) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var m = o[Symbol.asyncIterator],
-      i;
-  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
-    return this;
-  }, i);
-
-  function verb(n) {
-    i[n] = o[n] && function (v) {
-      return new Promise(function (resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
-      });
-    };
-  }
-
-  function settle(resolve, reject, d, v) {
-    Promise.resolve(v).then(function (v) {
-      resolve({
-        value: v,
-        done: d
-      });
-    }, reject);
-  }
-};
-
 import fs from 'fs';
 import path from 'path';
 /**
@@ -64,59 +6,33 @@ import path from 'path';
  *
  * @param dir path to the directory
  */
-
-export function makeCollectionFromFS(dir) {
-  return __awaiter(this, void 0, void 0, function* () {
-    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, '');
-  });
+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, '');
 }
-
-function buildCollectionRelative(dir, relativePath) {
-  var e_1, _a;
-
-  return __awaiter(this, void 0, void 0, function* () {
-    // Handles case when the dir is not existing or it is a file ==> throws an error
-    const dirname = path.join(dir, relativePath);
-    const entries = yield fs.promises.opendir(dirname);
-    let collection = [];
-
-    try {
-      for (var entries_1 = __asyncValues(entries), entries_1_1; entries_1_1 = yield entries_1.next(), !entries_1_1.done;) {
-        const entry = entries_1_1.value;
-        const fullPath = path.join(dir, relativePath, entry.name);
-        const entryPath = path.join(relativePath, entry.name);
-
-        if (entry.isFile()) {
-          collection.push({
-            path: entryPath,
-            data: new Uint8Array(yield fs.promises.readFile(fullPath))
-          });
-        } else if (entry.isDirectory()) {
-          collection = [...(yield buildCollectionRelative(dir, entryPath)), ...collection];
-        }
-      }
-    } catch (e_1_1) {
-      e_1 = {
-        error: e_1_1
-      };
-    } finally {
-      try {
-        if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) yield _a.call(entries_1);
-      } finally {
-        if (e_1) throw e_1.error;
-      }
+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,
+        data: new Uint8Array(await fs.promises.readFile(fullPath))
+      });
+    } else if (entry.isDirectory()) {
+      collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
     }
-
-    return collection;
-  });
+  }
+  return collection;
 }
 /**
  * Calculate folder size recursively
@@ -124,46 +40,22 @@ function buildCollectionRelative(dir, relativePath) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-
-
-export function getFolderSize(dir) {
-  var e_2, _a;
-
-  return __awaiter(this, void 0, void 0, function* () {
-    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 = yield fs.promises.opendir(dir);
-    let size = 0;
-
-    try {
-      for (var entries_2 = __asyncValues(entries), entries_2_1; entries_2_1 = yield entries_2.next(), !entries_2_1.done;) {
-        const entry = entries_2_1.value;
-
-        if (entry.isFile()) {
-          const stats = yield fs.promises.stat(path.join(dir, entry.name));
-          size += stats.size;
-        } else if (entry.isDirectory()) {
-          size += yield getFolderSize(path.join(dir, entry.name));
-        }
-      }
-    } catch (e_2_1) {
-      e_2 = {
-        error: e_2_1
-      };
-    } finally {
-      try {
-        if (entries_2_1 && !entries_2_1.done && (_a = entries_2.return)) yield _a.call(entries_2);
-      } finally {
-        if (e_2) throw e_2.error;
-      }
+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));
+      size += stats.size;
+    } else if (entry.isDirectory()) {
+      size += await getFolderSize(path.join(dir, entry.name));
     }
-
-    return size;
-  });
+  }
+  return size;
 }