Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/uncontrollable/lib/cjs/uncontrollable.js
49c99f97fe9aissn4frontend

uncontrollable.js
View Options

			"use strict";

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

			var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

			exports.__esModule = true;
			exports.default = uncontrollable;

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

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

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

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

			var _reactLifecyclesCompat = require("react-lifecycles-compat");

			var _invariant = _interopRequireDefault(require("invariant"));

			var Utils = _interopRequireWildcard(require("./utils"));

			var _jsxFileName = "/Users/jquense/src/uncontrollable/src/uncontrollable.js";

			function uncontrollable(Component, controlledValues, methods) {
			if (methods === void 0) {
			methods = [];
			}

			var displayName = Component.displayName \|\| Component.name \|\| 'Component';
			var canAcceptRef = Utils.canAcceptRef(Component);
			var controlledProps = Object.keys(controlledValues);
			var PROPS_TO_OMIT = controlledProps.map(Utils.defaultKey);
			!(canAcceptRef \|\| !methods.length) ? process.env.NODE_ENV !== "production" ? (0, _invariant.default)(false, '[uncontrollable] stateless function components cannot pass through methods ' + 'because they have no associated instances. Check component: ' + displayName + ', ' + 'attempting to pass through methods: ' + methods.join(', ')) : invariant(false) : void 0;

			var UncontrolledComponent =
			/#__PURE__/
			function (_React$Component) {
			(0, _inheritsLoose2.default)(UncontrolledComponent, _React$Component);

			function UncontrolledComponent() {
			var _this;

			for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
			args[_key] = arguments[_key];
			}

			_this = _React$Component.call.apply(_React$Component, [this].concat(args)) \|\| this;
			_this.handlers = Object.create(null);
			controlledProps.forEach(function (propName) {
			var handlerName = controlledValues[propName];

			var handleChange = function handleChange(value) {
			if (_this.props[handlerName]) {
			var _this$props;

			_this._notifying = true;

			for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
			args[_key2 - 1] = arguments[_key2];
			}

			(_this$props = _this.props)[handlerName].apply(_this$props, [value].concat(args));

			_this._notifying = false;
			}

			if (!_this.unmounted) _this.setState(function (_ref) {
			var _extends2;

			var values = _ref.values;
			return {
			values: (0, _extends3.default)(Object.create(null), values, (_extends2 = {}, _extends2[propName] = value, _extends2))
			};
			});
			};

			_this.handlers[handlerName] = handleChange;
			});
			if (methods.length) _this.attachRef = function (ref) {
			_this.inner = ref;
			};
			var values = Object.create(null);
			controlledProps.forEach(function (key) {
			values[key] = _this.props[Utils.defaultKey(key)];
			});
			_this.state = {
			values: values,
			prevProps: {}
			};
			return _this;
			}

			var _proto = UncontrolledComponent.prototype;

			_proto.shouldComponentUpdate = function shouldComponentUpdate() {
			//let setState trigger the update
			return !this._notifying;
			};

			UncontrolledComponent.getDerivedStateFromProps = function getDerivedStateFromProps(props, _ref2) {
			var values = _ref2.values,
			prevProps = _ref2.prevProps;
			var nextState = {
			values: (0, _extends3.default)(Object.create(null), values),
			prevProps: {}
			};
			controlledProps.forEach(function (key) {
			/**
			* If a prop switches from controlled to Uncontrolled
			* reset its value to the defaultValue
			*/
			nextState.prevProps[key] = props[key];

			if (!Utils.isProp(props, key) && Utils.isProp(prevProps, key)) {
			nextState.values[key] = props[Utils.defaultKey(key)];
			}
			});
			return nextState;
			};

			_proto.componentWillUnmount = function componentWillUnmount() {
			this.unmounted = true;
			};

			_proto.render = function render() {
			var _this2 = this;

			var _this$props2 = this.props,
			innerRef = _this$props2.innerRef,
			props = (0, _objectWithoutPropertiesLoose2.default)(_this$props2, ["innerRef"]);
			PROPS_TO_OMIT.forEach(function (prop) {
			delete props[prop];
			});
			var newProps = {};
			controlledProps.forEach(function (propName) {
			var propValue = _this2.props[propName];
			newProps[propName] = propValue !== undefined ? propValue : _this2.state.values[propName];
			});
			return _react.default.createElement(Component, (0, _extends3.default)({}, props, newProps, this.handlers, {
			ref: innerRef \|\| this.attachRef
			}));
			};

			return UncontrolledComponent;
			}(_react.default.Component);

			(0, _reactLifecyclesCompat.polyfill)(UncontrolledComponent);
			UncontrolledComponent.displayName = "Uncontrolled(" + displayName + ")";
			UncontrolledComponent.propTypes = (0, _extends3.default)({
			innerRef: function innerRef() {}
			}, Utils.uncontrolledPropTypes(controlledValues, displayName));
			methods.forEach(function (method) {
			UncontrolledComponent.prototype[method] = function $proxiedMethod() {
			var _this$inner;

			return (_this$inner = this.inner)[method].apply(_this$inner, arguments);
			};
			});
			var WrappedComponent = UncontrolledComponent;

			if (_react.default.forwardRef) {
			WrappedComponent = _react.default.forwardRef(function (props, ref) {
			return _react.default.createElement(UncontrolledComponent, (0, _extends3.default)({}, props, {
			innerRef: ref,
			__source: {
			fileName: _jsxFileName,
			lineNumber: 128
			},
			__self: this
			}));
			});
			WrappedComponent.propTypes = UncontrolledComponent.propTypes;
			}

			WrappedComponent.ControlledComponent = Component;
			/**
			* useful when wrapping a Component and you want to control
			* everything
			*/

			WrappedComponent.deferControlTo = function (newComponent, additions, nextMethods) {
			if (additions === void 0) {
			additions = {};
			}

			return uncontrollable(newComponent, (0, _extends3.default)({}, controlledValues, additions), nextMethods);
			};

			return WrappedComponent;
			}

			module.exports = exports["default"];