@junobuild/utils/dist/node/index.mjs.map

A collection of utilities and constants for Juno JS libs.

{
  "version": 3,
  "sources": ["../../src/utils/asserts.utils.ts", "../../src/utils/arrays.utils.ts", "../../src/utils/base64.utils.ts", "../../src/utils/date.utils.ts", "../../src/utils/debounce.utils.ts", "../../src/utils/nullish.utils.ts", "../../src/utils/did.utils.ts", "../../src/utils/json.utils.ts", "../../src/utils/doc.utils.ts", "../../src/utils/env.utils.ts", "../../src/utils/string.utils.ts"],
  "sourcesContent": ["export class InvalidPercentageError extends Error {}\nexport class NullishError extends Error {}\n\nexport const assertNonNullish: <T>(\n  value: T,\n  message?: string\n  // eslint-disable-next-line local-rules/prefer-object-params\n) => asserts value is NonNullable<T> = <T>(value: T, message?: string): void => {\n  if (value === null || value === undefined) {\n    throw new NullishError(message);\n  }\n};\n\n// eslint-disable-next-line local-rules/prefer-object-params\nexport const asNonNullish = <T>(value: T, message?: string): NonNullable<T> => {\n  assertNonNullish(value, message);\n  return value;\n};\n\nexport const assertPercentageNumber = (percentage: number) => {\n  if (percentage < 0 || percentage > 100) {\n    throw new InvalidPercentageError(`${percentage} is not a valid percentage number.`);\n  }\n};\n\n/**\n * Utility to enforce exhaustiveness checks in TypeScript.\n *\n * This function should only be called in branches of a `switch` or conditional\n * that should be unreachable if the union type has been fully handled.\n *\n * By typing the parameter as `never`, the compiler will emit an error if\n * a new variant is added to the union but not covered in the logic.\n *\n * @param _ - A value that should be of type `never`. If this is not the case,\n *            the TypeScript compiler will flag a type error.\n * @param message - Optional custom error message to include in the thrown error.\n * @throws {Error} Always throws when invoked at runtime.\n *\n */\n// eslint-disable-next-line local-rules/prefer-object-params\nexport const assertNever = (_: never, message?: string): never => {\n  throw new Error(message);\n};\n", "import {assertNonNullish} from './asserts.utils';\n\nexport const uint8ArrayToBigInt = (array: Uint8Array): bigint => {\n  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n  if (typeof view.getBigUint64 === 'function') {\n    return view.getBigUint64(0);\n  }\n  const high = BigInt(view.getUint32(0));\n  const low = BigInt(view.getUint32(4));\n\n  return (high << BigInt(32)) + low;\n};\n\nexport const bigIntToUint8Array = (value: bigint): Uint8Array => {\n  const buffer = new ArrayBuffer(8);\n  const view = new DataView(buffer);\n  if (typeof view.setBigUint64 === 'function') {\n    view.setBigUint64(0, value);\n  } else {\n    const high = Number(value >> BigInt(32));\n    const low = Number(value & BigInt(0xffffffff));\n\n    view.setUint32(0, high);\n    view.setUint32(4, low);\n  }\n\n  return new Uint8Array(buffer);\n};\n\nexport const numberToUint8Array = (value: number): Uint8Array => {\n  const view = new DataView(new ArrayBuffer(8));\n  for (let index = 7; index >= 0; --index) {\n    view.setUint8(index, value % 256);\n    value = value >> 8;\n  }\n  return new Uint8Array(view.buffer);\n};\n\nexport const arrayBufferToUint8Array = (buffer: ArrayBuffer): Uint8Array => new Uint8Array(buffer);\n\nexport const uint8ArrayToArrayOfNumber = (array: Uint8Array): Array<number> => Array.from(array);\n\nexport const arrayOfNumberToUint8Array = (numbers: Array<number>): Uint8Array =>\n  new Uint8Array(numbers);\n\nexport const asciiStringToByteArray = (text: string): Array<number> =>\n  Array.from(text).map((c) => c.charCodeAt(0));\n\nexport const hexStringToUint8Array = (hexString: string): Uint8Array => {\n  const matches = hexString.match(/.{1,2}/g);\n\n  assertNonNullish(matches, 'Invalid hex string.');\n\n  return Uint8Array.from(matches.map((byte) => parseInt(byte, 16)));\n};\n\n/**\n * Compare two Uint8Arrays for byte-level equality.\n *\n * @param {Object} params\n * @param {Uint8Array} params.a - First Uint8Array to compare.\n * @param {Uint8Array} params.b - Second Uint8Array to compare.\n * @returns {boolean} True if both arrays have the same length and identical contents.\n */\nexport const uint8ArraysEqual = ({a, b}: {a: Uint8Array; b: Uint8Array}) =>\n  a.length === b.length && a.every((byte, i) => byte === b[i]);\n\nexport const uint8ArrayToHexString = (bytes: Uint8Array | number[]) => {\n  if (!(bytes instanceof Uint8Array)) {\n    bytes = Uint8Array.from(bytes);\n  }\n  return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');\n};\n\nexport const candidNumberArrayToBigInt = (array: number[]): bigint => {\n  let result = 0n;\n  for (let i = array.length - 1; i >= 0; i--) {\n    result = (result << 32n) + BigInt(array[i]);\n  }\n  return result;\n};\n", "/**\n * Converts a Uint8Array (binary data) to a base64 encoded string.\n *\n * @param {Uint8Array} uint8Array - The Uint8Array containing binary data to be encoded.\n * @returns {string} - The base64 encoded string representation of the binary data.\n */\nexport const uint8ArrayToBase64 = (uint8Array: Uint8Array): string => {\n  // Spreading large Uint8Arrays or using Array.from loses precision when used together with String.fromCharCode.\n  // Therefore, we use a chunked loop, which better than a reducer or iterating on every value.\n  // Spreading a small chunk - such as 32kb - works as expected.\n  const chunkSize = 0x8000; // 32 kb\n  const chunks: string[] = [];\n  for (let i = 0; i < uint8Array.length; i += chunkSize) {\n    chunks.push(String.fromCharCode(...uint8Array.subarray(i, i + chunkSize)));\n  }\n  return btoa(chunks.join(''));\n};\n\n/**\n * Converts a base64 encoded string to a Uint8Array (binary data).\n *\n * @param {string} base64String - The base64 encoded string to be decoded.\n * @returns {Uint8Array} - The Uint8Array representation of the decoded binary data.\n */\nexport const base64ToUint8Array = (base64String: string): Uint8Array =>\n  Uint8Array.from(atob(base64String), (c) => c.charCodeAt(0));\n", "const NANOSECONDS_PER_MILLISECOND = 1_000_000n;\n\n/**\n * Returns the current timestamp in nanoseconds as a `bigint`.\n *\n * @returns {bigint} The current timestamp in nanoseconds.\n */\nexport const nowInBigIntNanoSeconds = (): bigint =>\n  BigInt(Date.now()) * NANOSECONDS_PER_MILLISECOND;\n\n/**\n * Converts a given `Date` object to a timestamp in nanoseconds as a `bigint`.\n *\n * @param {Date} date - The `Date` object to convert.\n * @returns {bigint} The timestamp in nanoseconds.\n */\nexport const toBigIntNanoSeconds = (date: Date): bigint =>\n  BigInt(date.getTime()) * NANOSECONDS_PER_MILLISECOND;\n", "/**\n * Creates a debounced version of the provided function.\n *\n * The debounced function postpones its execution until after a certain amount of time\n * has elapsed since the last time it was invoked. This is useful for limiting the rate\n * at which a function is called (e.g. in response to user input or events).\n *\n * @param {Function} func - The function to debounce. It will only be called after no new calls happen within the specified timeout.\n * @param {number} [timeout=300] - The debounce delay in milliseconds. Defaults to 300ms if not provided or invalid.\n * @returns {(args: unknown[]) => void} A debounced version of the original function.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, local-rules/prefer-object-params\nexport const debounce = (func: Function, timeout?: number) => {\n  let timer: NodeJS.Timer | undefined;\n\n  return (...args: unknown[]) => {\n    const next = () => func(...args);\n\n    if (timer) {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore TypeScript global and window confusion even if we are using @types/node\n      clearTimeout(timer);\n    }\n\n    timer = setTimeout(next, timeout !== undefined && timeout > 0 ? timeout : 300);\n  };\n};\n", "/**\n * Checks if a given argument is null or undefined.\n *\n * @template T - The type of the argument.\n * @param {T | undefined | null} argument - The argument to check.\n * @returns {argument is undefined | null} `true` if the argument is null or undefined; otherwise, `false`.\n */\nexport const isNullish = <T>(argument: T | undefined | null): argument is undefined | null =>\n  argument === null || argument === undefined;\n\n/**\n * Checks if a given argument is neither null nor undefined.\n *\n * @template T - The type of the argument.\n * @param {T | undefined | null} argument - The argument to check.\n * @returns {argument is NonNullable<T>} `true` if the argument is not null or undefined; otherwise, `false`.\n */\nexport const nonNullish = <T>(argument: T | undefined | null): argument is NonNullable<T> =>\n  !isNullish(argument);\n\n/**\n * Checks if a given value is not null, not undefined, and not an empty string.\n *\n * @param {string | undefined | null} value - The value to check.\n * @returns {boolean} `true` if the value is not null, not undefined, and not an empty string; otherwise, `false`.\n */\nexport const notEmptyString = (value: string | undefined | null): value is string =>\n  nonNullish(value) && value !== '';\n\n/**\n * Checks if a given value is null, undefined, or an empty string.\n *\n * @param {string | undefined | null} value - The value to check.\n * @returns {value is undefined | null | \"\"} Type predicate indicating if the value is null, undefined, or an empty string.\n */\nexport const isEmptyString = (value: string | undefined | null): value is undefined | null | '' =>\n  !notEmptyString(value);\n", "import type {Nullable, NullishNullable} from '../types/did.utils';\nimport {assertNonNullish} from './asserts.utils';\nimport {nonNullish} from './nullish.utils';\n\n/**\n * Converts a value into a Candid-style variant representation of an optional value.\n *\n * @template T The type of the value.\n * @param {T | null | undefined} value - The value to convert into a Candid-style variant.\n * @returns {Nullable<T>} A Candid-style variant representation: an empty array for `null` and `undefined` or an array with the value.\n */\nexport const toNullable = <T>(value?: T | null): Nullable<T> => (nonNullish(value) ? [value] : []);\n\n/**\n * Extracts the value from a Candid-style variant representation of an optional value.\n *\n * @template T The type of the value.\n * @param {Nullable<T>} value - A Candid-style variant representing an optional value.\n * @returns {T | undefined} The extracted value, or `undefined` if the array is empty.\n */\nexport const fromNullable = <T>(value: Nullable<T>): T | undefined => value?.[0];\n\n/**\n * Extracts the value from a Candid-style variant representation of an optional value,\n * ensuring the value is defined. Throws an error if the array is empty or the value is nullish.\n *\n * @template T The type of the value.\n * @param {Nullable<T>} value - A Candid-style variant representing an optional value.\n * @returns {T} The extracted value.\n * @throws {Error} If the array is empty or the value is nullish.\n */\nexport const fromDefinedNullable = <T>(value: Nullable<T>): T => {\n  const result = fromNullable(value);\n\n  assertNonNullish(result);\n\n  return result;\n};\n\n/**\n * Extracts the value from a nullish Candid-style variant representation.\n *\n * @template T The type of the value.\n * @param {NullishNullable<T>} value - A Candid-style variant or `undefined`.\n * @returns {T | undefined} The extracted value, or `undefined` if the input is nullish or the array is empty.\n */\nexport const fromNullishNullable = <T>(value: NullishNullable<T>): T | undefined =>\n  fromNullable(value ?? []);\n", "import {Principal} from '@icp-sdk/core/principal';\nimport {nonNullish} from './nullish.utils';\n\nconst JSON_KEY_BIGINT = '__bigint__';\nconst JSON_KEY_PRINCIPAL = '__principal__';\nconst JSON_KEY_UINT8ARRAY = '__uint8array__';\n\n/**\n * A custom replacer for `JSON.stringify` that converts specific types not natively supported\n * by the API into JSON-compatible formats.\n *\n * Supported conversions:\n * - `BigInt` \u2192 `{ \"__bigint__\": string }`\n * - `Principal` \u2192 `{ \"__principal__\": string }`\n * - `Uint8Array` \u2192 `{ \"__uint8array__\": number[] }`\n *\n * @param {string} _key - Ignored. Only provided for API compatibility.\n * @param {unknown} value - The value to transform before stringification.\n * @returns {unknown} The transformed value if it matches a known type, otherwise the original value.\n */\n// eslint-disable-next-line local-rules/prefer-object-params\nexport const jsonReplacer = (_key: string, value: unknown): unknown => {\n  if (typeof value === 'bigint') {\n    return {[JSON_KEY_BIGINT]: `${value}`};\n  }\n\n  if (nonNullish(value) && Principal.isPrincipal(value)) {\n    // isPrincipal asserts if a value is a Principal, but does not assert if the object\n    // contains functions such as toText(). That's why we construct a new object.\n    return {[JSON_KEY_PRINCIPAL]: Principal.from(value).toText()};\n  }\n\n  if (nonNullish(value) && value instanceof Uint8Array) {\n    return {[JSON_KEY_UINT8ARRAY]: Array.from(value)};\n  }\n\n  return value;\n};\n\n/**\n * A custom reviver for `JSON.parse` that reconstructs specific types from their JSON-encoded representations.\n *\n * This reverses the transformations applied by `jsonReplacer`, restoring the original types.\n *\n * Supported conversions:\n * - `{ \"__bigint__\": string }` \u2192 `BigInt`\n * - `{ \"__principal__\": string }` \u2192 `Principal`\n * - `{ \"__uint8array__\": number[] }` \u2192 `Uint8Array`\n *\n * @param {string} _key - Ignored but provided for API compatibility.\n * @param {unknown} value - The parsed value to transform.\n * @returns {unknown} The reconstructed value if it matches a known type, otherwise the original value.\n */\n// eslint-disable-next-line local-rules/prefer-object-params\nexport const jsonReviver = (_key: string, value: unknown): unknown => {\n  const mapValue = <T>(key: string): T => (value as Record<string, T>)[key];\n\n  if (nonNullish(value) && typeof value === 'object' && JSON_KEY_BIGINT in value) {\n    return BigInt(mapValue(JSON_KEY_BIGINT));\n  }\n\n  if (nonNullish(value) && typeof value === 'object' && JSON_KEY_PRINCIPAL in value) {\n    return Principal.fromText(mapValue(JSON_KEY_PRINCIPAL));\n  }\n\n  if (nonNullish(value) && typeof value === 'object' && JSON_KEY_UINT8ARRAY in value) {\n    return Uint8Array.from(mapValue(JSON_KEY_UINT8ARRAY));\n  }\n\n  return value;\n};\n", "import {jsonReplacer, jsonReviver} from './json.utils';\n\n/**\n * Converts data to a Uint8Array for transmission or storage.\n * @template T\n * @param {T} data - The data to convert.\n * @returns {Promise<Uint8Array>} A promise that resolves to a Uint8Array representation of the data.\n */\nexport const toArray = async <T>(data: T): Promise<Uint8Array> => {\n  const blob = new Blob([JSON.stringify(data, jsonReplacer)], {\n    type: 'application/json; charset=utf-8'\n  });\n  return new Uint8Array(await blob.arrayBuffer());\n};\n\n/**\n * Converts a Uint8Array or number array back to the original data type.\n * @template T\n * @param {(Uint8Array | number[])} data - The array to convert.\n * @returns {Promise<T>} A promise that resolves to the original data.\n */\nexport const fromArray = async <T>(data: Uint8Array | number[]): Promise<T> => {\n  const blob = new Blob(\n    [data instanceof Uint8Array ? (data as Uint8Array<ArrayBuffer>) : new Uint8Array(data)],\n    {\n      type: 'application/json; charset=utf-8'\n    }\n  );\n  return JSON.parse(await blob.text(), jsonReviver);\n};\n", "/**\n * Checks if the current environment is a browser.\n * @returns {boolean} True if the current environment is a browser, false otherwise.\n */\nexport const isBrowser = (): boolean => typeof window !== `undefined`;\n", "// Source: https://stackoverflow.com/a/77489094/5404186\nexport const convertCamelToSnake = (str: string): string =>\n  str.replace(/([a-zA-Z])(?=[A-Z])/g, '$1_').toLowerCase();\n\nexport const capitalize = (str: string): string => str.charAt(0).toUpperCase() + str.slice(1);\n"],
  "mappings": "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",
  "names": ["InvalidPercentageError", "NullishError", "assertNonNullish", "value", "message", "asNonNullish", "assertPercentageNumber", "percentage", "assertNever", "_", "uint8ArrayToBigInt", "array", "view", "high", "low", "bigIntToUint8Array", "value", "buffer", "numberToUint8Array", "index", "arrayBufferToUint8Array", "uint8ArrayToArrayOfNumber", "arrayOfNumberToUint8Array", "numbers", "asciiStringToByteArray", "text", "c", "hexStringToUint8Array", "hexString", "matches", "assertNonNullish", "byte", "uint8ArraysEqual", "a", "b", "i", "uint8ArrayToHexString", "bytes", "str", "candidNumberArrayToBigInt", "result", "uint8ArrayToBase64", "uint8Array", "chunks", "i", "base64ToUint8Array", "base64String", "c", "NANOSECONDS_PER_MILLISECOND", "nowInBigIntNanoSeconds", "toBigIntNanoSeconds", "date", "debounce", "func", "timeout", "timer", "args", "next", "isNullish", "argument", "nonNullish", "notEmptyString", "value", "isEmptyString", "toNullable", "value", "nonNullish", "fromNullable", "fromDefinedNullable", "result", "assertNonNullish", "fromNullishNullable", "Principal", "JSON_KEY_BIGINT", "JSON_KEY_PRINCIPAL", "JSON_KEY_UINT8ARRAY", "jsonReplacer", "_key", "value", "nonNullish", "Principal", "jsonReviver", "mapValue", "key", "toArray", "data", "blob", "jsonReplacer", "fromArray", "jsonReviver", "isBrowser", "convertCamelToSnake", "str", "capitalize"]
}