ima/page/componentHelpers.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getContextTypes = getContextTypes;
exports.setContextTypes = setContextTypes;
exports.getUtils = getUtils;
exports.localize = localize;
exports.link = link;
exports.cssClasses = cssClasses;
exports.defaultCssClasses = defaultCssClasses;
exports.fire = fire;
exports.listen = listen;
exports.unlisten = unlisten;

var _classnames = require("classnames");

var _classnames2 = _interopRequireDefault(_classnames);

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

var _propTypes2 = _interopRequireDefault(_propTypes);

var _react = require("react");

var _react2 = _interopRequireDefault(_react);

var _reactDom = require("react-dom");

var _reactDom2 = _interopRequireDefault(_reactDom);

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

const PRIVATE = {
  contextTypes: Symbol('contextTypes')
};

if (typeof $Debug !== 'undefined' && $Debug) {
  Object.freeze(PRIVATE);
}
/**
 * Retrieves the context type declarations for the specified component.
 *
 * @param {function(new: React.Component, ...*)} classConstructor The
 *        constructor of the react component.
 * @return {Object<string, function(...*): boolean>} The context type
 *         declarations associated with the specified component.
 */


function getContextTypes(classConstructor) {
  if (classConstructor.hasOwnProperty(PRIVATE.contextTypes)) {
    return this[PRIVATE.contextTypes];
  }

  return {
    $Utils: _propTypes2.default.object.isRequired
  };
}
/**
 * Overrides the previously associated context type declarations for the
 * specified component to the provided ones.
 *
 * @param {function(new: React.Component, ...*)} classConstructor The
 *        constructor of the react component.
 * @param {Object<string, function(...*): boolean>} contextTypes The new
 *        context type declarations to associate with the specified component.
 * @return {Object<string, function(...*): boolean>} The provided context type
 *         declarations.
 */


function setContextTypes(classConstructor, contextTypes) {
  return classConstructor[PRIVATE.contextTypes] = contextTypes;
}
/**
 * Retrieves the view utilities from the component's current context or
 * properties (preferring the context).
 *
 * @param {Object<string, *>} props The component's current properties.
 * @param {Object<string, *>} context The component's current context.
 * @return {Object<string, *>} The retrieved view utilities.
 * @throws Error Throw if the view utils cannot be located in the provided
 *         properties nor context.
 */


function getUtils(props, context) {
  const utils = context ? context.$Utils || props.$Utils : props.$Utils;

  if ($Debug && !utils) {
    throw new Error('The component cannot access the view utils because they were ' + 'not passed in the initial props or context as $Utils.');
  }

  return utils;
}
/**
 * Returns the localized phrase identified by the specified key. The
 * placeholders in the localization phrase will be replaced by the provided
 * values.
 *
 * @param {(AbstractComponent|AbstractPureComponent)} component The component
 *        requiring the localization.
 * @param {string} key Localization key.
 * @param {Object<string, (number|string)>=} params Values for replacing the
 *        placeholders in the localization phrase.
 * @return {string} Localized phrase.
 */


function localize(component, key, params) {
  return component.utils.$Dictionary.get(key, params);
}
/**
 * Generates an absolute URL using the provided route name (see the
 * <code>app/config/routes.js</code> file). The provided parameters will
 * replace the placeholders in the route pattern, while the extraneous
 * parameters will be appended to the generated URL's query string.
 *
 * @param {(AbstractComponent|AbstractPureComponent)} component The component
 *        requiring the generating of the URL.
 * @param {string} name The route name.
 * @param {Object<string, (number|string)>=} params Router parameters and
 *        extraneous parameters to add to the URL as a query string.
 * @return {string} The generated URL.
 */


function link(component, name, params) {
  return component.utils.$Router.link(name, params);
}
/**
 * Generate a string of CSS classes from the properties of the passed-in
 * object that resolve to {@code true}.
 *
 * @example
 *        this.cssClasses('my-class my-class-modificator', true);
 * @example
 *        this.cssClasses({
 *            'my-class': true,
 *            'my-class-modificator': this.props.modificator
 *        }, true);
 * @param {(AbstractComponent|AbstractPureComponent)} component The component
 *        requiring the composition of the CSS class names.
 * @param {(string|Object<string, boolean>)} classRules CSS classes in a
 *        string separated by whitespace, or a map of CSS class names to
 *        boolean values. The CSS class name will be included in the result
 *        only if the value is {@code true}.
 * @param {boolean} includeComponentClassName
 * @return {string} String of CSS classes that had their property resolved
 *         to {@code true}.
 */


function cssClasses(component, classRules, includeComponentClassName) {
  return component.utils.$CssClasses(classRules, includeComponentClassName && component);
}
/**
 * Generate a string of CSS classes from the properties of the passed-in
 * object that resolve to {@code true}.
 *
 * @param {(string|Object<string, boolean>)} classRules CSS classes in a
 *        string separated by whitespace, or a map of CSS class names to
 *        boolean values. The CSS class name will be included in the result
 *        only if the value is {@code true}.
 * @param {?(AbstractComponent|AbstractPureComponent|string)} component The component
 *        requiring the composition of the CSS class names, if it has the
 *        {@code className} property set and requires its inclusion this time.
 * @return {string} String of CSS classes that had their property resolved
 *         to {@code true}.
 */


function defaultCssClasses(classRules, component) {
  let extraClasses = typeof component === 'string' ? component : null;

  if (!extraClasses && (component instanceof _react2.default.Component || component instanceof _react2.default.PureComponent)) {
    extraClasses = component.props.className;
  }

  return (0, _classnames2.default)(classRules, extraClasses);
}
/**
 * Creates and sends a new IMA.js DOM custom event from the provided component.
 *
 * @param {(AbstractComponent|AbstractPureComponent)} component The component
 *        at which's root element the event will originate.
 * @param {string} eventName The name of the event.
 * @param {*=} data Data to send within the event.
 */


function fire(component, eventName, data = null) {
  return component.utils.$EventBus.fire(_reactDom2.default.findDOMNode(component), //eslint-disable-line react/no-find-dom-node
  eventName, data);
}
/**
 * Registers the provided event listener for execution whenever an IMA.js
 * DOM custom event of the specified name occurs at the specified event
 * target.
 *
 * @param {(AbstractComponent|AbstractPureComponent)} component The component
 *        requesting the registration of the event listener.
 * @param {(React.Element|EventTarget)} eventTarget The react component or
 *        event target at which the listener should listen for the event.
 * @param {string} eventName The name of the event for which to listen.
 * @param {function(Event)} listener The listener for event to register.
 */


function listen(component, eventTarget, eventName, listener) {
  if (eventTarget && !eventTarget.addEventListener) {
    // Safari doesn't have EventTarget
    eventTarget = _reactDom2.default.findDOMNode(eventTarget); //eslint-disable-line react/no-find-dom-node
  }

  return component.utils.$EventBus.listen(eventTarget, eventName, listener);
}
/**
 * Deregisters the provided event listener for an IMA.js DOM custom event
 * of the specified name at the specified event target.
 *
 * @param {(AbstractComponent|AbstractPureComponent)} component The component
 *        that requested the registration of the event listener.
 * @param {(React.Element|EventTarget)} eventTarget The react component or
 *        event target at which the listener should listen for the event.
 * @param {string} eventName The name of the event for which to listen.
 * @param {function(Event)} listener The listener for event to register.
 */


function unlisten(component, eventTarget, eventName, listener) {
  if (eventTarget && !eventTarget.addEventListener) {
    // Safari doesn't have EventTarget
    eventTarget = _reactDom2.default.findDOMNode(eventTarget); //eslint-disable-line react/no-find-dom-node
  }

  const eventBus = component.utils.$EventBus;
  return eventBus.unlisten(eventTarget, eventName, listener);
}

typeof $IMA !== 'undefined' && $IMA !== null && $IMA.Loader && $IMA.Loader.register('ima/page/componentHelpers', [], function (_export, _context) {
 'use strict';
 return {
   setters: [],
   execute: function () {
     _export('getContextTypes', exports.getContextTypes);
     _export('setContextTypes', exports.setContextTypes);
     _export('getUtils', exports.getUtils);
     _export('localize', exports.localize);
     _export('link', exports.link);
     _export('cssClasses', exports.cssClasses);
     _export('defaultCssClasses', exports.defaultCssClasses);
     _export('fire', exports.fire);
     _export('listen', exports.listen);
     _export('unlisten', exports.unlisten);
   }
 };
});