react-magnetic-di/lib/cjs/react/provider.js

Context driven dependency injection

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.withDi = withDi;
exports.DiProvider = void 0;

var _react = _interopRequireWildcard(require("react"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _constants = require("./constants");

var _context = require("./context");

var _utils = require("./utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (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 _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 DiProvider = function DiProvider(_ref) {
  var children = _ref.children,
      use = _ref.use,
      target = _ref.target;

  var _useContext = (0, _react.useContext)(_context.Context),
      _getDependencies = _useContext.getDependencies; // memo provider value so gets computed only once


  var value = (0, _react.useMemo)(function () {
    // create a map of dependency real -> replacement for fast lookup
    var replacementMap = use.reduce(function (m, d) {
      return m.set(d[_constants.KEY], d);
    }, new Map()); // support single or multiple targets

    var targets = target && (Array.isArray(target) ? target : [target]);
    return {
      getDependencies: function getDependencies(realDeps, targetChild) {
        // First we collect dependencies from parent provider(s) (if any)
        var dependencies = _getDependencies(realDeps, targetChild); // If no target or target is in the array of targets, map use


        if (!targetChild || !targets || targets.includes(targetChild)) {
          return dependencies.map(function (dep) {
            // dep can be either the original or a replacement
            // if another provider at the top has already swapped it
            // so we check if here we need to inject a different one
            // or return the original / parent replacement
            var real = dep[_constants.KEY] || dep;
            return replacementMap.get(real) || dep;
          });
        }

        return dependencies;
      }
    };
  }, [_getDependencies]); // ignore use & target props

  return /*#__PURE__*/_react["default"].createElement(_context.Context.Provider, {
    value: value
  }, children);
};

exports.DiProvider = DiProvider;
DiProvider.propTypes = {
  children: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].node]),
  target: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].arrayOf(_propTypes["default"].func)]),
  use: _propTypes["default"].arrayOf(_propTypes["default"].func).isRequired
};

function withDi(Comp, deps) {
  var target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  var WrappedComponent = /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
    return /*#__PURE__*/_react["default"].createElement(DiProvider, {
      use: deps,
      target: target
    }, /*#__PURE__*/_react["default"].createElement(Comp, _extends({
      ref: ref
    }, props)));
  });
  WrappedComponent.displayName = (0, _utils.getDisplayName)(Comp, 'withDi');
  return WrappedComponent;
}