@ethersphere/bee-js 3.3.0 → 3.3.1

package/dist/mjs/utils/type.js

@@ -1,20 +1,16 @@
-import { ADDRESS_HEX_LENGTH, BATCH_ID_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, PUBKEY_HEX_LENGTH, REFERENCE_HEX_LENGTH, TAGS_LIMIT_MAX, TAGS_LIMIT_MIN, PSS_TARGET_HEX_LENGTH_MAX, } from '../types';
-import { BeeArgumentError } from './error';
-import { isFile } from './file';
-import { assertHexString, assertPrefixedHexString } from './hex';
-import { isReadable } from './stream';
+import { ADDRESS_HEX_LENGTH, BATCH_ID_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, PUBKEY_HEX_LENGTH, REFERENCE_HEX_LENGTH, TAGS_LIMIT_MAX, TAGS_LIMIT_MIN, PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
+import { BeeArgumentError } from "./error.js";
+import { isFile } from "./file.js";
+import { assertHexString, assertPrefixedHexString } from "./hex.js";
+import { isReadable } from "./stream.js";
 export function isUint8Array(obj) {
-    return obj instanceof Uint8Array;
+  return obj instanceof Uint8Array;
 }
 export function isInteger(value) {
-    return ((typeof value === 'string' && /^-?(0|[1-9][0-9]*)$/g.test(value)) ||
-        (typeof value === 'number' &&
-            value > Number.MIN_SAFE_INTEGER &&
-            value < Number.MAX_SAFE_INTEGER &&
-            Number.isInteger(value)));
+  return typeof value === 'string' && /^-?(0|[1-9][0-9]*)$/g.test(value) || typeof value === 'number' && value > Number.MIN_SAFE_INTEGER && value < Number.MAX_SAFE_INTEGER && Number.isInteger(value);
 }
 export function isObject(value) {
-    return value !== null && typeof value === 'object';
+  return value !== null && typeof value === 'object';
 }
 /**
  * Generally it is discouraged to use `object` type, but in this case I think
@@ -26,271 +22,315 @@ export function isObject(value) {
  * @param value
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
+
 export function isStrictlyObject(value) {
-    return isObject(value) && !Array.isArray(value);
+  return isObject(value) && !Array.isArray(value);
 }
 /**
  * Asserts if object is Error
  *
  * @param e
  */
+
 export function isError(e) {
-    return e instanceof Error;
-}
-// eslint-disable-next-line @typescript-eslint/ban-types
+  return e instanceof Error;
+} // eslint-disable-next-line @typescript-eslint/ban-types
+
 export function assertStrictlyObject(value, name = 'value') {
-    if (!isStrictlyObject(value)) {
-        throw new TypeError(`${name} has to be an object that is not null nor array!`);
-    }
+  if (!isStrictlyObject(value)) {
+    throw new TypeError(`${name} has to be an object that is not null nor array!`);
+  }
 }
 export function assertBoolean(value, name = 'value') {
-    if (value !== true && value !== false)
-        throw new TypeError(`${name} is not boolean`);
+  if (value !== true && value !== false) throw new TypeError(`${name} is not boolean`);
 }
 export function assertInteger(value, name = 'value') {
-    if (!isInteger(value))
-        throw new TypeError(`${name} is not integer`);
+  if (!isInteger(value)) throw new TypeError(`${name} is not integer`);
 }
 export function assertNonNegativeInteger(value, name = 'Value') {
-    assertInteger(value, name);
-    if (Number(value) < 0)
-        throw new BeeArgumentError(`${name} has to be bigger or equal to zero`, value);
+  assertInteger(value, name);
+  if (Number(value) < 0) throw new BeeArgumentError(`${name} has to be bigger or equal to zero`, value);
 }
 export function assertReference(value) {
-    try {
-        assertHexString(value, REFERENCE_HEX_LENGTH);
-    }
-    catch (e) {
-        assertHexString(value, ENCRYPTED_REFERENCE_HEX_LENGTH);
-    }
+  try {
+    assertHexString(value, REFERENCE_HEX_LENGTH);
+  } catch (e) {
+    assertHexString(value, ENCRYPTED_REFERENCE_HEX_LENGTH);
+  }
 }
 export function assertAddress(value) {
-    assertHexString(value, ADDRESS_HEX_LENGTH, 'Address');
+  assertHexString(value, ADDRESS_HEX_LENGTH, 'Address');
 }
 export function assertBatchId(value) {
-    assertHexString(value, BATCH_ID_HEX_LENGTH, 'BatchId');
+  assertHexString(value, BATCH_ID_HEX_LENGTH, 'BatchId');
 }
 export function assertRequestOptions(value, name = 'RequestOptions') {
-    if (value === undefined) {
-        return;
-    }
-    if (!isStrictlyObject(value)) {
-        throw new TypeError(`${name} has to be an object!`);
-    }
-    const options = value;
-    if (options.retry) {
-        assertNonNegativeInteger(options.retry, `${name}.retry`);
-    }
-    if (options.timeout) {
-        assertNonNegativeInteger(options.timeout, `${name}.timeout`);
-    }
-    if (options.fetch && typeof options.fetch !== 'function') {
-        throw new TypeError(`${name}.fetch has to be a function or undefined!`);
-    }
+  if (value === undefined) {
+    return;
+  }
+
+  if (!isStrictlyObject(value)) {
+    throw new TypeError(`${name} has to be an object!`);
+  }
+
+  const options = value;
+
+  if (options.retry) {
+    assertNonNegativeInteger(options.retry, `${name}.retry`);
+  }
+
+  if (options.timeout) {
+    assertNonNegativeInteger(options.timeout, `${name}.timeout`);
+  }
+
+  if (options.fetch && typeof options.fetch !== 'function') {
+    throw new TypeError(`${name}.fetch has to be a function or undefined!`);
+  }
 }
 export function assertUploadOptions(value, name = 'UploadOptions') {
-    if (!isStrictlyObject(value)) {
-        throw new TypeError(`${name} has to be an object!`);
-    }
-    assertRequestOptions(value, name);
-    const options = value;
-    if (options.pin && typeof options.pin !== 'boolean') {
-        throw new TypeError(`options.pin property in ${name} has to be boolean or undefined!`);
-    }
-    if (options.encrypt && typeof options.encrypt !== 'boolean') {
-        throw new TypeError(`options.encrypt property in ${name} has to be boolean or undefined!`);
-    }
-    if (options.tag) {
-        if (typeof options.tag !== 'number') {
-            throw new TypeError(`options.tag property in ${name} has to be number or undefined!`);
-        }
-        assertNonNegativeInteger(options.tag, 'options.tag');
-    }
+  if (!isStrictlyObject(value)) {
+    throw new TypeError(`${name} has to be an object!`);
+  }
+
+  assertRequestOptions(value, name);
+  const options = value;
+
+  if (options.pin && typeof options.pin !== 'boolean') {
+    throw new TypeError(`options.pin property in ${name} has to be boolean or undefined!`);
+  }
+
+  if (options.encrypt && typeof options.encrypt !== 'boolean') {
+    throw new TypeError(`options.encrypt property in ${name} has to be boolean or undefined!`);
+  }
+
+  if (options.tag) {
+    if (typeof options.tag !== 'number') {
+      throw new TypeError(`options.tag property in ${name} has to be number or undefined!`);
+    }
+
+    assertNonNegativeInteger(options.tag, 'options.tag');
+  }
 }
 export function assertFileUploadOptions(value) {
-    assertUploadOptions(value, 'FileUploadOptions');
-    const options = value;
-    if (options.size) {
-        if (typeof options.size !== 'number') {
-            throw new TypeError('tag property in FileUploadOptions has to be number or undefined!');
-        }
-        assertNonNegativeInteger(options.size, 'options.size');
-    }
-    if (options.contentType && typeof options.contentType !== 'string') {
-        throw new TypeError('contentType property in FileUploadOptions has to be string or undefined!');
-    }
+  assertUploadOptions(value, 'FileUploadOptions');
+  const options = value;
+
+  if (options.size) {
+    if (typeof options.size !== 'number') {
+      throw new TypeError('tag property in FileUploadOptions has to be number or undefined!');
+    }
+
+    assertNonNegativeInteger(options.size, 'options.size');
+  }
+
+  if (options.contentType && typeof options.contentType !== 'string') {
+    throw new TypeError('contentType property in FileUploadOptions has to be string or undefined!');
+  }
 }
 export function assertCollectionUploadOptions(value) {
-    assertUploadOptions(value, 'CollectionUploadOptions');
-    const options = value;
-    if (options.indexDocument && typeof options.indexDocument !== 'string') {
-        throw new TypeError('indexDocument property in CollectionUploadOptions has to be string or undefined!');
-    }
-    if (options.errorDocument && typeof options.errorDocument !== 'string') {
-        throw new TypeError('errorDocument property in CollectionUploadOptions has to be string or undefined!');
-    }
+  assertUploadOptions(value, 'CollectionUploadOptions');
+  const options = value;
+
+  if (options.indexDocument && typeof options.indexDocument !== 'string') {
+    throw new TypeError('indexDocument property in CollectionUploadOptions has to be string or undefined!');
+  }
+
+  if (options.errorDocument && typeof options.errorDocument !== 'string') {
+    throw new TypeError('errorDocument property in CollectionUploadOptions has to be string or undefined!');
+  }
 }
 export function isTag(value) {
-    if (!isStrictlyObject(value)) {
-        return false;
-    }
-    const tag = value;
-    const numberProperties = ['total', 'processed', 'synced', 'uid'];
-    const correctNumberProperties = numberProperties.every(numberProperty => typeof tag[numberProperty] === 'number');
-    if (!correctNumberProperties || !tag.startedAt || typeof tag.startedAt !== 'string') {
-        return false;
-    }
-    return true;
+  if (!isStrictlyObject(value)) {
+    return false;
+  }
+
+  const tag = value;
+  const numberProperties = ['total', 'processed', 'synced', 'uid'];
+  const correctNumberProperties = numberProperties.every(numberProperty => typeof tag[numberProperty] === 'number');
+
+  if (!correctNumberProperties || !tag.startedAt || typeof tag.startedAt !== 'string') {
+    return false;
+  }
+
+  return true;
 }
 export function assertTag(value) {
-    if (!isStrictlyObject(value)) {
-        throw new TypeError('Tag is not an object!');
-    }
-    const tag = value;
-    const numberProperties = ['total', 'processed', 'synced', 'uid'];
-    for (const numberProperty of numberProperties) {
-        if (!tag[numberProperty]) {
-            throw new TypeError(`Tag's property '${numberProperty}' has to be specified!`);
-        }
-        if (typeof tag[numberProperty] !== 'number') {
-            throw new TypeError(`Tag's property '${numberProperty}' has to be number!`);
-        }
-    }
-    if (!tag.startedAt) {
-        throw new TypeError("Tag's property 'startedAt' has to be specified!");
-    }
-    if (typeof tag.startedAt !== 'string') {
-        throw new TypeError("Tag's property 'startedAt' has to be string!");
-    }
+  if (!isStrictlyObject(value)) {
+    throw new TypeError('Tag is not an object!');
+  }
+
+  const tag = value;
+  const numberProperties = ['total', 'processed', 'synced', 'uid'];
+
+  for (const numberProperty of numberProperties) {
+    if (!tag[numberProperty]) {
+      throw new TypeError(`Tag's property '${numberProperty}' has to be specified!`);
+    }
+
+    if (typeof tag[numberProperty] !== 'number') {
+      throw new TypeError(`Tag's property '${numberProperty}' has to be number!`);
+    }
+  }
+
+  if (!tag.startedAt) {
+    throw new TypeError("Tag's property 'startedAt' has to be specified!");
+  }
+
+  if (typeof tag.startedAt !== 'string') {
+    throw new TypeError("Tag's property 'startedAt' has to be string!");
+  }
 }
 export function assertAddressPrefix(value) {
-    assertHexString(value, undefined, 'AddressPrefix');
-    if (value.length > PSS_TARGET_HEX_LENGTH_MAX) {
-        throw new BeeArgumentError(`AddressPrefix must have length of ${PSS_TARGET_HEX_LENGTH_MAX} at most! Got string with ${value.length}`, value);
-    }
+  assertHexString(value, undefined, 'AddressPrefix');
+
+  if (value.length > PSS_TARGET_HEX_LENGTH_MAX) {
+    throw new BeeArgumentError(`AddressPrefix must have length of ${PSS_TARGET_HEX_LENGTH_MAX} at most! Got string with ${value.length}`, value);
+  }
 }
 export function assertPssMessageHandler(value) {
-    if (!isStrictlyObject(value)) {
-        throw new TypeError('PssMessageHandler has to be object!');
-    }
-    const handler = value;
-    if (typeof handler.onMessage !== 'function') {
-        throw new TypeError('onMessage property of PssMessageHandler has to be function!');
-    }
-    if (typeof handler.onError !== 'function') {
-        throw new TypeError('onError property of PssMessageHandler has to be function!');
-    }
+  if (!isStrictlyObject(value)) {
+    throw new TypeError('PssMessageHandler has to be object!');
+  }
+
+  const handler = value;
+
+  if (typeof handler.onMessage !== 'function') {
+    throw new TypeError('onMessage property of PssMessageHandler has to be function!');
+  }
+
+  if (typeof handler.onError !== 'function') {
+    throw new TypeError('onError property of PssMessageHandler has to be function!');
+  }
 }
 export function assertPublicKey(value) {
-    assertHexString(value, PUBKEY_HEX_LENGTH, 'PublicKey');
+  assertHexString(value, PUBKEY_HEX_LENGTH, 'PublicKey');
 }
 export function assertPostageBatchOptions(value) {
-    if (value === undefined) {
-        return;
-    }
-    assertStrictlyObject(value);
-    const options = value;
-    assertRequestOptions(options, 'PostageBatchOptions');
-    if (options?.gasPrice) {
-        assertNonNegativeInteger(options.gasPrice);
-    }
-    if (options?.immutableFlag !== undefined) {
-        assertBoolean(options.immutableFlag);
-    }
+  if (value === undefined) {
+    return;
+  }
+
+  assertStrictlyObject(value);
+  const options = value;
+  assertRequestOptions(options, 'PostageBatchOptions');
+
+  if (options?.gasPrice) {
+    assertNonNegativeInteger(options.gasPrice);
+  }
+
+  if (options?.immutableFlag !== undefined) {
+    assertBoolean(options.immutableFlag);
+  }
 }
 export function assertCashoutOptions(value) {
-    if (value === undefined) {
-        return;
-    }
-    assertStrictlyObject(value);
-    const options = value;
-    assertRequestOptions(options, 'PostageBatchOptions');
-    if (options?.gasLimit) {
-        assertNonNegativeInteger(options.gasLimit);
-    }
-    if (options?.gasPrice) {
-        assertNonNegativeInteger(options.gasPrice);
-    }
+  if (value === undefined) {
+    return;
+  }
+
+  assertStrictlyObject(value);
+  const options = value;
+  assertRequestOptions(options, 'PostageBatchOptions');
+
+  if (options?.gasLimit) {
+    assertNonNegativeInteger(options.gasLimit);
+  }
+
+  if (options?.gasPrice) {
+    assertNonNegativeInteger(options.gasPrice);
+  }
 }
 /**
  * Check whether the given parameter is valid data to upload
  * @param value
  * @throws TypeError if not valid
  */
+
 export function assertData(value) {
-    if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
-        throw new TypeError('Data must be either string or Uint8Array!');
-    }
+  if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+    throw new TypeError('Data must be either string or Uint8Array!');
+  }
 }
 /**
  * Check whether the given parameter is a correct file representation to file upload.
  * @param value
  * @throws TypeError if not valid
  */
+
 export function assertFileData(value) {
-    if (typeof value !== 'string' && !(value instanceof Uint8Array) && !isFile(value) && !isReadable(value)) {
-        throw new TypeError('Data must be either string, Readable, Uint8Array or File!');
-    }
+  if (typeof value !== 'string' && !(value instanceof Uint8Array) && !isFile(value) && !isReadable(value)) {
+    throw new TypeError('Data must be either string, Readable, Uint8Array or File!');
+  }
 }
 /**
  * Checks whether optional options for AllTags query are valid
  * @param options
  */
+
 export function assertAllTagsOptions(entry) {
-    if (entry !== undefined && !isStrictlyObject(entry)) {
-        throw new TypeError('options has to be an object or undefined!');
-    }
-    assertRequestOptions(entry, 'AllTagsOptions');
-    const options = entry;
-    if (options?.limit !== undefined) {
-        if (typeof options.limit !== 'number') {
-            throw new TypeError('AllTagsOptions.limit has to be a number or undefined!');
-        }
-        if (options.limit < TAGS_LIMIT_MIN) {
-            throw new BeeArgumentError(`AllTagsOptions.limit has to be at least ${TAGS_LIMIT_MIN}`, options.limit);
-        }
-        if (options.limit > TAGS_LIMIT_MAX) {
-            throw new BeeArgumentError(`AllTagsOptions.limit has to be at most ${TAGS_LIMIT_MAX}`, options.limit);
-        }
-    }
-    if (options?.offset !== undefined) {
-        assertNonNegativeInteger(options.offset, 'AllTagsOptions.offset');
-    }
+  if (entry !== undefined && !isStrictlyObject(entry)) {
+    throw new TypeError('options has to be an object or undefined!');
+  }
+
+  assertRequestOptions(entry, 'AllTagsOptions');
+  const options = entry;
+
+  if (options?.limit !== undefined) {
+    if (typeof options.limit !== 'number') {
+      throw new TypeError('AllTagsOptions.limit has to be a number or undefined!');
+    }
+
+    if (options.limit < TAGS_LIMIT_MIN) {
+      throw new BeeArgumentError(`AllTagsOptions.limit has to be at least ${TAGS_LIMIT_MIN}`, options.limit);
+    }
+
+    if (options.limit > TAGS_LIMIT_MAX) {
+      throw new BeeArgumentError(`AllTagsOptions.limit has to be at most ${TAGS_LIMIT_MAX}`, options.limit);
+    }
+  }
+
+  if (options?.offset !== undefined) {
+    assertNonNegativeInteger(options.offset, 'AllTagsOptions.offset');
+  }
 }
 /**
  * Utility functions that return Tag UID
  * @param tagUid
  */
+
 export function makeTagUid(tagUid) {
-    if (tagUid === undefined || tagUid === null) {
-        throw new TypeError('TagUid was expected but got undefined or null instead!');
-    }
-    if (isTag(tagUid)) {
-        return tagUid.uid;
-    }
-    else if (typeof tagUid === 'number') {
-        assertNonNegativeInteger(tagUid, 'UID');
-        return tagUid;
-    }
-    else if (typeof tagUid === 'string') {
-        const int = parseInt(tagUid);
-        if (isNaN(int)) {
-            throw new TypeError('Passed tagUid string is not valid integer!');
-        }
-        if (int < 0) {
-            throw new TypeError(`TagUid was expected to be positive non-negative integer! Got ${int}`);
-        }
-        return int;
-    }
-    throw new TypeError('tagUid has to be either Tag or a number (UID)!');
+  if (tagUid === undefined || tagUid === null) {
+    throw new TypeError('TagUid was expected but got undefined or null instead!');
+  }
+
+  if (isTag(tagUid)) {
+    return tagUid.uid;
+  } else if (typeof tagUid === 'number') {
+    assertNonNegativeInteger(tagUid, 'UID');
+    return tagUid;
+  } else if (typeof tagUid === 'string') {
+    const int = parseInt(tagUid);
+
+    if (isNaN(int)) {
+      throw new TypeError('Passed tagUid string is not valid integer!');
+    }
+
+    if (int < 0) {
+      throw new TypeError(`TagUid was expected to be positive non-negative integer! Got ${int}`);
+    }
+
+    return int;
+  }
+
+  throw new TypeError('tagUid has to be either Tag or a number (UID)!');
 }
 export function assertTransactionHash(transactionHash) {
-    if (typeof transactionHash !== 'string') {
-        throw new TypeError('TransactionHash has to be a string!');
-    }
-    assertPrefixedHexString(transactionHash, 'TransactionHash');
-    // Hash is 64 long + '0x' prefix = 66
-    if (transactionHash.length !== 66) {
-        throw new TypeError('TransactionHash has to be prefixed hex string with total length 66 (prefix including)');
-    }
-}
+  if (typeof transactionHash !== 'string') {
+    throw new TypeError('TransactionHash has to be a string!');
+  }
+
+  assertPrefixedHexString(transactionHash, 'TransactionHash'); // Hash is 64 long + '0x' prefix = 66
+
+  if (transactionHash.length !== 66) {
+    throw new TypeError('TransactionHash has to be prefixed hex string with total length 66 (prefix including)');
+  }
+}

package/dist/mjs/utils/uint64.js

@@ -1,23 +1,23 @@
-import { makeBytes } from './bytes';
-// TODO handle bigger values than 32 bit
+import { makeBytes } from "./bytes.js"; // TODO handle bigger values than 32 bit
 // For now it's good enough because we only use these functions
 // sequential feed indexes.
+
 export function writeUint64LittleEndian(value, bytes = makeBytes(8)) {
-    const dataView = new DataView(bytes.buffer);
-    const valueLower32 = value & 0xffffffff;
-    const littleEndian = true;
-    dataView.setUint32(0, valueLower32, littleEndian);
-    dataView.setUint32(4, 0, littleEndian);
-    return bytes;
+  const dataView = new DataView(bytes.buffer);
+  const valueLower32 = value & 0xffffffff;
+  const littleEndian = true;
+  dataView.setUint32(0, valueLower32, littleEndian);
+  dataView.setUint32(4, 0, littleEndian);
+  return bytes;
 }
 export function writeUint64BigEndian(value, bytes = makeBytes(8)) {
-    const dataView = new DataView(bytes.buffer);
-    const valueLower32 = value & 0xffffffff;
-    dataView.setUint32(0, 0);
-    dataView.setUint32(4, valueLower32);
-    return bytes;
+  const dataView = new DataView(bytes.buffer);
+  const valueLower32 = value & 0xffffffff;
+  dataView.setUint32(0, 0);
+  dataView.setUint32(4, valueLower32);
+  return bytes;
 }
 export function readUint64BigEndian(bytes) {
-    const dataView = new DataView(bytes.buffer);
-    return dataView.getUint32(4);
-}
+  const dataView = new DataView(bytes.buffer);
+  return dataView.getUint32(4);
+}