@ethersphere/bee-js 5.1.1 → 5.1.2

package/dist/cjs/modules/stewardship.js

@@ -1,13 +1,4 @@
 "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");
@@ -19,23 +10,19 @@ const stewardshipEndpoint = 'stewardship';
  * @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}`,
-        });
+async function reupload(kyOptions, reference) {
+    await (0, http_1.http)(kyOptions, {
+        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;
+async function isRetrievable(kyOptions, reference) {
+    const response = await (0, http_1.http)(kyOptions, {
+        method: 'get',
+        responseType: 'json',
+        path: `${stewardshipEndpoint}/${reference}`,
     });
+    return response.parsedData.isRetrievable;
 }
 exports.isRetrievable = isRetrievable;

package/dist/cjs/modules/tag.js

@@ -1,13 +1,4 @@
 "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");
@@ -17,15 +8,13 @@ const endpoint = 'tags';
  *
  * @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;
+async function createTag(kyOptions) {
+    const response = await (0, http_1.http)(kyOptions, {
+        method: 'post',
+        path: endpoint,
+        responseType: 'json',
     });
+    return response.parsedData;
 }
 exports.createTag = createTag;
 /**
@@ -34,14 +23,12 @@ exports.createTag = createTag;
  * @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;
+async function retrieveTag(kyOptions, uid) {
+    const response = await (0, http_1.http)(kyOptions, {
+        path: `${endpoint}/${uid}`,
+        responseType: 'json',
     });
+    return response.parsedData;
 }
 exports.retrieveTag = retrieveTag;
 /**
@@ -51,15 +38,13 @@ exports.retrieveTag = retrieveTag;
  * @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;
+async function getAllTags(kyOptions, offset, limit) {
+    const response = await (0, http_1.http)(kyOptions, {
+        path: `${endpoint}`,
+        searchParams: { offset, limit },
+        responseType: 'json',
     });
+    return response.parsedData.tags;
 }
 exports.getAllTags = getAllTags;
 /**
@@ -67,12 +52,10 @@ exports.getAllTags = getAllTags;
  * @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}`,
-        });
+async function deleteTag(kyOptions, uid) {
+    await (0, http_1.http)(kyOptions, {
+        method: 'delete',
+        path: `${endpoint}/${uid}`,
     });
 }
 exports.deleteTag = deleteTag;
@@ -82,15 +65,13 @@ exports.deleteTag = deleteTag;
  * @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,
-            },
-        });
+async function updateTag(kyOptions, uid, reference) {
+    await (0, http_1.http)(kyOptions, {
+        method: 'patch',
+        path: `${endpoint}/${uid}`,
+        json: {
+            reference,
+        },
     });
 }
 exports.updateTag = updateTag;

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

@@ -1,13 +1,4 @@
 "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;
 /**
@@ -16,10 +7,8 @@ exports.getFolderSize = exports.makeCollectionFromFS = void 0;
  *
  * @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!');
-    });
+async function makeCollectionFromFS(dir) {
+    throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 exports.makeCollectionFromFS = makeCollectionFromFS;
 /**
@@ -28,9 +17,7 @@ exports.makeCollectionFromFS = makeCollectionFromFS;
  * @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!');
-    });
+async function getFolderSize(dir) {
+    throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 exports.getFolderSize = getFolderSize;

package/dist/cjs/utils/collection.js

@@ -1,13 +1,4 @@
 "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");
@@ -35,20 +26,18 @@ function makeFilePath(file) {
     }
     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)),
-                });
-            }
+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 (0, file_1.fileArrayBuffer)(file)),
+            });
         }
-        return collection;
-    });
+    }
+    return collection;
 }
 exports.makeCollectionFromFileList = makeCollectionFromFileList;
 /**

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

@@ -1,20 +1,4 @@
 "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 };
 };
@@ -28,50 +12,35 @@ const path_1 = __importDefault(require("path"));
  *
  * @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, '');
-    });
+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, '');
 }
 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];
-                }
-            }
+async function buildCollectionRelative(dir, relativePath) {
+    // 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 = await fs_1.default.promises.opendir(dirname);
+    let collection = [];
+    for await (const entry of entries) {
+        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(await fs_1.default.promises.readFile(fullPath)),
+            });
         }
-        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; }
+        else if (entry.isDirectory()) {
+            collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
         }
-        return collection;
-    });
+    }
+    return collection;
 }
 /**
  * Calculate folder size recursively
@@ -79,37 +48,24 @@ function buildCollectionRelative(dir, relativePath) {
  * @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));
-                }
-            }
+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_1.default.promises.opendir(dir);
+    let size = 0;
+    for await (const entry of entries) {
+        if (entry.isFile()) {
+            const stats = await fs_1.default.promises.stat(path_1.default.join(dir, entry.name));
+            size += stats.size;
         }
-        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; }
+        else if (entry.isDirectory()) {
+            size += await getFolderSize(path_1.default.join(dir, entry.name));
         }
-        return size;
-    });
+    }
+    return size;
 }
 exports.getFolderSize = getFolderSize;

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

@@ -1,13 +1,4 @@
 "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.prepareWebsocketData = exports.prepareData = void 0;
 const stream_1 = require("./stream");
@@ -16,59 +7,55 @@ const stream_1 = require("./stream");
  *
  * @param data any string, ArrayBuffer or Uint8Array
  */
-function prepareData(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof data === 'string')
-            return new Blob([data], { type: 'text/plain' });
-        if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
-            return new Blob([data], { type: 'application/octet-stream' });
-        }
-        if (data instanceof Blob) {
-            return data;
-        }
-        // Currently it is not possible to stream requests from browsers
-        // there are already first experiments on this field (Chromium)
-        // but till it is fully implemented across browsers-land we have to
-        // buffer the data before sending the requests.
-        if ((0, stream_1.isNodeReadable)(data)) {
-            return new Promise(resolve => {
-                const buffers = [];
-                data.on('data', d => {
-                    buffers.push(d);
-                });
-                data.on('end', () => {
-                    resolve(new Blob(buffers, { type: 'application/octet-stream' }));
-                });
+async function prepareData(data) {
+    if (typeof data === 'string')
+        return new Blob([data], { type: 'text/plain' });
+    if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+        return new Blob([data], { type: 'application/octet-stream' });
+    }
+    if (data instanceof Blob) {
+        return data;
+    }
+    // Currently it is not possible to stream requests from browsers
+    // there are already first experiments on this field (Chromium)
+    // but till it is fully implemented across browsers-land we have to
+    // buffer the data before sending the requests.
+    if ((0, stream_1.isNodeReadable)(data)) {
+        return new Promise(resolve => {
+            const buffers = [];
+            data.on('data', d => {
+                buffers.push(d);
             });
-        }
-        if ((0, stream_1.isReadableStream)(data)) {
-            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                const reader = data.getReader();
-                const buffers = [];
-                let done, value;
-                do {
-                    ;
-                    ({ done, value } = yield reader.read());
-                    if (!done) {
-                        buffers.push(value);
-                    }
-                } while (!done);
+            data.on('end', () => {
                 resolve(new Blob(buffers, { type: 'application/octet-stream' }));
-            }));
-        }
-        throw new TypeError('unknown data type');
-    });
+            });
+        });
+    }
+    if ((0, stream_1.isReadableStream)(data)) {
+        return new Promise(async (resolve) => {
+            const reader = data.getReader();
+            const buffers = [];
+            let done, value;
+            do {
+                ;
+                ({ done, value } = await reader.read());
+                if (!done) {
+                    buffers.push(value);
+                }
+            } while (!done);
+            resolve(new Blob(buffers, { type: 'application/octet-stream' }));
+        });
+    }
+    throw new TypeError('unknown data type');
 }
 exports.prepareData = prepareData;
-function prepareWebsocketData(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof data === 'string')
-            return new TextEncoder().encode(data);
-        if (data instanceof ArrayBuffer)
-            return new Uint8Array(data);
-        if (data instanceof Blob)
-            return new Uint8Array(yield new Response(data).arrayBuffer());
-        throw new TypeError('unknown websocket data type');
-    });
+async function prepareWebsocketData(data) {
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (data instanceof Blob)
+        return new Uint8Array(await new Response(data).arrayBuffer());
+    throw new TypeError('unknown websocket data type');
 }
 exports.prepareWebsocketData = prepareWebsocketData;

package/dist/cjs/utils/data.js

@@ -1,13 +1,4 @@
 "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 };
 };
@@ -23,36 +14,32 @@ const stream_1 = require("./stream");
  *
  * @param data any string, ArrayBuffer, Uint8Array or Readable
  */
-function prepareData(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof data === 'string')
-            return new fetch_blob_1.default([data], { type: 'text/plain' });
-        if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
-            return new fetch_blob_1.default([data], { type: 'application/octet-stream' });
-        }
-        if (data instanceof fetch_blob_1.default || (0, stream_1.isNodeReadable)(data))
-            return data;
-        if ((0, stream_1.isReadableStream)(data)) {
-            return (0, stream_1.readableWebToNode)(data);
-        }
-        throw new TypeError('unknown data type');
-    });
+async function prepareData(data) {
+    if (typeof data === 'string')
+        return new fetch_blob_1.default([data], { type: 'text/plain' });
+    if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+        return new fetch_blob_1.default([data], { type: 'application/octet-stream' });
+    }
+    if (data instanceof fetch_blob_1.default || (0, stream_1.isNodeReadable)(data))
+        return data;
+    if ((0, stream_1.isReadableStream)(data)) {
+        return (0, stream_1.readableWebToNode)(data);
+    }
+    throw new TypeError('unknown data type');
 }
 exports.prepareData = prepareData;
 function isBufferArray(buffer) {
     return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
 }
-function prepareWebsocketData(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof data === 'string')
-            return new TextEncoder().encode(data);
-        if (data instanceof Buffer)
-            return new Uint8Array(data);
-        if (data instanceof ArrayBuffer)
-            return new Uint8Array(data);
-        if (isBufferArray(data))
-            return new Uint8Array(Buffer.concat(data));
-        throw new TypeError('unknown websocket data type');
-    });
+async function prepareWebsocketData(data) {
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    if (data instanceof Buffer)
+        return new Uint8Array(data);
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (isBufferArray(data))
+        return new Uint8Array(Buffer.concat(data));
+    throw new TypeError('unknown websocket data type');
 }
 exports.prepareWebsocketData = prepareWebsocketData;