@polkadot/types-codec 6.12.2-10

package/extended/Range.js

@@ -0,0 +1,75 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Tuple } from "../base/Tuple.js";
+
+var _rangeName = /*#__PURE__*/_classPrivateFieldLooseKey("rangeName");
+
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export class Range extends Tuple {
+  constructor(registry, Type, value, rangeName = 'Range') {
+    super(registry, {
+      end: Type,
+      start: Type
+    }, value);
+    Object.defineProperty(this, _rangeName, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _rangeName)[_rangeName] = rangeName;
+  }
+
+  static with(Types) {
+    return class extends Range {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the starting range value
+   */
+
+
+  get start() {
+    return this[0];
+  }
+  /**
+   * @description Returns the ending range value
+   */
+
+
+  get end() {
+    return this[1];
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${_classPrivateFieldLooseBase(this, _rangeName)[_rangeName]}<${this.start.toRawType()}>`;
+  }
+
+}
+export class RangeInclusive extends Range {
+  constructor(registry, type, value) {
+    super(registry, type, value, 'RangeInclusive');
+  }
+
+  static with(Types) {
+    return class extends RangeInclusive {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+
+}

package/extended/Type.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Type = void 0;
+
+var _Text = require("../native/Text.cjs");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+class Type extends _Text.Text {
+  constructor(registry) {
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    super(registry, value);
+    this.setOverride((0, _index.sanitize)(this.toString()));
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Type';
+  }
+
+}
+
+exports.Type = Type;

package/extended/Type.d.ts

@@ -0,0 +1,16 @@
+import type { CodecRegistry } from '../types';
+import { Text } from '../native/Text';
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+export declare class Type extends Text {
+    constructor(registry: CodecRegistry, value?: Text | Uint8Array | string);
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/extended/Type.js

@@ -0,0 +1,27 @@
+// Copyright 2017-2021 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Text } from "../native/Text.js";
+import { sanitize } from "../utils/index.js";
+/**
+ * @name Type
+ * @description
+ * This is a extended version of Text, specifically to handle types. Here we rely fully
+ * on what Text provides us, however we also adjust the types received from the runtime,
+ * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
+ */
+
+export class Type extends Text {
+  constructor(registry, value = '') {
+    super(registry, value);
+    this.setOverride(sanitize(this.toString()));
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Type';
+  }
+
+}

package/extended/U8aFixed.cjs

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.U8aFixed = void 0;
+
+var _util = require("@polkadot/util");
+
+var _Raw = require("../native/Raw.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal */
+function decodeU8aFixed(value, bitLength) {
+  const u8a = (0, _util.u8aToU8a)(value);
+  const byteLength = bitLength / 8;
+
+  if (!u8a.length) {
+    return [new Uint8Array(byteLength), 0];
+  }
+
+  (0, _util.assert)(u8a.length >= byteLength, () => `Expected at least ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  return [u8a.subarray(0, byteLength), byteLength];
+}
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+
+
+class U8aFixed extends _Raw.Raw {
+  constructor(registry) {
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Uint8Array();
+    let bitLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 256;
+    const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
+    super(registry, u8a, decodedLength);
+  }
+
+  static with(bitLength, typeName) {
+    return class extends U8aFixed {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[u8;${this.length}]`;
+  }
+
+}
+
+exports.U8aFixed = U8aFixed;

package/extended/U8aFixed.d.ts

@@ -0,0 +1,16 @@
+import type { AnyU8a, CodecClass, CodecRegistry, U8aBitLength } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+export declare class U8aFixed extends Raw {
+    constructor(registry: CodecRegistry, value?: AnyU8a, bitLength?: U8aBitLength);
+    static with(bitLength: U8aBitLength, typeName?: string): CodecClass<U8aFixed>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/extended/U8aFixed.js

@@ -0,0 +1,53 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert, u8aToU8a } from '@polkadot/util';
+import { Raw } from "../native/Raw.js";
+/** @internal */
+
+function decodeU8aFixed(value, bitLength) {
+  const u8a = u8aToU8a(value);
+  const byteLength = bitLength / 8;
+
+  if (!u8a.length) {
+    return [new Uint8Array(byteLength), 0];
+  }
+
+  assert(u8a.length >= byteLength, () => `Expected at least ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  return [u8a.subarray(0, byteLength), byteLength];
+}
+/**
+ * @name U8aFixed
+ * @description
+ * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
+ * to be used directly, rather is should be subclassed with the specific lengths.
+ */
+
+
+export class U8aFixed extends Raw {
+  constructor(registry, value = new Uint8Array(), bitLength = 256) {
+    const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
+    super(registry, u8a, decodedLength);
+  }
+
+  static with(bitLength, typeName) {
+    return class extends U8aFixed {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[u8;${this.length}]`;
+  }
+
+}

package/extended/WrapperOpaque.cjs

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WrapperOpaque = void 0;
+
+var _util = require("@polkadot/util");
+
+var _Base = require("../base/Base.cjs");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function decodeRaw(registry, Type, value) {
+  const Clazz = (0, _index.typeToConstructor)(registry, Type);
+
+  if ((0, _util.isU8a)(value)) {
+    const [, u8a] = (0, _util.compactStripLength)(value);
+    return new Clazz(registry, u8a);
+  }
+
+  return new Clazz(registry, value);
+}
+
+class WrapperOpaque extends _Base.Base {
+  constructor(registry, Type, value) {
+    super(registry, decodeRaw(registry, Type, value));
+  }
+
+  static with(Type) {
+    return class extends WrapperOpaque {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `WrapperOpaque<${this.inner.toRawType()}>`;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  toU8a(isBare) {
+    const u8a = super.toU8a(isBare);
+    return isBare ? u8a : (0, _util.compactAddLength)(u8a);
+  }
+
+}
+
+exports.WrapperOpaque = WrapperOpaque;

package/extended/WrapperOpaque.d.ts

@@ -0,0 +1,14 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { Base } from '../base/Base';
+export declare class WrapperOpaque<T extends Codec> extends Base<T> {
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: unknown);
+    static with<T extends Codec>(Type: CodecClass<T> | string): CodecClass<WrapperOpaque<T>>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    toU8a(isBare?: boolean): Uint8Array;
+}

package/extended/WrapperOpaque.js

@@ -0,0 +1,49 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { compactAddLength, compactStripLength, isU8a } from '@polkadot/util';
+import { Base } from "../base/Base.js";
+import { typeToConstructor } from "../utils/index.js";
+
+function decodeRaw(registry, Type, value) {
+  const Clazz = typeToConstructor(registry, Type);
+
+  if (isU8a(value)) {
+    const [, u8a] = compactStripLength(value);
+    return new Clazz(registry, u8a);
+  }
+
+  return new Clazz(registry, value);
+}
+
+export class WrapperOpaque extends Base {
+  constructor(registry, Type, value) {
+    super(registry, decodeRaw(registry, Type, value));
+  }
+
+  static with(Type) {
+    return class extends WrapperOpaque {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `WrapperOpaque<${this.inner.toRawType()}>`;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  toU8a(isBare) {
+    const u8a = super.toU8a(isBare);
+    return isBare ? u8a : compactAddLength(u8a);
+  }
+
+}

package/extended/index.cjs

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BTreeMap", {
+  enumerable: true,
+  get: function () {
+    return _BTreeMap.BTreeMap;
+  }
+});
+Object.defineProperty(exports, "BTreeSet", {
+  enumerable: true,
+  get: function () {
+    return _BTreeSet.BTreeSet;
+  }
+});
+Object.defineProperty(exports, "BitVec", {
+  enumerable: true,
+  get: function () {
+    return _BitVec.BitVec;
+  }
+});
+Object.defineProperty(exports, "Bytes", {
+  enumerable: true,
+  get: function () {
+    return _Bytes.Bytes;
+  }
+});
+Object.defineProperty(exports, "CodecMap", {
+  enumerable: true,
+  get: function () {
+    return _Map.CodecMap;
+  }
+});
+Object.defineProperty(exports, "HashMap", {
+  enumerable: true,
+  get: function () {
+    return _HashMap.HashMap;
+  }
+});
+Object.defineProperty(exports, "Linkage", {
+  enumerable: true,
+  get: function () {
+    return _Linkage.Linkage;
+  }
+});
+Object.defineProperty(exports, "Map", {
+  enumerable: true,
+  get: function () {
+    return _Map.CodecMap;
+  }
+});
+Object.defineProperty(exports, "Range", {
+  enumerable: true,
+  get: function () {
+    return _Range.Range;
+  }
+});
+Object.defineProperty(exports, "RangeInclusive", {
+  enumerable: true,
+  get: function () {
+    return _Range.RangeInclusive;
+  }
+});
+Object.defineProperty(exports, "Type", {
+  enumerable: true,
+  get: function () {
+    return _Type.Type;
+  }
+});
+Object.defineProperty(exports, "U8aFixed", {
+  enumerable: true,
+  get: function () {
+    return _U8aFixed.U8aFixed;
+  }
+});
+Object.defineProperty(exports, "WrapperOpaque", {
+  enumerable: true,
+  get: function () {
+    return _WrapperOpaque.WrapperOpaque;
+  }
+});
+
+var _BitVec = require("./BitVec.cjs");
+
+var _BTreeMap = require("./BTreeMap.cjs");
+
+var _BTreeSet = require("./BTreeSet.cjs");
+
+var _Bytes = require("./Bytes.cjs");
+
+var _HashMap = require("./HashMap.cjs");
+
+var _Linkage = require("./Linkage.cjs");
+
+var _Map = require("./Map.cjs");
+
+var _Range = require("./Range.cjs");
+
+var _Type = require("./Type.cjs");
+
+var _U8aFixed = require("./U8aFixed.cjs");
+
+var _WrapperOpaque = require("./WrapperOpaque.cjs");

package/extended/index.d.ts

@@ -0,0 +1,11 @@
+export { BitVec } from './BitVec';
+export { BTreeMap } from './BTreeMap';
+export { BTreeSet } from './BTreeSet';
+export { Bytes } from './Bytes';
+export { HashMap } from './HashMap';
+export { Linkage } from './Linkage';
+export { CodecMap, CodecMap as Map } from './Map';
+export { Range, RangeInclusive } from './Range';
+export { Type } from './Type';
+export { U8aFixed } from './U8aFixed';
+export { WrapperOpaque } from './WrapperOpaque';

package/extended/index.js

@@ -0,0 +1,13 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { BitVec } from "./BitVec.js";
+export { BTreeMap } from "./BTreeMap.js";
+export { BTreeSet } from "./BTreeSet.js";
+export { Bytes } from "./Bytes.js";
+export { HashMap } from "./HashMap.js";
+export { Linkage } from "./Linkage.js";
+export { CodecMap, CodecMap as Map } from "./Map.js";
+export { Range, RangeInclusive } from "./Range.js";
+export { Type } from "./Type.js";
+export { U8aFixed } from "./U8aFixed.js";
+export { WrapperOpaque } from "./WrapperOpaque.js";

package/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("./detectPackage.cjs");
+
+var _bundle = require("./bundle.cjs");
+
+Object.keys(_bundle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bundle[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bundle[key];
+    }
+  });
+});

package/index.d.ts

@@ -0,0 +1,2 @@
+import './detectPackage';
+export * from './bundle';

package/index.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import "./detectPackage.js";
+export * from "./bundle.js";