@onepercentio/one-ui 0.19.1 → 0.19.3

package/dist/hooks/useShortIntl.js

@@ -1,56 +1,84 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isolateMessages = void 0;
-const react_intl_1 = require("react-intl");
-const react_1 = require("react");
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useShortIntl;
+exports.isolateMessages = isolateMessages;
+var _reactIntl = require("react-intl");
+var _react = require("react");
+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) { _defineProperty(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; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 function useShortIntl() {
-    const intl = (0, react_intl_1.useIntl)();
-    const { formatMessage, formatNumber } = intl;
-    const [devMode, setDevMode] = (0, react_1.useState)(false);
-    (0, react_1.useEffect)(() => {
-        if (process.env.NODE_ENV === "development") {
-            const keyDownDetect = (ev) => {
-                if (ev.key === "i" && ev.ctrlKey) {
-                    const keyUpDetect = (ev) => {
-                        if (ev.key === "i") {
-                            setDevMode(false);
-                        }
-                    };
-                    setDevMode(true);
-                    window.addEventListener("keyup", keyUpDetect);
-                }
-            };
-            window.addEventListener("keydown", keyDownDetect);
+  const intl = (0, _reactIntl.useIntl)();
+  const formatMessage = intl.formatMessage,
+    formatNumber = intl.formatNumber;
+  const _useState = (0, _react.useState)(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    devMode = _useState2[0],
+    setDevMode = _useState2[1];
+  (0, _react.useEffect)(function () {
+    if (process.env.NODE_ENV === "development") {
+      const keyDownDetect = function keyDownDetect(ev) {
+        if (ev.key === "i" && ev.ctrlKey) {
+          const keyUpDetect = function keyUpDetect(ev) {
+            if (ev.key === "i") {
+              setDevMode(false);
+            }
+          };
+          setDevMode(true);
+          window.addEventListener("keyup", keyUpDetect);
         }
-    });
-    return Object.assign(Object.assign({}, intl), { txt: (id, params) => {
-            return devMode ? id : formatMessage({ id }, params);
-        }, formatToDoubleDecimal(val, options = {}) {
-            return formatNumber(val, Object.assign({ minimumFractionDigits: 2, maximumFractionDigits: 2 }, options));
-        },
-        formatBigNumber(bigNumber, options) {
-            const { decimalSeparator } = intl
-                .formatNumberToParts(1000.1)
-                .reduce((r, a) => {
-                if (a.type === "decimal")
-                    return Object.assign(Object.assign({}, r), { decimalSeparator: a.value });
-                if (a.type === "group")
-                    return Object.assign(Object.assign({}, r), { thousandSeparator: a.value });
-                return r;
-            }, {});
-            const integerPart = bigNumber.integerValue(1);
-            const integer = intl.formatNumber(integerPart.toNumber(), options);
-            const decimals = bigNumber
-                .minus(integerPart)
-                .decimalPlaces((options === null || options === void 0 ? void 0 : options.maximumFractionDigits) || bigNumber.decimalPlaces(), 5)
-                .toString()
-                .replace("0.", "");
-            return `${integer}${decimals !== "0" ? `${decimalSeparator}${decimals}` : ""}`;
-        } });
+      };
+      window.addEventListener("keydown", keyDownDetect);
+    }
+  });
+  return _objectSpread(_objectSpread({}, intl), {}, {
+    txt: function txt(id, params) {
+      return devMode ? id : formatMessage({
+        id: id
+      }, params);
+    },
+    formatToDoubleDecimal: function formatToDoubleDecimal(val) {
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return formatNumber(val, _objectSpread({
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+      }, options));
+    },
+    formatBigNumber: function formatBigNumber(bigNumber, options) {
+      const _intl$formatNumberToP = intl.formatNumberToParts(1000.1).reduce(function (r, a) {
+          if (a.type === "decimal") return _objectSpread(_objectSpread({}, r), {}, {
+            decimalSeparator: a.value
+          });
+          if (a.type === "group") return _objectSpread(_objectSpread({}, r), {}, {
+            thousandSeparator: a.value
+          });
+          return r;
+        }, {}),
+        decimalSeparator = _intl$formatNumberToP.decimalSeparator;
+      const integerPart = bigNumber.integerValue(1);
+      const integer = intl.formatNumber(integerPart.toNumber(), options);
+      const decimals = bigNumber.minus(integerPart).decimalPlaces((options === null || options === void 0 ? void 0 : options.maximumFractionDigits) || bigNumber.decimalPlaces(), 5).toString().replace("0.", "");
+      return "".concat(integer).concat(decimals !== "0" ? "".concat(decimalSeparator).concat(decimals) : "");
+    }
+  });
 }
-exports.default = useShortIntl;
 function isolateMessages(preffix, strings) {
-    return Object.entries(strings).reduce((r, [k, v]) => (Object.assign(Object.assign({}, r), { [`${preffix}.${k}`]: v })), {});
-}
-exports.isolateMessages = isolateMessages;
-//# sourceMappingURL=useShortIntl.js.map
+  return Object.entries(strings).reduce(function (r, _ref) {
+    let _ref2 = _slicedToArray(_ref, 2),
+      k = _ref2[0],
+      v = _ref2[1];
+    return _objectSpread(_objectSpread({}, r), {}, _defineProperty({}, "".concat(preffix, ".").concat(k), v));
+  }, {});
+}

package/dist/hooks/utility/useEvents.js

@@ -1,28 +1,34 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useEvents;
+var _react = require("react");
 /**
  * This hook allows for easier declaration of events and unsubscribers
  */
 function useEvents() {
-    const _eventSUbscriptionsMap = (0, react_1.useRef)({});
-    const subscriber = (e, cb) => {
-        if (!_eventSUbscriptionsMap.current[e])
-            _eventSUbscriptionsMap.current[e] = [];
-        _eventSUbscriptionsMap.current[e].push(cb);
-        return () => {
-            const arr = _eventSUbscriptionsMap.current[e];
-            arr.splice(arr.indexOf(cb), 1);
-        };
-    };
-    const dispatcher = (eventName, ...args) => {
-        const subscriptions = _eventSUbscriptionsMap.current[eventName] || [];
-        subscriptions.forEach((cb) => cb(...args));
+  const _eventSUbscriptionsMap = (0, _react.useRef)({});
+  const subscriber = function subscriber(e, cb) {
+    if (!_eventSUbscriptionsMap.current[e]) _eventSUbscriptionsMap.current[e] = [];
+    _eventSUbscriptionsMap.current[e].push(cb);
+    return function () {
+      const arr = _eventSUbscriptionsMap.current[e];
+      arr.splice(arr.indexOf(cb), 1);
     };
-    return {
-        subscriber,
-        dispatcher,
-    };
-}
-exports.default = useEvents;
-//# sourceMappingURL=useEvents.js.map
+  };
+  const dispatcher = function dispatcher(eventName) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    const subscriptions = _eventSUbscriptionsMap.current[eventName] || [];
+    subscriptions.forEach(function (cb) {
+      return cb.apply(void 0, args);
+    });
+  };
+  return {
+    subscriber: subscriber,
+    dispatcher: dispatcher
+  };
+}

package/dist/hooks/utility/useModule.js

@@ -1,15 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useModule;
+var _react = require("react");
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 /**
  * This provides an interface for async loading of modules
  */
 function useModule(moduleLoadPromiseFactory) {
-    const [moduleLoaded, setModuleLoaded] = (0, react_1.useState)();
-    (0, react_1.useLayoutEffect)(() => {
-        moduleLoadPromiseFactory().then(setModuleLoaded);
-    }, []);
-    return moduleLoaded;
-}
-exports.default = useModule;
-//# sourceMappingURL=useModule.js.map
+  const _useState = (0, _react.useState)(),
+    _useState2 = _slicedToArray(_useState, 2),
+    moduleLoaded = _useState2[0],
+    setModuleLoaded = _useState2[1];
+  (0, _react.useLayoutEffect)(function () {
+    moduleLoadPromiseFactory().then(setModuleLoaded);
+  }, []);
+  return moduleLoaded;
+}

package/dist/hooks/utility/useQuery.js

@@ -1,14 +1,20 @@
 "use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useQuery;
+var _react = require("react");
+var _reactRouterDom = require("react-router-dom");
 /**
  *
  * @returns A hook to obtain the query params from a url
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = require("react");
-const react_router_dom_1 = require("react-router-dom");
+
 function useQuery() {
-    const { search } = (0, react_router_dom_1.useLocation)();
-    return (0, react_1.useMemo)(() => new URLSearchParams(search), [search]);
-}
-exports.default = useQuery;
-//# sourceMappingURL=useQuery.js.map
+  const _useLocation = (0, _reactRouterDom.useLocation)(),
+    search = _useLocation.search;
+  return (0, _react.useMemo)(function () {
+    return new URLSearchParams(search);
+  }, [search]);
+}

package/dist/models/DebugLogger.js

@@ -1,10 +1,11 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = log;
 const rand = require("color-seed");
 const win = window;
 function log(filter, obj) {
-    if (win.DEBUG === "*" || filter.includes(win.DEBUG))
-        console.log(`%c ${filter}`, `color: ${rand.getColor(filter)}`, obj);
-}
-exports.default = log;
-//# sourceMappingURL=DebugLogger.js.map
+  if (win.DEBUG === "*" || filter.includes(win.DEBUG)) console.log("%c ".concat(filter), "color: ".concat(rand.getColor(filter)), obj);
+}

package/dist/models/GenericContract.js

@@ -1,14 +1,41 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const web3_eth_contract_1 = require("web3-eth-contract");
-class GenericContract extends web3_eth_contract_1.Contract {
-    constructor(jsonInterface, address, options) {
-        super(jsonInterface, address, options);
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _web3EthContract = require("web3-eth-contract");
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // @ts-nocheck
+// oh boy don't do this
+// TS4.0+
+// TS4.1+
+let GenericContract = /*#__PURE__*/function (_Contract) {
+  _inherits(GenericContract, _Contract);
+  var _super = _createSuper(GenericContract);
+  function GenericContract(jsonInterface, address, options) {
+    _classCallCheck(this, GenericContract);
+    return _super.call(this, jsonInterface, address, options);
+  }
+  _createClass(GenericContract, [{
+    key: "getPastEvents",
+    value: function getPastEvents(event, options, callback) {
+      return _get(_getPrototypeOf(GenericContract.prototype), "getPastEvents", this).call(this, event, options, callback);
     }
-    getPastEvents(event, options, callback) {
-        return super.getPastEvents(event, options, callback);
-    }
-}
-exports.default = GenericContract;
-//# sourceMappingURL=GenericContract.js.map
+  }]);
+  return GenericContract;
+}(_web3EthContract.Contract);
+exports.default = GenericContract;

package/dist/reac-app-env.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/storybookUtils/index.js

@@ -1,27 +1,45 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SideBySideContainer = exports.extractAllPossibilitiesFromEnumProp = void 0;
-const react_1 = __importDefault(require("react"));
-const Spacing_1 = __importDefault(require("../components/Spacing"));
-function extractAllPossibilitiesFromEnumProp(component, propName) {
-    return component.__docgenInfo.props[propName].type.value.map((a) => JSON.parse(a.value));
-}
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SideBySideContainer = SideBySideContainer;
 exports.extractAllPossibilitiesFromEnumProp = extractAllPossibilitiesFromEnumProp;
-function SideBySideContainer({ children, exampleName, }) {
-    return (react_1.default.createElement("div", { style: {
-            width: "25%",
-            marginRight: 24,
-            display: "inline-flex",
-            flexDirection: "column",
-        } },
-        react_1.default.createElement("span", { style: { borderBottom: "2px solid black", marginBottom: 14 } },
-            "Tipo: ",
-            react_1.default.createElement("b", null, exampleName)),
-        children,
-        react_1.default.createElement(Spacing_1.default, { size: "large" })));
+var _react = _interopRequireDefault(require("react"));
+var _Spacing = _interopRequireDefault(require("../components/Spacing"));
+var _Text2 = require("../components/Text/Text");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function extractAllPossibilitiesFromEnumProp(component, propName) {
+  console.log(component, _Text2._Text, component === _Text2._Text);
+  if (component === _Text2._Text) _Text2._Text.__docgenInfo.props[propName] = {
+    type: {
+      value: ["title", "description", "error", "caption", "highlightTitle", "highlight", "subtitle", "boldTitle", "link", "boldTitleBig", "content"].map(function (a) {
+        return {
+          value: JSON.stringify(a)
+        };
+      })
+    }
+  };
+  return component.__docgenInfo.props[propName].type.value.map(function (a) {
+    return JSON.parse(a.value);
+  });
 }
-exports.SideBySideContainer = SideBySideContainer;
-//# sourceMappingURL=index.js.map
+function SideBySideContainer(_ref) {
+  let children = _ref.children,
+    exampleName = _ref.exampleName;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      width: "25%",
+      marginRight: 24,
+      display: "inline-flex",
+      flexDirection: "column"
+    }
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    style: {
+      borderBottom: "2px solid black",
+      marginBottom: 14
+    }
+  }, "Tipo: ", /*#__PURE__*/_react.default.createElement("b", null, exampleName)), children, /*#__PURE__*/_react.default.createElement(_Spacing.default, {
+    size: "large"
+  }));
+}

package/dist/type-utils.js

@@ -1,3 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=type-utils.js.map
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/types.js

@@ -1,3 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/utility.d.js

@@ -0,0 +1,17 @@
+"use strict";
+
+/**
+ * These are typings made to support separated function and prevent excessive Generics usage accross the application
+ *
+ * Redeclare this namespace with the usefull typings for your project and enjoy intelisense :)
+ */
+let OnepercentUtility;
+(function () {
+  /** The ids used by the useShortIntl hooks */
+  /** A type hint to bind the LinkToId action and the SectionContainer identifier */
+  /** A type hint to autocomplete functions related to the AsyncProcess context */
+  let AsyncQueue;
+  (function () {})(AsyncQueue || (AsyncQueue = {}));
+  let UIElements;
+  (function () {})(UIElements || (UIElements = {}));
+})(OnepercentUtility || (OnepercentUtility = {}));

package/dist/utils/blockchain.js

@@ -1,61 +1,67 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendAndWaitForConfirmation = exports.dispatchAndWait = exports.waitForConfirmation = exports.isTransactionMined = void 0;
-function isTransactionMined(transactionHash, provider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const transaction = yield provider.eth.getTransactionReceipt(transactionHash);
-        if (!transaction ||
-            !transaction.blockHash ||
-            transaction.status === undefined)
-            return undefined; // I still don't know if it's loaded
-        else
-            return !!transaction.status === true;
-    });
-}
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dispatchAndWait = dispatchAndWait;
 exports.isTransactionMined = isTransactionMined;
-function waitForConfirmation(tHash, provider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise((r, rej) => __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                const bought = yield isTransactionMined(tHash, provider);
-                if (bought === undefined)
-                    yield new Promise((r) => setTimeout(() => r(), 2000));
-                else {
-                    if (bought)
-                        r();
-                    else
-                        rej('TRANSACTION_FAILED');
-                    break;
-                }
-            }
-        }));
-    });
-}
+exports.sendAndWaitForConfirmation = sendAndWaitForConfirmation;
 exports.waitForConfirmation = waitForConfirmation;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function isTransactionMined() {
+  return _isTransactionMined.apply(this, arguments);
+}
+function _isTransactionMined() {
+  _isTransactionMined = _asyncToGenerator(function* (transactionHash, provider) {
+    const transaction = yield provider.eth.getTransactionReceipt(transactionHash);
+    if (!transaction || !transaction.blockHash || transaction.status === undefined) return undefined; // I still don't know if it's loaded
+    else return !!transaction.status === true;
+  });
+  return _isTransactionMined.apply(this, arguments);
+}
+function waitForConfirmation() {
+  return _waitForConfirmation.apply(this, arguments);
+}
+function _waitForConfirmation() {
+  _waitForConfirmation = _asyncToGenerator(function* (tHash, provider) {
+    return new Promise( /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (r, rej) {
+        while (true) {
+          const bought = yield isTransactionMined(tHash, provider);
+          if (bought === undefined) yield new Promise(function (r) {
+            return setTimeout(function () {
+              return r();
+            }, 2000);
+          });else {
+            if (bought) r();else rej('TRANSACTION_FAILED');
+            break;
+          }
+        }
+      });
+      return function () {
+        return _ref.apply(this, arguments);
+      };
+    }());
+  });
+  return _waitForConfirmation.apply(this, arguments);
+}
 function dispatchAndWait(func) {
-    const _func = func;
-    return new Promise((r, rej) => {
-        _func.on('transactionHash', (tX) => {
-            r(tX);
-        });
-        _func.catch(rej);
+  const _func = func;
+  return new Promise(function (r, rej) {
+    _func.on('transactionHash', function (tX) {
+      r(tX);
     });
+    _func.catch(rej);
+  });
 }
-exports.dispatchAndWait = dispatchAndWait;
-function sendAndWaitForConfirmation(func, provider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const tHash = yield dispatchAndWait(func);
-        yield waitForConfirmation(tHash, provider);
-    });
+function sendAndWaitForConfirmation() {
+  return _sendAndWaitForConfirmation.apply(this, arguments);
 }
-exports.sendAndWaitForConfirmation = sendAndWaitForConfirmation;
-//# sourceMappingURL=blockchain.js.map
+function _sendAndWaitForConfirmation() {
+  _sendAndWaitForConfirmation = _asyncToGenerator(function* (func, provider) {
+    const tHash = yield dispatchAndWait(func);
+    yield waitForConfirmation(tHash, provider);
+  });
+  return _sendAndWaitForConfirmation.apply(this, arguments);
+}

package/dist/utils/flatten.js

@@ -1,15 +1,25 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatten = void 0;
-function flatten(obj) {
-    return Object.assign({}, ...(function _flatten(o, prevKey = "") {
-        return [].concat(...Object.keys(o).map((_k) => {
-            const k = _k;
-            return typeof o[k] === "object"
-                ? _flatten(o[k], prevKey ? `${prevKey}.${k}` : k)
-                : { [prevKey ? `${prevKey}.${k}` : k]: o[k] };
-        }));
-    })(obj));
-}
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.flatten = flatten;
-//# sourceMappingURL=flatten.js.map
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function flatten(obj) {
+  return Object.assign.apply(Object, [{}].concat(_toConsumableArray(function _flatten(o, _ref) {
+    let prevKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    return (_ref = []).concat.apply(_ref, _toConsumableArray(Object.keys(o).map(function (_k) {
+      const k = _k;
+      return _typeof(o[k]) === "object" ? _flatten(o[k], prevKey ? "".concat(prevKey, ".").concat(k) : k) : _defineProperty({}, prevKey ? "".concat(prevKey, ".").concat(k) : k, o[k]);
+    })));
+  }(obj))));
+}