Source: CompatibilityEventProxy.es.js

  1. /**
  2.  * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
  3.  *
  4.  * This library is free software; you can redistribute it and/or modify it under
  5.  * the terms of the GNU Lesser General Public License as published by the Free
  6.  * Software Foundation; either version 2.1 of the License, or (at your option)
  7.  * any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful, but WITHOUT
  10.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11.  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  12.  * details.
  13.  */
  15. import State from 'metal-state';
  17. import isObject from './util/is_object';
  19. /**
  20.  * Adds compatibility for YUI events, re-emitting events according to YUI naming
  21.  * and adding the capability of adding targets to bubble events to them.
  22.  */
  23. class CompatibilityEventProxy extends State {
  25. 	/**
  26. 	 * @inheritDoc
  27. 	 */
  28. 	constructor(config, element) {
  29. 		super(config, element);
  31. 		this.eventTargets_ = [];
  32. 		this.host = config.host;
  33. 		this.namespace = config.namespace;
  35. 		this.startCompatibility_();
  36. 	}
  38. 	/**
  39. 	 * Registers another event target as a bubble target.
  40. 	 *
  41. 	 * @param  {!Object} target The YUI component that receives the emitted
  42. 	 *         events.
  43. 	 * @private
  44. 	 */
  45. 	addTarget(target) {
  46. 		this.eventTargets_.push(target);
  47. 	}
  49. 	/**
  50. 	 * Checks if the event is an attribute modification event and adapts the
  51. 	 * event name accordingly.
  52. 	 *
  53. 	 * @param  {!String} eventName The event name.
  54. 	 * @private
  55. 	 * @return {String} The adapted event name.
  56. 	 */
  57. 	checkAttributeEvent_(eventName) {
  58. 		return eventName.replace(
  59. 			this.adaptedEvents.match,
  60. 			this.adaptedEvents.replace
  61. 		);
  62. 	}
  64. 	/**
  65. 	 * Emits the event adapted to YUI.
  66. 	 *
  67. 	 * @param  {!String} eventName The event name.
  68. 	 * @param  {!Event} event The event.
  69. 	 * @private
  70. 	 */
  71. 	emitCompatibleEvents_(eventName, event) {
  72. 		this.eventTargets_.forEach((target) => {
  73. 			if (target.fire) {
  74. 				const prefixedEventName = this.namespace
  75. 					? this.namespace + ':' + eventName
  76. 					: eventName;
  77. 				const yuiEvent = target._yuievt.events[prefixedEventName];
  79. 				if (isObject(event)) {
  80. 					try {
  81. 						event.target = this.host;
  82. 					}
  83. 					catch (e) {
  85. 						// Do nothing
  87. 					}
  88. 				}
  90. 				let emitFacadeReference;
  92. 				if (!this.emitFacade && yuiEvent) {
  93. 					emitFacadeReference = yuiEvent.emitFacade;
  94. 					yuiEvent.emitFacade = false;
  95. 				}
  97. 				target.fire(prefixedEventName, event);
  99. 				if (!this.emitFacade && yuiEvent) {
  100. 					yuiEvent.emitFacade = emitFacadeReference;
  101. 				}
  102. 			}
  103. 		});
  104. 	}
  106. 	/**
  107. 	 * Emits YUI-based events to maintain backwards compatibility.
  108. 	 *
  109. 	 * @private
  110. 	 */
  111. 	startCompatibility_() {
  112. 		this.host.on('*', (event, eventFacade) => {
  113. 			if (!eventFacade) {
  114. 				eventFacade = event;
  115. 			}
  117. 			const compatibleEvent = this.checkAttributeEvent_(eventFacade.type);
  119. 			if (compatibleEvent !== eventFacade.type) {
  120. 				eventFacade.type = compatibleEvent;
  121. 				this.host.emit(compatibleEvent, event, eventFacade);
  122. 			}
  123. 			else if (this.eventTargets_.length > 0) {
  124. 				this.emitCompatibleEvents_(compatibleEvent, event);
  125. 			}
  126. 		});
  127. 	}
  128. }
  130. /**
  131.  * State definition.
  132.  *
  133.  * @ignore
  134.  * @static
  135.  * @type {!Object}
  136.  */
  137. CompatibilityEventProxy.STATE = {
  139. 	/**
  140. 	 * Replaces event names with adapted YUI names.
  141. 	 *
  142. 	 * @instance
  143. 	 * @memberof CompatibilityEventProxy
  144. 	 * @type {Object}
  145. 	 */
  146. 	adaptedEvents: {
  147. 		value: {
  148. 			match: /(.*)(Changed)$/,
  149. 			replace: '$1Change',
  150. 		},
  151. 	},
  153. 	/**
  154. 	 * Whether the event facade should be emitted to the target.
  155. 	 *
  156. 	 * @default false
  157. 	 * @instance
  158. 	 * @memberof CompatibilityEventProxy
  159. 	 * @type {String}
  160. 	 */
  161. 	emitFacade: {
  162. 		value: false,
  163. 	},
  164. };
  166. export default CompatibilityEventProxy;