@pezkuwi/util 14.0.22 → 14.0.23

package/build-tsc-esm/object/keys.js

@@ -0,0 +1,7 @@
+/**
+ * @name objectKeys
+ * @summary A version of Object.keys that is typed for TS
+ */
+export function objectKeys(value) {
+    return Object.keys(value);
+}

package/build-tsc-esm/object/property.js

@@ -0,0 +1,34 @@
+/**
+ * @name objectProperty
+ * @summary Assign a get property on the input object
+ */
+export function objectProperty(that, key, getter, getName, index = 0) {
+    const name = getName
+        ? getName(key, index)
+        : key;
+    // There are 3 approaches here -
+    //  - Object.prototype.hasOwnProperty.call(that, key) - this only checks the current class, i.e
+    //    will retuirn false if the property is set in the parent class
+    //  - isUndefined(...) - this may yield a false positive when the property is there, but not set.
+    //    Additionally, on pre-defined getters it may make a call
+    //  - key in that - Does not need to be combined with either of the above and checks the full chain
+    if (!(name in that)) {
+        Object.defineProperty(that, name, {
+            enumerable: true,
+            // Unlike in lazy, we always call into the upper function, i.e. this method
+            // does not cache old values (it is expected to be used for dynamic values)
+            get: function () {
+                return getter(key, index, this);
+            }
+        });
+    }
+}
+/**
+ * @name objectProperties
+ * @summary Assign get properties on the input object
+ */
+export function objectProperties(that, keys, getter, getName) {
+    for (let i = 0, count = keys.length; i < count; i++) {
+        objectProperty(that, keys[i], getter, getName, i);
+    }
+}

package/build-tsc-esm/object/spread.js

@@ -0,0 +1,31 @@
+/**
+ * @name objectSpread
+ * @summary Concats all sources into the destination
+ * @description Spreads object properties while maintaining object integrity
+ */
+export function objectSpread(dest, ...sources) {
+    const filterProps = new Set(['__proto__', 'constructor', 'prototype']);
+    for (let i = 0, count = sources.length; i < count; i++) {
+        const src = sources[i];
+        if (src) {
+            if (typeof src.entries === 'function') {
+                for (const [key, value] of src.entries()) {
+                    if (!filterProps.has(key)) {
+                        dest[key] = value;
+                    }
+                }
+            }
+            else {
+                // Create a clean copy of the source object
+                const sanitizedSrc = Object.create(null);
+                for (const [key, value] of Object.entries(src)) {
+                    if (!filterProps.has(key)) {
+                        sanitizedSrc[key] = value;
+                    }
+                }
+                Object.assign(dest, sanitizedSrc);
+            }
+        }
+    }
+    return dest;
+}

package/build-tsc-esm/object/values.js

@@ -0,0 +1,7 @@
+/**
+ * @name objectValues
+ * @summary A version of Object.values that is typed for TS
+ */
+export function objectValues(obj) {
+    return Object.values(obj);
+}

package/build-tsc-esm/packageDetect.js

@@ -0,0 +1,5 @@
+import { packageInfo as decoderInfo } from '@pezkuwi/x-textdecoder';
+import { packageInfo as encoderInfo } from '@pezkuwi/x-textencoder';
+import { detectPackage } from './detectPackage.js';
+import { packageInfo } from './packageInfo.js';
+detectPackage(packageInfo, null, [decoderInfo, encoderInfo]);

package/build-tsc-esm/packageInfo.js

@@ -0,0 +1 @@
+export const packageInfo = { name: '@pezkuwi/util', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.23' };

package/build-tsc-esm/promisify.js

@@ -0,0 +1,27 @@
+/**
+ * @name promisify
+ * @summary Wraps an async callback into a `Promise`
+ * @description
+ * Wraps the supplied async function `fn` that has a standard JS callback `(error: Error, result: any)` into a `Promise`, passing the supplied parameters. When `error` is set, the Promise is rejected, else the Promise resolves with the `result` value.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * const { promisify } from '@pezkuwi/util';
+ *
+ * await promisify(null, ((a, cb) => cb(null, a), true); // resolves with `true`
+ * await promisify(null, (cb) => cb(new Error('error!'))); // rejects with `error!`
+ * ```
+ */
+export function promisify(self, fn, ...params) {
+    return new Promise((resolve, reject) => {
+        fn.apply(self, params.concat((error, result) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(result);
+            }
+        }));
+    });
+}

package/build-tsc-esm/string/camelCase.js

@@ -0,0 +1,59 @@
+export const CC_TO_UP = new Array(256);
+export const CC_TO_LO = new Array(256);
+for (let i = 0, count = CC_TO_UP.length; i < count; i++) {
+    CC_TO_LO[i] = String.fromCharCode(i).toLowerCase();
+    CC_TO_UP[i] = String.fromCharCode(i).toUpperCase();
+}
+/** @internal */
+function formatAllCaps(w) {
+    return w.slice(0, w.length - 1).toLowerCase() + CC_TO_UP[w.charCodeAt(w.length - 1)];
+}
+/**
+ * @internal
+ *
+ * Inspired by https://stackoverflow.com/a/2970667
+ *
+ * This is not as optimal as the original SO answer (we split into per-word),
+ * however it does pass the tests (which the SO version doesn't) and is still
+ * a major improvement over the original camelcase npm package -
+ *
+ *   camelcase: 20.88 μs/op
+ *        this:  1.00 μs/op
+ *
+ * Caveat of this: only Ascii, but acceptable for the intended usecase
+ */
+function converter(format) {
+    return (value) => {
+        const parts = value
+            // replace all separators (including consequtive) with spaces
+            .replace(/[-_., ]+/g, ' ')
+            // we don't want leading or trailing spaces
+            .trim()
+            // split into words
+            .split(' ');
+        let result = '';
+        for (let i = 0, count = parts.length; i < count; i++) {
+            const w = parts[i];
+            // apply the formatting
+            result += format(/^[\dA-Z]+$/.test(w)
+                // all full uppercase + letters are changed to lowercase
+                ? w.toLowerCase()
+                // all consecutive capitals + letters are changed to lowercase
+                // e.g. UUID64 -> uuid64, while preserving splits, eg. NFTOrder -> nftOrder
+                : w.replace(/^[\dA-Z]{2,}[^a-z]/, formatAllCaps), i);
+        }
+        return result;
+    };
+}
+/**
+ * @name stringCamelCase
+ * @summary Convert a dash/dot/underscore/space separated Ascii string/String to camelCase
+ */
+export const stringCamelCase = /*#__PURE__*/ converter((w, i) => 
+(i ? CC_TO_UP[w.charCodeAt(0)] : CC_TO_LO[w.charCodeAt(0)]) + w.slice(1));
+/**
+ * @name stringPascalCase
+ * @summary Convert a dash/dot/underscore/space separated Ascii string/String to PascalCase
+ */
+export const stringPascalCase = /*#__PURE__*/ converter((w) => 
+CC_TO_UP[w.charCodeAt(0)] + w.slice(1));

package/build-tsc-esm/string/index.js

@@ -0,0 +1,8 @@
+/**
+ * @summary Utility methods to convert to work with `string` values
+ */
+export { stringCamelCase, stringPascalCase } from './camelCase.js';
+export { stringLowerFirst, stringUpperFirst } from './lowerFirst.js';
+export { stringShorten } from './shorten.js';
+export { stringToHex } from './toHex.js';
+export { stringToU8a } from './toU8a.js';

package/build-tsc-esm/string/lowerFirst.js

@@ -0,0 +1,37 @@
+import { CC_TO_LO, CC_TO_UP } from './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'
+ * ```
+ */
+export const stringLowerFirst = /*#__PURE__*/ converter(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'
+ * ```
+ */
+export const stringUpperFirst = /*#__PURE__*/ converter(CC_TO_UP);

package/build-tsc-esm/string/shorten.js

@@ -0,0 +1,19 @@
+/**
+ * @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 '@pezkuwi/util';
+ *
+ * stringShorten('1234567890', 2); // => 12..90
+ * ```
+ */
+export function stringShorten(value, prefixLength = 6) {
+    return value.length <= 2 + 2 * prefixLength
+        ? value.toString()
+        : `${value.substring(0, prefixLength)}…${value.slice(-prefixLength)}`;
+}

package/build-tsc-esm/string/toHex.js

@@ -0,0 +1,19 @@
+import { u8aToHex } from '../u8a/toHex.js';
+import { stringToU8a } from './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
+ * ```
+ */
+export function stringToHex(value) {
+    return u8aToHex(stringToU8a(value));
+}

package/build-tsc-esm/string/toU8a.js

@@ -0,0 +1,21 @@
+import { TextEncoder } from '@pezkuwi/x-textencoder';
+const encoder = new 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]
+ * ```
+ */
+export function stringToU8a(value) {
+    return value
+        ? encoder.encode(value.toString())
+        : new Uint8Array();
+}

package/build-tsc-esm/stringify.js

@@ -0,0 +1,15 @@
+import { isBigInt } from './is/bigInt.js';
+/** @internal */
+function replacer(_, v) {
+    return 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.
+ */
+export function stringify(value, space) {
+    return JSON.stringify(value, replacer, space);
+}

package/build-tsc-esm/types.js

@@ -0,0 +1 @@
+export {};

package/build-tsc-esm/u8a/cmp.js

@@ -0,0 +1,46 @@
+import { u8aToU8a } from './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
+ * ```
+ */
+export function u8aCmp(a, b) {
+    const u8aa = u8aToU8a(a);
+    const u8ab = 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/build-tsc-esm/u8a/concat.js

@@ -0,0 +1,47 @@
+import { u8aToU8a } from './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]
+ * ```
+ */
+export function u8aConcat(...list) {
+    const count = list.length;
+    const u8as = new Array(count);
+    let length = 0;
+    for (let i = 0; i < count; i++) {
+        u8as[i] = u8aToU8a(list[i]);
+        length += u8as[i].length;
+    }
+    return u8aConcatStrict(u8as, length);
+}
+/**
+ * @name u8aConcatStrict
+ * @description A strict version of [[u8aConcat]], accepting only Uint8Array inputs
+ */
+export 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/build-tsc-esm/u8a/concatBuffer.js

@@ -0,0 +1,26 @@
+import { u8aToU8a } from './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]
+ * ```
+ */
+export function u8aConcat(...list) {
+    const count = list.length;
+    const u8as = new Array(count);
+    for (let i = 0; i < count; i++) {
+        u8as[i] = u8aToU8a(list[i]);
+    }
+    return Uint8Array.from(Buffer.concat(u8as));
+}

package/build-tsc-esm/u8a/empty.js

@@ -0,0 +1,17 @@
+/**
+ * @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 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/build-tsc-esm/u8a/eq.js

@@ -0,0 +1,37 @@
+import { u8aToU8a } from './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
+ * ```
+ */
+export function u8aEq(a, b) {
+    const u8aa = u8aToU8a(a);
+    const u8ab = 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/build-tsc-esm/u8a/fixLength.js

@@ -0,0 +1,28 @@
+/**
+ * @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
+ * ```
+ */
+export 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/build-tsc-esm/u8a/index.js

@@ -0,0 +1,18 @@
+/**
+ * @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';
+export { u8aEq } from './eq.js';
+export { u8aFixLength } from './fixLength.js';
+export { u8aSorted } from './sorted.js';
+export { u8aToBigInt } from './toBigInt.js';
+export { u8aToBn } from './toBn.js';
+export { u8aToBuffer } from './toBuffer.js';
+export { u8aToFloat } from './toFloat.js';
+export { u8aToHex } from './toHex.js';
+export { u8aToNumber } from './toNumber.js';
+export { u8aToString } from './toString.js';
+export { u8aToU8a } from './toU8a.js';
+export { U8A_WRAP_ETHEREUM, U8A_WRAP_POSTFIX, U8A_WRAP_PREFIX, u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from './wrap.js';

package/build-tsc-esm/u8a/sorted.js

@@ -0,0 +1,18 @@
+import { u8aCmp } from './cmp.js';
+/**
+ * @name u8aSorted
+ * @summary Sorts an array of Uint8Arrays
+ * @description
+ * For input `UInt8Array[]` return the sorted result
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aSorted} from '@pezkuwi/util';
+ *
+ * u8aSorted([new Uint8Array([0x69]), new Uint8Array([0x68])]); // [0x68, 0x69]
+ * ```
+ */
+export function u8aSorted(u8as) {
+    return u8as.sort(u8aCmp);
+}

package/build-tsc-esm/u8a/toBigInt.js

@@ -0,0 +1,70 @@
+import { BigInt } from '@pezkuwi/x-bigint';
+import { _1n } from '../bi/consts.js';
+const U8_MAX = BigInt(256);
+const U16_MAX = BigInt(256 * 256);
+const U64_MAX = BigInt('0x10000000000000000');
+/**
+ * @name u8aToBigInt
+ * @summary Creates a BigInt from a Uint8Array object.
+ */
+export function u8aToBigInt(value, { isLe = true, isNegative = false } = {}) {
+    // slice + reverse is expensive, however SCALE is LE by default so this is the path
+    // we are most interested in (the BE is added for the sake of being comprehensive)
+    if (!isLe) {
+        value = value.slice().reverse();
+    }
+    const count = value.length;
+    if (isNegative && count && (value[count - 1] & 0x80)) {
+        switch (count) {
+            case 0:
+                return BigInt(0);
+            case 1:
+                return BigInt(((value[0] ^ 0x0000_00ff) * -1) - 1);
+            case 2:
+                return BigInt((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+            case 4:
+                return BigInt((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+        }
+        const dvI = new DataView(value.buffer, value.byteOffset);
+        if (count === 8) {
+            return dvI.getBigInt64(0, true);
+        }
+        let result = BigInt(0);
+        const mod = count % 2;
+        for (let i = count - 2; i >= mod; i -= 2) {
+            result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true) ^ 0xffff);
+        }
+        if (mod) {
+            result = (result * U8_MAX) + BigInt(value[0] ^ 0xff);
+        }
+        return (result * -_1n) - _1n;
+    }
+    switch (count) {
+        case 0:
+            return BigInt(0);
+        case 1:
+            return BigInt(value[0]);
+        case 2:
+            return BigInt(value[0] + (value[1] << 8));
+        case 4:
+            return BigInt(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+    }
+    const dvI = new DataView(value.buffer, value.byteOffset);
+    switch (count) {
+        case 8:
+            return dvI.getBigUint64(0, true);
+        case 16:
+            return (dvI.getBigUint64(8, true) * U64_MAX) + dvI.getBigUint64(0, true);
+        default: {
+            let result = BigInt(0);
+            const mod = count % 2;
+            for (let i = count - 2; i >= mod; i -= 2) {
+                result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true));
+            }
+            if (mod) {
+                result = (result * U8_MAX) + BigInt(value[0]);
+            }
+            return result;
+        }
+    }
+}