@ethersphere/bee-js 3.3.0 → 3.3.1

package/dist/mjs/modules/tag.js

@@ -1,17 +1,18 @@
-import { http } from '../utils/http';
+import { http } from "../utils/http.js";
 const endpoint = 'tags';
 /**
  * Create new tag on the Bee node
  *
  * @param url Bee tag URL
  */
+
 export async function createTag(ky) {
-    const response = await http(ky, {
-        method: 'post',
-        path: endpoint,
-        responseType: 'json',
-    });
-    return response.data;
+  const response = await http(ky, {
+    method: 'post',
+    path: endpoint,
+    responseType: 'json'
+  });
+  return response.data;
 }
 /**
  * Retrieve tag information from Bee node
@@ -19,12 +20,13 @@ export async function createTag(ky) {
  * @param url Bee tag URL
  * @param uid UID of tag to be retrieved
  */
+
 export async function retrieveTag(ky, uid) {
-    const response = await http(ky, {
-        path: `${endpoint}/${uid}`,
-        responseType: 'json',
-    });
-    return response.data;
+  const response = await http(ky, {
+    path: `${endpoint}/${uid}`,
+    responseType: 'json'
+  });
+  return response.data;
 }
 /**
  * Get limited listing of all tags.
@@ -33,24 +35,29 @@ export async function retrieveTag(ky, uid) {
  * @param offset
  * @param limit
  */
+
 export async function getAllTags(ky, offset, limit) {
-    const response = await http(ky, {
-        path: `${endpoint}`,
-        searchParams: { offset, limit },
-        responseType: 'json',
-    });
-    return response.data.tags;
+  const response = await http(ky, {
+    path: `${endpoint}`,
+    searchParams: {
+      offset,
+      limit
+    },
+    responseType: 'json'
+  });
+  return response.data.tags;
 }
 /**
  * Removes tag from the Bee node.
  * @param url
  * @param uid
  */
+
 export async function deleteTag(ky, uid) {
-    await http(ky, {
-        method: 'delete',
-        path: `${endpoint}/${uid}`,
-    });
+  await http(ky, {
+    method: 'delete',
+    path: `${endpoint}/${uid}`
+  });
 }
 /**
  * Updates tag
@@ -58,12 +65,13 @@ export async function deleteTag(ky, uid) {
  * @param uid
  * @param reference
  */
+
 export async function updateTag(ky, uid, reference) {
-    await http(ky, {
-        method: 'patch',
-        path: `${endpoint}/${uid}`,
-        json: {
-            reference,
-        },
-    });
-}
+  await http(ky, {
+    method: 'patch',
+    path: `${endpoint}/${uid}`,
+    json: {
+      reference
+    }
+  });
+}

package/dist/mjs/package.json

@@ -1,6 +1,7 @@
 {
     "type": "module",
     "browser": {
+     "stream": false,
       "./utils/data.js": "./utils/data.browser.js",
       "./utils/collection.node.js": "./utils/collection.browser.js"
     }

package/dist/mjs/types/debug.js

@@ -1,6 +1,7 @@
 export var BeeModes;
+
 (function (BeeModes) {
-    BeeModes["FULL"] = "full";
-    BeeModes["LIGHT"] = "light";
-    BeeModes["DEV"] = "dev";
-})(BeeModes || (BeeModes = {}));
+  BeeModes["FULL"] = "full";
+  BeeModes["LIGHT"] = "light";
+  BeeModes["DEV"] = "dev";
+})(BeeModes || (BeeModes = {}));

package/dist/mjs/types/index.js

@@ -1,4 +1,4 @@
-export * from './debug';
+export * from "./debug.js";
 export const SPAN_SIZE = 8;
 export const SECTION_SIZE = 32;
 export const BRANCHES = 128;
@@ -14,20 +14,24 @@ export const ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
 /**
  * Minimal depth that can be used for creation of postage batch
  */
+
 export const STAMPS_DEPTH_MIN = 17;
 /**
  * Maximal depth that can be used for creation of postage batch
  */
+
 export const STAMPS_DEPTH_MAX = 255;
 export const TAGS_LIMIT_MIN = 1;
 export const TAGS_LIMIT_MAX = 1000;
 /*********************************************************
  * Writers and Readers interfaces
  */
+
 export const TOPIC_BYTES_LENGTH = 32;
 export const TOPIC_HEX_LENGTH = 64;
 /*********************************************************
  * Ethereum compatible signing interfaces and definitions
  */
+
 export const SIGNATURE_HEX_LENGTH = 130;
-export const SIGNATURE_BYTES_LENGTH = 65;
+export const SIGNATURE_BYTES_LENGTH = 65;

package/dist/mjs/types/ky-options.js

@@ -0,0 +1,7 @@
+/**
+ * Types extracted from Ky as a backport for older Ky non-ESM version
+ *
+ * @author https://github.com/sindresorhus
+ * @licence MIT https://github.com/sindresorhus/ky/blob/main/license
+ */
+export {};

package/dist/mjs/types/ky-universal/common.js

@@ -0,0 +1,7 @@
+/**
+ * Types extracted from Ky as a backport for older Ky non-ESM version
+ *
+ * @author https://github.com/sindresorhus
+ * @licence MIT https://github.com/sindresorhus/ky/blob/main/license
+ */
+export {};

package/dist/mjs/types/ky-universal/hooks.js

@@ -0,0 +1,7 @@
+/**
+ * Types extracted from Ky as a backport for older Ky non-ESM version
+ *
+ * @author https://github.com/sindresorhus
+ * @licence MIT https://github.com/sindresorhus/ky/blob/main/license
+ */
+export {};

package/dist/mjs/types/ky-universal/retry.js

@@ -0,0 +1,7 @@
+/**
+ * Types extracted from Ky as a backport for older Ky non-ESM version
+ *
+ * @author https://github.com/sindresorhus
+ * @licence MIT https://github.com/sindresorhus/ky/blob/main/license
+ */
+export {};

package/dist/mjs/utils/bytes.js

@@ -1,12 +1,13 @@
-import { bytesToHex } from './hex';
+import { bytesToHex } from "./hex.js";
 /**
  * Type guard for `Bytes<T>` type
  *
  * @param b       The byte array
  * @param length  The length of the byte array
  */
+
 export function isBytes(b, length) {
-    return b instanceof Uint8Array && b.length === length;
+  return b instanceof Uint8Array && b.length === length;
 }
 /**
  * Verifies if a byte array has a certain length
@@ -14,10 +15,11 @@ export function isBytes(b, length) {
  * @param b       The byte array
  * @param length  The specified length
  */
+
 export function assertBytes(b, length) {
-    if (!isBytes(b, length)) {
-        throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
-    }
+  if (!isBytes(b, length)) {
+    throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
+  }
 }
 /**
  * Type guard for FlexBytes<Min,Max> type
@@ -26,8 +28,9 @@ export function assertBytes(b, length) {
  * @param min     Minimum size of the array
  * @param max     Maximum size of the array
  */
+
 export function isFlexBytes(b, min, max) {
-    return b instanceof Uint8Array && b.length >= min && b.length <= max;
+  return b instanceof Uint8Array && b.length >= min && b.length <= max;
 }
 /**
  * Verifies if a byte array has a certain length between min and max
@@ -36,10 +39,11 @@ export function isFlexBytes(b, min, max) {
  * @param min     Minimum size of the array
  * @param max     Maximum size of the array
  */
+
 export function assertFlexBytes(b, min, max) {
-    if (!isFlexBytes(b, min, max)) {
-        throw new TypeError(`Parameter is not valid FlexBytes of  min: ${min}, max: ${max}, length: ${b.length}`);
-    }
+  if (!isFlexBytes(b, min, max)) {
+    throw new TypeError(`Parameter is not valid FlexBytes of  min: ${min}, max: ${max}, length: ${b.length}`);
+  }
 }
 /**
  * Return `length` bytes starting from `offset`
@@ -48,11 +52,12 @@ export function assertFlexBytes(b, min, max) {
  * @param offset The offset to start from
  * @param length The length of data to be returned
  */
+
 export function bytesAtOffset(data, offset, length) {
-    const offsetBytes = data.slice(offset, offset + length);
-    // We are returning strongly typed Bytes so we have to verify that length is really what we claim
-    assertBytes(offsetBytes, length);
-    return offsetBytes;
+  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;
 }
 /**
  * Return flex bytes starting from `offset`
@@ -62,12 +67,11 @@ export function bytesAtOffset(data, offset, length) {
  * @param _min   The minimum size of the data
  * @param _max   The maximum size of the data
  */
-export function flexBytesAtOffset(data, offset, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_min, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+export function flexBytesAtOffset(data, offset, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+_min, // eslint-disable-next-line @typescript-eslint/no-unused-vars
 _max) {
-    return data.slice(offset);
+  return data.slice(offset);
 }
 /**
  * Returns true if two byte arrays are equal
@@ -75,21 +79,23 @@ _max) {
  * @param a Byte array to compare
  * @param b Byte array to compare
  */
+
 export function bytesEqual(a, b) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
+  return a.length === b.length && a.every((value, index) => value === b[index]);
 }
 /**
  * Returns a new byte array filled with zeroes with the specified length
  *
  * @param length The length of data to be returned
  */
+
 export function makeBytes(length) {
-    return new Uint8Array(length);
+  return new Uint8Array(length);
 }
 export function wrapBytesWithHelpers(data) {
-    return Object.assign(data, {
-        text: () => new TextDecoder('utf-8').decode(data),
-        json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
-        hex: () => bytesToHex(data),
-    });
-}
+  return Object.assign(data, {
+    text: () => new TextDecoder('utf-8').decode(data),
+    json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
+    hex: () => bytesToHex(data)
+  });
+}

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

@@ -5,7 +5,7 @@
  * @param dir path to the directory
  */
 export async function makeCollectionFromFS(dir) {
-    throw new Error('Creating Collection from File System is not supported in browsers!');
+  throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 /**
  * Calculate folder size recursively
@@ -13,6 +13,7 @@ export async function makeCollectionFromFS(dir) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
+
 export async function getFolderSize(dir) {
-    throw new Error('Creating Collection from File System is not supported in browsers!');
-}
+  throw new Error('Creating Collection from File System is not supported in browsers!');
+}

package/dist/mjs/utils/collection.js

@@ -1,38 +1,46 @@
-import { BeeArgumentError } from './error';
-import { fileArrayBuffer } from './file';
-import { isUint8Array } from './type';
+import { BeeArgumentError } from "./error.js";
+import { fileArrayBuffer } from "./file.js";
+import { isUint8Array } from "./type.js";
 export function isCollection(data) {
-    if (!Array.isArray(data)) {
-        return false;
-    }
-    return data.every(entry => typeof entry === 'object' && entry.data && entry.path && isUint8Array(entry.data));
+  if (!Array.isArray(data)) {
+    return false;
+  }
+
+  return data.every(entry => typeof entry === 'object' && entry.data && entry.path && isUint8Array(entry.data));
 }
 export function assertCollection(data) {
-    if (!isCollection(data)) {
-        throw new BeeArgumentError('invalid collection', data);
-    }
+  if (!isCollection(data)) {
+    throw new BeeArgumentError('invalid collection', data);
+  }
 }
+
 function makeFilePath(file) {
-    if (file.webkitRelativePath && file.webkitRelativePath !== '') {
-        return file.webkitRelativePath.replace(/.*?\//i, '');
-    }
-    if (file.name) {
-        return file.name;
-    }
-    throw new TypeError('file is not valid File object');
+  if (file.webkitRelativePath && file.webkitRelativePath !== '') {
+    return file.webkitRelativePath.replace(/.*?\//i, '');
+  }
+
+  if (file.name) {
+    return file.name;
+  }
+
+  throw new TypeError('file is not valid File object');
 }
+
 export async function makeCollectionFromFileList(fileList) {
-    const collection = [];
-    for (let i = 0; i < fileList.length; i++) {
-        const file = fileList[i];
-        if (file) {
-            collection.push({
-                path: makeFilePath(file),
-                data: new Uint8Array(await fileArrayBuffer(file)),
-            });
-        }
+  const collection = [];
+
+  for (let i = 0; i < fileList.length; i++) {
+    const file = fileList[i];
+
+    if (file) {
+      collection.push({
+        path: makeFilePath(file),
+        data: new Uint8Array(await fileArrayBuffer(file))
+      });
     }
-    return collection;
+  }
+
+  return collection;
 }
 /**
  * Calculate cumulative size of files
@@ -40,13 +48,17 @@ export async function makeCollectionFromFileList(fileList) {
  * @param fileList list of files to check
  * @returns size in bytes
  */
+
 export function getCollectionSize(fileList) {
-    let sum = 0;
-    for (let i = 0; i < fileList.length; i++) {
-        const file = fileList[i];
-        if (file) {
-            sum += file.size;
-        }
+  let sum = 0;
+
+  for (let i = 0; i < fileList.length; i++) {
+    const file = fileList[i];
+
+    if (file) {
+      sum += file.size;
     }
-    return sum;
-}
+  }
+
+  return sum;
+}

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

@@ -6,34 +6,40 @@ 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!');
-    }
-    if (dir === '') {
-        throw new TypeError('dir must not be empty string!');
-    }
-    return buildCollectionRelative(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, '');
 }
+
 async function buildCollectionRelative(dir, relativePath) {
-    // Handles case when the dir is not existing or it is a file ==> throws an error
-    const dirname = path.join(dir, relativePath);
-    const entries = await fs.promises.opendir(dirname);
-    let collection = [];
-    for await (const entry of entries) {
-        const fullPath = path.join(dir, relativePath, entry.name);
-        const entryPath = path.join(relativePath, entry.name);
-        if (entry.isFile()) {
-            collection.push({
-                path: entryPath,
-                data: new Uint8Array(await fs.promises.readFile(fullPath)),
-            });
-        }
-        else if (entry.isDirectory()) {
-            collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
-        }
+  // Handles case when the dir is not existing or it is a file ==> throws an error
+  const dirname = path.join(dir, relativePath);
+  const entries = await fs.promises.opendir(dirname);
+  let collection = [];
+
+  for await (const entry of entries) {
+    const fullPath = path.join(dir, relativePath, entry.name);
+    const entryPath = path.join(relativePath, entry.name);
+
+    if (entry.isFile()) {
+      collection.push({
+        path: entryPath,
+        data: new Uint8Array(await fs.promises.readFile(fullPath))
+      });
+    } else if (entry.isDirectory()) {
+      collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
     }
-    return collection;
+  }
+
+  return collection;
 }
 /**
  * Calculate folder size recursively
@@ -41,23 +47,28 @@ async function buildCollectionRelative(dir, relativePath) {
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
+
+
 export async function getFolderSize(dir) {
-    if (typeof dir !== 'string') {
-        throw new TypeError('dir has to be string!');
-    }
-    if (dir === '') {
-        throw new TypeError('dir must not be empty string!');
+  if (typeof dir !== 'string') {
+    throw new TypeError('dir has to be string!');
+  }
+
+  if (dir === '') {
+    throw new TypeError('dir must not be empty string!');
+  }
+
+  const entries = await fs.promises.opendir(dir);
+  let size = 0;
+
+  for await (const entry of entries) {
+    if (entry.isFile()) {
+      const stats = await fs.promises.stat(path.join(dir, entry.name));
+      size += stats.size;
+    } else if (entry.isDirectory()) {
+      size += await getFolderSize(path.join(dir, entry.name));
     }
-    const entries = await fs.promises.opendir(dir);
-    let size = 0;
-    for await (const entry of entries) {
-        if (entry.isFile()) {
-            const stats = await fs.promises.stat(path.join(dir, entry.name));
-            size += stats.size;
-        }
-        else if (entry.isDirectory()) {
-            size += await getFolderSize(path.join(dir, entry.name));
-        }
-    }
-    return size;
-}
+  }
+
+  return size;
+}