@injectable-ts/react/index.cjs.js

Purely-functional strictly-typed IoC/DI for TypeScript

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var React = require('react');
var core = require('@injectable-ts/core');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n["default"] = e;
  return Object.freeze(n);
}

var React__namespace = /*#__PURE__*/_interopNamespace(React);

const context = /* @__PURE__ */ React.createContext(undefined);

/* @__NO_SIDE_EFFECTS__ */ function useInjectable(input, overrides) {
    const dependencies = React.useContext(context);
    if (dependencies === undefined) {
        throw new Error('useInjectable must be called within DependenciesProvider subtree');
    }
    return React.useMemo(() => 
    // eslint-disable-next-line no-restricted-syntax
    input(overrides === undefined
        ? dependencies
        : Object.assign(Object.assign({}, dependencies), overrides)), [dependencies, overrides, input]);
}

const checkedAccessor = (dependencies, name) => {
    if (name in dependencies) {
        return dependencies[name];
    }
    throw new Error(`Missing dependency: ${JSON.stringify(name)}`);
};
/* @__NO_SIDE_EFFECTS__ */ function DependenciesProvider(props) {
    const previousDependencies = React.useContext(context);
    const mergedDependencies = React.useMemo(() => (Object.assign(Object.assign({ [core.TOKEN_ACCESSOR_KEY]: checkedAccessor }, previousDependencies), props.value)), [previousDependencies, props.value]);
    return (React__namespace.createElement(context.Provider, { value: mergedDependencies }, props.children));
}

exports.DependenciesProvider = DependenciesProvider;
exports.useInjectable = useInjectable;