@ethersphere/bee-js 3.2.0 → 3.3.0

package/dist/cjs/modules/pss.js

@@ -0,0 +1,55 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribe = exports.send = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const data_1 = require("../utils/data");
+const http_1 = require("../utils/http");
+const headers_1 = require("../utils/headers");
+const endpoint = 'pss';
+/**
+ * Send to recipient or target with Postal Service for Swarm
+ *
+ * @param ky Ky instance for given Bee class instance
+ * @param topic Topic name
+ * @param target Target message address prefix
+ * @param data
+ * @param postageBatchId Postage BatchId that will be assigned to sent message
+ * @param recipient Recipient public key
+ *
+ */
+function send(ky, topic, target, data, postageBatchId, recipient) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, http_1.http)(ky, {
+            method: 'post',
+            path: `${endpoint}/send/${topic}/${target}`,
+            body: yield (0, data_1.prepareData)(data),
+            responseType: 'json',
+            searchParams: { recipient },
+            headers: (0, headers_1.extractUploadHeaders)(postageBatchId),
+        });
+    });
+}
+exports.send = send;
+/**
+ * Subscribe for messages on the given topic
+ *
+ * @param url Bee node URL
+ * @param topic Topic name
+ */
+function subscribe(url, topic) {
+    const wsUrl = url.replace(/^http/i, 'ws');
+    return new isomorphic_ws_1.default(`${wsUrl}/${endpoint}/subscribe/${topic}`);
+}
+exports.subscribe = subscribe;

package/dist/cjs/modules/soc.js

@@ -0,0 +1,40 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upload = void 0;
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const socEndpoint = 'soc';
+/**
+ * Upload single owner chunk (SOC) to a Bee node
+ *
+ * @param ky Ky instance
+ * @param owner           Owner's ethereum address in hex
+ * @param identifier      Arbitrary identifier in hex
+ * @param signature       Signature in hex
+ * @param data            Content addressed chunk data to be uploaded
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options         Additional options like tag, encryption, pinning
+ */
+function upload(ky, owner, identifier, signature, data, postageBatchId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, http_1.http)(ky, {
+            method: 'post',
+            path: `${socEndpoint}/${owner}/${identifier}`,
+            body: data,
+            headers: Object.assign({ 'content-type': 'application/octet-stream' }, (0, headers_1.extractUploadHeaders)(postageBatchId, options)),
+            responseType: 'json',
+            searchParams: { sig: signature },
+        });
+        return response.data.reference;
+    });
+}
+exports.upload = upload;

package/dist/cjs/modules/status.js

@@ -0,0 +1,26 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConnection = void 0;
+const http_1 = require("../utils/http");
+/**
+ * Ping the base bee URL. If connection was not successful throw error
+ *
+ * @param ky Ky instance for given Bee class instance
+ */
+function checkConnection(ky) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, http_1.http)(ky, {
+            path: '',
+        });
+    });
+}
+exports.checkConnection = checkConnection;

package/dist/cjs/modules/stewardship.js

@@ -0,0 +1,41 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRetrievable = exports.reupload = void 0;
+const http_1 = require("../utils/http");
+const stewardshipEndpoint = 'stewardship';
+/**
+ * Reupload locally pinned data
+ * @param ky Ky instance
+ * @param reference
+ * @param options
+ * @throws BeeResponseError if not locally pinned or invalid data
+ */
+function reupload(ky, reference) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, http_1.http)(ky, {
+            method: 'put',
+            path: `${stewardshipEndpoint}/${reference}`,
+        });
+    });
+}
+exports.reupload = reupload;
+function isRetrievable(ky, reference) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, http_1.http)(ky, {
+            method: 'get',
+            responseType: 'json',
+            path: `${stewardshipEndpoint}/${reference}`,
+        });
+        return response.data.isRetrievable;
+    });
+}
+exports.isRetrievable = isRetrievable;

package/dist/cjs/modules/tag.js

@@ -0,0 +1,96 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTag = exports.deleteTag = exports.getAllTags = exports.retrieveTag = exports.createTag = void 0;
+const http_1 = require("../utils/http");
+const endpoint = 'tags';
+/**
+ * Create new tag on the Bee node
+ *
+ * @param url Bee tag URL
+ */
+function createTag(ky) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, http_1.http)(ky, {
+            method: 'post',
+            path: endpoint,
+            responseType: 'json',
+        });
+        return response.data;
+    });
+}
+exports.createTag = createTag;
+/**
+ * Retrieve tag information from Bee node
+ *
+ * @param url Bee tag URL
+ * @param uid UID of tag to be retrieved
+ */
+function retrieveTag(ky, uid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, http_1.http)(ky, {
+            path: `${endpoint}/${uid}`,
+            responseType: 'json',
+        });
+        return response.data;
+    });
+}
+exports.retrieveTag = retrieveTag;
+/**
+ * Get limited listing of all tags.
+ *
+ * @param url
+ * @param offset
+ * @param limit
+ */
+function getAllTags(ky, offset, limit) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, http_1.http)(ky, {
+            path: `${endpoint}`,
+            searchParams: { offset, limit },
+            responseType: 'json',
+        });
+        return response.data.tags;
+    });
+}
+exports.getAllTags = getAllTags;
+/**
+ * Removes tag from the Bee node.
+ * @param url
+ * @param uid
+ */
+function deleteTag(ky, uid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, http_1.http)(ky, {
+            method: 'delete',
+            path: `${endpoint}/${uid}`,
+        });
+    });
+}
+exports.deleteTag = deleteTag;
+/**
+ * Updates tag
+ * @param url
+ * @param uid
+ * @param reference
+ */
+function updateTag(ky, uid, reference) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, http_1.http)(ky, {
+            method: 'patch',
+            path: `${endpoint}/${uid}`,
+            json: {
+                reference,
+            },
+        });
+    });
+}
+exports.updateTag = updateTag;

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+    "type": "commonjs",
+    "browser": {
+      "./utils/data.js": "./utils/data.browser.js",
+      "./utils/collection.node.js": "./utils/collection.browser.js"
+    }
+}

package/dist/cjs/types/debug.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeeModes = void 0;
+var BeeModes;
+(function (BeeModes) {
+    BeeModes["FULL"] = "full";
+    BeeModes["LIGHT"] = "light";
+    BeeModes["DEV"] = "dev";
+})(BeeModes = exports.BeeModes || (exports.BeeModes = {}));

package/dist/cjs/types/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNATURE_BYTES_LENGTH = exports.SIGNATURE_HEX_LENGTH = exports.TOPIC_HEX_LENGTH = exports.TOPIC_BYTES_LENGTH = exports.TAGS_LIMIT_MAX = exports.TAGS_LIMIT_MIN = exports.STAMPS_DEPTH_MAX = exports.STAMPS_DEPTH_MIN = exports.ENCRYPTED_REFERENCE_BYTES_LENGTH = exports.REFERENCE_BYTES_LENGTH = exports.ENCRYPTED_REFERENCE_HEX_LENGTH = exports.REFERENCE_HEX_LENGTH = exports.BATCH_ID_HEX_LENGTH = exports.PUBKEY_HEX_LENGTH = exports.PSS_TARGET_HEX_LENGTH_MAX = exports.ADDRESS_HEX_LENGTH = exports.CHUNK_SIZE = exports.BRANCHES = exports.SECTION_SIZE = exports.SPAN_SIZE = void 0;
+__exportStar(require("./debug"), exports);
+exports.SPAN_SIZE = 8;
+exports.SECTION_SIZE = 32;
+exports.BRANCHES = 128;
+exports.CHUNK_SIZE = exports.SECTION_SIZE * exports.BRANCHES;
+exports.ADDRESS_HEX_LENGTH = 64;
+exports.PSS_TARGET_HEX_LENGTH_MAX = 6;
+exports.PUBKEY_HEX_LENGTH = 66;
+exports.BATCH_ID_HEX_LENGTH = 64;
+exports.REFERENCE_HEX_LENGTH = 64;
+exports.ENCRYPTED_REFERENCE_HEX_LENGTH = 128;
+exports.REFERENCE_BYTES_LENGTH = 32;
+exports.ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
+/**
+ * Minimal depth that can be used for creation of postage batch
+ */
+exports.STAMPS_DEPTH_MIN = 17;
+/**
+ * Maximal depth that can be used for creation of postage batch
+ */
+exports.STAMPS_DEPTH_MAX = 255;
+exports.TAGS_LIMIT_MIN = 1;
+exports.TAGS_LIMIT_MAX = 1000;
+/*********************************************************
+ * Writers and Readers interfaces
+ */
+exports.TOPIC_BYTES_LENGTH = 32;
+exports.TOPIC_HEX_LENGTH = 64;
+/*********************************************************
+ * Ethereum compatible signing interfaces and definitions
+ */
+exports.SIGNATURE_HEX_LENGTH = 130;
+exports.SIGNATURE_BYTES_LENGTH = 65;

package/dist/cjs/utils/bytes.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapBytesWithHelpers = exports.makeBytes = exports.bytesEqual = exports.flexBytesAtOffset = exports.bytesAtOffset = exports.assertFlexBytes = exports.isFlexBytes = exports.assertBytes = exports.isBytes = void 0;
+const hex_1 = require("./hex");
+/**
+ * Type guard for `Bytes<T>` type
+ *
+ * @param b       The byte array
+ * @param length  The length of the byte array
+ */
+function isBytes(b, length) {
+    return b instanceof Uint8Array && b.length === length;
+}
+exports.isBytes = isBytes;
+/**
+ * Verifies if a byte array has a certain length
+ *
+ * @param b       The byte array
+ * @param length  The specified length
+ */
+function assertBytes(b, length) {
+    if (!isBytes(b, length)) {
+        throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
+    }
+}
+exports.assertBytes = assertBytes;
+/**
+ * Type guard for FlexBytes<Min,Max> type
+ *
+ * @param b       The byte array
+ * @param min     Minimum size of the array
+ * @param max     Maximum size of the array
+ */
+function isFlexBytes(b, min, max) {
+    return b instanceof Uint8Array && b.length >= min && b.length <= max;
+}
+exports.isFlexBytes = isFlexBytes;
+/**
+ * Verifies if a byte array has a certain length between min and max
+ *
+ * @param b       The byte array
+ * @param min     Minimum size of the array
+ * @param max     Maximum size of the array
+ */
+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}`);
+    }
+}
+exports.assertFlexBytes = assertFlexBytes;
+/**
+ * Return `length` bytes starting from `offset`
+ *
+ * @param data   The original data
+ * @param offset The offset to start from
+ * @param length The length of data to be returned
+ */
+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
+    assertBytes(offsetBytes, length);
+    return offsetBytes;
+}
+exports.bytesAtOffset = bytesAtOffset;
+/**
+ * Return flex bytes starting from `offset`
+ *
+ * @param data   The original data
+ * @param offset The offset to start from
+ * @param _min   The minimum size of the data
+ * @param _max   The maximum size of the data
+ */
+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);
+}
+exports.flexBytesAtOffset = flexBytesAtOffset;
+/**
+ * Returns true if two byte arrays are equal
+ *
+ * @param a Byte array to compare
+ * @param b Byte array to compare
+ */
+function bytesEqual(a, b) {
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+exports.bytesEqual = bytesEqual;
+/**
+ * Returns a new byte array filled with zeroes with the specified length
+ *
+ * @param length The length of data to be returned
+ */
+function makeBytes(length) {
+    return new Uint8Array(length);
+}
+exports.makeBytes = makeBytes;
+function wrapBytesWithHelpers(data) {
+    return Object.assign(data, {
+        text: () => new TextDecoder('utf-8').decode(data),
+        json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
+        hex: () => (0, hex_1.bytesToHex)(data),
+    });
+}
+exports.wrapBytesWithHelpers = wrapBytesWithHelpers;

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

@@ -0,0 +1,36 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderSize = exports.makeCollectionFromFS = void 0;
+/**
+ * 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
+ */
+function makeCollectionFromFS(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new Error('Creating Collection from File System is not supported in browsers!');
+    });
+}
+exports.makeCollectionFromFS = makeCollectionFromFS;
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+function getFolderSize(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        throw new Error('Creating Collection from File System is not supported in browsers!');
+    });
+}
+exports.getFolderSize = getFolderSize;

package/dist/cjs/utils/collection.js

@@ -0,0 +1,70 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCollectionSize = exports.makeCollectionFromFileList = exports.assertCollection = exports.isCollection = void 0;
+const error_1 = require("./error");
+const file_1 = require("./file");
+const type_1 = require("./type");
+function isCollection(data) {
+    if (!Array.isArray(data)) {
+        return false;
+    }
+    return data.every(entry => typeof entry === 'object' && entry.data && entry.path && (0, type_1.isUint8Array)(entry.data));
+}
+exports.isCollection = isCollection;
+function assertCollection(data) {
+    if (!isCollection(data)) {
+        throw new error_1.BeeArgumentError('invalid collection', data);
+    }
+}
+exports.assertCollection = assertCollection;
+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');
+}
+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 (0, file_1.fileArrayBuffer)(file)),
+                });
+            }
+        }
+        return collection;
+    });
+}
+exports.makeCollectionFromFileList = makeCollectionFromFileList;
+/**
+ * Calculate cumulative size of files
+ *
+ * @param fileList list of files to check
+ * @returns size in bytes
+ */
+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;
+}
+exports.getCollectionSize = getCollectionSize;

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

@@ -0,0 +1,115 @@
+"use strict";
+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); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderSize = exports.makeCollectionFromFS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 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
+ */
+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, '');
+    });
+}
+exports.makeCollectionFromFS = makeCollectionFromFS;
+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_1.default.join(dir, relativePath);
+        const entries = yield fs_1.default.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_1.default.join(dir, relativePath, entry.name);
+                const entryPath = path_1.default.join(relativePath, entry.name);
+                if (entry.isFile()) {
+                    collection.push({
+                        path: entryPath,
+                        data: new Uint8Array(yield fs_1.default.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;
+    });
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+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_1.default.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_1.default.promises.stat(path_1.default.join(dir, entry.name));
+                    size += stats.size;
+                }
+                else if (entry.isDirectory()) {
+                    size += yield getFolderSize(path_1.default.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;
+    });
+}
+exports.getFolderSize = getFolderSize;