@open-web3/api-mobx/scripts/mobx.js

MobX integration for polkadot.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

exports.__esModule = true;
exports.default = gerateMobx;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _types = require("@polkadot/types");

var defaultDefs = _interopRequireWildcard(require("@polkadot/types/interfaces/definitions"));

var _StorageKey = require("@polkadot/types/primitive/StorageKey");

var _create = require("@polkadot/types/create");

var _util = require("@polkadot/util");

var _util2 = require("./util");

var Handlebars = _interopRequireWildcard(require("handlebars"));

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

Handlebars.registerHelper('inc', function (value) {
  return parseInt(value) + 1;
}); // From a storage entry metadata, we return [args, returnType]

/** @internal */

function entrySignature(allDefs, registry, storageEntry, imports) {
  const format = type => (0, _util2.formatType)(allDefs, type, imports);

  const outputType = (0, _StorageKey.unwrapStorageType)(registry, storageEntry.type, storageEntry.modifier.isOptional);

  if (storageEntry.type.isPlain) {
    (0, _util2.setImports)(allDefs, imports, [storageEntry.type.asPlain.toString()]);
    return [[], (0, _util2.formatType)(allDefs, outputType, imports)];
  } else if (storageEntry.type.isMap) {
    // Find similar types of the `key` type
    const key = (0, _util2.getSimilarTypes)(allDefs, registry, storageEntry.type.asMap.key.toString(), imports);
    const value = storageEntry.type.asMap.value.toString();
    (0, _util2.setImports)(allDefs, imports, [...key, value]);
    return [[key.map(format).join(' | ')], (0, _util2.formatType)(allDefs, outputType, imports)];
  }

  throw new Error(`entryArgs: Cannot parse args of entry ${storageEntry.name.toString()}`);
}

const template = (0, _util2.readTemplate)('mobx');
const generateForMetaTemplate = Handlebars.compile(template);
/** @internal */

function generateForMeta(registry, meta, dest, extraTypes) {
  (0, _util2.writeFile)(dest, () => {
    const allTypes = _objectSpread({
      '@polkadot/types/interfaces': defaultDefs
    }, extraTypes);

    const imports = (0, _util2.createImports)(allTypes);
    const allDefs = Object.entries(allTypes).reduce((defs, _ref) => {
      let [path, obj] = _ref;
      return Object.entries(obj).reduce((defs, _ref2) => {
        let [key, value] = _ref2;
        return _objectSpread(_objectSpread({}, defs), {}, {
          [`${path}/${key}`]: value
        });
      }, defs);
    }, {});
    const modules = meta.asLatest.pallets.sort(_util2.compareName).filter(mod => !mod.storage.isNone).map(_ref3 => {
      let {
        name,
        storage
      } = _ref3;
      const items = storage.unwrap().items.sort(_util2.compareName).map(storageEntry => {
        const [args, returnType] = entrySignature(allDefs, registry, storageEntry, imports);
        let entryType = `${returnType} | null`;

        if (storageEntry.type.isMap) {
          entryType = `StorageMap<${args.join(', ')}, ${returnType}>`;
        }

        return {
          args,
          docs: storageEntry.docs,
          entryType,
          name: (0, _util.stringCamelCase)(storageEntry.name.toString()),
          returnType
        };
      });
      return {
        items,
        name: (0, _util.stringCamelCase)(name.toString())
      };
    });
    const types = [...Object.keys(imports.localTypes).sort().map(packagePath => ({
      file: packagePath,
      types: Object.keys(imports.localTypes[packagePath])
    })), {
      file: '@open-web3/api-mobx',
      types: ['StorageMap', 'BaseStorageType']
    }];
    return generateForMetaTemplate({
      headerType: 'chain',
      imports,
      modules,
      types
    });
  });
}
/**
 * Generate StorageType for api-mobx
 *
 * @param {string} dest
 * @param {string} metadataHex
 * @param {Record<string, Record<string, { types: Record<string, any> }>>} [definations={}]
 * @param {RegisteredTypes} [knownTypes={}]
 * @returns {void}
 */


function gerateMobx(dest, metadataHex, definations, knownTypes) {
  if (definations === void 0) {
    definations = {};
  }

  if (knownTypes === void 0) {
    knownTypes = {};
  }

  const registry = new _create.TypeRegistry();
  registry.setKnownTypes(knownTypes);
  (0, _util2.registerDefinitions)(registry, definations);
  return generateForMeta(registry, new _types.Metadata(registry, metadataHex), dest, definations);
}