@pezkuwi/types-codec 16.5.8 → 16.5.9

package/build-deno/base/Option.ts

@@ -1,273 +0,0 @@
-
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { AnyJson, Codec, CodecClass, DefinitionSetter, Inspect, IOption, IU8a, Registry } from '../types/index.ts';
-
-import { identity, isCodec, isNull, isU8a, isUndefined, u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { typeToConstructor } from '../utils/index.ts';
-import { Null } from './Null.ts';
-
-class None extends Null {
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public override toRawType (): string {
-    return 'None';
-  }
-}
-
-/** @internal */
-function decodeOption (registry: Registry, Type: CodecClass, value?: unknown): Codec {
-  if (value instanceof Type) {
-    // don't re-create, use as it (which also caters for derived types)
-    return value;
-  } else if (value instanceof Option) {
-    if (value.value instanceof Type) {
-      // same instance, return it
-      return value.value;
-    } else if (value.isNone) {
-      // internal is None, we are also none
-      return new None(registry);
-    }
-
-    // convert the actual value into known
-    return new Type(registry, value.value);
-  } else if (isNull(value) || isUndefined(value) || value === '0x' || value instanceof None) {
-    // anything empty we pass as-is
-    return new None(registry);
-  } else if (isU8a(value)) {
-    // the isU8a check happens last in the if-tree - since the wrapped value
-    // may be an instance of it, so Type and Option checks go in first
-    return !value.length || value[0] === 0
-      ? new None(registry)
-      : new Type(registry, value.subarray(1));
-  }
-
-  return new Type(registry, value);
-}
-
-/**
- * @name Option
- * @description
- * An Option is an optional field. Basically the first byte indicates that there is
- * is value to follow. If the byte is `1` there is an actual value. So the Option
- * implements that - decodes, checks for optionality and wraps the required structure
- * with a value if/as required/found.
- */
-export class Option<T extends Codec> implements IOption<T> {
-  readonly registry: Registry;
-
-  public createdAtHash?: IU8a;
-  public initialU8aLength?: number;
-  public isStorageFallback?: boolean;
-
-  readonly #Type: CodecClass<T>;
-  readonly #raw: T;
-
-  constructor (registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { definition, setDefinition = identity }: DefinitionSetter<CodecClass<T>> = {}) {
-    const Type = definition || setDefinition(typeToConstructor(registry, typeName));
-    const decoded = isU8a(value) && value.length && !isCodec(value)
-      ? value[0] === 0
-        ? new None(registry)
-        : new Type(registry, value.subarray(1))
-      : decodeOption(registry, Type, value);
-
-    this.registry = registry;
-    this.#Type = Type;
-    this.#raw = decoded as T;
-
-    if (decoded?.initialU8aLength) {
-      this.initialU8aLength = 1 + decoded.initialU8aLength;
-    }
-  }
-
-  public static with<O extends Codec> (Type: CodecClass<O> | string): CodecClass<Option<O>> {
-    let definition: CodecClass<O> | undefined;
-
-    const setDefinition = <T> (d: CodecClass<T>): CodecClass<T> => {
-      definition = d as unknown as CodecClass<O>;
-
-      return d;
-    };
-
-    return class extends Option<O> {
-      constructor (registry: Registry, value?: unknown) {
-        super(registry, Type, value, { definition, setDefinition });
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  public get encodedLength (): number {
-    // boolean byte (has value, doesn't have) along with wrapped length
-    return 1 + this.#raw.encodedLength;
-  }
-
-  /**
-   * @description returns a hash of the contents
-   */
-  public get hash (): IU8a {
-    return this.registry.hash(this.toU8a());
-  }
-
-  /**
-   * @description Checks if the Option has no value
-   */
-  public get isEmpty (): boolean {
-    return this.isNone;
-  }
-
-  /**
-   * @description Checks if the Option has no value
-   */
-  public get isNone (): boolean {
-    return this.#raw instanceof None;
-  }
-
-  /**
-   * @description Checks if the Option has a value
-   */
-  public get isSome (): boolean {
-    return !this.isNone;
-  }
-
-  /**
-   * @description The actual value for the Option
-   */
-  public get value (): T {
-    return this.#raw;
-  }
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  public eq (other?: unknown): boolean {
-    if (other instanceof Option) {
-      return (this.isSome === other.isSome) && this.value.eq(other.value);
-    }
-
-    return this.value.eq(other);
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  public inspect (): Inspect {
-    if (this.isNone) {
-      return { outer: [new Uint8Array([0])] };
-    }
-
-    const { inner, outer = [] } = this.#raw.inspect();
-
-    return {
-      inner,
-      outer: [new Uint8Array([1]), ...outer]
-    };
-  }
-
-  /**
-   * @description Returns a hex string representation of the value
-   */
-  public toHex (): HexString {
-    // This attempts to align with the JSON encoding - actually in this case
-    // the isSome value is correct, however the `isNone` may be problematic
-    return this.isNone
-      ? '0x'
-      : u8aToHex(this.toU8a().subarray(1));
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  public toHuman (isExtended?: boolean, disableAscii?: boolean): AnyJson {
-    return this.#raw.toHuman(isExtended, disableAscii);
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  public toJSON (): AnyJson {
-    return this.isNone
-      ? null
-      : this.#raw.toJSON();
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  public toPrimitive (disableAscii?: boolean): AnyJson {
-    return this.isNone
-      ? null
-      : this.#raw.toPrimitive(disableAscii);
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (isBare?: boolean): string {
-    const wrapped = this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType();
-
-    return isBare
-      ? wrapped
-      : `Option<${wrapped}>`;
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  public toString (): string {
-    return this.#raw.toString();
-  }
-
-  /**
-   * @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)
-   */
-  public toU8a (isBare?: boolean): Uint8Array {
-    if (isBare) {
-      return this.#raw.toU8a(true);
-    }
-
-    const u8a = new Uint8Array(this.encodedLength);
-
-    if (this.isSome) {
-      u8a.set([1]);
-      u8a.set(this.#raw.toU8a(), 1);
-    }
-
-    return u8a;
-  }
-
-  /**
-   * @description Returns the value that the Option represents (if available), throws if null
-   */
-  public unwrap (): T {
-    if (this.isNone) {
-      throw new Error('Option: unwrapping a None value');
-    }
-
-    return this.#raw;
-  }
-
-  /**
-   * @description Returns the value that the Option represents (if available) or defaultValue if none
-   * @param defaultValue The value to return if the option isNone
-   */
-  public unwrapOr<O> (defaultValue: O): T | O {
-    return this.isSome
-      ? this.unwrap()
-      : defaultValue;
-  }
-
-  /**
-   * @description Returns the value that the Option represents (if available) or defaultValue if none
-   * @param defaultValue The value to return if the option isNone
-   */
-  public unwrapOrDefault (): T {
-    return this.isSome
-      ? this.unwrap()
-      : new this.#Type(this.registry);
-  }
-}

package/build-deno/base/Result.ts

@@ -1,77 +0,0 @@
-
-import type { Codec, CodecClass, IResult, Registry } from '../types/index.ts';
-
-import { Enum } from './Enum.ts';
-
-/**
- * @name Result
- * @description
- * A Result maps to the Rust Result type, that can either wrap a success or error value
- */
-export class Result<O extends Codec, E extends Codec> extends Enum implements IResult<O, E> {
-  constructor (registry: Registry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown) {
-    // NOTE This is order-dependent, Ok (with index 0) needs to be first
-    // eslint-disable-next-line sort-keys
-    super(registry, { Ok, Err }, value);
-  }
-
-  public static override with<O extends Codec, E extends Codec> (Types: { Ok: CodecClass<O> | string; Err: CodecClass<E> | string }): CodecClass<Result<O, E>> {
-    return class extends Result<O, E> {
-      constructor (registry: Registry, value?: unknown) {
-        super(registry, Types.Ok, Types.Err, value);
-      }
-    };
-  }
-
-  /**
-   * @description Returns the wrapper Err value (if isErr)
-   */
-  public get asErr (): E {
-    if (!this.isErr) {
-      throw new Error('Cannot extract Err value from Ok result, check isErr first');
-    }
-
-    return this.value as E;
-  }
-
-  /**
-   * @description Returns the wrapper Ok value (if isOk)
-   */
-  public get asOk (): O {
-    if (!this.isOk) {
-      throw new Error('Cannot extract Ok value from Err result, check isOk first');
-    }
-
-    return this.value as O;
-  }
-
-  /**
-   * @description Checks if the Result has no value
-   */
-  public override get isEmpty (): boolean {
-    return this.isOk && this.value.isEmpty;
-  }
-
-  /**
-   * @description Checks if the Result wraps an Err value
-   */
-  public get isErr (): boolean {
-    return !this.isOk;
-  }
-
-  /**
-   * @description Checks if the Result wraps an Ok value
-   */
-  public get isOk (): boolean {
-    return this.index === 0;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public override toRawType (): string {
-    const Types = this._toRawStruct() as { Ok: unknown; Err: unknown };
-
-    return `Result<${Types.Ok as string},${Types.Err as string}>`;
-  }
-}

package/build-deno/base/Tuple.ts

@@ -1,147 +0,0 @@
-
-import type { AnyTupleValue, Codec, CodecClass, DefinitionSetter, Inspect, ITuple, Registry } from '../types/index.ts';
-
-import { identity, isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { AbstractArray } from '../abstract/Array.ts';
-import { decodeU8a, mapToTypeMap, typesToConstructors, typeToConstructor } from '../utils/index.ts';
-
-type TupleType = (CodecClass | string);
-
-type TupleTypes = TupleType[] | Record<string, CodecClass | string>;
-
-type Definition = [CodecClass[], string[]];
-
-/** @internal */
-function decodeTuple (registry: Registry, result: Codec[], value: Exclude<AnyTupleValue, Uint8Array> | undefined, Classes: Definition): [Codec[], number] {
-  if (Array.isArray(value)) {
-    const Types = Classes[0];
-
-    for (let i = 0, count = Types.length; i < count; i++) {
-      try {
-        const entry = value?.[i];
-
-        result[i] = entry instanceof Types[i]
-          ? entry
-          : new Types[i](registry, entry);
-      } catch (error) {
-        throw new Error(`Tuple: failed on ${i}:: ${(error as Error).message}`);
-      }
-    }
-
-    return [result, 0];
-  } else if (isHex(value)) {
-    return decodeU8a(registry, result, u8aToU8a(value), Classes);
-  } else if (!value || !result.length) {
-    const Types = Classes[0];
-
-    for (let i = 0, count = Types.length; i < count; i++) {
-      result[i] = new Types[i](registry);
-    }
-
-    return [result, 0];
-  }
-
-  throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${stringify(value)}`);
-}
-
-/**
- * @name Tuple
- * @description
- * A Tuple defines an anonymous fixed-length array, where each element has its
- * own type. It extends the base JS `Array` object.
- */
-export class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
-  #Types: Definition;
-
-  constructor (registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition = identity }: DefinitionSetter<Definition> = {}) {
-    const Classes = definition || setDefinition(
-      Array.isArray(Types)
-        ? [typesToConstructors(registry, Types), []]
-        : isFunction(Types) || isString(Types)
-          ? [[typeToConstructor(registry, Types)], []]
-          : mapToTypeMap(registry, Types)
-    );
-
-    super(registry, Classes[0].length);
-
-    this.initialU8aLength = (
-      isU8a(value)
-        ? decodeU8a(registry, this, value, Classes)
-        : decodeTuple(registry, this, value, Classes)
-    )[1];
-    this.#Types = Classes;
-  }
-
-  public static with (Types: TupleTypes | TupleType): CodecClass<Tuple> {
-    let definition: Definition | undefined;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = (d: Definition) =>
-      definition = d;
-
-    return class extends Tuple {
-      constructor (registry: Registry, value?: AnyTupleValue) {
-        super(registry, Types, value, { definition, setDefinition });
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  public override get encodedLength (): number {
-    let total = 0;
-
-    for (let i = 0, count = this.length; i < count; i++) {
-      total += this[i].encodedLength;
-    }
-
-    return total;
-  }
-
-  /**
-   * @description The types definition of the tuple
-   */
-  public get Types (): string[] {
-    return this.#Types[1].length
-      ? this.#Types[1]
-      : this.#Types[0].map((T) => new T(this.registry).toRawType());
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  public override inspect (): Inspect {
-    return {
-      inner: this.inspectInner()
-    };
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (): string {
-    const types = this.#Types[0].map((T) =>
-      this.registry.getClassName(T) || new T(this.registry).toRawType()
-    );
-
-    return `(${types.join(',')})`;
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  public override toString (): string {
-    // Overwrite the default toString representation of Array.
-    return stringify(this.toJSON());
-  }
-
-  /**
-   * @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)
-   */
-  public override toU8a (isBare?: boolean): Uint8Array {
-    return u8aConcatStrict(this.toU8aInner(isBare));
-  }
-}

package/build-deno/base/UInt.ts

@@ -1,28 +0,0 @@
-
-import type { AnyNumber, CodecClass, Registry, UIntBitLength } from '../types/index.ts';
-
-import { AbstractInt } from '../abstract/Int.ts';
-
-/**
- * @name UInt
- * @description
- * A generic unsigned integer codec. For Bizinikiwi all numbers are Little Endian encoded,
- * this handles the encoding and decoding of those numbers. Upon construction
- * the bitLength is provided and any additional use keeps the number to this
- * length. This extends `BN`, so all methods available on a normal `BN` object
- * is available here.
- * @noInheritDoc
- */
-export class UInt extends AbstractInt {
-  public static with (bitLength: UIntBitLength, typeName?: string): CodecClass<UInt> {
-    return class extends UInt {
-      constructor (registry: Registry, value?: AnyNumber | null) {
-        super(registry, value, bitLength);
-      }
-
-      public override toRawType (): string {
-        return typeName || super.toRawType();
-      }
-    };
-  }
-}

package/build-deno/base/Vec.ts

@@ -1,131 +0,0 @@
-
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { Codec, CodecClass, DefinitionSetter, Registry } from '../types/index.ts';
-
-import { compactFromU8aLim, identity, isHex, isU8a, logger, stringify, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { AbstractArray } from '../abstract/Array.ts';
-import { decodeU8aVec, typeToConstructor } from '../utils/index.ts';
-
-const MAX_LENGTH = 512 * 1024;
-
-const l = logger('Vec');
-
-function decodeVecLength (value: Uint8Array | HexString | unknown[]): [Uint8Array | unknown[] | null, number, number] {
-  if (Array.isArray(value)) {
-    return [value, value.length, 0];
-  } else if (isU8a(value) || isHex(value)) {
-    const u8a = u8aToU8a(value);
-    const [startAt, length] = compactFromU8aLim(u8a);
-
-    if (length > MAX_LENGTH) {
-      throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
-    }
-
-    return [u8a, length, startAt];
-  } else if (!value) {
-    return [null, 0, 0];
-  }
-
-  throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${stringify(value)}`);
-}
-
-export function decodeVec<T extends Codec> (registry: Registry, result: T[], value: Uint8Array | HexString | unknown[] | null, startAt: number, Type: CodecClass<T>): [number, number] {
-  if (Array.isArray(value)) {
-    const count = result.length;
-
-    for (let i = 0; i < count; i++) {
-      // 26/08/2022 this is actually a false positive - after recent eslint upgdates
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      const entry = value[i];
-
-      try {
-        result[i] = entry instanceof Type
-          ? entry
-          : new Type(registry, entry);
-      } catch (error) {
-        l.error(`Unable to decode on index ${i}`, (error as Error).message);
-
-        throw error;
-      }
-    }
-
-    return [0, 0];
-  } else if (!value) {
-    return [0, 0];
-  }
-
-  // we don't need more checks, we already limited it via the length decoding
-  return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
-}
-
-/**
- * @name Vec
- * @description
- * This manages codec arrays. Internally it keeps track of the length (as decoded) and allows
- * construction with the passed `Type` in the constructor. It is an extension to Array, providing
- * specific encoding/decoding on top of the base type.
- */
-export class Vec<T extends Codec> extends AbstractArray<T> {
-  #Type: CodecClass<T>;
-
-  constructor (registry: Registry, Type: CodecClass<T> | string, value: Uint8Array | HexString | unknown[] = [], { definition, setDefinition = identity }: DefinitionSetter<CodecClass<T>> = {}) {
-    const [decodeFrom, length, startAt] = decodeVecLength(value);
-
-    super(registry, length);
-
-    this.#Type = definition || setDefinition(typeToConstructor<T>(registry, Type));
-
-    this.initialU8aLength = (
-      isU8a(decodeFrom)
-        ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type)
-        : decodeVec(registry, this, decodeFrom, startAt, this.#Type)
-    )[0];
-  }
-
-  public static with<O extends Codec> (Type: CodecClass<O> | string): CodecClass<Vec<O>> {
-    let definition: CodecClass<O> | undefined;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = <T> (d: CodecClass<T>) =>
-      (definition = d as unknown as CodecClass<O>) as unknown as CodecClass<T>;
-
-    return class extends Vec<O> {
-      constructor (registry: Registry, value?: any[]) {
-        super(registry, Type, value, { definition, setDefinition });
-      }
-    };
-  }
-
-  /**
-   * @description The type for the items
-   */
-  public get Type (): string {
-    return this.#Type.name;
-  }
-
-  /**
-   * @description Finds the index of the value in the array
-   */
-  public override indexOf (other?: unknown): number {
-    // convert type first, this removes overhead from the eq
-    const check = other instanceof this.#Type
-      ? other
-      : new this.#Type(this.registry, other);
-
-    for (let i = 0, count = this.length; i < count; i++) {
-      if (check.eq(this[i])) {
-        return i;
-      }
-    }
-
-    return -1;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (): string {
-    return `Vec<${this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType()}>`;
-  }
-}

package/build-deno/base/VecAny.ts

@@ -1,21 +0,0 @@
-
-import type { Codec } from '../types/index.ts';
-
-import { AbstractArray } from '../abstract/Array.ts';
-
-/**
- * @name VecAny
- * @description
- * This manages codec arrays, assuming that the inputs are already of type Codec. Unlike
- * a vector, this can be used to manage array-like structures with variable arguments of
- * any types
- */
-export class VecAny<T extends Codec> extends AbstractArray<T> {
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (): string {
-    // FIXME This is basically an any type, cannot instantiate via createType
-    return 'Vec<Codec>';
-  }
-}