@pezkuwi/util 14.0.1 → 14.0.4

package/cjs/string/lowerFirst.d.ts

@@ -0,0 +1,31 @@
+import type { AnyString } from '../types.js';
+/**
+ * @name stringLowerFirst
+ * @summary Lowercase the first letter of a string
+ * @description
+ * Lowercase the first letter of a string
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringLowerFirst } from '@polkadot/util';
+ *
+ * stringLowerFirst('ABC'); // => 'aBC'
+ * ```
+ */
+export declare const stringLowerFirst: (value?: AnyString | null) => string;
+/**
+ * @name stringUpperFirst
+ * @summary Uppercase the first letter of a string
+ * @description
+ * Lowercase the first letter of a string
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringUpperFirst } from '@polkadot/util';
+ *
+ * stringUpperFirst('abc'); // => 'Abc'
+ * ```
+ */
+export declare const stringUpperFirst: (value?: AnyString | null) => string;

package/cjs/string/lowerFirst.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringUpperFirst = exports.stringLowerFirst = void 0;
+const camelCase_js_1 = require("./camelCase.js");
+/** @internal */
+function converter(map) {
+    return (value) => value
+        ? map[value.charCodeAt(0)] + value.slice(1)
+        : '';
+}
+/**
+ * @name stringLowerFirst
+ * @summary Lowercase the first letter of a string
+ * @description
+ * Lowercase the first letter of a string
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringLowerFirst } from '@pezkuwi/util';
+ *
+ * stringLowerFirst('ABC'); // => 'aBC'
+ * ```
+ */
+exports.stringLowerFirst = converter(camelCase_js_1.CC_TO_LO);
+/**
+ * @name stringUpperFirst
+ * @summary Uppercase the first letter of a string
+ * @description
+ * Lowercase the first letter of a string
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringUpperFirst } from '@pezkuwi/util';
+ *
+ * stringUpperFirst('abc'); // => 'Abc'
+ * ```
+ */
+exports.stringUpperFirst = converter(camelCase_js_1.CC_TO_UP);

package/cjs/string/shorten.d.ts

@@ -0,0 +1,16 @@
+import type { AnyString } from '../types.js';
+/**
+ * @name stringShorten
+ * @summary Returns a string with maximum length
+ * @description
+ * Checks the string against the `prefixLength`, if longer than double this, shortens it by placing `..` in the middle of it
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringShorten } from '@polkadot/util';
+ *
+ * stringShorten('1234567890', 2); // => 12..90
+ * ```
+ */
+export declare function stringShorten(value: AnyString, prefixLength?: number): string;

package/{src/string/shorten.ts → cjs/string/shorten.js}

@@ -1,8 +1,6 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AnyString } from '../types.js';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringShorten = stringShorten;
 /**
  * @name stringShorten
  * @summary Returns a string with maximum length
@@ -17,8 +15,8 @@ import type { AnyString } from '../types.js';
  * stringShorten('1234567890', 2); // => 12..90
  * ```
  */
-export function stringShorten (value: AnyString, prefixLength = 6): string {
-  return value.length <= 2 + 2 * prefixLength
-    ? value.toString()
-    : `${value.substring(0, prefixLength)}…${value.slice(-prefixLength)}`;
+function stringShorten(value, prefixLength = 6) {
+    return value.length <= 2 + 2 * prefixLength
+        ? value.toString()
+        : `${value.substring(0, prefixLength)}…${value.slice(-prefixLength)}`;
 }

package/cjs/string/toHex.d.ts

@@ -0,0 +1,16 @@
+import type { AnyString, HexString } from '../types.js';
+/**
+ * @name stringToHex
+ * @summary Creates a hex string from a utf-8 string
+ * @description
+ * String input values return the actual encoded hex value.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringToHex } from '@polkadot/util';
+ *
+ * stringToU8a('hello'); // 0x68656c6c6f
+ * ```
+ */
+export declare function stringToHex(value?: AnyString): HexString;

package/cjs/string/toHex.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToHex = stringToHex;
+const toHex_js_1 = require("../u8a/toHex.js");
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name stringToHex
+ * @summary Creates a hex string from a utf-8 string
+ * @description
+ * String input values return the actual encoded hex value.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringToHex } from '@pezkuwi/util';
+ *
+ * stringToU8a('hello'); // 0x68656c6c6f
+ * ```
+ */
+function stringToHex(value) {
+    return (0, toHex_js_1.u8aToHex)((0, toU8a_js_1.stringToU8a)(value));
+}

package/cjs/string/toU8a.d.ts

@@ -0,0 +1,16 @@
+import type { AnyString } from '../types.js';
+/**
+ * @name stringToU8a
+ * @summary Creates a Uint8Array object from a utf-8 string.
+ * @description
+ * String input values return the actual encoded `UInt8Array`. `null` or `undefined` values returns an empty encoded array.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringToU8a } from '@polkadot/util';
+ *
+ * stringToU8a('hello'); // [0x68, 0x65, 0x6c, 0x6c, 0x6f]
+ * ```
+ */
+export declare function stringToU8a(value?: AnyString | null): Uint8Array;

package/cjs/string/toU8a.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToU8a = stringToU8a;
+const x_textencoder_1 = require("@pezkuwi/x-textencoder");
+const encoder = new x_textencoder_1.TextEncoder();
+/**
+ * @name stringToU8a
+ * @summary Creates a Uint8Array object from a utf-8 string.
+ * @description
+ * String input values return the actual encoded `UInt8Array`. `null` or `undefined` values returns an empty encoded array.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { stringToU8a } from '@pezkuwi/util';
+ *
+ * stringToU8a('hello'); // [0x68, 0x65, 0x6c, 0x6c, 0x6f]
+ * ```
+ */
+function stringToU8a(value) {
+    return value
+        ? encoder.encode(value.toString())
+        : new Uint8Array();
+}

package/cjs/stringify.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @name stringify
+ * @summary Performs a JSON.stringify, with BigInt handling
+ * @description A wrapper for JSON.stringify that handles BigInt values transparently, converting them to string. No differences from the native JSON.stringify function otherwise.
+ */
+export declare function stringify(value: unknown, space?: string | number): string;

package/cjs/stringify.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+const bigInt_js_1 = require("./is/bigInt.js");
+/** @internal */
+function replacer(_, v) {
+    return (0, bigInt_js_1.isBigInt)(v)
+        ? v.toString()
+        : v;
+}
+/**
+ * @name stringify
+ * @summary Performs a JSON.stringify, with BigInt handling
+ * @description A wrapper for JSON.stringify that handles BigInt values transparently, converting them to string. No differences from the native JSON.stringify function otherwise.
+ */
+function stringify(value, space) {
+    return JSON.stringify(value, replacer, space);
+}

package/cjs/types.d.ts

@@ -0,0 +1,62 @@
+import type { BN } from './bn/bn.js';
+/** An interface that defines an actual JS class */
+export interface Class<T = any, A extends unknown[] = any[]> {
+    prototype: T;
+    new (...args: A): T;
+    hasOwnProperty(prop: string): boolean;
+    isPrototypeOf(other: unknown): boolean;
+}
+export type Constructor<T = any, A extends unknown[] = any[]> = Class<T, A>;
+export interface ToBigInt {
+    toBigInt: () => bigint;
+}
+export interface ToBn {
+    toBn: () => BN;
+}
+export interface SiDef {
+    power: number;
+    text: string;
+    value: string;
+}
+export interface Logger {
+    debug: (...values: unknown[]) => void;
+    error: (...values: unknown[]) => void;
+    log: (...values: unknown[]) => void;
+    noop: (...values: unknown[]) => void;
+    warn: (...values: unknown[]) => void;
+}
+export interface ToBnOptions {
+    /** Convert in LE format */
+    isLe?: boolean;
+    /** Number is signed, apply two's complement */
+    isNegative?: boolean;
+}
+export interface NumberOptions extends ToBnOptions {
+    /** Limit to the specified bitLength, despite input length */
+    bitLength?: number;
+}
+export interface Time {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+}
+export type Memoized<F> = F & {
+    unmemoize: (...args: unknown[]) => void;
+};
+export type AnyString = string | String;
+export type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f';
+export type HexString = `0x${string}`;
+export interface BufferObject extends Uint8Array {
+    equals: (otherBuffer: Uint8Array) => boolean;
+    readDoubleLE: (offset?: number) => number;
+}
+export interface BufferClass extends Class<BufferObject> {
+    from: <T = BufferObject>(value: unknown) => T;
+    isBuffer: (value: unknown) => boolean;
+}
+export type U8aLike = number[] | Uint8Array | AnyString;
+export interface Observable {
+    next: (...params: unknown[]) => unknown;
+}

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/u8a/cmp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @name u8aCmp
+ * @summary Compares two Uint8Arrays for sorting.
+ * @description
+ * For `UInt8Array` (or hex string) input values returning -1, 0 or +1
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aCmp } from '@polkadot/util';
+ *
+ * u8aCmp(new Uint8Array([0x67, 0x65]), new Uint8Array([0x68, 0x65])); // -1
+ * u8aCmp(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // 0
+ * u8aCmp(new Uint8Array([0x69, 0x65]), new Uint8Array([0x68, 0x65])); // +1
+ * ```
+ */
+export declare function u8aCmp(a: string | Uint8Array, b: string | Uint8Array): number;

package/cjs/u8a/cmp.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8aCmp = u8aCmp;
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name u8aCmp
+ * @summary Compares two Uint8Arrays for sorting.
+ * @description
+ * For `UInt8Array` (or hex string) input values returning -1, 0 or +1
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aCmp } from '@pezkuwi/util';
+ *
+ * u8aCmp(new Uint8Array([0x67, 0x65]), new Uint8Array([0x68, 0x65])); // -1
+ * u8aCmp(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // 0
+ * u8aCmp(new Uint8Array([0x69, 0x65]), new Uint8Array([0x68, 0x65])); // +1
+ * ```
+ */
+function u8aCmp(a, b) {
+    const u8aa = (0, toU8a_js_1.u8aToU8a)(a);
+    const u8ab = (0, toU8a_js_1.u8aToU8a)(b);
+    let i = 0;
+    while (true) {
+        const overA = i >= u8aa.length;
+        const overB = i >= u8ab.length;
+        if (overA && overB) {
+            // both ends reached
+            return 0;
+        }
+        else if (overA) {
+            // a has no more data, b has data
+            return -1;
+        }
+        else if (overB) {
+            // b has no more data, a has data
+            return 1;
+        }
+        else if (u8aa[i] !== u8ab[i]) {
+            // the number in this index doesn't match
+            // (we don't use u8aa[i] - u8ab[i] since that doesn't match with localeCompare)
+            return u8aa[i] > u8ab[i]
+                ? 1
+                : -1;
+        }
+        i++;
+    }
+}

package/cjs/u8a/concat.d.ts

@@ -0,0 +1,24 @@
+import type { U8aLike } from '../types.js';
+/**
+ * @name u8aConcat
+ * @summary Creates a concatenated Uint8Array from the inputs.
+ * @description
+ * Concatenates the input arrays into a single `UInt8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { { u8aConcat } from '@polkadot/util';
+ *
+ * u8aConcat(
+ *   new Uint8Array([1, 2, 3]),
+ *   new Uint8Array([4, 5, 6])
+ * ); // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+export declare function u8aConcat(...list: readonly U8aLike[]): Uint8Array;
+/**
+ * @name u8aConcatStrict
+ * @description A strict version of [[u8aConcat]], accepting only Uint8Array inputs
+ */
+export declare function u8aConcatStrict(u8as: readonly Uint8Array[], length?: number): Uint8Array;

package/cjs/u8a/concat.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8aConcat = u8aConcat;
+exports.u8aConcatStrict = u8aConcatStrict;
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name u8aConcat
+ * @summary Creates a concatenated Uint8Array from the inputs.
+ * @description
+ * Concatenates the input arrays into a single `UInt8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { { u8aConcat } from '@pezkuwi/util';
+ *
+ * u8aConcat(
+ *   new Uint8Array([1, 2, 3]),
+ *   new Uint8Array([4, 5, 6])
+ * ); // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+function u8aConcat(...list) {
+    const count = list.length;
+    const u8as = new Array(count);
+    let length = 0;
+    for (let i = 0; i < count; i++) {
+        u8as[i] = (0, toU8a_js_1.u8aToU8a)(list[i]);
+        length += u8as[i].length;
+    }
+    return u8aConcatStrict(u8as, length);
+}
+/**
+ * @name u8aConcatStrict
+ * @description A strict version of [[u8aConcat]], accepting only Uint8Array inputs
+ */
+function u8aConcatStrict(u8as, length = 0) {
+    const count = u8as.length;
+    let offset = 0;
+    if (!length) {
+        for (let i = 0; i < count; i++) {
+            length += u8as[i].length;
+        }
+    }
+    const result = new Uint8Array(length);
+    for (let i = 0; i < count; i++) {
+        result.set(u8as[i], offset);
+        offset += u8as[i].length;
+    }
+    return result;
+}

package/cjs/u8a/concatBuffer.d.ts

@@ -0,0 +1,19 @@
+import type { U8aLike } from '../types.js';
+/**
+ * @name u8aConcat
+ * @summary Creates a concatenated Uint8Array from the inputs.
+ * @description
+ * Concatenates the input arrays into a single `UInt8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { { u8aConcat } from '@polkadot/util';
+ *
+ * u8aConcat(
+ *   new Uint8Array([1, 2, 3]),
+ *   new Uint8Array([4, 5, 6])
+ * ); // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+export declare function u8aConcat(...list: readonly U8aLike[]): Uint8Array;

package/cjs/u8a/concatBuffer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8aConcat = u8aConcat;
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name u8aConcat
+ * @summary Creates a concatenated Uint8Array from the inputs.
+ * @description
+ * Concatenates the input arrays into a single `UInt8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { { u8aConcat } from '@pezkuwi/util';
+ *
+ * u8aConcat(
+ *   new Uint8Array([1, 2, 3]),
+ *   new Uint8Array([4, 5, 6])
+ * ); // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+function u8aConcat(...list) {
+    const count = list.length;
+    const u8as = new Array(count);
+    for (let i = 0; i < count; i++) {
+        u8as[i] = (0, toU8a_js_1.u8aToU8a)(list[i]);
+    }
+    return Uint8Array.from(Buffer.concat(u8as));
+}

package/cjs/u8a/empty.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @name u8aEmpty
+ * @summary Tests for a `Uint8Array` for emptyness
+ * @description
+ * Checks to see if the input `Uint8Array` has zero length or contains all 0 values.
+ */
+export declare function u8aEmpty(value: Uint8Array): boolean;

package/cjs/u8a/empty.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8aEmpty = u8aEmpty;
+/**
+ * @name u8aEmpty
+ * @summary Tests for a `Uint8Array` for emptyness
+ * @description
+ * Checks to see if the input `Uint8Array` has zero length or contains all 0 values.
+ */
+function u8aEmpty(value) {
+    const len = value.length | 0;
+    // on smaller sizes, the byte-by-byte compare is faster than allocating
+    // another object for DataView (on very large arrays the DataView is faster)
+    for (let i = 0; i < len; i++) {
+        if (value[i] | 0) {
+            return false;
+        }
+    }
+    return true;
+}

package/cjs/u8a/eq.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name u8aEq
+ * @summary Compares two Uint8Arrays for equality.
+ * @description
+ * For `UInt8Array` (or hex string) input values true if there is a match.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aEq } from '@polkadot/util';
+ *
+ * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
+ * ```
+ */
+export declare function u8aEq(a: string | Uint8Array, b: string | Uint8Array): boolean;

package/cjs/u8a/eq.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8aEq = u8aEq;
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name u8aEq
+ * @summary Compares two Uint8Arrays for equality.
+ * @description
+ * For `UInt8Array` (or hex string) input values true if there is a match.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aEq } from '@pezkuwi/util';
+ *
+ * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
+ * ```
+ */
+function u8aEq(a, b) {
+    const u8aa = (0, toU8a_js_1.u8aToU8a)(a);
+    const u8ab = (0, toU8a_js_1.u8aToU8a)(b);
+    if (u8aa.length === u8ab.length) {
+        const dvA = new DataView(u8aa.buffer, u8aa.byteOffset);
+        const dvB = new DataView(u8ab.buffer, u8ab.byteOffset);
+        const mod = (u8aa.length % 4) | 0;
+        const length = (u8aa.length - mod) | 0;
+        for (let i = 0; i < length; i += 4) {
+            if (dvA.getUint32(i) !== dvB.getUint32(i)) {
+                return false;
+            }
+        }
+        for (let i = length, count = u8aa.length; i < count; i++) {
+            if (u8aa[i] !== u8ab[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/cjs/u8a/fixLength.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @name u8aFixLength
+ * @summary Shifts a Uint8Array to a specific bitLength
+ * @description
+ * Returns a uint8Array with the specified number of bits contained in the return value. (If bitLength is -1, length checking is not done). Values with more bits are trimmed to the specified length.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aFixLength } from '@polkadot/util';
+ *
+ * u8aFixLength('0x12') // => 0x12
+ * u8aFixLength('0x12', 16) // => 0x0012
+ * u8aFixLength('0x1234', 8) // => 0x12
+ * ```
+ */
+export declare function u8aFixLength(value: Uint8Array, bitLength?: number, atStart?: boolean): Uint8Array;

package/cjs/u8a/fixLength.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8aFixLength = u8aFixLength;
+/**
+ * @name u8aFixLength
+ * @summary Shifts a Uint8Array to a specific bitLength
+ * @description
+ * Returns a uint8Array with the specified number of bits contained in the return value. (If bitLength is -1, length checking is not done). Values with more bits are trimmed to the specified length.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aFixLength } from '@pezkuwi/util';
+ *
+ * u8aFixLength('0x12') // => 0x12
+ * u8aFixLength('0x12', 16) // => 0x0012
+ * u8aFixLength('0x1234', 8) // => 0x12
+ * ```
+ */
+function u8aFixLength(value, bitLength = -1, atStart = false) {
+    const byteLength = Math.ceil(bitLength / 8);
+    if (bitLength === -1 || value.length === byteLength) {
+        return value;
+    }
+    else if (value.length > byteLength) {
+        return value.subarray(0, byteLength);
+    }
+    const result = new Uint8Array(byteLength);
+    result.set(value, atStart ? 0 : (byteLength - value.length));
+    return result;
+}

package/{src/u8a/index.ts → cjs/u8a/index.d.ts}

@@ -1,10 +1,6 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Utility methods to convert to and from `Uint8Array` objects
  */
-
 export { u8aCmp } from './cmp.js';
 export { u8aConcat, u8aConcatStrict } from './concat.js';
 export { u8aEmpty } from './empty.js';