@elliemae/ds-shared 2.3.0-alpha.8 → 2.3.0-next.10

package/cjs/GroupContext/Group.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+var GroupContext = require('./GroupContext.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const getValueItem = e => {
+  const {
+    target,
+    currentTarget
+  } = e;
+
+  if (target) {
+    const {
+      value
+    } = target;
+    return value;
+  }
+
+  if (currentTarget) {
+    const {
+      value
+    } = currentTarget;
+    return value;
+  }
+
+  return e;
+};
+
+const toggleItemValue = (array, e) => {
+  const newvalue = getValueItem(e);
+  const res = array;
+  const index = array.indexOf(newvalue);
+
+  if (index === -1) {
+    res.push(newvalue);
+  } else {
+    res.splice(index, 1);
+  }
+
+  return res;
+};
+
+const {
+  Provider
+} = GroupContext.GroupContext;
+/** deprecated use CheckableGroup instead */
+
+class Group extends React.Component {
+  constructor(props) {
+    super(props);
+    const {
+      activeValue,
+      disabled
+    } = props;
+    this.state = {
+      activeValue,
+      disabled,
+      prevValue: null,
+      onChange: this.handleChange.bind(this)
+    };
+  }
+
+  static getDerivedStateFromProps(nextProps, _ref) {
+    let {
+      prevValue
+    } = _ref;
+    if (nextProps.activeValue === prevValue) return null;
+    return {
+      activeValue: nextProps.activeValue,
+      prevValue: nextProps.activeValue
+    };
+  }
+
+  handleChange(e) {
+    const {
+      multiple,
+      onChange
+    } = this.props;
+    const {
+      activeValue
+    } = this.state;
+    const value = getValueItem(e);
+    let newValue;
+
+    if (multiple) {
+      newValue = toggleItemValue(activeValue || [], value);
+    } else if (activeValue !== value) {
+      // default behaviour it will be toggle the active value
+      newValue = value;
+    }
+
+    this.setState({
+      activeValue: newValue
+    });
+
+    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      rest[_key - 1] = arguments[_key];
+    }
+
+    if (onChange) onChange(newValue, ...rest);
+  }
+
+  render() {
+    const {
+      children
+    } = this.props;
+    return /*#__PURE__*/_jsx__default["default"](Provider, {
+      value: this.state
+    }, void 0, children);
+  }
+
+}
+
+Group.defaultProps = {
+  multiple: false
+};
+
+module.exports = Group;

package/cjs/GroupContext/GroupContext.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const GroupContext = /*#__PURE__*/React__default["default"].createContext();
+
+exports.GroupContext = GroupContext;

package/cjs/GroupContext/GroupItem.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('react');
+var GroupContext = require('./GroupContext.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const {
+  Consumer
+} = GroupContext.GroupContext;
+
+const GroupItem = _ref => {
+  let {
+    render
+  } = _ref;
+  return /*#__PURE__*/_jsx__default["default"](Consumer, {}, void 0, context => render(context));
+};
+
+module.exports = GroupItem;

package/cjs/GroupContext/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Group = require('./Group.js');
+var GroupContext = require('./GroupContext.js');
+var GroupItem = require('./GroupItem.js');
+
+
+
+exports.Group = Group;
+exports.GroupContext = GroupContext.GroupContext;
+exports.GroupItem = GroupItem;

package/cjs/ScrollSync/ScrollSync.js

@@ -0,0 +1,153 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.find.js');
+require('core-js/modules/esnext.iterator.find.js');
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const ScrollSyncContext = /*#__PURE__*/React__default["default"].createContext();
+const {
+  Provider
+} = ScrollSyncContext;
+class ScrollSync extends React.Component {
+  constructor(props) {
+    super(props);
+    this.panes = {};
+
+    this.registerPane = (node, groups) => {
+      groups.forEach(group => {
+        if (!this.panes[group]) {
+          this.panes[group] = [];
+        }
+
+        if (this.panes[group].length > 0) {
+          this.syncScrollPosition(this.panes[group][0], node);
+        }
+
+        this.panes[group].push(node);
+      });
+      this.addEvents(node, groups);
+    };
+
+    this.unregisterPane = (node, groups) => {
+      groups.forEach(group => {
+        if (this.findPane(node, group)) {
+          this.removeEvents(node);
+          this.panes[group].splice(this.panes[group].indexOf(node), 1);
+        }
+      });
+    };
+
+    this.addEvents = (node, groups) => {
+      /* For some reason element.addEventListener doesnt work with document.body */
+      node.onscroll = this.handlePaneScroll.bind(this, node, groups); // eslint-disable-line
+    };
+
+    this.removeEvents = node => {
+      /* For some reason element.removeEventListener doesnt work with document.body */
+      node.onscroll = null; // eslint-disable-line
+    };
+
+    this.findPane = (node, group) => {
+      if (!this.panes[group]) {
+        return false;
+      }
+
+      return this.panes[group].find(pane => pane === node);
+    };
+
+    this.handlePaneScroll = (node, groups, e) => {
+      const {
+        enabled
+      } = this.props;
+      if (this.props.onScroll) this.props.onScroll(e);
+      if (!enabled) return;
+      window.requestAnimationFrame(() => {
+        this.syncScrollPositions(node, groups);
+      });
+    };
+
+    this.syncScrollPositions = (scrolledPane, groups) => {
+      groups.forEach(group => {
+        this.panes[group].forEach(pane => {
+          /* For all panes beside the currently scrolling one */
+          if (scrolledPane !== pane) {
+            /* Remove event listeners from the node that we'll manipulate */
+            this.removeEvents(pane, group);
+            this.syncScrollPosition(scrolledPane, pane);
+            /* Re-attach event listeners after we're done scrolling */
+
+            window.requestAnimationFrame(() => {
+              this.addEvents(pane, groups);
+            });
+          }
+        });
+      });
+    };
+
+    this.syncContext = {
+      registerPane: this.registerPane,
+      unregisterPane: this.unregisterPane
+    };
+  }
+
+  syncScrollPosition(scrolledPane, pane) {
+    const {
+      scrollTop,
+      scrollHeight,
+      clientHeight,
+      scrollLeft,
+      scrollWidth,
+      clientWidth
+    } = scrolledPane;
+    const scrollTopOffset = scrollHeight - clientHeight;
+    const scrollLeftOffset = scrollWidth - clientWidth;
+    const {
+      proportional,
+      vertical,
+      horizontal
+    } = this.props;
+    /* Calculate the actual pane height */
+
+    const paneHeight = pane.scrollHeight - clientHeight;
+    const paneWidth = pane.scrollWidth - clientWidth;
+    /* Adjust the scrollTop position of it accordingly */
+
+    if (vertical && scrollTopOffset > 0) {
+      pane.scrollTop = proportional ? paneHeight * scrollTop / scrollTopOffset : scrollTop; // eslint-disable-line
+    }
+
+    if (horizontal && scrollLeftOffset > 0) {
+      pane.scrollLeft = proportional ? paneWidth * scrollLeft / scrollLeftOffset : scrollLeft; // eslint-disable-line
+    }
+  }
+
+  render() {
+    const {
+      children
+    } = this.props;
+    return /*#__PURE__*/_jsx__default["default"](Provider, {
+      value: this.syncContext
+    }, void 0, React__default["default"].Children.only(children));
+  }
+
+}
+ScrollSync.defaultProps = {
+  proportional: true,
+  vertical: true,
+  horizontal: true,
+  enabled: true
+};
+
+exports.ScrollSyncContext = ScrollSyncContext;
+exports["default"] = ScrollSync;

package/cjs/ScrollSync/ScrollSyncPane.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.constructor.js');
+require('core-js/modules/esnext.async-iterator.to-array.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.to-array.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var React = require('react');
+var ScrollSync = require('./ScrollSync.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+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__default["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; }
+
+class ScrollSyncPane extends React.Component {
+  constructor() {
+    super(...arguments);
+
+    this.toArray = groups => [].concat(groups);
+  }
+
+  componentWillUnmount() {
+    const {
+      enabled,
+      group,
+      syncContext
+    } = this.props;
+    const {
+      unregisterPane
+    } = syncContext;
+    if (enabled) unregisterPane(this.node, this.toArray(group));
+  }
+
+  render() {
+    const {
+      children,
+      group,
+      syncContext,
+      notPaginated
+    } = this.props;
+    const {
+      registerPane
+    } = syncContext;
+    return children({
+      registerPane: node => {
+        if (notPaginated) {
+          const virtualizedBody = node.querySelector('.virtualized-body-wrapper');
+
+          if (virtualizedBody) {
+            registerPane(virtualizedBody, this.toArray(group));
+          }
+        }
+
+        return registerPane(node, this.toArray(group));
+      }
+    });
+  }
+
+}
+
+ScrollSyncPane.defaultProps = {
+  group: 'default',
+  enabled: true
+};
+var ScrollSyncPane$1 = (props => /*#__PURE__*/_jsx__default["default"](ScrollSync.ScrollSyncContext.Consumer, {}, void 0, context => /*#__PURE__*/jsxRuntime.jsx(ScrollSyncPane, _objectSpread(_objectSpread({}, props), {}, {
+  syncContext: context
+}))));
+
+module.exports = ScrollSyncPane$1;

package/cjs/ScrollSync/ScrollSyncProvider.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.find.js');
+require('core-js/modules/esnext.iterator.find.js');
+var React = require('react');
+var raf = require('raf');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var raf__default = /*#__PURE__*/_interopDefaultLegacy(raf);
+
+const ScrollSyncContext = /*#__PURE__*/React__default["default"].createContext();
+const {
+  Provider
+} = ScrollSyncContext;
+
+function ScrollSyncProvider(_ref) {
+  let {
+    enabled,
+    horizontal,
+    vertical,
+    children
+  } = _ref;
+  useRef();
+
+  raf__default["default"]((scrolledPane, pane) => {
+    const {
+      scrollTop,
+      scrollHeight,
+      clientHeight,
+      scrollLeft,
+      scrollWidth,
+      clientWidth
+    } = scrolledPane;
+    const scrollTopOffset = scrollHeight - clientHeight;
+    const scrollLeftOffset = scrollWidth - clientWidth;
+    const {
+      proportional,
+      vertical,
+      horizontal
+    } = this.props;
+    /* Calculate the actual pane height */
+
+    const paneHeight = pane.scrollHeight - clientHeight;
+    const paneWidth = pane.scrollWidth - clientWidth;
+    /* Adjust the scrollTop position of it accordingly */
+
+    if (vertical && scrollTopOffset > 0) {
+      pane.scrollTop = proportional ? paneHeight * scrollTop / scrollTopOffset : scrollTop; // eslint-disable-line
+    }
+
+    if (horizontal && scrollLeftOffset > 0) {
+      pane.scrollLeft = proportional ? paneWidth * scrollLeft / scrollLeftOffset : scrollLeft; // eslint-disable-line
+    }
+  });
+  return /*#__PURE__*/_jsx__default["default"](Provider, {}, void 0, children);
+}
+
+ScrollSyncProvider.defaultProps = {};
+
+module.exports = ScrollSyncProvider;

package/cjs/ScrollSync/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ScrollSync = require('./ScrollSync.js');
+var ScrollSyncPane = require('./ScrollSyncPane.js');
+
+
+
+exports.ScrollSync = ScrollSync["default"];
+exports.ScrollSyncPane = ScrollSyncPane;

package/cjs/ScrollSync/useScrollSync.js

@@ -0,0 +1,10 @@
+'use strict';
+
+function useScrollSync(props) {
+  return {};
+}
+
+useScrollSync.propTypes = {};
+useScrollSync.defaultProps = {};
+
+module.exports = useScrollSync;

package/cjs/constants.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DEFAULT_DELAY_OPEN = 200;
+const DEFAULT_DELAY_CLOSE = 300;
+const sizeOptions = ['small', 'medium', 'large', 'x-large'];
+const AM = 'am';
+const PM = 'pm';
+const ARROW_UP = 'ArrowUp';
+const ARROW_DOWN = 'ArrowDown';
+const BACKSPACE = 'Backspace';
+const ESCAPE = 'Escape';
+const HOME = 'Home';
+const SHIFT = 'Shift';
+const END = 'End';
+const HOUR_RANGE_12 = {
+  min: 0,
+  max: 12
+};
+const HOUR_RANGE_24 = {
+  min: 0,
+  max: 24
+};
+const GENERAL_TIME_RANGE = {
+  min: 0,
+  max: 59
+};
+const PLACEHOLDER_TIME = {
+  hour: 'hour',
+  minutes: 'minutes',
+  seconds: 'seconds',
+  meridiem: 'meridiem'
+};
+
+exports.AM = AM;
+exports.ARROW_DOWN = ARROW_DOWN;
+exports.ARROW_UP = ARROW_UP;
+exports.BACKSPACE = BACKSPACE;
+exports.DEFAULT_DELAY_CLOSE = DEFAULT_DELAY_CLOSE;
+exports.DEFAULT_DELAY_OPEN = DEFAULT_DELAY_OPEN;
+exports.END = END;
+exports.ESCAPE = ESCAPE;
+exports.GENERAL_TIME_RANGE = GENERAL_TIME_RANGE;
+exports.HOME = HOME;
+exports.HOUR_RANGE_12 = HOUR_RANGE_12;
+exports.HOUR_RANGE_24 = HOUR_RANGE_24;
+exports.PLACEHOLDER_TIME = PLACEHOLDER_TIME;
+exports.PM = PM;
+exports.SHIFT = SHIFT;
+exports.sizeOptions = sizeOptions;

package/cjs/createDataInstance/createInstancePlugin.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+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__default["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; }
+
+function getDecoratorsFromHooks(hooks, decorators) {
+  const nextDecorators = _objectSpread({}, decorators);
+
+  Object.keys(hooks).forEach(decorator => {
+    if (Array.isArray(decorators[decorator])) {
+      nextDecorators[decorator] = [...decorators[decorator], hooks[decorator]];
+    } else {
+      nextDecorators[decorator] = hooks[decorator];
+    }
+  });
+  return nextDecorators;
+}
+
+function createInstancePlugin(name, hooks) {
+  return decorators => getDecoratorsFromHooks(hooks, decorators);
+}
+
+module.exports = createInstancePlugin;

package/cjs/createDataInstance/createInstanceRef.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var uuid = require('uuid');
+var React = require('react');
+var lodash = require('lodash');
+var utils = require('./utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+
+const _excluded = ["uuid", "data", "renderers", "plugins", "customDecorators"];
+
+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__default["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; }
+const defaultDecorators = {
+  instance: [],
+  state: [],
+  hotKeys: [],
+  renderers: [],
+  composeData: []
+};
+function createDataInstanceRef(_ref) {
+  let {
+    uuid: uuidProp,
+    data,
+    renderers,
+    plugins,
+    customDecorators
+  } = _ref,
+      props = _objectWithoutProperties__default["default"](_ref, _excluded);
+
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const instance = React.useRef(); // eslint-disable-next-line react-hooks/rules-of-hooks
+
+  const [uuid$1] = React.useState(uuidProp || (() => uuid.v4()));
+  instance.current = {
+    uuid: uuid$1,
+    state: {},
+    actions: {},
+    hotKeys: {},
+    // keyboard hotkeys to run specific actions
+    originalData: data,
+    records: [],
+    // item abstraction with meta data for originalData
+    renderers,
+
+    ref(key) {
+      // eslint-disable-next-line no-return-assign
+      return node => instance.current.refs[key] = node;
+    },
+
+    getInstance() {
+      return instance.current;
+    },
+
+    props
+  }; // eslint-disable-next-line react-hooks/rules-of-hooks
+
+  const decorators = React.useMemo(() => {
+    let nextDecorators = _objectSpread(_objectSpread({}, defaultDecorators), customDecorators);
+
+    plugins.forEach(plugin => {
+      if (!plugin) return;
+      nextDecorators = plugin(nextDecorators);
+    });
+    Object.keys(nextDecorators).forEach(key => {
+      if (Array.isArray(nextDecorators[key])) nextDecorators[key] = lodash.orderBy(nextDecorators[key], item => item.order);
+    });
+    return nextDecorators;
+  }, []); // the plugins are defined on creation, but not changed at runtime
+  // todo: test if getting the hooks without registering them
+  //  here would be beneficial to memoize instance and squeeze performance
+
+  instance.current = decorators.instance.reduce(utils.mergeInstance, instance.current);
+  instance.current = decorators.state.reduce(utils.registerStateHookToInstance, instance.current);
+  instance.current = decorators.hotKeys.reduce(utils.registerHotKeysHookToInstance, instance.current);
+  instance.current.renderers = decorators.renderers.reduce((result, decorator) => decorator(result, instance.current), renderers);
+  return {
+    instance,
+    decorators
+  };
+}
+
+module.exports = createDataInstanceRef;