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

package/dist/cjs/modules/stewardship.js

@@ -0,0 +1,28 @@
+"use strict";
+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
+ */
+async function reupload(requestOptions, reference) {
+    await (0, http_1.http)(requestOptions, {
+        method: 'put',
+        url: `${stewardshipEndpoint}/${reference}`,
+    });
+}
+exports.reupload = reupload;
+async function isRetrievable(requestOptions, reference) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'get',
+        responseType: 'json',
+        url: `${stewardshipEndpoint}/${reference}`,
+    });
+    return response.data.isRetrievable;
+}
+exports.isRetrievable = isRetrievable;

package/dist/cjs/modules/tag.js

@@ -0,0 +1,77 @@
+"use strict";
+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
+ */
+async function createTag(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: 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
+ */
+async function retrieveTag(requestOptions, uid) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${endpoint}/${uid}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.retrieveTag = retrieveTag;
+/**
+ * Get limited listing of all tags.
+ *
+ * @param url
+ * @param offset
+ * @param limit
+ */
+async function getAllTags(requestOptions, offset, limit) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: endpoint,
+        params: { offset, limit },
+        responseType: 'json',
+    });
+    return response.data.tags;
+}
+exports.getAllTags = getAllTags;
+/**
+ * Removes tag from the Bee node.
+ * @param url
+ * @param uid
+ */
+async function deleteTag(requestOptions, uid) {
+    await (0, http_1.http)(requestOptions, {
+        method: 'delete',
+        url: `${endpoint}/${uid}`,
+    });
+}
+exports.deleteTag = deleteTag;
+/**
+ * Updates tag
+ * @param url
+ * @param uid
+ * @param reference
+ */
+async function updateTag(requestOptions, uid, reference) {
+    await (0, http_1.http)(requestOptions, {
+        method: 'patch',
+        url: `${endpoint}/${uid}`,
+        data: {
+            reference,
+        },
+    });
+}
+exports.updateTag = updateTag;

package/dist/cjs/package.json

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

package/dist/cjs/types/debug.js

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

package/dist/cjs/types/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.FEED_INDEX_HEX_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;
+exports.FEED_INDEX_HEX_LENGTH = 16;
+/*********************************************************
+ * 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,121 @@
+"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.hasBytesAtOffset = 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;
+/**
+ * Function that verifies if passed data are Bytes and if the array has "length" number of bytes under given offset.
+ * @param data
+ * @param offset
+ * @param length
+ */
+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);
+}
+exports.hasBytesAtOffset = hasBytesAtOffset;
+/**
+ * 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,23 @@
+"use strict";
+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
+ */
+async function makeCollectionFromFS(dir) {
+    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
+ */
+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

@@ -0,0 +1,59 @@
+"use strict";
+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');
+}
+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;
+}
+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,71 @@
+"use strict";
+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
+ */
+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;
+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)),
+            });
+        }
+        else if (entry.isDirectory()) {
+            collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
+        }
+    }
+    return collection;
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+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;
+        }
+        else if (entry.isDirectory()) {
+            size += await getFolderSize(path_1.default.join(dir, entry.name));
+        }
+    }
+    return size;
+}
+exports.getFolderSize = getFolderSize;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWebsocketData = exports.prepareData = void 0;
+const stream_1 = require("./stream");
+/**
+ * Validates input and converts to Uint8Array
+ *
+ * @param data any string, ArrayBuffer or Uint8Array
+ */
+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);
+            });
+            data.on('end', () => {
+                resolve(new Blob(buffers, { type: 'application/octet-stream' }));
+            });
+        });
+    }
+    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;
+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

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWebsocketData = exports.prepareData = void 0;
+const fetch_blob_1 = __importDefault(require("fetch-blob"));
+const stream_1 = require("./stream");
+/**
+ * Prepare data for valid input for node-fetch.
+ *
+ * node-fetch is not using WHATWG ReadableStream but NodeJS Readable so we need to convert in case of ReadableStream,
+ * but the typings are set to use ReadableStream so hence why type conversion here.
+ *
+ * @param data any string, ArrayBuffer, Uint8Array or Readable
+ */
+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);
+}
+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;

package/dist/cjs/utils/error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeeArgumentError = exports.BeeError = void 0;
+class BeeError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.BeeError = BeeError;
+class BeeArgumentError extends BeeError {
+    constructor(message, value) {
+        super(message);
+        this.value = value;
+    }
+}
+exports.BeeArgumentError = BeeArgumentError;