@pezkuwi/util 14.0.12 → 14.0.14

package/build-deno/compact/toU8a.ts

@@ -1,51 +0,0 @@
-
-import { BN, BN_ONE, BN_TWO, bnToBn, bnToU8a } from '../bn/index.ts';
-import { u8aConcatStrict } from '../u8a/index.ts';
-
-const MAX_U8 = BN_TWO.pow(new BN(8 - 2)).isub(BN_ONE);
-const MAX_U16 = BN_TWO.pow(new BN(16 - 2)).isub(BN_ONE);
-const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(BN_ONE);
-const BL_16 = { bitLength: 16 };
-const BL_32 = { bitLength: 32 };
-
-/**
- * @name compactToU8a
- * @description Encodes a number into a compact representation
- * @example
- * <BR>
- *
- * ```javascript
- * import { compactToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
- * ```
- */
-export function compactToU8a (value: BN | bigint | number): Uint8Array {
-  const bn = bnToBn(value);
-
-  if (bn.lte(MAX_U8)) {
-    return new Uint8Array([bn.toNumber() << 2]);
-  } else if (bn.lte(MAX_U16)) {
-    return bnToU8a(bn.shln(2).iadd(BN_ONE), BL_16);
-  } else if (bn.lte(MAX_U32)) {
-    return bnToU8a(bn.shln(2).iadd(BN_TWO), BL_32);
-  }
-
-  const u8a = bnToU8a(bn);
-  let length = u8a.length;
-
-  // adjust to the minimum number of bytes
-  while (u8a[length - 1] === 0) {
-    length--;
-  }
-
-  if (length < 4) {
-    throw new Error('Invalid length, previous checks match anything less than 2^30');
-  }
-
-  return u8aConcatStrict([
-    // subtract 4 as minimum (also catered for in decoding)
-    new Uint8Array([((length - 4) << 2) + 0b11]),
-    u8a.subarray(0, length)
-  ]);
-}

package/build-deno/compact/types.ts

@@ -1,2 +0,0 @@
-
-export type BitLength = 8 | 16 | 32 | 64 | 128 | 256;

package/build-deno/detectPackage.ts

@@ -1,136 +0,0 @@
-
-import { xglobal } from 'https://deno.land/x/pezkuwi/x-global/mod.ts';
-
-import { isFunction } from './is/function.ts';
-
-type This = typeof globalThis;
-
-interface VersionPath {
-  path: string;
-  type: string;
-  version: string;
-}
-
-interface PackageInfo extends VersionPath {
-  name: string;
-}
-
-interface PjsChecks extends This {
-  __polkadotjs: Record<string, VersionPath[]>;
-}
-
-type PjsGlobal = This & PjsChecks & Record<string, unknown>;
-type FnString = () => string | undefined;
-
-const DEDUPE = 'Either remove and explicitly install matching versions or dedupe using your package manager.\nThe following conflicting packages were found:';
-
-export const POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = 'POLKADOTJS_DISABLE_ESM_CJS_WARNING';
-
-/** @internal */
-function getEntry (name: string): VersionPath[] {
-  const _global = xglobal as PjsGlobal;
-
-  if (!_global.__polkadotjs) {
-    _global.__polkadotjs = {};
-  }
-
-  if (!_global.__polkadotjs[name]) {
-    _global.__polkadotjs[name] = [];
-  }
-
-  return _global.__polkadotjs[name];
-}
-
-/** @internal */
-function formatDisplay <T extends { version: string }> (all: T[], fmt: (version: string, data: T) => string[]): string {
-  let max = 0;
-
-  for (let i = 0, count = all.length; i < count; i++) {
-    max = Math.max(max, all[i].version.length);
-  }
-
-  return all
-    .map((d) => `\t${fmt(d.version.padEnd(max), d).join('\t')}`)
-    .join('\n');
-}
-
-/** @internal */
-function formatInfo (version: string, { name }: PackageInfo): string[] {
-  return [
-    version,
-    name
-  ];
-}
-
-/** @internal */
-function formatVersion (version: string, { path, type }: VersionPath): string[] {
-  let extracted: string;
-
-  if (path && path.length >= 5) {
-    const nmIndex = path.indexOf('node_modules');
-
-    extracted = nmIndex === -1
-      ? path
-      : path.substring(nmIndex);
-  } else {
-    extracted = '<unknown>';
-  }
-
-  return [
-    `${`${type || ''}`.padStart(3)} ${version}`,
-    extracted
-  ];
-}
-
-/** @internal */
-function getPath (infoPath?: string, pathOrFn?: FnString | string | false | null): string {
-  if (infoPath) {
-    return infoPath;
-  } else if (isFunction(pathOrFn)) {
-    try {
-      return pathOrFn() || '';
-    } catch {
-      return '';
-    }
-  }
-
-  return pathOrFn || '';
-}
-
-/** @internal */
-function warn <T extends { version: string }> (pre: string, all: T[], fmt: (version: string, data: T) => string[]): void {
-  console.warn(`${pre}\n${DEDUPE}\n${formatDisplay(all, fmt)}`);
-}
-
-/**
- * @name detectPackage
- * @summary Checks that a specific package is only imported once
- * @description A `@pezkuwi/*` version detection utility, checking for one occurrence of a package in addition to checking for dependency versions.
- */
-export function detectPackage ({ name, path, type, version }: PackageInfo, pathOrFn?: FnString | string | false | null, deps: PackageInfo[] = []): void {
-  if (!name.startsWith('@pezkuwi')) {
-    throw new Error(`Invalid package descriptor ${name}`);
-  }
-
-  const entry = getEntry(name);
-
-  entry.push({ path: getPath(path, pathOrFn), type, version });
-
-  // if we have more than one entry at DIFFERENT version types then warn. If there is
-  // more than one entry at the same version and ESM/CJS dual warnings are disabled,
-  // then do not display warnings
-  const entriesSameVersion = entry.every((e) => e.version === version);
-  const esmCjsWarningDisabled = xglobal.process?.env?.[POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG] === '1';
-  const multipleEntries = entry.length !== 1;
-  const disableWarnings = esmCjsWarningDisabled && entriesSameVersion;
-
-  if (multipleEntries && !disableWarnings) {
-    warn(`${name} has multiple versions, ensure that there is only one installed.`, entry, formatVersion);
-  } else {
-    const mismatches = deps.filter((d) => d && d.version !== version);
-
-    if (mismatches.length) {
-      warn(`${name} requires direct dependencies exactly matching version ${version}.`, mismatches, formatInfo);
-    }
-  }
-}

package/build-deno/extractTime.ts

@@ -1,69 +0,0 @@
-
-import type { Time } from './types.ts';
-
-const MIN_MS = 60 * 1000;
-const HR_MS = MIN_MS * 60;
-const DAY_MS = HR_MS * 24;
-const ZERO: Time = { days: 0, hours: 0, milliseconds: 0, minutes: 0, seconds: 0 };
-
-/** @internal */
-function add (a: Partial<Time>, b: Time): Time {
-  return {
-    days: (a.days || 0) + b.days,
-    hours: (a.hours || 0) + b.hours,
-    milliseconds: (a.milliseconds || 0) + b.milliseconds,
-    minutes: (a.minutes || 0) + b.minutes,
-    seconds: (a.seconds || 0) + b.seconds
-  };
-}
-
-/** @internal */
-function extractSecs (ms: number): Time {
-  const s = ms / 1000;
-
-  if (s < 60) {
-    const seconds = ~~s;
-
-    return add({ seconds }, extractTime(ms - (seconds * 1000)));
-  }
-
-  const m = s / 60;
-
-  if (m < 60) {
-    const minutes = ~~m;
-
-    return add({ minutes }, extractTime(ms - (minutes * MIN_MS)));
-  }
-
-  const h = m / 60;
-
-  if (h < 24) {
-    const hours = ~~h;
-
-    return add({ hours }, extractTime(ms - (hours * HR_MS)));
-  }
-
-  const days = ~~(h / 24);
-
-  return add({ days }, extractTime(ms - (days * DAY_MS)));
-}
-
-/**
- * @name extractTime
- * @summary Convert a quantity of seconds to Time array representing accumulated {days, minutes, hours, seconds, milliseconds}
- * @example
- * <BR>
- *
- * ```javascript
- * import { extractTime } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * const { days, minutes, hours, seconds, milliseconds } = extractTime(6000); // 0, 0, 10, 0, 0
- * ```
- */
-export function extractTime (milliseconds?: number): Time {
-  return !milliseconds
-    ? ZERO
-    : milliseconds < 1000
-      ? add({ milliseconds }, ZERO)
-      : extractSecs(milliseconds);
-}

package/build-deno/float/index.ts

@@ -1,2 +0,0 @@
-
-export { floatToU8a } from './toU8a.ts';

package/build-deno/float/toU8a.ts

@@ -1,27 +0,0 @@
-
-interface Options {
-  bitLength?: 32 | 64;
-  isLe?: boolean;
-}
-
-/**
- * @name floatToU8a
- * @description Converts a float into a U8a representation (While we don't use BE in SCALE
- * we still allow for either representation, although, as elsewhere, isLe is default)
- */
-export function floatToU8a (value: String | string | number | Number = 0.0, { bitLength = 32, isLe = true }: Options = {}): Uint8Array {
-  if (bitLength !== 32 && bitLength !== 64) {
-    throw new Error('Invalid bitLength provided, expected 32 or 64');
-  }
-
-  const result = new Uint8Array(bitLength / 8);
-  const dv = new DataView(result.buffer, result.byteOffset);
-
-  if (bitLength === 32) {
-    dv.setFloat32(0, Number(value), isLe);
-  } else {
-    dv.setFloat64(0, Number(value), isLe);
-  }
-
-  return result;
-}

package/build-deno/format/formatBalance.ts

@@ -1,172 +0,0 @@
-
-import type { BN } from '../bn/bn.ts';
-import type { SiDef, ToBn } from '../types.ts';
-
-import { bnToBn } from '../bn/toBn.ts';
-import { isBoolean } from '../is/boolean.ts';
-import { formatDecimal } from './formatDecimal.ts';
-import { getSeparator } from './getSeparator.ts';
-import { calcSi, findSi, SI, SI_MID } from './si.ts';
-
-interface Defaults {
-  decimals: number;
-  unit: string;
-}
-
-interface SetDefaults {
-  decimals?: number[] | number;
-  unit?: string[] | string;
-}
-
-interface Options {
-  /**
-   * @description The number of decimals
-   */
-  decimals?: number;
-  /**
-   * @description Format the number with this specific unit
-   */
-  forceUnit?: string;
-  /**
-   * @description Returns value using all available decimals
-   */
-  withAll?: boolean;
-  /**
-   * @description Format with SI, i.e. m/M/etc. (default = true)
-   */
-  withSi?: boolean;
-  /**
-   * @description Format with full SI, i.e. mili/Mega/etc.
-   */
-  withSiFull?: boolean;
-  /**
-   * @description Add the unit (useful in Balance formats)
-   */
-  withUnit?: boolean | string;
-  /**
-   * @description Returns all trailing zeros, otherwise removes (default = true)
-   */
-  withZero?: boolean;
-  /**
-   * @description The locale to use
-   */
-  locale?: string;
-}
-
-interface BalanceFormatter {
-  <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, options?: Options): string;
-  calcSi (text: string, decimals?: number): SiDef;
-  findSi (type: string): SiDef;
-  getDefaults (): Defaults;
-  getOptions (decimals?: number): SiDef[];
-  setDefaults (defaults: SetDefaults): void;
-}
-
-const DEFAULT_DECIMALS = 0;
-const DEFAULT_UNIT = SI[SI_MID].text;
-
-let defaultDecimals = DEFAULT_DECIMALS;
-let defaultUnit = DEFAULT_UNIT;
-
-function _formatBalance <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, { decimals = defaultDecimals, forceUnit, locale = 'en', withAll = false, withSi = true, withSiFull = false, withUnit = true, withZero = true }: Options = {}): string {
-  // we only work with string inputs here - convert anything
-  // into the string-only value
-  let text = bnToBn(input).toString();
-
-  if (text.length === 0 || text === '0') {
-    return '0';
-  }
-
-  // strip the negative sign so we can work with clean groupings, re-add this in the
-  // end when we return the result (from here on we work with positive numbers)
-  let sign = '';
-
-  if (text[0].startsWith('-')) {
-    sign = '-';
-    text = text.substring(1);
-  }
-
-  // We start at midpoint (8) minus 1 - this means that values display as
-  // 123.4567 instead of 0.1234 k (so we always have the most relevant).
-  const si = calcSi(text, decimals, forceUnit);
-  const mid = text.length - (decimals + si.power);
-  const pre = mid <= 0 ? '0' : text.substring(0, mid);
-
-  // get the post from the midpoint onward and then first add max decimals
-  // before trimming to the correct (calculated) amount of decimals again
-  let post = text
-    .padStart(mid < 0 ? decimals : 1, '0')
-    .substring(mid < 0 ? 0 : mid)
-    .padEnd(withAll ? Math.max(decimals, 4) : 4, '0')
-    .substring(0, withAll ? Math.max(4, decimals + si.power) : 4);
-
-  // remove all trailing 0's (if required via flag)
-  if (!withZero) {
-    let end = post.length - 1;
-
-    // This looks inefficient, however it is better to do the checks and
-    // only make one final slice than it is to do it in multiples
-    do {
-      if (post[end] === '0') {
-        end--;
-      }
-    } while (post[end] === '0');
-
-    post = post.substring(0, end + 1);
-  }
-
-  // the display unit
-  const unit = isBoolean(withUnit)
-    ? SI[SI_MID].text
-    : withUnit;
-
-  // format the units for display based on the flags
-  const units = withSi || withSiFull
-    ? si.value === '-'
-      ? withUnit
-        ? ` ${unit}`
-        : ''
-      : ` ${withSiFull ? `${si.text}${withUnit ? ' ' : ''}` : si.value}${withUnit ? unit : ''}`
-    : '';
-
-  const { decimal, thousand } = getSeparator(locale);
-
-  return `${sign}${formatDecimal(pre, thousand)}${post && `${decimal}${post}`}${units}`;
-}
-
-export const formatBalance = _formatBalance as BalanceFormatter;
-
-formatBalance.calcSi = (text: string, decimals: number = defaultDecimals): SiDef =>
-  calcSi(text, decimals);
-
-formatBalance.findSi = findSi;
-
-formatBalance.getDefaults = (): Defaults => {
-  return {
-    decimals: defaultDecimals,
-    unit: defaultUnit
-  };
-};
-
-formatBalance.getOptions = (decimals: number = defaultDecimals): SiDef[] => {
-  return SI.filter(({ power }): boolean =>
-    power < 0
-      ? (decimals + power) >= 0
-      : true
-  );
-};
-
-formatBalance.setDefaults = ({ decimals, unit }: SetDefaults): void => {
-  defaultDecimals = (
-    Array.isArray(decimals)
-      ? decimals[0]
-      : decimals
-  ) ?? defaultDecimals;
-  defaultUnit = (
-    Array.isArray(unit)
-      ? unit[0]
-      : unit
-  ) ?? defaultUnit;
-
-  SI[SI_MID].text = defaultUnit;
-};

package/build-deno/format/formatDate.ts

@@ -1,20 +0,0 @@
-
-/** @internal */
-function zeroPad (value: number): string {
-  return value.toString().padStart(2, '0');
-}
-
-/**
- * @name formatDate
- * @description Formats a date in CCYY-MM-DD HH:MM:SS format
- */
-export function formatDate (date: Date): string {
-  const year = date.getFullYear().toString();
-  const month = zeroPad((date.getMonth() + 1));
-  const day = zeroPad(date.getDate());
-  const hour = zeroPad(date.getHours());
-  const minute = zeroPad(date.getMinutes());
-  const second = zeroPad(date.getSeconds());
-
-  return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
-}

package/build-deno/format/formatDecimal.ts

@@ -1,19 +0,0 @@
-
-const NUMBER_REGEX = new RegExp('(\\d+?)(?=(\\d{3})+(?!\\d)|$)', 'g');
-
-/**
- * @name formatDecimal
- * @description Formats a number into string format with thousand separators
- */
-export function formatDecimal (value: string, separator = ','): string {
-  // We can do this by adjusting the regx, however for the sake of clarity
-  // we rather strip and re-add the negative sign in the output
-  const isNegative = value[0].startsWith('-');
-  const matched = isNegative
-    ? value.substring(1).match(NUMBER_REGEX)
-    : value.match(NUMBER_REGEX);
-
-  return matched
-    ? `${isNegative ? '-' : ''}${matched.join(separator)}`
-    : value;
-}

package/build-deno/format/formatElapsed.ts

@@ -1,33 +0,0 @@
-
-import type { BN } from '../bn/bn.ts';
-import type { ToBn } from '../types.ts';
-
-import { bnToBn } from '../bn/toBn.ts';
-
-/** @internal */
-function formatValue (elapsed: number): string {
-  if (elapsed < 15) {
-    return `${elapsed.toFixed(1)}s`;
-  } else if (elapsed < 60) {
-    return `${elapsed | 0}s`;
-  } else if (elapsed < 3600) {
-    return `${elapsed / 60 | 0}m`;
-  }
-
-  return `${elapsed / 3600 | 0}h`;
-}
-
-/**
- * @name formatElapsed
- * @description Formats an elapsed value into s, m, h or day segments
- */
-export function formatElapsed <ExtToBn extends ToBn> (now?: Date | null, value?: bigint | BN | ExtToBn | Date | number | null): string {
-  const tsNow = now?.getTime() || 0;
-  const tsValue = value instanceof Date
-    ? value.getTime()
-    : bnToBn(value).toNumber();
-
-  return (tsNow && tsValue)
-    ? formatValue(Math.max(Math.abs(tsNow - tsValue), 0) / 1000)
-    : '0.0s';
-}

package/build-deno/format/formatNumber.ts

@@ -1,27 +0,0 @@
-
-import type { BN } from '../bn/bn.ts';
-import type { ToBn } from '../types.ts';
-
-import { bnToBn } from '../bn/toBn.ts';
-import { formatDecimal } from './formatDecimal.ts';
-import { getSeparator } from './getSeparator.ts';
-
-interface Options {
-  /**
-   * @description The locale to use
-   */
-  locale?: string;
-}
-
-/**
- * @name formatNumber
- * @description Formats a number into string format with thousand separators
- */
-export function formatNumber <ExtToBn extends ToBn> (
-  value?: ExtToBn | BN | bigint | number | null,
-  { locale = 'en' }: Options = {}
-): string {
-  const { thousand } = getSeparator(locale);
-
-  return formatDecimal(bnToBn(value).toString(), thousand);
-}

package/build-deno/format/getSeparator.ts

@@ -1,13 +0,0 @@
-
-/**
- * Get the decimal and thousand separator of a locale
- * @param locale
- * @returns {decimal: string, thousand: string}
- */
-export function getSeparator (locale?: string):
-{ thousand: string, decimal: string } {
-  return {
-    decimal: (0.1).toLocaleString(locale, { useGrouping: false }).charAt(1),
-    thousand: (1000).toLocaleString(locale, { useGrouping: true }).replace(/\d/g, '').charAt(0)
-  };
-}

package/build-deno/format/index.ts

@@ -1,7 +0,0 @@
-
-export { formatBalance } from './formatBalance.ts';
-export { formatDate } from './formatDate.ts';
-export { formatDecimal } from './formatDecimal.ts';
-export { formatElapsed } from './formatElapsed.ts';
-export { formatNumber } from './formatNumber.ts';
-export { calcSi, findSi } from './si.ts';

package/build-deno/format/si.ts

@@ -1,49 +0,0 @@
-
-import type { SiDef } from '../types.ts';
-
-/** @internal */
-export const SI_MID = 8;
-
-/** @internal */
-export const SI: SiDef[] = [
-  { power: -24, text: 'yocto', value: 'y' },
-  { power: -21, text: 'zepto', value: 'z' },
-  { power: -18, text: 'atto', value: 'a' },
-  { power: -15, text: 'femto', value: 'f' },
-  { power: -12, text: 'pico', value: 'p' },
-  { power: -9, text: 'nano', value: 'n' },
-  { power: -6, text: 'micro', value: 'µ' },
-  { power: -3, text: 'milli', value: 'm' },
-  { power: 0, text: 'Unit', value: '-' }, // position 8
-  { power: 3, text: 'Kilo', value: 'k' },
-  { power: 6, text: 'Mill', value: 'M' }, // Mega, M
-  { power: 9, text: 'Bill', value: 'B' }, // Giga, G
-  { power: 12, text: 'Tril', value: 'T' }, // Tera, T
-  { power: 15, text: 'Peta', value: 'P' },
-  { power: 18, text: 'Exa', value: 'E' },
-  { power: 21, text: 'Zeta', value: 'Z' },
-  { power: 24, text: 'Yotta', value: 'Y' }
-];
-
-/** @internal */
-export function findSi (type: string): SiDef {
-  // use a loop here, better RN support (which doesn't have [].find)
-  for (let i = 0, count = SI.length; i < count; i++) {
-    if (SI[i].value === type) {
-      return SI[i];
-    }
-  }
-
-  return SI[SI_MID];
-}
-
-/** @internal */
-export function calcSi (text: string, decimals: number, forceUnit?: string): SiDef {
-  if (forceUnit) {
-    return findSi(forceUnit);
-  }
-
-  const siDefIndex = (SI_MID - 1) + Math.ceil((text.length - decimals) / 3);
-
-  return SI[siDefIndex] || SI[siDefIndex < 0 ? 0 : SI.length - 1];
-}

package/build-deno/has.ts

@@ -1,33 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import type { BufferClass } from './types.ts';
-
-import { BigInt } from 'https://deno.land/x/pezkuwi/x-bigint/mod.ts';
-import { xglobal } from 'https://deno.land/x/pezkuwi/x-global/mod.ts';
-
-declare const __dirname: unknown;
-declare const module: unknown;
-declare const require: unknown;
-
-/** true if the environment has proper BigInt support */
-export const hasBigInt = typeof BigInt === 'function' && typeof BigInt.asIntN === 'function';
-
-/** true if the environment is CJS */
-export const hasCjs = typeof require === 'function' && typeof module !== 'undefined';
-
-/** true if the environment has __dirname available */
-export const hasDirname = typeof __dirname !== 'undefined';
-
-/** true if the environment is ESM */
-export const hasEsm = !hasCjs;
-
-/** true if the environment has WebAssembly available */
-export const hasWasm = typeof WebAssembly !== 'undefined';
-
-
-/** true if the environment has support for Buffer (typically Node.js) */
-export const hasBuffer = typeof xglobal.Buffer === 'function' && typeof (xglobal.Buffer as unknown as BufferClass).isBuffer === 'function';
-
-/** true if the environment has process available (typically Node.js) */
-export const hasProcess = typeof xglobal.process === 'object';