@pezkuwi/types-codec 16.5.8 → 16.5.9

package/build/cjs/utils/sanitize.d.ts

@@ -1,15 +0,0 @@
-import type { AnyString } from '../types/index.js';
-type Mapper = (value: string) => string;
-export declare function trim(): Mapper;
-export declare function findClosing(value: string, start: number): number;
-export declare function alias(src: string, dest: string, withChecks?: boolean): Mapper;
-export declare function cleanupCompact(): Mapper;
-export declare function flattenSingleTuple(): Mapper;
-export declare function removeExtensions(type: string, isSized: boolean): Mapper;
-export declare function removeColons(): Mapper;
-export declare function removeGenerics(): Mapper;
-export declare function removePairOf(): Mapper;
-export declare function removeTraits(): Mapper;
-export declare function removeWrap(check: string): Mapper;
-export declare function sanitize(value: AnyString): string;
-export {};

package/build/cjs/utils/sanitize.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trim = trim;
-exports.findClosing = findClosing;
-exports.alias = alias;
-exports.cleanupCompact = cleanupCompact;
-exports.flattenSingleTuple = flattenSingleTuple;
-exports.removeExtensions = removeExtensions;
-exports.removeColons = removeColons;
-exports.removeGenerics = removeGenerics;
-exports.removePairOf = removePairOf;
-exports.removeTraits = removeTraits;
-exports.removeWrap = removeWrap;
-exports.sanitize = sanitize;
-const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
-const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
-const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
-const mappings = [
-    // alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
-    alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false),
-    alias('VecDeque<', 'Vec<', false),
-    // <T::Balance as HasCompact>
-    cleanupCompact(),
-    // Change BoundedVec<Type, Size> to Vec<Type>
-    removeExtensions('Bounded', true),
-    // Change WeakVec<Type> to Vec<Type>
-    removeExtensions('Weak', false),
-    // Remove all the trait prefixes
-    removeTraits(),
-    // remove PairOf<T> -> (T, T)
-    removePairOf(),
-    // remove boxing, `Box<Proposal>` -> `Proposal`
-    removeWrap('Box<'),
-    // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
-    removeGenerics(),
-    // alias String -> Text (compat with jsonrpc methods)
-    alias('String', 'Text'),
-    // alias Vec<u8> -> Bytes
-    alias('Vec<u8>', 'Bytes'),
-    alias('&\\[u8\\]', 'Bytes'),
-    alias("&'static\\[u8\\]", 'Bytes'),
-    // alias RawAddress -> Address
-    alias('RawAddress', 'Address'),
-    // lookups, mapped to Address/AccountId as appropriate in runtime
-    alias('Lookup::Source', 'LookupSource'),
-    alias('Lookup::Target', 'LookupTarget'),
-    // HACK duplication between contracts & primitives, however contracts prefixed with exec
-    alias('exec::StorageKey', 'ContractStorageKey'),
-    // flattens tuples with one value, `(AccountId)` -> `AccountId`
-    flattenSingleTuple(),
-    // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
-    removeColons(),
-    // remove all trailing spaces - this should always be the last
-    trim()
-];
-function trim() {
-    return (value) => value.trim();
-}
-function findClosing(value, start) {
-    let depth = 0;
-    for (let i = start, count = value.length; i < count; i++) {
-        if (value[i] === '>') {
-            if (!depth) {
-                return i;
-            }
-            depth--;
-        }
-        else if (value[i] === '<') {
-            depth++;
-        }
-    }
-    throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
-}
-function alias(src, dest, withChecks = true) {
-    const from = new RegExp(`(^${src}|${BOX_PRECEDING.map((box) => `\\${box}${src}`).join('|')})`, 'g');
-    const to = (src) => {
-        from.lastIndex = 0;
-        return withChecks && BOX_PRECEDING.includes(src[0])
-            ? `${src[0]}${dest}`
-            : dest;
-    };
-    return (value) => value.replace(from, to);
-}
-function cleanupCompact() {
-    return (value) => {
-        if (value.includes(' as HasCompact')) {
-            for (let i = 0, count = value.length; i < count; i++) {
-                if (value[i] === '<') {
-                    const end = findClosing(value, i + 1) - 14;
-                    if (value.substring(end, end + 14) === ' as HasCompact') {
-                        value = `Compact<${value.substring(i + 1, end)}>`;
-                    }
-                }
-            }
-        }
-        return value;
-    };
-}
-function flattenSingleTuple() {
-    const from1 = /,\)/g;
-    const from2 = /\(([^,]+)\)/;
-    return (value) => {
-        from1.lastIndex = 0;
-        return value
-            // tuples may have trailing commas, e.g. (u32, BlockNumber, )
-            .replace(from1, ')')
-            // change (u32) -> u32
-            .replace(from2, '$1');
-    };
-}
-function replaceTagWith(value, matcher, replacer) {
-    let index = -1;
-    while (true) {
-        index = value.indexOf(matcher, index + 1);
-        if (index === -1) {
-            return value;
-        }
-        const start = index + matcher.length;
-        const end = findClosing(value, start);
-        value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
-    }
-}
-function removeExtensions(type, isSized) {
-    return (value) => {
-        for (let i = 0, count = BOUNDED.length; i < count; i++) {
-            const tag = BOUNDED[i];
-            value = replaceTagWith(value, `${type}${tag}<`, (v) => {
-                const parts = v
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter((s) => s);
-                if (isSized) {
-                    parts.pop();
-                }
-                return `${tag}<${parts.join(',')}>`;
-            });
-        }
-        return value;
-    };
-}
-function removeColons() {
-    return (value) => {
-        let index = 0;
-        while (index !== -1) {
-            index = value.indexOf('::');
-            if (index === 0) {
-                value = value.substring(2);
-            }
-            else if (index !== -1) {
-                let start = index;
-                while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
-                    start--;
-                }
-                value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
-            }
-        }
-        return value;
-    };
-}
-function removeGenerics() {
-    return (value) => {
-        for (let i = 0, count = value.length; i < count; i++) {
-            if (value[i] === '<') {
-                // check against the allowed wrappers, be it Vec<..>, Option<...> ...
-                const box = ALLOWED_BOXES.find((box) => {
-                    const start = i - box.length;
-                    return ((start >= 0 &&
-                        value.substring(start, i) === box) && (
-                    // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
-                    start === 0 ||
-                        BOX_PRECEDING.includes(value[start - 1])));
-                });
-                // we have not found anything, unwrap generic innards
-                if (!box) {
-                    const end = findClosing(value, i + 1);
-                    value = `${value.substring(0, i)}${value.substring(end + 1)}`;
-                }
-            }
-        }
-        return value;
-    };
-}
-function removePairOf() {
-    const replacer = (v) => `(${v},${v})`;
-    return (value) => replaceTagWith(value, 'PairOf<', replacer);
-}
-function removeTraits() {
-    const from1 = /\s/g;
-    const from2 = /(T|Self)::/g;
-    const from3 = /<(T|Self)asTrait>::/g;
-    const from4 = /<Tas[a-z]+::Trait>::/g;
-    const from5 = /<LookupasStaticLookup>/g;
-    const from6 = /::Type/g;
-    return (value) => {
-        from1.lastIndex = 0;
-        from2.lastIndex = 0;
-        from3.lastIndex = 0;
-        from4.lastIndex = 0;
-        from5.lastIndex = 0;
-        from6.lastIndex = 0;
-        return value
-            // remove all whitespaces
-            .replace(from1, '')
-            // anything `T::<type>` to end up as `<type>`
-            .replace(from2, '')
-            // replace `<T as Trait>::` (whitespaces were removed above)
-            .replace(from3, '')
-            // replace `<T as something::Trait>::` (whitespaces were removed above)
-            .replace(from4, '')
-            // replace <Lookup as StaticLookup>
-            .replace(from5, 'Lookup')
-            // replace `<...>::Type`
-            .replace(from6, '');
-    };
-}
-function removeWrap(check) {
-    const replacer = (v) => v;
-    return (value) => replaceTagWith(value, check, replacer);
-}
-const sanitizeMap = new Map();
-function sanitize(value) {
-    const startValue = value.toString();
-    const memoized = sanitizeMap.get(startValue);
-    if (memoized) {
-        return memoized;
-    }
-    let result = startValue;
-    for (let i = 0, count = mappings.length; i < count; i++) {
-        result = mappings[i](result);
-    }
-    sanitizeMap.set(startValue, result);
-    return result;
-}

package/build/cjs/utils/sortValues.d.ts

@@ -1,12 +0,0 @@
-import type { BN } from '@pezkuwi/util';
-import type { Codec } from '../types/index.js';
-type SortArg = Codec | Codec[] | number[] | BN | bigint | number | Uint8Array;
-/**
-* Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
-*/
-export declare function sortAsc<V extends SortArg = Codec>(a: V, b: V): number;
-export declare function sortSet<V extends Codec = Codec>(set: Set<V>): Set<V>;
-export declare function sortMap<K extends Codec = Codec, V extends Codec = Codec>(map: Map<K, V>): Map<K, V>;
-export {};

package/build/cjs/utils/sortValues.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortAsc = sortAsc;
-exports.sortSet = sortSet;
-exports.sortMap = sortMap;
-const util_1 = require("@pezkuwi/util");
-/** @internal **/
-function isArrayLike(arg) {
-    return arg instanceof Uint8Array || Array.isArray(arg);
-}
-/** @internal **/
-function isEnum(arg) {
-    return (0, util_1.isCodec)(arg) && (0, util_1.isNumber)(arg.index) && (0, util_1.isCodec)(arg.value);
-}
-/** @internal **/
-function isOption(arg) {
-    return (0, util_1.isCodec)(arg) && (0, util_1.isBoolean)(arg.isSome) && (0, util_1.isCodec)(arg.value);
-}
-/** @internal */
-function isNumberLike(arg) {
-    return (0, util_1.isNumber)(arg) || (0, util_1.isBn)(arg) || (0, util_1.isBigInt)(arg);
-}
-/** @internal */
-function sortArray(a, b) {
-    // Vec, Tuple, Bytes etc.
-    let sortRes = 0;
-    const minLen = Math.min(a.length, b.length);
-    for (let i = 0; i < minLen; ++i) {
-        sortRes = sortAsc(a[i], b[i]);
-        if (sortRes !== 0) {
-            return sortRes;
-        }
-    }
-    return a.length - b.length;
-}
-/** @internal */
-function checkForDuplicates(container, seen, arg) {
-    // Convert the value to hex.
-    if ((0, util_1.isCodec)(arg)) {
-        const hex = arg.toHex();
-        // Check if we have seen the value.
-        if (seen.has(hex)) {
-            // Duplicates are not allowed.
-            throw new Error(`Duplicate value in ${container}: ${(0, util_1.stringify)(arg)}`);
-        }
-        seen.add(hex);
-    }
-    return true;
-}
-/**
-* Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
-*/
-function sortAsc(a, b) {
-    if (isNumberLike(a) && isNumberLike(b)) {
-        return (0, util_1.bnToBn)(a).cmp((0, util_1.bnToBn)(b));
-    }
-    else if (a instanceof Map && b instanceof Map) {
-        return sortAsc(Array.from(a.values()), Array.from(b.values()));
-    }
-    else if (isEnum(a) && isEnum(b)) {
-        return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
-    }
-    else if (isOption(a) && isOption(b)) {
-        return sortAsc(a.isNone ? 0 : 1, b.isNone ? 0 : 1) || sortAsc(a.value, b.value);
-    }
-    else if (isArrayLike(a) && isArrayLike(b)) {
-        return sortArray(a, b);
-    }
-    else if ((0, util_1.isCodec)(a) && (0, util_1.isCodec)(b)) {
-        // Text, Bool etc.
-        return sortAsc(a.toU8a(true), b.toU8a(true));
-    }
-    throw new Error(`Attempting to sort unrecognized values: ${(0, util_1.stringify)(a)} (typeof ${typeof a}) <-> ${(0, util_1.stringify)(b)} (typeof ${typeof b})`);
-}
-function sortSet(set) {
-    const seen = new Set();
-    return new Set(Array.from(set).filter((value) => checkForDuplicates('BTreeSet', seen, value)).sort(sortAsc));
-}
-function sortMap(map) {
-    const seen = new Set();
-    return new Map(Array.from(map.entries()).filter(([key]) => checkForDuplicates('BTreeMap', seen, key)).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
-}

package/build/cjs/utils/toConstructors.d.ts

@@ -1,16 +0,0 @@
-import type { Codec, CodecClass, Registry } from '../types/index.js';
-/**
- * @internal
- * From a type string or class, return the associated type class
- */
-export declare function typeToConstructor<T extends Codec = Codec>(registry: Registry, type: string | CodecClass<T>): CodecClass<T>;
-/**
- * @internal
- * Takes an input array of types and returns the associated classes for it
-*/
-export declare function typesToConstructors<T extends Codec = Codec>(registry: Registry, types: (string | CodecClass<T>)[]): CodecClass<T>[];
-/**
- * @internal
- * Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
- */
-export declare function mapToTypeMap(registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]];

package/build/cjs/utils/toConstructors.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeToConstructor = typeToConstructor;
-exports.typesToConstructors = typesToConstructors;
-exports.mapToTypeMap = mapToTypeMap;
-/**
- * @internal
- * From a type string or class, return the associated type class
- */
-function typeToConstructor(registry, type) {
-    return typeof type === 'function'
-        ? type
-        : registry.createClassUnsafe(type);
-}
-/**
- * @internal
- * Takes an input array of types and returns the associated classes for it
-*/
-function typesToConstructors(registry, types) {
-    const count = types.length;
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-        result[i] = typeToConstructor(registry, types[i]);
-    }
-    return result;
-}
-/**
- * @internal
- * Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
- */
-function mapToTypeMap(registry, input) {
-    const entries = Object.entries(input);
-    const count = entries.length;
-    const output = [new Array(count), new Array(count)];
-    for (let i = 0; i < count; i++) {
-        output[1][i] = entries[i][0];
-        output[0][i] = typeToConstructor(registry, entries[i][1]);
-    }
-    return output;
-}

package/build/cjs/utils/typesToMap.d.ts

@@ -1,2 +0,0 @@
-import type { CodecClass, Registry } from '../types/index.js';
-export declare function typesToMap(registry: Registry, [Types, keys]: [CodecClass[], string[]]): Record<string, string>;

package/build/cjs/utils/typesToMap.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typesToMap = typesToMap;
-function typesToMap(registry, [Types, keys]) {
-    const result = {};
-    for (let i = 0, count = keys.length; i < count; i++) {
-        result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
-    }
-    return result;
-}

package/build/cjs/utils/util.d.ts

@@ -1,3 +0,0 @@
-export declare function hasEq(o: unknown): o is {
-    eq: (other: unknown) => boolean;
-};

package/build/cjs/utils/util.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasEq = hasEq;
-const util_1 = require("@pezkuwi/util");
-function hasEq(o) {
-    return (0, util_1.isFunction)(o.eq);
-}

package/build/extended/BTreeMap.d.ts

@@ -1,5 +0,0 @@
-import type { Codec, CodecClass } from '../types/index.js';
-import { CodecMap } from './Map.js';
-export declare class BTreeMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
-    static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
-}

package/build/extended/BTreeMap.js

@@ -1,10 +0,0 @@
-import { CodecMap } from './Map.js';
-export class BTreeMap extends CodecMap {
-    static with(keyType, valType) {
-        return class extends BTreeMap {
-            constructor(registry, value) {
-                super(registry, keyType, valType, value, 'BTreeMap');
-            }
-        };
-    }
-}

package/build/extended/BTreeSet.d.ts

@@ -1,64 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { AnyJson, Codec, CodecClass, Inspect, ISet, IU8a, Registry } from '../types/index.js';
-export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements ISet<V> {
-    #private;
-    readonly registry: Registry;
-    createdAtHash?: IU8a;
-    initialU8aLength?: number;
-    isStorageFallback?: boolean;
-    constructor(registry: Registry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
-    static with<V extends Codec>(valType: CodecClass<V> | string): CodecClass<BTreeSet<V>>;
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength(): number;
-    /**
-     * @description Returns a hash of the value
-     */
-    get hash(): IU8a;
-    /**
-     * @description Checks if the value is an empty value
-     */
-    get isEmpty(): boolean;
-    /**
-     * @description The actual set values as a string[]
-     */
-    get strings(): string[];
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other?: unknown): boolean;
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect(): Inspect;
-    /**
-     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
-     */
-    toHex(): HexString;
-    /**
-     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-     */
-    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON(): AnyJson;
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    toRawType(): string;
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(disableAscii?: boolean): AnyJson;
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString(): string;
-    /**
-     * @description Encodes the value as a Uint8Array as per the SCALE specifications
-     * @param isBare true when the value has none of the type-specific prefixes (internal)
-     */
-    toU8a(isBare?: boolean): Uint8Array;
-}