From 2e40c371d90762220228b3ab5b1d276607b69a94 Mon Sep 17 00:00:00 2001 From: Sam Kauffman Date: Thu, 2 Aug 2018 15:33:30 -0400 Subject: [PATCH] commit dist to build from repo hopefully this will be pushed to NPM soon --- .gitignore | 1 - dist/SimpleMap.js | 36 ++++++++ dist/extendReactClass.js | 95 ++++++++++++++++++++ dist/generateAppendClassName.js | 61 +++++++++++++ dist/index.js | 77 ++++++++++++++++ dist/isIterable.js | 41 +++++++++ dist/linkClass.js | 153 ++++++++++++++++++++++++++++++++ dist/makeConfiguration.js | 63 +++++++++++++ dist/parseStyleName.js | 38 ++++++++ dist/renderNothing.js | 19 ++++ dist/wrapStatelessFunction.js | 78 ++++++++++++++++ 11 files changed, 661 insertions(+), 1 deletion(-) create mode 100644 dist/SimpleMap.js create mode 100644 dist/extendReactClass.js create mode 100644 dist/generateAppendClassName.js create mode 100644 dist/index.js create mode 100644 dist/isIterable.js create mode 100644 dist/linkClass.js create mode 100644 dist/makeConfiguration.js create mode 100644 dist/parseStyleName.js create mode 100644 dist/renderNothing.js create mode 100644 dist/wrapStatelessFunction.js diff --git a/.gitignore b/.gitignore index d54786c..3d02704 100755 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ node_modules coverage -dist *.log .* !.README diff --git a/dist/SimpleMap.js b/dist/SimpleMap.js new file mode 100644 index 0000000..66b85b7 --- /dev/null +++ b/dist/SimpleMap.js @@ -0,0 +1,36 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _class = function () { + function _class() { + _classCallCheck(this, _class); + + this.size = 0; + this.keys = []; + this.values = []; + } + + _class.prototype.get = function get(key) { + var index = this.keys.indexOf(key); + + return this.values[index]; + }; + + _class.prototype.set = function set(key, value) { + this.keys.push(key); + this.values.push(value); + this.size = this.keys.length; + + return value; + }; + + return _class; +}(); + +exports.default = _class; +module.exports = exports["default"]; \ No newline at end of file diff --git a/dist/extendReactClass.js b/dist/extendReactClass.js new file mode 100644 index 0000000..be8112c --- /dev/null +++ b/dist/extendReactClass.js @@ -0,0 +1,95 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _isObject2 = require('lodash/isObject'); + +var _isObject3 = _interopRequireDefault(_isObject2); + +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _hoistNonReactStatics = require('hoist-non-react-statics'); + +var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics); + +var _linkClass = require('./linkClass'); + +var _linkClass2 = _interopRequireDefault(_linkClass); + +var _renderNothing = require('./renderNothing'); + +var _renderNothing2 = _interopRequireDefault(_renderNothing); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } /* eslint-disable react/prop-types */ + +/** + * @param {ReactClass} Component + * @param {Object} defaultStyles + * @param {Object} options + * @returns {ReactClass} + */ +exports.default = function (Component, defaultStyles, options) { + var WrappedComponent = function (_Component) { + _inherits(WrappedComponent, _Component); + + function WrappedComponent() { + _classCallCheck(this, WrappedComponent); + + return _possibleConstructorReturn(this, _Component.apply(this, arguments)); + } + + WrappedComponent.prototype.render = function render() { + var styles = void 0; + + var hasDefaultstyles = (0, _isObject3.default)(defaultStyles); + + if (this.props.styles || hasDefaultstyles) { + var props = Object.assign({}, this.props); + + if (props.styles) { + styles = props.styles; + } else if (hasDefaultstyles) { + styles = defaultStyles; + delete props.styles; + } + + Object.defineProperty(props, 'styles', { + configurable: true, + enumerable: false, + value: styles, + writable: false + }); + + this.props = props; + } else { + styles = {}; + } + + var renderResult = _Component.prototype.render.call(this); + + if (renderResult) { + return (0, _linkClass2.default)(renderResult, styles, options); + } + + return (0, _renderNothing2.default)(_react2.default.version); + }; + + return WrappedComponent; + }(Component); + + return (0, _hoistNonReactStatics2.default)(WrappedComponent, Component); +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/generateAppendClassName.js b/dist/generateAppendClassName.js new file mode 100644 index 0000000..23467e1 --- /dev/null +++ b/dist/generateAppendClassName.js @@ -0,0 +1,61 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _SimpleMap = require('./SimpleMap'); + +var _SimpleMap2 = _interopRequireDefault(_SimpleMap); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var CustomMap = typeof Map === 'undefined' ? _SimpleMap2.default : Map; + +var stylesIndex = new CustomMap(); + +exports.default = function (styles, styleNames, handleNotFoundStyleName) { + var appendClassName = void 0; + var stylesIndexMap = void 0; + + stylesIndexMap = stylesIndex.get(styles); + + if (stylesIndexMap) { + var styleNameIndex = stylesIndexMap.get(styleNames); + + if (styleNameIndex) { + return styleNameIndex; + } + } else { + stylesIndexMap = new CustomMap(); + stylesIndex.set(styles, new CustomMap()); + } + + appendClassName = ''; + + for (var styleName in styleNames) { + if (styleNames.hasOwnProperty(styleName)) { + var className = styles[styleNames[styleName]]; + + if (className) { + appendClassName += ' ' + className; + } else { + if (handleNotFoundStyleName === 'throw') { + throw new Error('"' + styleNames[styleName] + '" CSS module is undefined.'); + } + if (handleNotFoundStyleName === 'log') { + // eslint-disable-next-line no-console + console.warn('"' + styleNames[styleName] + '" CSS module is undefined.'); + } + } + } + } + + appendClassName = appendClassName.trim(); + + stylesIndexMap.set(styleNames, appendClassName); + + return appendClassName; +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..9b4810c --- /dev/null +++ b/dist/index.js @@ -0,0 +1,77 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _isFunction2 = require('lodash/isFunction'); + +var _isFunction3 = _interopRequireDefault(_isFunction2); + +var _extendReactClass = require('./extendReactClass'); + +var _extendReactClass2 = _interopRequireDefault(_extendReactClass); + +var _wrapStatelessFunction = require('./wrapStatelessFunction'); + +var _wrapStatelessFunction2 = _interopRequireDefault(_wrapStatelessFunction); + +var _makeConfiguration = require('./makeConfiguration'); + +var _makeConfiguration2 = _interopRequireDefault(_makeConfiguration); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Determines if the given object has the signature of a class that inherits React.Component. + */ + + +/** + * @see https://github.com/gajus/react-css-modules#options + */ +var isReactComponent = function isReactComponent(maybeReactComponent) { + return 'prototype' in maybeReactComponent && (0, _isFunction3.default)(maybeReactComponent.prototype.render); +}; + +/** + * When used as a function. + */ +var functionConstructor = function functionConstructor(Component, defaultStyles, options) { + var decoratedClass = void 0; + + var configuration = (0, _makeConfiguration2.default)(options); + + if (isReactComponent(Component)) { + decoratedClass = (0, _extendReactClass2.default)(Component, defaultStyles, configuration); + } else { + decoratedClass = (0, _wrapStatelessFunction2.default)(Component, defaultStyles, configuration); + } + + if (Component.displayName) { + decoratedClass.displayName = Component.displayName; + } else { + decoratedClass.displayName = Component.name; + } + + return decoratedClass; +}; + +/** + * When used as a ES7 decorator. + */ +var decoratorConstructor = function decoratorConstructor(defaultStyles, options) { + return function (Component) { + return functionConstructor(Component, defaultStyles, options); + }; +}; + +exports.default = function () { + if ((0, _isFunction3.default)(arguments.length <= 0 ? undefined : arguments[0])) { + return functionConstructor(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]); + } else { + return decoratorConstructor(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1]); + } +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/isIterable.js b/dist/isIterable.js new file mode 100644 index 0000000..1d3f1a3 --- /dev/null +++ b/dist/isIterable.js @@ -0,0 +1,41 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _isObject2 = require('lodash/isObject'); + +var _isObject3 = _interopRequireDefault(_isObject2); + +var _isFunction2 = require('lodash/isFunction'); + +var _isFunction3 = _interopRequireDefault(_isFunction2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var ITERATOR_SYMBOL = typeof Symbol !== 'undefined' && (0, _isFunction3.default)(Symbol) && Symbol.iterator; +var OLD_ITERATOR_SYMBOL = '@@iterator'; + +/** + * @see https://github.com/lodash/lodash/issues/1668 + * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols + */ + +exports.default = function (maybeIterable) { + var iterator = void 0; + + if (!(0, _isObject3.default)(maybeIterable)) { + return false; + } + + if (ITERATOR_SYMBOL) { + iterator = maybeIterable[ITERATOR_SYMBOL]; + } else { + iterator = maybeIterable[OLD_ITERATOR_SYMBOL]; + } + + return (0, _isFunction3.default)(iterator); +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/linkClass.js b/dist/linkClass.js new file mode 100644 index 0000000..d685007 --- /dev/null +++ b/dist/linkClass.js @@ -0,0 +1,153 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _isObject2 = require('lodash/isObject'); + +var _isObject3 = _interopRequireDefault(_isObject2); + +var _isArray2 = require('lodash/isArray'); + +var _isArray3 = _interopRequireDefault(_isArray2); + +var _forEach2 = require('lodash/forEach'); + +var _forEach3 = _interopRequireDefault(_forEach2); + +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _objectUnfreeze = require('object-unfreeze'); + +var _objectUnfreeze2 = _interopRequireDefault(_objectUnfreeze); + +var _isIterable = require('./isIterable'); + +var _isIterable2 = _interopRequireDefault(_isIterable); + +var _parseStyleName = require('./parseStyleName'); + +var _parseStyleName2 = _interopRequireDefault(_parseStyleName); + +var _generateAppendClassName = require('./generateAppendClassName'); + +var _generateAppendClassName2 = _interopRequireDefault(_generateAppendClassName); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + +var linkArray = function linkArray(array, styles, configuration) { + (0, _forEach3.default)(array, function (value, index) { + if (_react2.default.isValidElement(value)) { + // eslint-disable-next-line no-use-before-define + array[index] = linkElement(_react2.default.Children.only(value), styles, configuration); + } else if ((0, _isArray3.default)(value)) { + array[index] = linkArray(value, styles, configuration); + } + }); + + return array; +}; + +var linkElement = function linkElement(element, styles, configuration) { + var appendClassName = void 0; + var elementShallowCopy = void 0; + + elementShallowCopy = element; + + if (Array.isArray(elementShallowCopy)) { + return elementShallowCopy.map(function (arrayElement) { + return linkElement(arrayElement, styles, configuration); + }); + } + + var elementIsFrozen = Object.isFrozen && Object.isFrozen(elementShallowCopy); + var propsFrozen = Object.isFrozen && Object.isFrozen(elementShallowCopy.props); + var propsNotExtensible = Object.isExtensible && !Object.isExtensible(elementShallowCopy.props); + + if (elementIsFrozen) { + // https://github.com/facebook/react/blob/v0.13.3/src/classic/element/ReactElement.js#L131 + elementShallowCopy = (0, _objectUnfreeze2.default)(elementShallowCopy); + elementShallowCopy.props = (0, _objectUnfreeze2.default)(elementShallowCopy.props); + } else if (propsFrozen || propsNotExtensible) { + elementShallowCopy.props = (0, _objectUnfreeze2.default)(elementShallowCopy.props); + } + + var styleNames = (0, _parseStyleName2.default)(elementShallowCopy.props.styleName || '', configuration.allowMultiple); + + var _elementShallowCopy$p = elementShallowCopy.props, + children = _elementShallowCopy$p.children, + restProps = _objectWithoutProperties(_elementShallowCopy$p, ['children']); + + if (_react2.default.isValidElement(children)) { + elementShallowCopy.props.children = linkElement(_react2.default.Children.only(children), styles, configuration); + } else if ((0, _isArray3.default)(children) || (0, _isIterable2.default)(children)) { + elementShallowCopy.props.children = _react2.default.Children.map(children, function (node) { + if (_react2.default.isValidElement(node)) { + // eslint-disable-next-line no-use-before-define + return linkElement(_react2.default.Children.only(node), styles, configuration); + } else { + return node; + } + }); + } + + (0, _forEach3.default)(restProps, function (propValue, propName) { + if (_react2.default.isValidElement(propValue)) { + elementShallowCopy.props[propName] = linkElement(_react2.default.Children.only(propValue), styles, configuration); + } else if ((0, _isArray3.default)(propValue)) { + elementShallowCopy.props[propName] = linkArray(propValue, styles, configuration); + } + }); + + if (styleNames.length) { + appendClassName = (0, _generateAppendClassName2.default)(styles, styleNames, configuration.handleNotFoundStyleName); + + if (appendClassName) { + if (elementShallowCopy.props.className) { + appendClassName = elementShallowCopy.props.className + ' ' + appendClassName; + } + + elementShallowCopy.props.className = appendClassName; + } + } + + delete elementShallowCopy.props.styleName; + + if (elementIsFrozen) { + Object.freeze(elementShallowCopy.props); + Object.freeze(elementShallowCopy); + } else if (propsFrozen) { + Object.freeze(elementShallowCopy.props); + } + + if (propsNotExtensible) { + Object.preventExtensions(elementShallowCopy.props); + } + + return elementShallowCopy; +}; + +/** + * @param {ReactElement} element + * @param {Object} styles CSS modules class map. + * @param {CSSModules~Options} configuration + */ + +exports.default = function (element) { + var styles = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var configuration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + // @see https://github.com/gajus/react-css-modules/pull/30 + if (!(0, _isObject3.default)(element)) { + return element; + } + + return linkElement(element, styles, configuration); +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/makeConfiguration.js b/dist/makeConfiguration.js new file mode 100644 index 0000000..1a09ed0 --- /dev/null +++ b/dist/makeConfiguration.js @@ -0,0 +1,63 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _includes2 = require('lodash/includes'); + +var _includes3 = _interopRequireDefault(_includes2); + +var _isBoolean2 = require('lodash/isBoolean'); + +var _isBoolean3 = _interopRequireDefault(_isBoolean2); + +var _isUndefined2 = require('lodash/isUndefined'); + +var _isUndefined3 = _interopRequireDefault(_isUndefined2); + +var _forEach2 = require('lodash/forEach'); + +var _forEach3 = _interopRequireDefault(_forEach2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * @typedef CSSModules~Options + * @see {@link https://github.com/gajus/react-css-modules#options} + * @property {boolean} allowMultiple + * @property {string} handleNotFoundStyleName + */ + +/** + * @param {CSSModules~Options} userConfiguration + * @returns {CSSModules~Options} + */ +exports.default = function () { + var userConfiguration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var configuration = { + allowMultiple: false, + handleNotFoundStyleName: 'throw' + }; + + (0, _forEach3.default)(userConfiguration, function (value, name) { + if ((0, _isUndefined3.default)(configuration[name])) { + throw new Error('Unknown configuration property "' + name + '".'); + } + + if (name === 'allowMultiple' && !(0, _isBoolean3.default)(value)) { + throw new Error('"allowMultiple" property value must be a boolean.'); + } + + if (name === 'handleNotFoundStyleName' && !(0, _includes3.default)(['throw', 'log', 'ignore'], value)) { + throw new Error('"handleNotFoundStyleName" property value must be "throw", "log" or "ignore".'); + } + + configuration[name] = value; + }); + + return configuration; +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/parseStyleName.js b/dist/parseStyleName.js new file mode 100644 index 0000000..c50643f --- /dev/null +++ b/dist/parseStyleName.js @@ -0,0 +1,38 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _filter2 = require('lodash/filter'); + +var _filter3 = _interopRequireDefault(_filter2); + +var _trim2 = require('lodash/trim'); + +var _trim3 = _interopRequireDefault(_trim2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var styleNameIndex = {}; + +exports.default = function (styleNamePropertyValue, allowMultiple) { + var styleNames = void 0; + + if (styleNameIndex[styleNamePropertyValue]) { + styleNames = styleNameIndex[styleNamePropertyValue]; + } else { + styleNames = (0, _trim3.default)(styleNamePropertyValue).split(/\s+/); + styleNames = (0, _filter3.default)(styleNames); + + styleNameIndex[styleNamePropertyValue] = styleNames; + } + + if (allowMultiple === false && styleNames.length > 1) { + throw new Error('ReactElement styleName property defines multiple module names ("' + styleNamePropertyValue + '").'); + } + + return styleNames; +}; + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/renderNothing.js b/dist/renderNothing.js new file mode 100644 index 0000000..b6e2dd2 --- /dev/null +++ b/dist/renderNothing.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +exports.default = function (version) { + var major = version.split('.')[0]; + + return parseInt(major, 10) < 15 ? _react2.default.createElement('noscript') : null; +}; + +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +module.exports = exports['default']; \ No newline at end of file diff --git a/dist/wrapStatelessFunction.js b/dist/wrapStatelessFunction.js new file mode 100644 index 0000000..a77f00b --- /dev/null +++ b/dist/wrapStatelessFunction.js @@ -0,0 +1,78 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _assign2 = require('lodash/assign'); + +var _assign3 = _interopRequireDefault(_assign2); + +var _isObject2 = require('lodash/isObject'); + +var _isObject3 = _interopRequireDefault(_isObject2); + +var _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _linkClass = require('./linkClass'); + +var _linkClass2 = _interopRequireDefault(_linkClass); + +var _renderNothing = require('./renderNothing'); + +var _renderNothing2 = _interopRequireDefault(_renderNothing); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * @see https://facebook.github.io/react/blog/2015/09/10/react-v0.14-rc1.html#stateless-function-components + */ +exports.default = function (Component, defaultStyles, options) { + var WrappedComponent = function WrappedComponent() { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var styles = void 0; + var useProps = void 0; + var hasDefaultstyles = (0, _isObject3.default)(defaultStyles); + + if (props.styles || hasDefaultstyles) { + useProps = Object.assign({}, props); + + if (props.styles) { + styles = props.styles; + } else { + styles = defaultStyles; + } + + Object.defineProperty(useProps, 'styles', { + configurable: true, + enumerable: false, + value: styles, + writable: false + }); + } else { + useProps = props; + styles = {}; + } + + var renderResult = Component.apply(undefined, [useProps].concat(args)); + + if (renderResult) { + return (0, _linkClass2.default)(renderResult, styles, options); + } + + return (0, _renderNothing2.default)(_react2.default.version); + }; + + (0, _assign3.default)(WrappedComponent, Component); + + return WrappedComponent; +}; /* eslint-disable react/prop-types */ + +module.exports = exports['default']; \ No newline at end of file