@ethersphere/bee-js 3.3.2-pre.1 → 3.3.3

package/dist/mjs/modules/soc.js

@@ -1,3 +1,35 @@
+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 { extractUploadHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 const socEndpoint = 'soc';
@@ -13,19 +45,20 @@ const socEndpoint = 'soc';
  * @param options         Additional options like tag, encryption, pinning
  */
 
-export async function upload(ky, owner, identifier, signature, data, postageBatchId, options) {
-  const response = await http(ky, {
-    method: 'post',
-    path: `${socEndpoint}/${owner}/${identifier}`,
-    body: data,
-    headers: {
-      'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options)
-    },
-    responseType: 'json',
-    searchParams: {
-      sig: signature
-    }
+export function upload(ky, owner, identifier, signature, data, postageBatchId, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const response = yield http(ky, {
+      method: 'post',
+      path: `${socEndpoint}/${owner}/${identifier}`,
+      body: data,
+      headers: Object.assign({
+        'content-type': 'application/octet-stream'
+      }, extractUploadHeaders(postageBatchId, options)),
+      responseType: 'json',
+      searchParams: {
+        sig: signature
+      }
+    });
+    return response.data.reference;
   });
-  return response.data.reference;
 }

package/dist/mjs/modules/status.js

@@ -1,3 +1,35 @@
+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";
 /**
  * Ping the base bee URL. If connection was not successful throw error
@@ -5,8 +37,10 @@ import { http } from "../utils/http.js";
  * @param ky Ky instance for given Bee class instance
  */
 
-export async function checkConnection(ky) {
-  await http(ky, {
-    path: ''
+export function checkConnection(ky) {
+  return __awaiter(this, void 0, void 0, function* () {
+    yield http(ky, {
+      path: ''
+    });
   });
 }

package/dist/mjs/modules/stewardship.js

@@ -1,3 +1,35 @@
+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 stewardshipEndpoint = 'stewardship';
 /**
@@ -8,17 +40,21 @@ const stewardshipEndpoint = 'stewardship';
  * @throws BeeResponseError if not locally pinned or invalid data
  */
 
-export async function reupload(ky, reference) {
-  await http(ky, {
-    method: 'put',
-    path: `${stewardshipEndpoint}/${reference}`
+export function reupload(ky, reference) {
+  return __awaiter(this, void 0, void 0, function* () {
+    yield http(ky, {
+      method: 'put',
+      path: `${stewardshipEndpoint}/${reference}`
+    });
   });
 }
-export async function isRetrievable(ky, reference) {
-  const response = await http(ky, {
-    method: 'get',
-    responseType: 'json',
-    path: `${stewardshipEndpoint}/${reference}`
+export function isRetrievable(ky, reference) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const response = yield http(ky, {
+      method: 'get',
+      responseType: 'json',
+      path: `${stewardshipEndpoint}/${reference}`
+    });
+    return response.data.isRetrievable;
   });
-  return response.data.isRetrievable;
 }

package/dist/mjs/modules/tag.js

@@ -1,3 +1,35 @@
+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';
 /**
@@ -6,13 +38,15 @@ const endpoint = 'tags';
  * @param url Bee tag URL
  */
 
-export async function createTag(ky) {
-  const response = await http(ky, {
-    method: 'post',
-    path: endpoint,
-    responseType: 'json'
+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;
   });
-  return response.data;
 }
 /**
  * Retrieve tag information from Bee node
@@ -21,12 +55,14 @@ export async function createTag(ky) {
  * @param uid UID of tag to be retrieved
  */
 
-export async function retrieveTag(ky, uid) {
-  const response = await http(ky, {
-    path: `${endpoint}/${uid}`,
-    responseType: 'json'
+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;
   });
-  return response.data;
 }
 /**
  * Get limited listing of all tags.
@@ -36,16 +72,18 @@ export async function retrieveTag(ky, uid) {
  * @param limit
  */
 
-export async function getAllTags(ky, offset, limit) {
-  const response = await http(ky, {
-    path: `${endpoint}`,
-    searchParams: {
-      offset,
-      limit
-    },
-    responseType: 'json'
+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;
   });
-  return response.data.tags;
 }
 /**
  * Removes tag from the Bee node.
@@ -53,10 +91,12 @@ export async function getAllTags(ky, offset, limit) {
  * @param uid
  */
 
-export async function deleteTag(ky, uid) {
-  await http(ky, {
-    method: 'delete',
-    path: `${endpoint}/${uid}`
+export function deleteTag(ky, uid) {
+  return __awaiter(this, void 0, void 0, function* () {
+    yield http(ky, {
+      method: 'delete',
+      path: `${endpoint}/${uid}`
+    });
   });
 }
 /**
@@ -66,12 +106,14 @@ export async function deleteTag(ky, uid) {
  * @param reference
  */
 
-export async function updateTag(ky, uid, reference) {
-  await http(ky, {
-    method: 'patch',
-    path: `${endpoint}/${uid}`,
-    json: {
-      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
+      }
+    });
   });
 }

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

@@ -1,11 +1,46 @@
+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 async function makeCollectionFromFS(dir) {
-  throw new Error('Creating Collection from File System is not supported in browsers!');
+
+
+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!');
+  });
 }
 /**
  * Calculate folder size recursively
@@ -14,6 +49,8 @@ export async function makeCollectionFromFS(dir) {
  * @returns size in bytes
  */
 
-export async function getFolderSize(dir) {
-  throw new Error('Creating Collection from File System is not supported in browsers!');
+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!');
+  });
 }

package/dist/mjs/utils/collection.js

@@ -1,3 +1,35 @@
+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";
@@ -26,21 +58,23 @@ function makeFilePath(file) {
   throw new TypeError('file is not valid File object');
 }
 
-export async function makeCollectionFromFileList(fileList) {
-  const collection = [];
+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];
+    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))
-      });
+      if (file) {
+        collection.push({
+          path: makeFilePath(file),
+          data: new Uint8Array(yield fileArrayBuffer(file))
+        });
+      }
     }
-  }
 
-  return collection;
+    return collection;
+  });
 }
 /**
  * Calculate cumulative size of files

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

@@ -1,3 +1,61 @@
+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';
 /**
@@ -7,39 +65,58 @@ 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!');
-  }
+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!');
-  }
+    if (dir === '') {
+      throw new TypeError('dir must not be empty string!');
+    }
 
-  return buildCollectionRelative(dir, '');
+    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 = [];
+function buildCollectionRelative(dir, relativePath) {
+  var e_1, _a;
 
-  for await (const entry of entries) {
-    const fullPath = path.join(dir, relativePath, entry.name);
-    const entryPath = path.join(relativePath, entry.name);
+  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 = [];
 
-    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];
+    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;
+      }
     }
-  }
 
-  return collection;
+    return collection;
+  });
 }
 /**
  * Calculate folder size recursively
@@ -49,26 +126,44 @@ async function buildCollectionRelative(dir, relativePath) {
  */
 
 
-export async function getFolderSize(dir) {
-  if (typeof dir !== 'string') {
-    throw new TypeError('dir has to be string!');
-  }
+export function getFolderSize(dir) {
+  var e_2, _a;
 
-  if (dir === '') {
-    throw new TypeError('dir must not be empty string!');
-  }
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof dir !== 'string') {
+      throw new TypeError('dir has to be string!');
+    }
 
-  const entries = await fs.promises.opendir(dir);
-  let size = 0;
+    if (dir === '') {
+      throw new TypeError('dir must not be empty string!');
+    }
 
-  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));
+    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;
+      }
     }
-  }
 
-  return size;
+    return size;
+  });
 }