@pezkuwi/util 14.0.1 → 14.0.4

package/src/format/formatNumber.spec.ts

@@ -1,60 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { BN } from '../bn/index.js';
-import { formatNumber } from './index.js';
-
-describe('formatNumber', (): void => {
-  it('formats empty', (): void => {
-    expect(
-      formatNumber()
-    ).toEqual('0');
-  });
-
-  it('formats negative numbers', (): void => {
-    expect(
-      formatNumber(-123456)
-    ).toEqual('-123,456');
-  });
-
-  it('formats BN numbers', (): void => {
-    expect(
-      formatNumber(new BN(12345))
-    ).toEqual('12,345');
-  });
-
-  it('formats BigInt numbers', (): void => {
-    expect(
-      formatNumber(123456789n)
-    ).toEqual('123,456,789');
-  });
-
-  it('formats Compact<BN>', (): void => {
-    expect(
-      formatNumber({
-        toBn: (): BN => new BN(12345),
-        unwrap: (): BN => new BN(0)
-      })
-    ).toEqual('12,345');
-  });
-
-  it('formats negative numbers (locale=sl)', (): void => {
-    expect(
-      formatNumber(-123456, { locale: 'sl' })
-    ).toEqual('-123.456');
-  });
-
-  it('formats BN numbers (locale=sl)', (): void => {
-    expect(
-      formatNumber(new BN(12345), { locale: 'sl' })
-    ).toEqual('12.345');
-  });
-
-  it('formats BigInt numbers (locale=sl)', (): void => {
-    expect(
-      formatNumber(123456789n, { locale: 'sl' })
-    ).toEqual('123.456.789');
-  });
-});

package/src/format/formatNumber.ts

@@ -1,29 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { BN } from '../bn/bn.js';
-import type { ToBn } from '../types.js';
-
-import { bnToBn } from '../bn/toBn.js';
-import { formatDecimal } from './formatDecimal.js';
-import { getSeparator } from './getSeparator.js';
-
-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/src/format/getSeparator.spec.ts

@@ -1,53 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { getSeparator } from './getSeparator.js';
-
-describe('getSeparator', (): void => {
-  const normalizeSeparator = (separator: string) =>
-    separator === '\u202F' ? ' ' : separator;
-
-  const testLocales = [
-    { decimal: '.', locale: 'en', thousand: ',' },
-    { decimal: '.', locale: 'en-gb', thousand: ',' },
-    { decimal: ',', locale: 'sl', thousand: '.' },
-    { decimal: ',', locale: 'sl-si', thousand: '.' },
-    { decimal: ',', locale: 'it-it', thousand: '.' },
-    { decimal: '.', locale: 'ja-jp', thousand: ',' },
-    { decimal: '.', locale: 'hi-IN', thousand: ',' },
-    { decimal: '.', locale: undefined, thousand: ',' } // Fallback test
-  ];
-
-  testLocales.forEach(({ decimal, locale, thousand }) => {
-    it(`uses ${locale || 'system default'} locale`, (): void => {
-      expect(
-        getSeparator(locale)
-      ).toEqual({ decimal, thousand });
-    });
-  });
-
-  it('falls back for invalid locale', (): void => {
-    expect(
-      getSeparator('invalid-locale')
-    ).toEqual({ decimal: '.', thousand: ',' }); // Default fallback
-  });
-
-  it('matches system locale dynamically', (): void => {
-    const n = 1000.1;
-    const expected = {
-      decimal: n.toLocaleString().substring(5, 6),
-      thousand: n.toLocaleString().substring(1, 2)
-    };
-
-    expect(getSeparator()).toEqual(expected);
-  });
-
-  it('handles locales with unique separators', (): void => {
-    const result = getSeparator('fr-FR');
-
-    expect(normalizeSeparator(result.thousand)).toBe(' ');
-    expect(result.decimal).toBe(',');
-  });
-});

package/src/format/getSeparator.ts

@@ -1,15 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.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/src/format/si.ts

@@ -1,52 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { SiDef } from '../types.js';
-
-/** @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' }
-];
-
-// Given a SI type (e.g. k, m, Y) find the SI definition
-/** @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/src/has.spec.ts

@@ -1,12 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hasBuffer } from './has.js';
-
-describe('hasBuffer', (): void => {
-  it('has Buffer (Jest + Node.js)', (): void => {
-    expect(hasBuffer).toEqual(typeof Buffer !== 'undefined');
-  });
-});

package/src/hex/addPrefix.spec.ts

@@ -1,32 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexAddPrefix } from './index.js';
-
-describe('hexAddPrefix', (): void => {
-  it('does not add when prefix is available', (): void => {
-    expect(
-      hexAddPrefix('0x0123')
-    ).toEqual('0x0123');
-  });
-
-  it('adds the prefix when it is not available', (): void => {
-    expect(
-      hexAddPrefix('0123')
-    ).toEqual('0x0123');
-  });
-
-  it('adds extra 0 when length % 2 === 1', (): void => {
-    expect(
-      hexAddPrefix('123')
-    ).toEqual('0x0123');
-  });
-
-  it('returns null as 0x', (): void => {
-    expect(
-      hexAddPrefix(null)
-    ).toEqual('0x');
-  });
-});

package/src/hex/fixLength.spec.ts

@@ -1,38 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexFixLength } from './index.js';
-
-describe('hexFixLength', (): void => {
-  it('returns bitLength === -1 as-is', (): void => {
-    expect(
-      hexFixLength('0x12345678')
-    ).toEqual('0x12345678');
-  });
-
-  it('does not change when bitlength === length', (): void => {
-    expect(
-      hexFixLength('0x12345678', 32)
-    ).toEqual('0x12345678');
-  });
-
-  it('trims values when bitLength > length', (): void => {
-    expect(
-      hexFixLength('0x12345678', 16)
-    ).toEqual('0x5678');
-  });
-
-  it('returns as-is when bitLength < length', (): void => {
-    expect(
-      hexFixLength('0x1234', 32)
-    ).toEqual('0x1234');
-  });
-
-  it('adds zeros when bitLength < length (withPadded)', (): void => {
-    expect(
-      hexFixLength('0x1234', 32, true)
-    ).toEqual('0x00001234');
-  });
-});

package/src/hex/hasPrefix.spec.ts

@@ -1,32 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexHasPrefix } from './index.js';
-
-describe('hexHasPrefix', (): void => {
-  it('returns true when hex prefix is found', (): void => {
-    expect(
-      hexHasPrefix('0x1234')
-    ).toEqual(true);
-  });
-
-  it('returns false when no prefix attached', (): void => {
-    expect(
-      hexHasPrefix('123')
-    ).toEqual(false);
-  });
-
-  it('returns false when null value supplied', (): void => {
-    expect(
-      hexHasPrefix(null)
-    ).toEqual(false);
-  });
-
-  it('returns false when non-string value supplied', (): void => {
-    expect(
-      hexHasPrefix(false as unknown as string)
-    ).toEqual(false);
-  });
-});

package/src/hex/stripPrefix.spec.ts

@@ -1,44 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexStripPrefix } from './index.js';
-
-describe('hexStripPrefix', (): void => {
-  it('returns an empty string when null value supplied', (): void => {
-    expect(
-      hexStripPrefix(null)
-    ).toEqual('');
-  });
-
-  it('returns an empty string when 0x value supplied', (): void => {
-    expect(
-      hexStripPrefix('0x')
-    ).toEqual('');
-  });
-
-  it('strips the prefix from hex strings', (): void => {
-    expect(
-      hexStripPrefix('0x1223')
-    ).toEqual('1223');
-  });
-
-  it('strips the prefix from hex strings (non 2 lnegth)', (): void => {
-    expect(
-      hexStripPrefix('0x123')
-    ).toEqual('123');
-  });
-
-  it('returns un-prefixed hex as-is', (): void => {
-    expect(
-      hexStripPrefix('abcd1223')
-    ).toEqual('abcd1223');
-  });
-
-  it('throws when invalid hex', (): void => {
-    expect(
-      () => hexStripPrefix('0x0x01ab')
-    ).toThrow(/Expected hex value to convert/);
-  });
-});

package/src/hex/toBigInt.spec.ts

@@ -1,74 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexToBigInt } from './index.js';
-
-describe('hexToBigInt', (): void => {
-  it('converts prefixed hex values to BN', (): void => {
-    expect(
-      hexToBigInt('0x81')
-    ).toEqual(0x81n);
-  });
-
-  it('converts null values to BN(0)', (): void => {
-    expect(
-      hexToBigInt(null)
-    ).toEqual(0n);
-  });
-
-  it('converts 0x values to BN(0)', (): void => {
-    expect(
-      hexToBigInt('0x')
-    ).toEqual(0n);
-  });
-
-  it('should convert with Big Endian by default', (): void => {
-    expect(
-      hexToBigInt('0x0100123456')
-    ).toEqual(0x0100123456n);
-  });
-
-  it('converts 0x values to BN(0) (LE)', (): void => {
-    expect(
-      hexToBigInt('0x', { isLe: true })
-    ).toEqual(0n);
-  });
-
-  it('converts little-endian', (): void => {
-    expect(
-      hexToBigInt('0x4500000000000000', { isLe: true })
-    ).toEqual(69n);
-  });
-
-  it('handles negative numbers (LE)', (): void => {
-    expect(
-      hexToBigInt('0x2efb', { isLe: true, isNegative: true })
-    ).toEqual(-1234n);
-  });
-
-  it('handles negative numbers (BE)', (): void => {
-    expect(
-      hexToBigInt('0xfb2e', { isLe: false, isNegative: true })
-    ).toEqual(-1234n);
-  });
-
-  it('handles negative numbers (LE, 128)', (): void => {
-    expect(
-      hexToBigInt('0x00009c584c491ff2ffffffffffffffff', { isLe: true, isNegative: true })
-    ).toEqual(-1000000000000000000n);
-  });
-
-  it('handles starting zeros correctly (BE)', (): void => {
-    expect(
-      hexToBigInt('0x0000000000000100', { isLe: false })
-    ).toEqual(256n);
-  });
-
-  it('handles starting zeros correctly (LE)', (): void => {
-    expect(
-      hexToBigInt('0x0001000000000000', { isLe: true })
-    ).toEqual(256n);
-  });
-});

package/src/hex/toBigInt.ts

@@ -1,19 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ToBnOptions } from '../types.js';
-
-import { BigInt } from '@pezkuwi/x-bigint';
-
-import { u8aToBigInt } from '../u8a/toBigInt.js';
-import { hexToU8a } from './toU8a.js';
-
-/**
- * @name hexToBigInt
- * @summary Creates a BigInt instance object from a hex string.
- */
-export function hexToBigInt (value?: string | null, { isLe = false, isNegative = false }: ToBnOptions = {}): bigint {
-  return !value || value === '0x'
-    ? BigInt(0)
-    : u8aToBigInt(hexToU8a(value), { isLe, isNegative });
-}

package/src/hex/toBn.spec.ts

@@ -1,74 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexToBn } from './index.js';
-
-describe('hexToBn', (): void => {
-  it('converts prefixed hex values to BN', (): void => {
-    expect(
-      hexToBn('0x81').toString(16)
-    ).toBe('81');
-  });
-
-  it('converts null values to BN(0)', (): void => {
-    expect(
-      hexToBn(null).toNumber()
-    ).toBe(0);
-  });
-
-  it('converts 0x values to BN(0)', (): void => {
-    expect(
-      hexToBn('0x').toNumber()
-    ).toBe(0);
-  });
-
-  it('should convert with Big Endian by default', (): void => {
-    expect(
-      hexToBn('0x0100').toNumber()
-    ).toBe(256);
-  });
-
-  it('converts 0x values to BN(0) (LE)', (): void => {
-    expect(
-      hexToBn('0x', { isLe: true }).toNumber()
-    ).toBe(0);
-  });
-
-  it('converts little-endian', (): void => {
-    expect(
-      hexToBn('0x4500000000000000', { isLe: true }).toNumber()
-    ).toBe(69);
-  });
-
-  it('handles negative numbers (LE)', (): void => {
-    expect(
-      hexToBn('0x2efb', { isLe: true, isNegative: true }).toNumber()
-    ).toBe(-1234);
-  });
-
-  it('handles negative numbers (BE)', (): void => {
-    expect(
-      hexToBn('0xfb2e', { isLe: false, isNegative: true }).toNumber()
-    ).toBe(-1234);
-  });
-
-  it('handles negative numbers (LE, 128)', (): void => {
-    expect(
-      hexToBn('0x00009c584c491ff2ffffffffffffffff', { isLe: true, isNegative: true }).toString()
-    ).toEqual('-1000000000000000000');
-  });
-
-  it('handles starting zeros correctly (BE)', (): void => {
-    expect(
-      hexToBn('0x0000000000000100', { isLe: false }).toNumber()
-    ).toBe(256);
-  });
-
-  it('handles starting zeros correctly (LE)', (): void => {
-    expect(
-      hexToBn('0x0001000000000000', { isLe: true }).toNumber()
-    ).toBe(256);
-  });
-});

package/src/hex/toNumber.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexToNumber } from './index.js';
-
-describe('hexToNumber', (): void => {
-  it('converts an empty to NaN', (): void => {
-    expect(
-      hexToNumber()
-    ).toEqual(NaN);
-  });
-
-  it('converts to a number from hex', (): void => {
-    expect(
-      hexToNumber('0x1234')
-    ).toEqual(0x1234);
-  });
-});

package/src/hex/toString.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexToString } from './index.js';
-
-describe('hexToString', (): void => {
-  it('converts an empty to ""', (): void => {
-    expect(
-      hexToString()
-    ).toEqual('');
-  });
-
-  it('converts to a string from hex', (): void => {
-    expect(
-      hexToString('0x68656c6c6f')
-    ).toEqual('hello');
-  });
-});

package/src/hex/toU8a.spec.ts

@@ -1,76 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { perfCmp } from '../test/index.js';
-import { hexToU8a } from './index.js';
-import { hexToU8a as hexToU8aBuffer } from './toU8aBuffer.js';
-
-let ptest = '0x';
-
-for (let i = 0; i < 1_000_000; i++) {
-  ptest += (i % 256).toString(16);
-}
-
-describe('hexToU8a', (): void => {
-  it('returns an empty Uint8Array when null provided', (): void => {
-    expect(
-      hexToU8a(null)
-    ).toHaveLength(0);
-  });
-
-  it('returns an empty Uint8Array when 0x provided', (): void => {
-    expect(
-      hexToU8a('0x')
-    ).toHaveLength(0);
-  });
-
-  it('returns a Uint8Array with the correct values', (): void => {
-    expect(
-      hexToU8a('0x80000a')
-    ).toEqual(
-      new Uint8Array([128, 0, 10])
-    );
-  });
-
-  it('returns a Uint8Array with the correct values (bitLength > provided)', (): void => {
-    expect(
-      hexToU8a('0x80000A', 64)
-    ).toEqual(
-      new Uint8Array([0, 0, 0, 0, 0, 128, 0, 10])
-    );
-  });
-
-  it('returns a Uint8Array with the correct values (bitLength < provided)', (): void => {
-    expect(
-      hexToU8a('0x80000a', 16)
-    ).toEqual(
-      new Uint8Array([128, 0])
-    );
-  });
-
-  it('converts a non-aligned string', (): void => {
-    expect(
-      hexToU8a('0x123')
-    ).toEqual(new Uint8Array([0x12, 0x30]));
-  });
-
-  it('converts known bytes to their correct values', (): void => {
-    expect(
-      hexToU8a('0x68656c6c6f20776f726c64') // hello world (11 bytes, non-aligned)
-    ).toEqual(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64]));
-  });
-
-  it('converts known bytes to their correct values (upper/lower)', (): void => {
-    expect(
-      hexToU8a('0x68656C6c6f20776F726c64') // hello world (11 bytes, non-aligned)
-    ).toEqual(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64]));
-  });
-
-  perfCmp('hexToU8a', ['hexToU8aBuffer', 'hexToU8a'], 40, [[ptest]], (s: string, isSecond) =>
-    isSecond
-      ? hexToU8a(s)
-      : hexToU8aBuffer(s)
-  );
-});