caip/dist/index.umd.js

CAIP standard utils

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = global || self, factory(global.caip = {}));
})(this, (function (exports) {
  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  var CAIP2 = {
    name: "chainId",
    regex: "[-:a-zA-Z0-9]{5,41}",
    parameters: {
      delimiter: ":",
      values: {
        0: {
          name: "namespace",
          regex: "[-a-z0-9]{3,8}"
        },
        1: {
          name: "reference",
          regex: "[-a-zA-Z0-9]{1,32}"
        }
      }
    }
  };
  var CAIP10 = {
    name: "accountId",
    regex: "[-:a-zA-Z0-9]{7,106}",
    parameters: {
      delimiter: ":",
      values: {
        0: {
          name: "namespace",
          regex: "[-a-z0-9]{3,8}"
        },
        1: {
          name: "reference",
          regex: "[-a-zA-Z0-9]{1,32}"
        },
        2: {
          name: "address",
          regex: "[a-zA-Z0-9]{1,64}"
        }
      }
    }
  };
  var AssetName$1 = {
    name: "assetName",
    regex: "[-:a-zA-Z0-9]{5,73}",
    parameters: {
      delimiter: ":",
      values: {
        0: {
          name: "namespace",
          regex: "[-a-z0-9]{3,8}"
        },
        1: {
          name: "reference",
          regex: "[-a-zA-Z0-9]{1,64}"
        }
      }
    }
  };
  var CAIP19AssetType = {
    name: "assetType",
    regex: "[-:a-zA-Z0-9]{11,115}",
    parameters: {
      delimiter: "/",
      values: {
        0: CAIP2,
        1: AssetName$1
      }
    }
  };
  var CAIP19AssetId = {
    name: "assetId",
    regex: "[-:a-zA-Z0-9]{13,148}",
    parameters: {
      delimiter: "/",
      values: {
        0: CAIP2,
        1: AssetName$1,
        2: {
          name: "tokenId",
          regex: "[-a-zA-Z0-9]{1,32}"
        }
      }
    }
  };
  var CAIP = {
    "2": CAIP2,
    "10": CAIP10,
    "19": {
      assetName: AssetName$1,
      assetType: CAIP19AssetType,
      assetId: CAIP19AssetId
    }
  };

  function splitParams(id, spec) {
    return id.split(spec.parameters.delimiter);
  }
  function getParams(id, spec) {
    var arr = splitParams(id, spec);
    var params = {};
    arr.forEach(function (value, index) {
      params[spec.parameters.values[index].name] = value;
    });
    return params;
  }
  function joinParams(params, spec) {
    return Object.values(spec.parameters.values).map(function (parameter) {
      var param = params[parameter.name];
      return typeof param === "string" ? param : joinParams(param, parameter);
    }).join(spec.parameters.delimiter);
  }
  function isValidId(id, spec) {
    if (!new RegExp(spec.regex).test(id)) return false;
    var params = splitParams(id, spec);
    if (params.length !== Object.keys(spec.parameters.values).length) return false;
    var matches = params.map(function (param, index) {
      return new RegExp(spec.parameters.values[index].regex).test(param);
    }).filter(function (x) {
      return !!x;
    });
    if (matches.length !== params.length) return false;
    return true;
  }

  var ChainId = /*#__PURE__*/function () {
    function ChainId(params) {
      if (typeof params === "string") {
        params = ChainId.parse(params);
      }

      this.namespace = params.namespace;
      this.reference = params.reference;
    }

    ChainId.parse = function parse(id) {
      if (!isValidId(id, this.spec)) {
        throw new Error("Invalid " + this.spec.name + " provided: " + id);
      }

      return new ChainId(getParams(id, this.spec)).toJSON();
    };

    ChainId.format = function format(params) {
      return joinParams(params, this.spec);
    };

    var _proto = ChainId.prototype;

    _proto.toString = function toString() {
      return ChainId.format(this.toJSON());
    };

    _proto.toJSON = function toJSON() {
      return {
        namespace: this.namespace,
        reference: this.reference
      };
    };

    return ChainId;
  }();
  ChainId.spec = CAIP["2"];

  var AccountId = /*#__PURE__*/function () {
    function AccountId(params) {
      if (typeof params === "string") {
        params = AccountId.parse(params);
      }

      this.chainId = new ChainId(params.chainId);
      this.address = params.address;
    }

    AccountId.parse = function parse(id) {
      if (!isValidId(id, this.spec)) {
        throw new Error("Invalid " + this.spec.name + " provided: " + id);
      }

      var _getParams = getParams(id, this.spec),
          namespace = _getParams.namespace,
          reference = _getParams.reference,
          address = _getParams.address;

      var chainId = new ChainId({
        namespace: namespace,
        reference: reference
      });
      return new AccountId({
        chainId: chainId,
        address: address
      }).toJSON();
    };

    AccountId.format = function format(params) {
      var chainId = new ChainId(params.chainId);

      var splitParams = _extends({}, chainId.toJSON(), {
        address: params.address
      });

      return joinParams(splitParams, this.spec);
    };

    var _proto = AccountId.prototype;

    _proto.toString = function toString() {
      return AccountId.format(this.toJSON());
    };

    _proto.toJSON = function toJSON() {
      return {
        chainId: this.chainId.toJSON(),
        address: this.address
      };
    };

    return AccountId;
  }();
  AccountId.spec = CAIP["10"];

  var AssetName = /*#__PURE__*/function () {
    function AssetName(params) {
      if (typeof params === "string") {
        params = AssetName.parse(params);
      }

      this.namespace = params.namespace;
      this.reference = params.reference;
    }

    AssetName.parse = function parse(id) {
      if (!isValidId(id, this.spec)) {
        throw new Error("Invalid " + this.spec.name + " provided: " + id);
      }

      return new AssetName(getParams(id, this.spec)).toJSON();
    };

    AssetName.format = function format(params) {
      return joinParams(params, this.spec);
    };

    var _proto = AssetName.prototype;

    _proto.toString = function toString() {
      return AssetName.format(this.toJSON());
    };

    _proto.toJSON = function toJSON() {
      return {
        namespace: this.namespace,
        reference: this.reference
      };
    };

    return AssetName;
  }();
  AssetName.spec = CAIP["19"].assetName;

  var AssetType = /*#__PURE__*/function () {
    function AssetType(params) {
      if (typeof params === "string") {
        params = AssetType.parse(params);
      }

      this.chainId = new ChainId(params.chainId);
      this.assetName = new AssetName(params.assetName);
    }

    AssetType.parse = function parse(id) {
      if (!isValidId(id, this.spec)) {
        throw new Error("Invalid " + this.spec.name + " provided: " + id);
      }

      return new AssetType(getParams(id, this.spec)).toJSON();
    };

    AssetType.format = function format(params) {
      return joinParams(params, this.spec);
    };

    var _proto = AssetType.prototype;

    _proto.toString = function toString() {
      return AssetType.format(this.toJSON());
    };

    _proto.toJSON = function toJSON() {
      return {
        chainId: this.chainId.toJSON(),
        assetName: this.assetName
      };
    };

    return AssetType;
  }();
  AssetType.spec = CAIP["19"].assetType;

  var AssetId = /*#__PURE__*/function () {
    function AssetId(params) {
      if (typeof params === "string") {
        params = AssetId.parse(params);
      }

      this.chainId = new ChainId(params.chainId);
      this.assetName = new AssetName(params.assetName);
      this.tokenId = params.tokenId;
    }

    AssetId.parse = function parse(id) {
      if (!isValidId(id, this.spec)) {
        throw new Error("Invalid " + this.spec.name + " provided: " + id);
      }

      return new AssetId(getParams(id, this.spec)).toJSON();
    };

    AssetId.format = function format(params) {
      return joinParams(params, this.spec);
    };

    var _proto = AssetId.prototype;

    _proto.toString = function toString() {
      return AssetId.format(this.toJSON());
    };

    _proto.toJSON = function toJSON() {
      return {
        chainId: this.chainId.toJSON(),
        assetName: this.assetName.toJSON(),
        tokenId: this.tokenId
      };
    };

    return AssetId;
  }();
  AssetId.spec = CAIP["19"].assetId;

  exports.AccountId = AccountId;
  exports.AssetId = AssetId;
  exports.AssetType = AssetType;
  exports.ChainId = ChainId;

}));
//# sourceMappingURL=index.umd.js.map