|
|
@@ -1,1032 +1,936 @@
|
|
|
(function (global, factory) {
|
|
|
- typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
|
|
- typeof define === 'function' && define.amd ? define(factory) :
|
|
|
- (global.ResizeObserver = factory());
|
|
|
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
|
|
+ typeof define === 'function' && define.amd ? define(factory) :
|
|
|
+ (global.ResizeObserver = factory());
|
|
|
}(this, (function () { 'use strict';
|
|
|
|
|
|
-/**
|
|
|
- * A collection of shims that provide minimal functionality of the ES6 collections.
|
|
|
- *
|
|
|
- * These implementations are not meant to be used outside of the ResizeObserver
|
|
|
- * modules as they cover only a limited range of use cases.
|
|
|
- */
|
|
|
-/* eslint-disable require-jsdoc, valid-jsdoc */
|
|
|
-var MapShim = (function () {
|
|
|
- if (typeof Map !== 'undefined') {
|
|
|
- return Map;
|
|
|
- }
|
|
|
-
|
|
|
/**
|
|
|
- * Returns index in provided array that matches the specified key.
|
|
|
+ * A collection of shims that provide minimal functionality of the ES6 collections.
|
|
|
*
|
|
|
- * @param {Array<Array>} arr
|
|
|
- * @param {*} key
|
|
|
- * @returns {number}
|
|
|
+ * These implementations are not meant to be used outside of the ResizeObserver
|
|
|
+ * modules as they cover only a limited range of use cases.
|
|
|
*/
|
|
|
- function getIndex(arr, key) {
|
|
|
- var result = -1;
|
|
|
-
|
|
|
- arr.some(function (entry, index) {
|
|
|
- if (entry[0] === key) {
|
|
|
- result = index;
|
|
|
-
|
|
|
- return true;
|
|
|
+ /* eslint-disable require-jsdoc, valid-jsdoc */
|
|
|
+ var MapShim = (function () {
|
|
|
+ if (typeof Map !== 'undefined') {
|
|
|
+ return Map;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Returns index in provided array that matches the specified key.
|
|
|
+ *
|
|
|
+ * @param {Array<Array>} arr
|
|
|
+ * @param {*} key
|
|
|
+ * @returns {number}
|
|
|
+ */
|
|
|
+ function getIndex(arr, key) {
|
|
|
+ var result = -1;
|
|
|
+ arr.some(function (entry, index) {
|
|
|
+ if (entry[0] === key) {
|
|
|
+ result = index;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ });
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ return /** @class */ (function () {
|
|
|
+ function class_1() {
|
|
|
+ this.__entries__ = [];
|
|
|
}
|
|
|
+ Object.defineProperty(class_1.prototype, "size", {
|
|
|
+ /**
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ get: function () {
|
|
|
+ return this.__entries__.length;
|
|
|
+ },
|
|
|
+ enumerable: true,
|
|
|
+ configurable: true
|
|
|
+ });
|
|
|
+ /**
|
|
|
+ * @param {*} key
|
|
|
+ * @returns {*}
|
|
|
+ */
|
|
|
+ class_1.prototype.get = function (key) {
|
|
|
+ var index = getIndex(this.__entries__, key);
|
|
|
+ var entry = this.__entries__[index];
|
|
|
+ return entry && entry[1];
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * @param {*} key
|
|
|
+ * @param {*} value
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ class_1.prototype.set = function (key, value) {
|
|
|
+ var index = getIndex(this.__entries__, key);
|
|
|
+ if (~index) {
|
|
|
+ this.__entries__[index][1] = value;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ this.__entries__.push([key, value]);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * @param {*} key
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ class_1.prototype.delete = function (key) {
|
|
|
+ var entries = this.__entries__;
|
|
|
+ var index = getIndex(entries, key);
|
|
|
+ if (~index) {
|
|
|
+ entries.splice(index, 1);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * @param {*} key
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ class_1.prototype.has = function (key) {
|
|
|
+ return !!~getIndex(this.__entries__, key);
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ class_1.prototype.clear = function () {
|
|
|
+ this.__entries__.splice(0);
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * @param {Function} callback
|
|
|
+ * @param {*} [ctx=null]
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ class_1.prototype.forEach = function (callback, ctx) {
|
|
|
+ if (ctx === void 0) { ctx = null; }
|
|
|
+ for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
|
|
|
+ var entry = _a[_i];
|
|
|
+ callback.call(ctx, entry[1], entry[0]);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ return class_1;
|
|
|
+ }());
|
|
|
+ })();
|
|
|
|
|
|
- return false;
|
|
|
- });
|
|
|
-
|
|
|
- return result;
|
|
|
- }
|
|
|
+ /**
|
|
|
+ * Detects whether window and document objects are available in current environment.
|
|
|
+ */
|
|
|
+ var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;
|
|
|
|
|
|
- return (function () {
|
|
|
- function anonymous() {
|
|
|
- this.__entries__ = [];
|
|
|
+ // Returns global object of a current environment.
|
|
|
+ var global$1 = (function () {
|
|
|
+ if (typeof global !== 'undefined' && global.Math === Math) {
|
|
|
+ return global;
|
|
|
}
|
|
|
+ if (typeof self !== 'undefined' && self.Math === Math) {
|
|
|
+ return self;
|
|
|
+ }
|
|
|
+ if (typeof window !== 'undefined' && window.Math === Math) {
|
|
|
+ return window;
|
|
|
+ }
|
|
|
+ // eslint-disable-next-line no-new-func
|
|
|
+ return Function('return this')();
|
|
|
+ })();
|
|
|
|
|
|
- var prototypeAccessors = { size: { configurable: true } };
|
|
|
+ /**
|
|
|
+ * A shim for the requestAnimationFrame which falls back to the setTimeout if
|
|
|
+ * first one is not supported.
|
|
|
+ *
|
|
|
+ * @returns {number} Requests' identifier.
|
|
|
+ */
|
|
|
+ var requestAnimationFrame$1 = (function () {
|
|
|
+ if (typeof requestAnimationFrame === 'function') {
|
|
|
+ // It's required to use a bounded function because IE sometimes throws
|
|
|
+ // an "Invalid calling object" error if rAF is invoked without the global
|
|
|
+ // object on the left hand side.
|
|
|
+ return requestAnimationFrame.bind(global$1);
|
|
|
+ }
|
|
|
+ return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };
|
|
|
+ })();
|
|
|
|
|
|
+ // Defines minimum timeout before adding a trailing call.
|
|
|
+ var trailingTimeout = 2;
|
|
|
+ /**
|
|
|
+ * Creates a wrapper function which ensures that provided callback will be
|
|
|
+ * invoked only once during the specified delay period.
|
|
|
+ *
|
|
|
+ * @param {Function} callback - Function to be invoked after the delay period.
|
|
|
+ * @param {number} delay - Delay after which to invoke callback.
|
|
|
+ * @returns {Function}
|
|
|
+ */
|
|
|
+ function throttle (callback, delay) {
|
|
|
+ var leadingCall = false, trailingCall = false, lastCallTime = 0;
|
|
|
/**
|
|
|
- * @returns {boolean}
|
|
|
+ * Invokes the original callback function and schedules new invocation if
|
|
|
+ * the "proxy" was called during current request.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
*/
|
|
|
- prototypeAccessors.size.get = function () {
|
|
|
- return this.__entries__.length;
|
|
|
- };
|
|
|
-
|
|
|
+ function resolvePending() {
|
|
|
+ if (leadingCall) {
|
|
|
+ leadingCall = false;
|
|
|
+ callback();
|
|
|
+ }
|
|
|
+ if (trailingCall) {
|
|
|
+ proxy();
|
|
|
+ }
|
|
|
+ }
|
|
|
/**
|
|
|
- * @param {*} key
|
|
|
- * @returns {*}
|
|
|
+ * Callback invoked after the specified delay. It will further postpone
|
|
|
+ * invocation of the original function delegating it to the
|
|
|
+ * requestAnimationFrame.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ function timeoutCallback() {
|
|
|
+ requestAnimationFrame$1(resolvePending);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Schedules invocation of the original function.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
*/
|
|
|
- anonymous.prototype.get = function (key) {
|
|
|
- var index = getIndex(this.__entries__, key);
|
|
|
- var entry = this.__entries__[index];
|
|
|
+ function proxy() {
|
|
|
+ var timeStamp = Date.now();
|
|
|
+ if (leadingCall) {
|
|
|
+ // Reject immediately following calls.
|
|
|
+ if (timeStamp - lastCallTime < trailingTimeout) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // Schedule new call to be in invoked when the pending one is resolved.
|
|
|
+ // This is important for "transitions" which never actually start
|
|
|
+ // immediately so there is a chance that we might miss one if change
|
|
|
+ // happens amids the pending invocation.
|
|
|
+ trailingCall = true;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ leadingCall = true;
|
|
|
+ trailingCall = false;
|
|
|
+ setTimeout(timeoutCallback, delay);
|
|
|
+ }
|
|
|
+ lastCallTime = timeStamp;
|
|
|
+ }
|
|
|
+ return proxy;
|
|
|
+ }
|
|
|
|
|
|
- return entry && entry[1];
|
|
|
+ // Minimum delay before invoking the update of observers.
|
|
|
+ var REFRESH_DELAY = 20;
|
|
|
+ // A list of substrings of CSS properties used to find transition events that
|
|
|
+ // might affect dimensions of observed elements.
|
|
|
+ var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
|
|
|
+ // Check if MutationObserver is available.
|
|
|
+ var mutationObserverSupported = typeof MutationObserver !== 'undefined';
|
|
|
+ /**
|
|
|
+ * Singleton controller class which handles updates of ResizeObserver instances.
|
|
|
+ */
|
|
|
+ var ResizeObserverController = /** @class */ (function () {
|
|
|
+ /**
|
|
|
+ * Creates a new instance of ResizeObserverController.
|
|
|
+ *
|
|
|
+ * @private
|
|
|
+ */
|
|
|
+ function ResizeObserverController() {
|
|
|
+ /**
|
|
|
+ * Indicates whether DOM listeners have been added.
|
|
|
+ *
|
|
|
+ * @private {boolean}
|
|
|
+ */
|
|
|
+ this.connected_ = false;
|
|
|
+ /**
|
|
|
+ * Tells that controller has subscribed for Mutation Events.
|
|
|
+ *
|
|
|
+ * @private {boolean}
|
|
|
+ */
|
|
|
+ this.mutationEventsAdded_ = false;
|
|
|
+ /**
|
|
|
+ * Keeps reference to the instance of MutationObserver.
|
|
|
+ *
|
|
|
+ * @private {MutationObserver}
|
|
|
+ */
|
|
|
+ this.mutationsObserver_ = null;
|
|
|
+ /**
|
|
|
+ * A list of connected observers.
|
|
|
+ *
|
|
|
+ * @private {Array<ResizeObserverSPI>}
|
|
|
+ */
|
|
|
+ this.observers_ = [];
|
|
|
+ this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
|
|
|
+ this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds observer to observers list.
|
|
|
+ *
|
|
|
+ * @param {ResizeObserverSPI} observer - Observer to be added.
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverController.prototype.addObserver = function (observer) {
|
|
|
+ if (!~this.observers_.indexOf(observer)) {
|
|
|
+ this.observers_.push(observer);
|
|
|
+ }
|
|
|
+ // Add listeners if they haven't been added yet.
|
|
|
+ if (!this.connected_) {
|
|
|
+ this.connect_();
|
|
|
+ }
|
|
|
};
|
|
|
-
|
|
|
/**
|
|
|
- * @param {*} key
|
|
|
- * @param {*} value
|
|
|
+ * Removes observer from observers list.
|
|
|
+ *
|
|
|
+ * @param {ResizeObserverSPI} observer - Observer to be removed.
|
|
|
* @returns {void}
|
|
|
*/
|
|
|
- anonymous.prototype.set = function (key, value) {
|
|
|
- var index = getIndex(this.__entries__, key);
|
|
|
-
|
|
|
+ ResizeObserverController.prototype.removeObserver = function (observer) {
|
|
|
+ var observers = this.observers_;
|
|
|
+ var index = observers.indexOf(observer);
|
|
|
+ // Remove observer if it's present in registry.
|
|
|
if (~index) {
|
|
|
- this.__entries__[index][1] = value;
|
|
|
- } else {
|
|
|
- this.__entries__.push([key, value]);
|
|
|
+ observers.splice(index, 1);
|
|
|
+ }
|
|
|
+ // Remove listeners if controller has no connected observers.
|
|
|
+ if (!observers.length && this.connected_) {
|
|
|
+ this.disconnect_();
|
|
|
}
|
|
|
};
|
|
|
-
|
|
|
/**
|
|
|
- * @param {*} key
|
|
|
+ * Invokes the update of observers. It will continue running updates insofar
|
|
|
+ * it detects changes.
|
|
|
+ *
|
|
|
* @returns {void}
|
|
|
*/
|
|
|
- anonymous.prototype.delete = function (key) {
|
|
|
- var entries = this.__entries__;
|
|
|
- var index = getIndex(entries, key);
|
|
|
-
|
|
|
- if (~index) {
|
|
|
- entries.splice(index, 1);
|
|
|
+ ResizeObserverController.prototype.refresh = function () {
|
|
|
+ var changesDetected = this.updateObservers_();
|
|
|
+ // Continue running updates if changes have been detected as there might
|
|
|
+ // be future ones caused by CSS transitions.
|
|
|
+ if (changesDetected) {
|
|
|
+ this.refresh();
|
|
|
}
|
|
|
};
|
|
|
-
|
|
|
/**
|
|
|
- * @param {*} key
|
|
|
+ * Updates every observer from observers list and notifies them of queued
|
|
|
+ * entries.
|
|
|
+ *
|
|
|
+ * @private
|
|
|
+ * @returns {boolean} Returns "true" if any observer has detected changes in
|
|
|
+ * dimensions of it's elements.
|
|
|
+ */
|
|
|
+ ResizeObserverController.prototype.updateObservers_ = function () {
|
|
|
+ // Collect observers that have active observations.
|
|
|
+ var activeObservers = this.observers_.filter(function (observer) {
|
|
|
+ return observer.gatherActive(), observer.hasActive();
|
|
|
+ });
|
|
|
+ // Deliver notifications in a separate cycle in order to avoid any
|
|
|
+ // collisions between observers, e.g. when multiple instances of
|
|
|
+ // ResizeObserver are tracking the same element and the callback of one
|
|
|
+ // of them changes content dimensions of the observed target. Sometimes
|
|
|
+ // this may result in notifications being blocked for the rest of observers.
|
|
|
+ activeObservers.forEach(function (observer) { return observer.broadcastActive(); });
|
|
|
+ return activeObservers.length > 0;
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Initializes DOM listeners.
|
|
|
+ *
|
|
|
+ * @private
|
|
|
* @returns {void}
|
|
|
*/
|
|
|
- anonymous.prototype.has = function (key) {
|
|
|
- return !!~getIndex(this.__entries__, key);
|
|
|
+ ResizeObserverController.prototype.connect_ = function () {
|
|
|
+ // Do nothing if running in a non-browser environment or if listeners
|
|
|
+ // have been already added.
|
|
|
+ if (!isBrowser || this.connected_) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // Subscription to the "Transitionend" event is used as a workaround for
|
|
|
+ // delayed transitions. This way it's possible to capture at least the
|
|
|
+ // final state of an element.
|
|
|
+ document.addEventListener('transitionend', this.onTransitionEnd_);
|
|
|
+ window.addEventListener('resize', this.refresh);
|
|
|
+ if (mutationObserverSupported) {
|
|
|
+ this.mutationsObserver_ = new MutationObserver(this.refresh);
|
|
|
+ this.mutationsObserver_.observe(document, {
|
|
|
+ attributes: true,
|
|
|
+ childList: true,
|
|
|
+ characterData: true,
|
|
|
+ subtree: true
|
|
|
+ });
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ document.addEventListener('DOMSubtreeModified', this.refresh);
|
|
|
+ this.mutationEventsAdded_ = true;
|
|
|
+ }
|
|
|
+ this.connected_ = true;
|
|
|
};
|
|
|
-
|
|
|
/**
|
|
|
+ * Removes DOM listeners.
|
|
|
+ *
|
|
|
+ * @private
|
|
|
* @returns {void}
|
|
|
*/
|
|
|
- anonymous.prototype.clear = function () {
|
|
|
- this.__entries__.splice(0);
|
|
|
+ ResizeObserverController.prototype.disconnect_ = function () {
|
|
|
+ // Do nothing if running in a non-browser environment or if listeners
|
|
|
+ // have been already removed.
|
|
|
+ if (!isBrowser || !this.connected_) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ document.removeEventListener('transitionend', this.onTransitionEnd_);
|
|
|
+ window.removeEventListener('resize', this.refresh);
|
|
|
+ if (this.mutationsObserver_) {
|
|
|
+ this.mutationsObserver_.disconnect();
|
|
|
+ }
|
|
|
+ if (this.mutationEventsAdded_) {
|
|
|
+ document.removeEventListener('DOMSubtreeModified', this.refresh);
|
|
|
+ }
|
|
|
+ this.mutationsObserver_ = null;
|
|
|
+ this.mutationEventsAdded_ = false;
|
|
|
+ this.connected_ = false;
|
|
|
};
|
|
|
-
|
|
|
/**
|
|
|
- * @param {Function} callback
|
|
|
- * @param {*} [ctx=null]
|
|
|
+ * "Transitionend" event handler.
|
|
|
+ *
|
|
|
+ * @private
|
|
|
+ * @param {TransitionEvent} event
|
|
|
* @returns {void}
|
|
|
*/
|
|
|
- anonymous.prototype.forEach = function (callback, ctx) {
|
|
|
- var this$1 = this;
|
|
|
- if ( ctx === void 0 ) ctx = null;
|
|
|
-
|
|
|
- for (var i = 0, list = this$1.__entries__; i < list.length; i += 1) {
|
|
|
- var entry = list[i];
|
|
|
-
|
|
|
- callback.call(ctx, entry[1], entry[0]);
|
|
|
+ ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {
|
|
|
+ var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;
|
|
|
+ // Detect whether transition may affect dimensions of an element.
|
|
|
+ var isReflowProperty = transitionKeys.some(function (key) {
|
|
|
+ return !!~propertyName.indexOf(key);
|
|
|
+ });
|
|
|
+ if (isReflowProperty) {
|
|
|
+ this.refresh();
|
|
|
}
|
|
|
};
|
|
|
-
|
|
|
- Object.defineProperties( anonymous.prototype, prototypeAccessors );
|
|
|
-
|
|
|
- return anonymous;
|
|
|
+ /**
|
|
|
+ * Returns instance of the ResizeObserverController.
|
|
|
+ *
|
|
|
+ * @returns {ResizeObserverController}
|
|
|
+ */
|
|
|
+ ResizeObserverController.getInstance = function () {
|
|
|
+ if (!this.instance_) {
|
|
|
+ this.instance_ = new ResizeObserverController();
|
|
|
+ }
|
|
|
+ return this.instance_;
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Holds reference to the controller's instance.
|
|
|
+ *
|
|
|
+ * @private {ResizeObserverController}
|
|
|
+ */
|
|
|
+ ResizeObserverController.instance_ = null;
|
|
|
+ return ResizeObserverController;
|
|
|
}());
|
|
|
-})();
|
|
|
|
|
|
-/**
|
|
|
- * Detects whether window and document objects are available in current environment.
|
|
|
- */
|
|
|
-var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;
|
|
|
-
|
|
|
-// Returns global object of a current environment.
|
|
|
-var global$1 = (function () {
|
|
|
- if (typeof global !== 'undefined' && global.Math === Math) {
|
|
|
- return global;
|
|
|
- }
|
|
|
-
|
|
|
- if (typeof self !== 'undefined' && self.Math === Math) {
|
|
|
- return self;
|
|
|
- }
|
|
|
-
|
|
|
- if (typeof window !== 'undefined' && window.Math === Math) {
|
|
|
- return window;
|
|
|
- }
|
|
|
+ /**
|
|
|
+ * Defines non-writable/enumerable properties of the provided target object.
|
|
|
+ *
|
|
|
+ * @param {Object} target - Object for which to define properties.
|
|
|
+ * @param {Object} props - Properties to be defined.
|
|
|
+ * @returns {Object} Target object.
|
|
|
+ */
|
|
|
+ var defineConfigurable = (function (target, props) {
|
|
|
+ for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
|
|
|
+ var key = _a[_i];
|
|
|
+ Object.defineProperty(target, key, {
|
|
|
+ value: props[key],
|
|
|
+ enumerable: false,
|
|
|
+ writable: false,
|
|
|
+ configurable: true
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return target;
|
|
|
+ });
|
|
|
|
|
|
- // eslint-disable-next-line no-new-func
|
|
|
- return Function('return this')();
|
|
|
-})();
|
|
|
+ /**
|
|
|
+ * Returns the global object associated with provided element.
|
|
|
+ *
|
|
|
+ * @param {Object} target
|
|
|
+ * @returns {Object}
|
|
|
+ */
|
|
|
+ var getWindowOf = (function (target) {
|
|
|
+ // Assume that the element is an instance of Node, which means that it
|
|
|
+ // has the "ownerDocument" property from which we can retrieve a
|
|
|
+ // corresponding global object.
|
|
|
+ var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
|
|
|
+ // Return the local global object if it's not possible extract one from
|
|
|
+ // provided element.
|
|
|
+ return ownerGlobal || global$1;
|
|
|
+ });
|
|
|
|
|
|
-/**
|
|
|
- * A shim for the requestAnimationFrame which falls back to the setTimeout if
|
|
|
- * first one is not supported.
|
|
|
- *
|
|
|
- * @returns {number} Requests' identifier.
|
|
|
- */
|
|
|
-var requestAnimationFrame$1 = (function () {
|
|
|
- if (typeof requestAnimationFrame === 'function') {
|
|
|
- // It's required to use a bounded function because IE sometimes throws
|
|
|
- // an "Invalid calling object" error if rAF is invoked without the global
|
|
|
- // object on the left hand side.
|
|
|
- return requestAnimationFrame.bind(global$1);
|
|
|
+ // Placeholder of an empty content rectangle.
|
|
|
+ var emptyRect = createRectInit(0, 0, 0, 0);
|
|
|
+ /**
|
|
|
+ * Converts provided string to a number.
|
|
|
+ *
|
|
|
+ * @param {number|string} value
|
|
|
+ * @returns {number}
|
|
|
+ */
|
|
|
+ function toFloat(value) {
|
|
|
+ return parseFloat(value) || 0;
|
|
|
}
|
|
|
-
|
|
|
- return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };
|
|
|
-})();
|
|
|
-
|
|
|
-// Defines minimum timeout before adding a trailing call.
|
|
|
-var trailingTimeout = 2;
|
|
|
-
|
|
|
-/**
|
|
|
- * Creates a wrapper function which ensures that provided callback will be
|
|
|
- * invoked only once during the specified delay period.
|
|
|
- *
|
|
|
- * @param {Function} callback - Function to be invoked after the delay period.
|
|
|
- * @param {number} delay - Delay after which to invoke callback.
|
|
|
- * @returns {Function}
|
|
|
- */
|
|
|
-var throttle = function (callback, delay) {
|
|
|
- var leadingCall = false,
|
|
|
- trailingCall = false,
|
|
|
- lastCallTime = 0;
|
|
|
-
|
|
|
/**
|
|
|
- * Invokes the original callback function and schedules new invocation if
|
|
|
- * the "proxy" was called during current request.
|
|
|
+ * Extracts borders size from provided styles.
|
|
|
*
|
|
|
- * @returns {void}
|
|
|
+ * @param {CSSStyleDeclaration} styles
|
|
|
+ * @param {...string} positions - Borders positions (top, right, ...)
|
|
|
+ * @returns {number}
|
|
|
*/
|
|
|
- function resolvePending() {
|
|
|
- if (leadingCall) {
|
|
|
- leadingCall = false;
|
|
|
-
|
|
|
- callback();
|
|
|
+ function getBordersSize(styles) {
|
|
|
+ var positions = [];
|
|
|
+ for (var _i = 1; _i < arguments.length; _i++) {
|
|
|
+ positions[_i - 1] = arguments[_i];
|
|
|
}
|
|
|
-
|
|
|
- if (trailingCall) {
|
|
|
- proxy();
|
|
|
+ return positions.reduce(function (size, position) {
|
|
|
+ var value = styles['border-' + position + '-width'];
|
|
|
+ return size + toFloat(value);
|
|
|
+ }, 0);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Extracts paddings sizes from provided styles.
|
|
|
+ *
|
|
|
+ * @param {CSSStyleDeclaration} styles
|
|
|
+ * @returns {Object} Paddings box.
|
|
|
+ */
|
|
|
+ function getPaddings(styles) {
|
|
|
+ var positions = ['top', 'right', 'bottom', 'left'];
|
|
|
+ var paddings = {};
|
|
|
+ for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
|
|
|
+ var position = positions_1[_i];
|
|
|
+ var value = styles['padding-' + position];
|
|
|
+ paddings[position] = toFloat(value);
|
|
|
}
|
|
|
+ return paddings;
|
|
|
}
|
|
|
-
|
|
|
/**
|
|
|
- * Callback invoked after the specified delay. It will further postpone
|
|
|
- * invocation of the original function delegating it to the
|
|
|
- * requestAnimationFrame.
|
|
|
+ * Calculates content rectangle of provided SVG element.
|
|
|
*
|
|
|
- * @returns {void}
|
|
|
+ * @param {SVGGraphicsElement} target - Element content rectangle of which needs
|
|
|
+ * to be calculated.
|
|
|
+ * @returns {DOMRectInit}
|
|
|
*/
|
|
|
- function timeoutCallback() {
|
|
|
- requestAnimationFrame$1(resolvePending);
|
|
|
+ function getSVGContentRect(target) {
|
|
|
+ var bbox = target.getBBox();
|
|
|
+ return createRectInit(0, 0, bbox.width, bbox.height);
|
|
|
}
|
|
|
-
|
|
|
/**
|
|
|
- * Schedules invocation of the original function.
|
|
|
+ * Calculates content rectangle of provided HTMLElement.
|
|
|
*
|
|
|
- * @returns {void}
|
|
|
+ * @param {HTMLElement} target - Element for which to calculate the content rectangle.
|
|
|
+ * @returns {DOMRectInit}
|
|
|
*/
|
|
|
- function proxy() {
|
|
|
- var timeStamp = Date.now();
|
|
|
-
|
|
|
- if (leadingCall) {
|
|
|
- // Reject immediately following calls.
|
|
|
- if (timeStamp - lastCallTime < trailingTimeout) {
|
|
|
- return;
|
|
|
+ function getHTMLElementContentRect(target) {
|
|
|
+ // Client width & height properties can't be
|
|
|
+ // used exclusively as they provide rounded values.
|
|
|
+ var clientWidth = target.clientWidth, clientHeight = target.clientHeight;
|
|
|
+ // By this condition we can catch all non-replaced inline, hidden and
|
|
|
+ // detached elements. Though elements with width & height properties less
|
|
|
+ // than 0.5 will be discarded as well.
|
|
|
+ //
|
|
|
+ // Without it we would need to implement separate methods for each of
|
|
|
+ // those cases and it's not possible to perform a precise and performance
|
|
|
+ // effective test for hidden elements. E.g. even jQuery's ':visible' filter
|
|
|
+ // gives wrong results for elements with width & height less than 0.5.
|
|
|
+ if (!clientWidth && !clientHeight) {
|
|
|
+ return emptyRect;
|
|
|
+ }
|
|
|
+ var styles = getWindowOf(target).getComputedStyle(target);
|
|
|
+ var paddings = getPaddings(styles);
|
|
|
+ var horizPad = paddings.left + paddings.right;
|
|
|
+ var vertPad = paddings.top + paddings.bottom;
|
|
|
+ // Computed styles of width & height are being used because they are the
|
|
|
+ // only dimensions available to JS that contain non-rounded values. It could
|
|
|
+ // be possible to utilize the getBoundingClientRect if only it's data wasn't
|
|
|
+ // affected by CSS transformations let alone paddings, borders and scroll bars.
|
|
|
+ var width = toFloat(styles.width), height = toFloat(styles.height);
|
|
|
+ // Width & height include paddings and borders when the 'border-box' box
|
|
|
+ // model is applied (except for IE).
|
|
|
+ if (styles.boxSizing === 'border-box') {
|
|
|
+ // Following conditions are required to handle Internet Explorer which
|
|
|
+ // doesn't include paddings and borders to computed CSS dimensions.
|
|
|
+ //
|
|
|
+ // We can say that if CSS dimensions + paddings are equal to the "client"
|
|
|
+ // properties then it's either IE, and thus we don't need to subtract
|
|
|
+ // anything, or an element merely doesn't have paddings/borders styles.
|
|
|
+ if (Math.round(width + horizPad) !== clientWidth) {
|
|
|
+ width -= getBordersSize(styles, 'left', 'right') + horizPad;
|
|
|
+ }
|
|
|
+ if (Math.round(height + vertPad) !== clientHeight) {
|
|
|
+ height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
|
|
|
}
|
|
|
-
|
|
|
- // Schedule new call to be in invoked when the pending one is resolved.
|
|
|
- // This is important for "transitions" which never actually start
|
|
|
- // immediately so there is a chance that we might miss one if change
|
|
|
- // happens amids the pending invocation.
|
|
|
- trailingCall = true;
|
|
|
- } else {
|
|
|
- leadingCall = true;
|
|
|
- trailingCall = false;
|
|
|
-
|
|
|
- setTimeout(timeoutCallback, delay);
|
|
|
}
|
|
|
-
|
|
|
- lastCallTime = timeStamp;
|
|
|
- }
|
|
|
-
|
|
|
- return proxy;
|
|
|
-};
|
|
|
-
|
|
|
-// Minimum delay before invoking the update of observers.
|
|
|
-var REFRESH_DELAY = 20;
|
|
|
-
|
|
|
-// A list of substrings of CSS properties used to find transition events that
|
|
|
-// might affect dimensions of observed elements.
|
|
|
-var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
|
|
|
-
|
|
|
-// Check if MutationObserver is available.
|
|
|
-var mutationObserverSupported = typeof MutationObserver !== 'undefined';
|
|
|
-
|
|
|
-/**
|
|
|
- * Singleton controller class which handles updates of ResizeObserver instances.
|
|
|
- */
|
|
|
-var ResizeObserverController = function() {
|
|
|
- this.connected_ = false;
|
|
|
- this.mutationEventsAdded_ = false;
|
|
|
- this.mutationsObserver_ = null;
|
|
|
- this.observers_ = [];
|
|
|
-
|
|
|
- this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
|
|
|
- this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Adds observer to observers list.
|
|
|
- *
|
|
|
- * @param {ResizeObserverSPI} observer - Observer to be added.
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * Holds reference to the controller's instance.
|
|
|
- *
|
|
|
- * @private {ResizeObserverController}
|
|
|
- */
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * Keeps reference to the instance of MutationObserver.
|
|
|
- *
|
|
|
- * @private {MutationObserver}
|
|
|
- */
|
|
|
-
|
|
|
-/**
|
|
|
- * Indicates whether DOM listeners have been added.
|
|
|
- *
|
|
|
- * @private {boolean}
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.addObserver = function (observer) {
|
|
|
- if (!~this.observers_.indexOf(observer)) {
|
|
|
- this.observers_.push(observer);
|
|
|
- }
|
|
|
-
|
|
|
- // Add listeners if they haven't been added yet.
|
|
|
- if (!this.connected_) {
|
|
|
- this.connect_();
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Removes observer from observers list.
|
|
|
- *
|
|
|
- * @param {ResizeObserverSPI} observer - Observer to be removed.
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.removeObserver = function (observer) {
|
|
|
- var observers = this.observers_;
|
|
|
- var index = observers.indexOf(observer);
|
|
|
-
|
|
|
- // Remove observer if it's present in registry.
|
|
|
- if (~index) {
|
|
|
- observers.splice(index, 1);
|
|
|
- }
|
|
|
-
|
|
|
- // Remove listeners if controller has no connected observers.
|
|
|
- if (!observers.length && this.connected_) {
|
|
|
- this.disconnect_();
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Invokes the update of observers. It will continue running updates insofar
|
|
|
- * it detects changes.
|
|
|
- *
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.refresh = function () {
|
|
|
- var changesDetected = this.updateObservers_();
|
|
|
-
|
|
|
- // Continue running updates if changes have been detected as there might
|
|
|
- // be future ones caused by CSS transitions.
|
|
|
- if (changesDetected) {
|
|
|
- this.refresh();
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Updates every observer from observers list and notifies them of queued
|
|
|
- * entries.
|
|
|
- *
|
|
|
- * @private
|
|
|
- * @returns {boolean} Returns "true" if any observer has detected changes in
|
|
|
- * dimensions of it's elements.
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.updateObservers_ = function () {
|
|
|
- // Collect observers that have active observations.
|
|
|
- var activeObservers = this.observers_.filter(function (observer) {
|
|
|
- return observer.gatherActive(), observer.hasActive();
|
|
|
- });
|
|
|
-
|
|
|
- // Deliver notifications in a separate cycle in order to avoid any
|
|
|
- // collisions between observers, e.g. when multiple instances of
|
|
|
- // ResizeObserver are tracking the same element and the callback of one
|
|
|
- // of them changes content dimensions of the observed target. Sometimes
|
|
|
- // this may result in notifications being blocked for the rest of observers.
|
|
|
- activeObservers.forEach(function (observer) { return observer.broadcastActive(); });
|
|
|
-
|
|
|
- return activeObservers.length > 0;
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Initializes DOM listeners.
|
|
|
- *
|
|
|
- * @private
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.connect_ = function () {
|
|
|
- // Do nothing if running in a non-browser environment or if listeners
|
|
|
- // have been already added.
|
|
|
- if (!isBrowser || this.connected_) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- // Subscription to the "Transitionend" event is used as a workaround for
|
|
|
- // delayed transitions. This way it's possible to capture at least the
|
|
|
- // final state of an element.
|
|
|
- document.addEventListener('transitionend', this.onTransitionEnd_);
|
|
|
-
|
|
|
- window.addEventListener('resize', this.refresh);
|
|
|
-
|
|
|
- if (mutationObserverSupported) {
|
|
|
- this.mutationsObserver_ = new MutationObserver(this.refresh);
|
|
|
-
|
|
|
- this.mutationsObserver_.observe(document, {
|
|
|
- attributes: true,
|
|
|
- childList: true,
|
|
|
- characterData: true,
|
|
|
- subtree: true
|
|
|
- });
|
|
|
- } else {
|
|
|
- document.addEventListener('DOMSubtreeModified', this.refresh);
|
|
|
-
|
|
|
- this.mutationEventsAdded_ = true;
|
|
|
- }
|
|
|
-
|
|
|
- this.connected_ = true;
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Removes DOM listeners.
|
|
|
- *
|
|
|
- * @private
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.disconnect_ = function () {
|
|
|
- // Do nothing if running in a non-browser environment or if listeners
|
|
|
- // have been already removed.
|
|
|
- if (!isBrowser || !this.connected_) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- document.removeEventListener('transitionend', this.onTransitionEnd_);
|
|
|
- window.removeEventListener('resize', this.refresh);
|
|
|
-
|
|
|
- if (this.mutationsObserver_) {
|
|
|
- this.mutationsObserver_.disconnect();
|
|
|
- }
|
|
|
-
|
|
|
- if (this.mutationEventsAdded_) {
|
|
|
- document.removeEventListener('DOMSubtreeModified', this.refresh);
|
|
|
+ // Following steps can't be applied to the document's root element as its
|
|
|
+ // client[Width/Height] properties represent viewport area of the window.
|
|
|
+ // Besides, it's as well not necessary as the <html> itself neither has
|
|
|
+ // rendered scroll bars nor it can be clipped.
|
|
|
+ if (!isDocumentElement(target)) {
|
|
|
+ // In some browsers (only in Firefox, actually) CSS width & height
|
|
|
+ // include scroll bars size which can be removed at this step as scroll
|
|
|
+ // bars are the only difference between rounded dimensions + paddings
|
|
|
+ // and "client" properties, though that is not always true in Chrome.
|
|
|
+ var vertScrollbar = Math.round(width + horizPad) - clientWidth;
|
|
|
+ var horizScrollbar = Math.round(height + vertPad) - clientHeight;
|
|
|
+ // Chrome has a rather weird rounding of "client" properties.
|
|
|
+ // E.g. for an element with content width of 314.2px it sometimes gives
|
|
|
+ // the client width of 315px and for the width of 314.7px it may give
|
|
|
+ // 314px. And it doesn't happen all the time. So just ignore this delta
|
|
|
+ // as a non-relevant.
|
|
|
+ if (Math.abs(vertScrollbar) !== 1) {
|
|
|
+ width -= vertScrollbar;
|
|
|
+ }
|
|
|
+ if (Math.abs(horizScrollbar) !== 1) {
|
|
|
+ height -= horizScrollbar;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return createRectInit(paddings.left, paddings.top, width, height);
|
|
|
}
|
|
|
-
|
|
|
- this.mutationsObserver_ = null;
|
|
|
- this.mutationEventsAdded_ = false;
|
|
|
- this.connected_ = false;
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * "Transitionend" event handler.
|
|
|
- *
|
|
|
- * @private
|
|
|
- * @param {TransitionEvent} event
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverController.prototype.onTransitionEnd_ = function (ref) {
|
|
|
- var propertyName = ref.propertyName; if ( propertyName === void 0 ) propertyName = '';
|
|
|
-
|
|
|
- // Detect whether transition may affect dimensions of an element.
|
|
|
- var isReflowProperty = transitionKeys.some(function (key) {
|
|
|
- return !!~propertyName.indexOf(key);
|
|
|
- });
|
|
|
-
|
|
|
- if (isReflowProperty) {
|
|
|
- this.refresh();
|
|
|
+ /**
|
|
|
+ * Checks whether provided element is an instance of the SVGGraphicsElement.
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element to be checked.
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ var isSVGGraphicsElement = (function () {
|
|
|
+ // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
|
|
|
+ // interface.
|
|
|
+ if (typeof SVGGraphicsElement !== 'undefined') {
|
|
|
+ return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };
|
|
|
+ }
|
|
|
+ // If it's so, then check that element is at least an instance of the
|
|
|
+ // SVGElement and that it has the "getBBox" method.
|
|
|
+ // eslint-disable-next-line no-extra-parens
|
|
|
+ return function (target) { return (target instanceof getWindowOf(target).SVGElement &&
|
|
|
+ typeof target.getBBox === 'function'); };
|
|
|
+ })();
|
|
|
+ /**
|
|
|
+ * Checks whether provided element is a document element (<html>).
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element to be checked.
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ function isDocumentElement(target) {
|
|
|
+ return target === getWindowOf(target).document.documentElement;
|
|
|
}
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Returns instance of the ResizeObserverController.
|
|
|
- *
|
|
|
- * @returns {ResizeObserverController}
|
|
|
- */
|
|
|
-ResizeObserverController.getInstance = function () {
|
|
|
- if (!this.instance_) {
|
|
|
- this.instance_ = new ResizeObserverController();
|
|
|
+ /**
|
|
|
+ * Calculates an appropriate content rectangle for provided html or svg element.
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element content rectangle of which needs to be calculated.
|
|
|
+ * @returns {DOMRectInit}
|
|
|
+ */
|
|
|
+ function getContentRect(target) {
|
|
|
+ if (!isBrowser) {
|
|
|
+ return emptyRect;
|
|
|
+ }
|
|
|
+ if (isSVGGraphicsElement(target)) {
|
|
|
+ return getSVGContentRect(target);
|
|
|
+ }
|
|
|
+ return getHTMLElementContentRect(target);
|
|
|
}
|
|
|
-
|
|
|
- return this.instance_;
|
|
|
-};
|
|
|
-
|
|
|
-ResizeObserverController.instance_ = null;
|
|
|
-
|
|
|
-/**
|
|
|
- * Defines non-writable/enumerable properties of the provided target object.
|
|
|
- *
|
|
|
- * @param {Object} target - Object for which to define properties.
|
|
|
- * @param {Object} props - Properties to be defined.
|
|
|
- * @returns {Object} Target object.
|
|
|
- */
|
|
|
-var defineConfigurable = (function (target, props) {
|
|
|
- for (var i = 0, list = Object.keys(props); i < list.length; i += 1) {
|
|
|
- var key = list[i];
|
|
|
-
|
|
|
- Object.defineProperty(target, key, {
|
|
|
- value: props[key],
|
|
|
- enumerable: false,
|
|
|
- writable: false,
|
|
|
- configurable: true
|
|
|
+ /**
|
|
|
+ * Creates rectangle with an interface of the DOMRectReadOnly.
|
|
|
+ * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
|
|
|
+ *
|
|
|
+ * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
|
|
|
+ * @returns {DOMRectReadOnly}
|
|
|
+ */
|
|
|
+ function createReadOnlyRect(_a) {
|
|
|
+ var x = _a.x, y = _a.y, width = _a.width, height = _a.height;
|
|
|
+ // If DOMRectReadOnly is available use it as a prototype for the rectangle.
|
|
|
+ var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
|
|
|
+ var rect = Object.create(Constr.prototype);
|
|
|
+ // Rectangle's properties are not writable and non-enumerable.
|
|
|
+ defineConfigurable(rect, {
|
|
|
+ x: x, y: y, width: width, height: height,
|
|
|
+ top: y,
|
|
|
+ right: x + width,
|
|
|
+ bottom: height + y,
|
|
|
+ left: x
|
|
|
});
|
|
|
+ return rect;
|
|
|
}
|
|
|
-
|
|
|
- return target;
|
|
|
-});
|
|
|
-
|
|
|
-/**
|
|
|
- * Returns the global object associated with provided element.
|
|
|
- *
|
|
|
- * @param {Object} target
|
|
|
- * @returns {Object}
|
|
|
- */
|
|
|
-var getWindowOf = (function (target) {
|
|
|
- // Assume that the element is an instance of Node, which means that it
|
|
|
- // has the "ownerDocument" property from which we can retrieve a
|
|
|
- // corresponding global object.
|
|
|
- var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
|
|
|
-
|
|
|
- // Return the local global object if it's not possible extract one from
|
|
|
- // provided element.
|
|
|
- return ownerGlobal || global$1;
|
|
|
-});
|
|
|
-
|
|
|
-// Placeholder of an empty content rectangle.
|
|
|
-var emptyRect = createRectInit(0, 0, 0, 0);
|
|
|
-
|
|
|
-/**
|
|
|
- * Converts provided string to a number.
|
|
|
- *
|
|
|
- * @param {number|string} value
|
|
|
- * @returns {number}
|
|
|
- */
|
|
|
-function toFloat(value) {
|
|
|
- return parseFloat(value) || 0;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Extracts borders size from provided styles.
|
|
|
- *
|
|
|
- * @param {CSSStyleDeclaration} styles
|
|
|
- * @param {...string} positions - Borders positions (top, right, ...)
|
|
|
- * @returns {number}
|
|
|
- */
|
|
|
-function getBordersSize(styles) {
|
|
|
- var positions = [], len = arguments.length - 1;
|
|
|
- while ( len-- > 0 ) positions[ len ] = arguments[ len + 1 ];
|
|
|
-
|
|
|
- return positions.reduce(function (size, position) {
|
|
|
- var value = styles['border-' + position + '-width'];
|
|
|
-
|
|
|
- return size + toFloat(value);
|
|
|
- }, 0);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Extracts paddings sizes from provided styles.
|
|
|
- *
|
|
|
- * @param {CSSStyleDeclaration} styles
|
|
|
- * @returns {Object} Paddings box.
|
|
|
- */
|
|
|
-function getPaddings(styles) {
|
|
|
- var positions = ['top', 'right', 'bottom', 'left'];
|
|
|
- var paddings = {};
|
|
|
-
|
|
|
- for (var i = 0, list = positions; i < list.length; i += 1) {
|
|
|
- var position = list[i];
|
|
|
-
|
|
|
- var value = styles['padding-' + position];
|
|
|
-
|
|
|
- paddings[position] = toFloat(value);
|
|
|
- }
|
|
|
-
|
|
|
- return paddings;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Calculates content rectangle of provided SVG element.
|
|
|
- *
|
|
|
- * @param {SVGGraphicsElement} target - Element content rectangle of which needs
|
|
|
- * to be calculated.
|
|
|
- * @returns {DOMRectInit}
|
|
|
- */
|
|
|
-function getSVGContentRect(target) {
|
|
|
- var bbox = target.getBBox();
|
|
|
-
|
|
|
- return createRectInit(0, 0, bbox.width, bbox.height);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Calculates content rectangle of provided HTMLElement.
|
|
|
- *
|
|
|
- * @param {HTMLElement} target - Element for which to calculate the content rectangle.
|
|
|
- * @returns {DOMRectInit}
|
|
|
- */
|
|
|
-function getHTMLElementContentRect(target) {
|
|
|
- // Client width & height properties can't be
|
|
|
- // used exclusively as they provide rounded values.
|
|
|
- var clientWidth = target.clientWidth;
|
|
|
- var clientHeight = target.clientHeight;
|
|
|
-
|
|
|
- // By this condition we can catch all non-replaced inline, hidden and
|
|
|
- // detached elements. Though elements with width & height properties less
|
|
|
- // than 0.5 will be discarded as well.
|
|
|
- //
|
|
|
- // Without it we would need to implement separate methods for each of
|
|
|
- // those cases and it's not possible to perform a precise and performance
|
|
|
- // effective test for hidden elements. E.g. even jQuery's ':visible' filter
|
|
|
- // gives wrong results for elements with width & height less than 0.5.
|
|
|
- if (!clientWidth && !clientHeight) {
|
|
|
- return emptyRect;
|
|
|
+ /**
|
|
|
+ * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
|
|
|
+ * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
|
|
|
+ *
|
|
|
+ * @param {number} x - X coordinate.
|
|
|
+ * @param {number} y - Y coordinate.
|
|
|
+ * @param {number} width - Rectangle's width.
|
|
|
+ * @param {number} height - Rectangle's height.
|
|
|
+ * @returns {DOMRectInit}
|
|
|
+ */
|
|
|
+ function createRectInit(x, y, width, height) {
|
|
|
+ return { x: x, y: y, width: width, height: height };
|
|
|
}
|
|
|
|
|
|
- var styles = getWindowOf(target).getComputedStyle(target);
|
|
|
- var paddings = getPaddings(styles);
|
|
|
- var horizPad = paddings.left + paddings.right;
|
|
|
- var vertPad = paddings.top + paddings.bottom;
|
|
|
-
|
|
|
- // Computed styles of width & height are being used because they are the
|
|
|
- // only dimensions available to JS that contain non-rounded values. It could
|
|
|
- // be possible to utilize the getBoundingClientRect if only it's data wasn't
|
|
|
- // affected by CSS transformations let alone paddings, borders and scroll bars.
|
|
|
- var width = toFloat(styles.width),
|
|
|
- height = toFloat(styles.height);
|
|
|
-
|
|
|
- // Width & height include paddings and borders when the 'border-box' box
|
|
|
- // model is applied (except for IE).
|
|
|
- if (styles.boxSizing === 'border-box') {
|
|
|
- // Following conditions are required to handle Internet Explorer which
|
|
|
- // doesn't include paddings and borders to computed CSS dimensions.
|
|
|
- //
|
|
|
- // We can say that if CSS dimensions + paddings are equal to the "client"
|
|
|
- // properties then it's either IE, and thus we don't need to subtract
|
|
|
- // anything, or an element merely doesn't have paddings/borders styles.
|
|
|
- if (Math.round(width + horizPad) !== clientWidth) {
|
|
|
- width -= getBordersSize(styles, 'left', 'right') + horizPad;
|
|
|
+ /**
|
|
|
+ * Class that is responsible for computations of the content rectangle of
|
|
|
+ * provided DOM element and for keeping track of it's changes.
|
|
|
+ */
|
|
|
+ var ResizeObservation = /** @class */ (function () {
|
|
|
+ /**
|
|
|
+ * Creates an instance of ResizeObservation.
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element to be observed.
|
|
|
+ */
|
|
|
+ function ResizeObservation(target) {
|
|
|
+ /**
|
|
|
+ * Broadcasted width of content rectangle.
|
|
|
+ *
|
|
|
+ * @type {number}
|
|
|
+ */
|
|
|
+ this.broadcastWidth = 0;
|
|
|
+ /**
|
|
|
+ * Broadcasted height of content rectangle.
|
|
|
+ *
|
|
|
+ * @type {number}
|
|
|
+ */
|
|
|
+ this.broadcastHeight = 0;
|
|
|
+ /**
|
|
|
+ * Reference to the last observed content rectangle.
|
|
|
+ *
|
|
|
+ * @private {DOMRectInit}
|
|
|
+ */
|
|
|
+ this.contentRect_ = createRectInit(0, 0, 0, 0);
|
|
|
+ this.target = target;
|
|
|
}
|
|
|
+ /**
|
|
|
+ * Updates content rectangle and tells whether it's width or height properties
|
|
|
+ * have changed since the last broadcast.
|
|
|
+ *
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ ResizeObservation.prototype.isActive = function () {
|
|
|
+ var rect = getContentRect(this.target);
|
|
|
+ this.contentRect_ = rect;
|
|
|
+ return (rect.width !== this.broadcastWidth ||
|
|
|
+ rect.height !== this.broadcastHeight);
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
|
|
|
+ * from the corresponding properties of the last observed content rectangle.
|
|
|
+ *
|
|
|
+ * @returns {DOMRectInit} Last observed content rectangle.
|
|
|
+ */
|
|
|
+ ResizeObservation.prototype.broadcastRect = function () {
|
|
|
+ var rect = this.contentRect_;
|
|
|
+ this.broadcastWidth = rect.width;
|
|
|
+ this.broadcastHeight = rect.height;
|
|
|
+ return rect;
|
|
|
+ };
|
|
|
+ return ResizeObservation;
|
|
|
+ }());
|
|
|
|
|
|
- if (Math.round(height + vertPad) !== clientHeight) {
|
|
|
- height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
|
|
|
+ var ResizeObserverEntry = /** @class */ (function () {
|
|
|
+ /**
|
|
|
+ * Creates an instance of ResizeObserverEntry.
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element that is being observed.
|
|
|
+ * @param {DOMRectInit} rectInit - Data of the element's content rectangle.
|
|
|
+ */
|
|
|
+ function ResizeObserverEntry(target, rectInit) {
|
|
|
+ var contentRect = createReadOnlyRect(rectInit);
|
|
|
+ // According to the specification following properties are not writable
|
|
|
+ // and are also not enumerable in the native implementation.
|
|
|
+ //
|
|
|
+ // Property accessors are not being used as they'd require to define a
|
|
|
+ // private WeakMap storage which may cause memory leaks in browsers that
|
|
|
+ // don't support this type of collections.
|
|
|
+ defineConfigurable(this, { target: target, contentRect: contentRect });
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- // Following steps can't be applied to the document's root element as its
|
|
|
- // client[Width/Height] properties represent viewport area of the window.
|
|
|
- // Besides, it's as well not necessary as the <html> itself neither has
|
|
|
- // rendered scroll bars nor it can be clipped.
|
|
|
- if (!isDocumentElement(target)) {
|
|
|
- // In some browsers (only in Firefox, actually) CSS width & height
|
|
|
- // include scroll bars size which can be removed at this step as scroll
|
|
|
- // bars are the only difference between rounded dimensions + paddings
|
|
|
- // and "client" properties, though that is not always true in Chrome.
|
|
|
- var vertScrollbar = Math.round(width + horizPad) - clientWidth;
|
|
|
- var horizScrollbar = Math.round(height + vertPad) - clientHeight;
|
|
|
+ return ResizeObserverEntry;
|
|
|
+ }());
|
|
|
|
|
|
- // Chrome has a rather weird rounding of "client" properties.
|
|
|
- // E.g. for an element with content width of 314.2px it sometimes gives
|
|
|
- // the client width of 315px and for the width of 314.7px it may give
|
|
|
- // 314px. And it doesn't happen all the time. So just ignore this delta
|
|
|
- // as a non-relevant.
|
|
|
- if (Math.abs(vertScrollbar) !== 1) {
|
|
|
- width -= vertScrollbar;
|
|
|
+ var ResizeObserverSPI = /** @class */ (function () {
|
|
|
+ /**
|
|
|
+ * Creates a new instance of ResizeObserver.
|
|
|
+ *
|
|
|
+ * @param {ResizeObserverCallback} callback - Callback function that is invoked
|
|
|
+ * when one of the observed elements changes it's content dimensions.
|
|
|
+ * @param {ResizeObserverController} controller - Controller instance which
|
|
|
+ * is responsible for the updates of observer.
|
|
|
+ * @param {ResizeObserver} callbackCtx - Reference to the public
|
|
|
+ * ResizeObserver instance which will be passed to callback function.
|
|
|
+ */
|
|
|
+ function ResizeObserverSPI(callback, controller, callbackCtx) {
|
|
|
+ /**
|
|
|
+ * Collection of resize observations that have detected changes in dimensions
|
|
|
+ * of elements.
|
|
|
+ *
|
|
|
+ * @private {Array<ResizeObservation>}
|
|
|
+ */
|
|
|
+ this.activeObservations_ = [];
|
|
|
+ /**
|
|
|
+ * Registry of the ResizeObservation instances.
|
|
|
+ *
|
|
|
+ * @private {Map<Element, ResizeObservation>}
|
|
|
+ */
|
|
|
+ this.observations_ = new MapShim();
|
|
|
+ if (typeof callback !== 'function') {
|
|
|
+ throw new TypeError('The callback provided as parameter 1 is not a function.');
|
|
|
+ }
|
|
|
+ this.callback_ = callback;
|
|
|
+ this.controller_ = controller;
|
|
|
+ this.callbackCtx_ = callbackCtx;
|
|
|
}
|
|
|
+ /**
|
|
|
+ * Starts observing provided element.
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element to be observed.
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.observe = function (target) {
|
|
|
+ if (!arguments.length) {
|
|
|
+ throw new TypeError('1 argument required, but only 0 present.');
|
|
|
+ }
|
|
|
+ // Do nothing if current environment doesn't have the Element interface.
|
|
|
+ if (typeof Element === 'undefined' || !(Element instanceof Object)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!(target instanceof getWindowOf(target).Element)) {
|
|
|
+ throw new TypeError('parameter 1 is not of type "Element".');
|
|
|
+ }
|
|
|
+ var observations = this.observations_;
|
|
|
+ // Do nothing if element is already being observed.
|
|
|
+ if (observations.has(target)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ observations.set(target, new ResizeObservation(target));
|
|
|
+ this.controller_.addObserver(this);
|
|
|
+ // Force the update of observations.
|
|
|
+ this.controller_.refresh();
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Stops observing provided element.
|
|
|
+ *
|
|
|
+ * @param {Element} target - Element to stop observing.
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.unobserve = function (target) {
|
|
|
+ if (!arguments.length) {
|
|
|
+ throw new TypeError('1 argument required, but only 0 present.');
|
|
|
+ }
|
|
|
+ // Do nothing if current environment doesn't have the Element interface.
|
|
|
+ if (typeof Element === 'undefined' || !(Element instanceof Object)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!(target instanceof getWindowOf(target).Element)) {
|
|
|
+ throw new TypeError('parameter 1 is not of type "Element".');
|
|
|
+ }
|
|
|
+ var observations = this.observations_;
|
|
|
+ // Do nothing if element is not being observed.
|
|
|
+ if (!observations.has(target)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ observations.delete(target);
|
|
|
+ if (!observations.size) {
|
|
|
+ this.controller_.removeObserver(this);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Stops observing all elements.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.disconnect = function () {
|
|
|
+ this.clearActive();
|
|
|
+ this.observations_.clear();
|
|
|
+ this.controller_.removeObserver(this);
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Collects observation instances the associated element of which has changed
|
|
|
+ * it's content rectangle.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.gatherActive = function () {
|
|
|
+ var _this = this;
|
|
|
+ this.clearActive();
|
|
|
+ this.observations_.forEach(function (observation) {
|
|
|
+ if (observation.isActive()) {
|
|
|
+ _this.activeObservations_.push(observation);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Invokes initial callback function with a list of ResizeObserverEntry
|
|
|
+ * instances collected from active resize observations.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.broadcastActive = function () {
|
|
|
+ // Do nothing if observer doesn't have active observations.
|
|
|
+ if (!this.hasActive()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ var ctx = this.callbackCtx_;
|
|
|
+ // Create ResizeObserverEntry instance for every active observation.
|
|
|
+ var entries = this.activeObservations_.map(function (observation) {
|
|
|
+ return new ResizeObserverEntry(observation.target, observation.broadcastRect());
|
|
|
+ });
|
|
|
+ this.callback_.call(ctx, entries, ctx);
|
|
|
+ this.clearActive();
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Clears the collection of active observations.
|
|
|
+ *
|
|
|
+ * @returns {void}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.clearActive = function () {
|
|
|
+ this.activeObservations_.splice(0);
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Tells whether observer has active observations.
|
|
|
+ *
|
|
|
+ * @returns {boolean}
|
|
|
+ */
|
|
|
+ ResizeObserverSPI.prototype.hasActive = function () {
|
|
|
+ return this.activeObservations_.length > 0;
|
|
|
+ };
|
|
|
+ return ResizeObserverSPI;
|
|
|
+ }());
|
|
|
|
|
|
- if (Math.abs(horizScrollbar) !== 1) {
|
|
|
- height -= horizScrollbar;
|
|
|
+ // Registry of internal observers. If WeakMap is not available use current shim
|
|
|
+ // for the Map collection as it has all required methods and because WeakMap
|
|
|
+ // can't be fully polyfilled anyway.
|
|
|
+ var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
|
|
|
+ /**
|
|
|
+ * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
|
|
|
+ * exposing only those methods and properties that are defined in the spec.
|
|
|
+ */
|
|
|
+ var ResizeObserver = /** @class */ (function () {
|
|
|
+ /**
|
|
|
+ * Creates a new instance of ResizeObserver.
|
|
|
+ *
|
|
|
+ * @param {ResizeObserverCallback} callback - Callback that is invoked when
|
|
|
+ * dimensions of the observed elements change.
|
|
|
+ */
|
|
|
+ function ResizeObserver(callback) {
|
|
|
+ if (!(this instanceof ResizeObserver)) {
|
|
|
+ throw new TypeError('Cannot call a class as a function.');
|
|
|
+ }
|
|
|
+ if (!arguments.length) {
|
|
|
+ throw new TypeError('1 argument required, but only 0 present.');
|
|
|
+ }
|
|
|
+ var controller = ResizeObserverController.getInstance();
|
|
|
+ var observer = new ResizeObserverSPI(callback, controller, this);
|
|
|
+ observers.set(this, observer);
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- return createRectInit(paddings.left, paddings.top, width, height);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Checks whether provided element is an instance of the SVGGraphicsElement.
|
|
|
- *
|
|
|
- * @param {Element} target - Element to be checked.
|
|
|
- * @returns {boolean}
|
|
|
- */
|
|
|
-var isSVGGraphicsElement = (function () {
|
|
|
- // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
|
|
|
- // interface.
|
|
|
- if (typeof SVGGraphicsElement !== 'undefined') {
|
|
|
- return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };
|
|
|
- }
|
|
|
-
|
|
|
- // If it's so, then check that element is at least an instance of the
|
|
|
- // SVGElement and that it has the "getBBox" method.
|
|
|
- // eslint-disable-next-line no-extra-parens
|
|
|
- return function (target) { return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function'; };
|
|
|
-})();
|
|
|
-
|
|
|
-/**
|
|
|
- * Checks whether provided element is a document element (<html>).
|
|
|
- *
|
|
|
- * @param {Element} target - Element to be checked.
|
|
|
- * @returns {boolean}
|
|
|
- */
|
|
|
-function isDocumentElement(target) {
|
|
|
- return target === getWindowOf(target).document.documentElement;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Calculates an appropriate content rectangle for provided html or svg element.
|
|
|
- *
|
|
|
- * @param {Element} target - Element content rectangle of which needs to be calculated.
|
|
|
- * @returns {DOMRectInit}
|
|
|
- */
|
|
|
-function getContentRect(target) {
|
|
|
- if (!isBrowser) {
|
|
|
- return emptyRect;
|
|
|
- }
|
|
|
-
|
|
|
- if (isSVGGraphicsElement(target)) {
|
|
|
- return getSVGContentRect(target);
|
|
|
- }
|
|
|
-
|
|
|
- return getHTMLElementContentRect(target);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Creates rectangle with an interface of the DOMRectReadOnly.
|
|
|
- * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
|
|
|
- *
|
|
|
- * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
|
|
|
- * @returns {DOMRectReadOnly}
|
|
|
- */
|
|
|
-function createReadOnlyRect(ref) {
|
|
|
- var x = ref.x;
|
|
|
- var y = ref.y;
|
|
|
- var width = ref.width;
|
|
|
- var height = ref.height;
|
|
|
-
|
|
|
- // If DOMRectReadOnly is available use it as a prototype for the rectangle.
|
|
|
- var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
|
|
|
- var rect = Object.create(Constr.prototype);
|
|
|
-
|
|
|
- // Rectangle's properties are not writable and non-enumerable.
|
|
|
- defineConfigurable(rect, {
|
|
|
- x: x, y: y, width: width, height: height,
|
|
|
- top: y,
|
|
|
- right: x + width,
|
|
|
- bottom: height + y,
|
|
|
- left: x
|
|
|
+ return ResizeObserver;
|
|
|
+ }());
|
|
|
+ // Expose public methods of ResizeObserver.
|
|
|
+ [
|
|
|
+ 'observe',
|
|
|
+ 'unobserve',
|
|
|
+ 'disconnect'
|
|
|
+ ].forEach(function (method) {
|
|
|
+ ResizeObserver.prototype[method] = function () {
|
|
|
+ var _a;
|
|
|
+ return (_a = observers.get(this))[method].apply(_a, arguments);
|
|
|
+ };
|
|
|
});
|
|
|
|
|
|
- return rect;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
|
|
|
- * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
|
|
|
- *
|
|
|
- * @param {number} x - X coordinate.
|
|
|
- * @param {number} y - Y coordinate.
|
|
|
- * @param {number} width - Rectangle's width.
|
|
|
- * @param {number} height - Rectangle's height.
|
|
|
- * @returns {DOMRectInit}
|
|
|
- */
|
|
|
-function createRectInit(x, y, width, height) {
|
|
|
- return { x: x, y: y, width: width, height: height };
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Class that is responsible for computations of the content rectangle of
|
|
|
- * provided DOM element and for keeping track of it's changes.
|
|
|
- */
|
|
|
-var ResizeObservation = function(target) {
|
|
|
- this.broadcastWidth = 0;
|
|
|
- this.broadcastHeight = 0;
|
|
|
- this.contentRect_ = createRectInit(0, 0, 0, 0);
|
|
|
-
|
|
|
- this.target = target;
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Updates content rectangle and tells whether it's width or height properties
|
|
|
- * have changed since the last broadcast.
|
|
|
- *
|
|
|
- * @returns {boolean}
|
|
|
- */
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * Reference to the last observed content rectangle.
|
|
|
- *
|
|
|
- * @private {DOMRectInit}
|
|
|
- */
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * Broadcasted width of content rectangle.
|
|
|
- *
|
|
|
- * @type {number}
|
|
|
- */
|
|
|
-ResizeObservation.prototype.isActive = function () {
|
|
|
- var rect = getContentRect(this.target);
|
|
|
-
|
|
|
- this.contentRect_ = rect;
|
|
|
-
|
|
|
- return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
|
|
|
- * from the corresponding properties of the last observed content rectangle.
|
|
|
- *
|
|
|
- * @returns {DOMRectInit} Last observed content rectangle.
|
|
|
- */
|
|
|
-ResizeObservation.prototype.broadcastRect = function () {
|
|
|
- var rect = this.contentRect_;
|
|
|
-
|
|
|
- this.broadcastWidth = rect.width;
|
|
|
- this.broadcastHeight = rect.height;
|
|
|
-
|
|
|
- return rect;
|
|
|
-};
|
|
|
-
|
|
|
-var ResizeObserverEntry = function(target, rectInit) {
|
|
|
- var contentRect = createReadOnlyRect(rectInit);
|
|
|
-
|
|
|
- // According to the specification following properties are not writable
|
|
|
- // and are also not enumerable in the native implementation.
|
|
|
- //
|
|
|
- // Property accessors are not being used as they'd require to define a
|
|
|
- // private WeakMap storage which may cause memory leaks in browsers that
|
|
|
- // don't support this type of collections.
|
|
|
- defineConfigurable(this, { target: target, contentRect: contentRect });
|
|
|
-};
|
|
|
-
|
|
|
-var ResizeObserverSPI = function(callback, controller, callbackCtx) {
|
|
|
- this.activeObservations_ = [];
|
|
|
- this.observations_ = new MapShim();
|
|
|
-
|
|
|
- if (typeof callback !== 'function') {
|
|
|
- throw new TypeError('The callback provided as parameter 1 is not a function.');
|
|
|
- }
|
|
|
-
|
|
|
- this.callback_ = callback;
|
|
|
- this.controller_ = controller;
|
|
|
- this.callbackCtx_ = callbackCtx;
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Starts observing provided element.
|
|
|
- *
|
|
|
- * @param {Element} target - Element to be observed.
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * Registry of the ResizeObservation instances.
|
|
|
- *
|
|
|
- * @private {Map<Element, ResizeObservation>}
|
|
|
- */
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * Public ResizeObserver instance which will be passed to the callback
|
|
|
- * function and used as a value of it's "this" binding.
|
|
|
- *
|
|
|
- * @private {ResizeObserver}
|
|
|
- */
|
|
|
-
|
|
|
-/**
|
|
|
- * Collection of resize observations that have detected changes in dimensions
|
|
|
- * of elements.
|
|
|
- *
|
|
|
- * @private {Array<ResizeObservation>}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.observe = function (target) {
|
|
|
- if (!arguments.length) {
|
|
|
- throw new TypeError('1 argument required, but only 0 present.');
|
|
|
- }
|
|
|
-
|
|
|
- // Do nothing if current environment doesn't have the Element interface.
|
|
|
- if (typeof Element === 'undefined' || !(Element instanceof Object)) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (!(target instanceof getWindowOf(target).Element)) {
|
|
|
- throw new TypeError('parameter 1 is not of type "Element".');
|
|
|
- }
|
|
|
-
|
|
|
- var observations = this.observations_;
|
|
|
-
|
|
|
- // Do nothing if element is already being observed.
|
|
|
- if (observations.has(target)) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- observations.set(target, new ResizeObservation(target));
|
|
|
-
|
|
|
- this.controller_.addObserver(this);
|
|
|
-
|
|
|
- // Force the update of observations.
|
|
|
- this.controller_.refresh();
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Stops observing provided element.
|
|
|
- *
|
|
|
- * @param {Element} target - Element to stop observing.
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.unobserve = function (target) {
|
|
|
- if (!arguments.length) {
|
|
|
- throw new TypeError('1 argument required, but only 0 present.');
|
|
|
- }
|
|
|
-
|
|
|
- // Do nothing if current environment doesn't have the Element interface.
|
|
|
- if (typeof Element === 'undefined' || !(Element instanceof Object)) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (!(target instanceof getWindowOf(target).Element)) {
|
|
|
- throw new TypeError('parameter 1 is not of type "Element".');
|
|
|
- }
|
|
|
-
|
|
|
- var observations = this.observations_;
|
|
|
-
|
|
|
- // Do nothing if element is not being observed.
|
|
|
- if (!observations.has(target)) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- observations.delete(target);
|
|
|
-
|
|
|
- if (!observations.size) {
|
|
|
- this.controller_.removeObserver(this);
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Stops observing all elements.
|
|
|
- *
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.disconnect = function () {
|
|
|
- this.clearActive();
|
|
|
- this.observations_.clear();
|
|
|
- this.controller_.removeObserver(this);
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Collects observation instances the associated element of which has changed
|
|
|
- * it's content rectangle.
|
|
|
- *
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.gatherActive = function () {
|
|
|
- var this$1 = this;
|
|
|
-
|
|
|
- this.clearActive();
|
|
|
-
|
|
|
- this.observations_.forEach(function (observation) {
|
|
|
- if (observation.isActive()) {
|
|
|
- this$1.activeObservations_.push(observation);
|
|
|
+ var index = (function () {
|
|
|
+ // Export existing implementation if available.
|
|
|
+ if (typeof global$1.ResizeObserver !== 'undefined') {
|
|
|
+ return global$1.ResizeObserver;
|
|
|
}
|
|
|
- });
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Invokes initial callback function with a list of ResizeObserverEntry
|
|
|
- * instances collected from active resize observations.
|
|
|
- *
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.broadcastActive = function () {
|
|
|
- // Do nothing if observer doesn't have active observations.
|
|
|
- if (!this.hasActive()) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- var ctx = this.callbackCtx_;
|
|
|
-
|
|
|
- // Create ResizeObserverEntry instance for every active observation.
|
|
|
- var entries = this.activeObservations_.map(function (observation) {
|
|
|
- return new ResizeObserverEntry(observation.target, observation.broadcastRect());
|
|
|
- });
|
|
|
-
|
|
|
- this.callback_.call(ctx, entries, ctx);
|
|
|
- this.clearActive();
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Clears the collection of active observations.
|
|
|
- *
|
|
|
- * @returns {void}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.clearActive = function () {
|
|
|
- this.activeObservations_.splice(0);
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Tells whether observer has active observations.
|
|
|
- *
|
|
|
- * @returns {boolean}
|
|
|
- */
|
|
|
-ResizeObserverSPI.prototype.hasActive = function () {
|
|
|
- return this.activeObservations_.length > 0;
|
|
|
-};
|
|
|
-
|
|
|
-// Registry of internal observers. If WeakMap is not available use current shim
|
|
|
-// for the Map collection as it has all required methods and because WeakMap
|
|
|
-// can't be fully polyfilled anyway.
|
|
|
-var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
|
|
|
-
|
|
|
-/**
|
|
|
- * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
|
|
|
- * exposing only those methods and properties that are defined in the spec.
|
|
|
- */
|
|
|
-var ResizeObserver = function(callback) {
|
|
|
- if (!(this instanceof ResizeObserver)) {
|
|
|
- throw new TypeError('Cannot call a class as a function.');
|
|
|
- }
|
|
|
- if (!arguments.length) {
|
|
|
- throw new TypeError('1 argument required, but only 0 present.');
|
|
|
- }
|
|
|
-
|
|
|
- var controller = ResizeObserverController.getInstance();
|
|
|
- var observer = new ResizeObserverSPI(callback, controller, this);
|
|
|
-
|
|
|
- observers.set(this, observer);
|
|
|
-};
|
|
|
-
|
|
|
-// Expose public methods of ResizeObserver.
|
|
|
-['observe', 'unobserve', 'disconnect'].forEach(function (method) {
|
|
|
- ResizeObserver.prototype[method] = function () {
|
|
|
- return (ref = observers.get(this))[method].apply(ref, arguments);
|
|
|
- var ref;
|
|
|
- };
|
|
|
-});
|
|
|
-
|
|
|
-var index = (function () {
|
|
|
- // Export existing implementation if available.
|
|
|
- if (typeof global$1.ResizeObserver !== 'undefined') {
|
|
|
- return global$1.ResizeObserver;
|
|
|
- }
|
|
|
-
|
|
|
- return ResizeObserver;
|
|
|
-})();
|
|
|
+ return ResizeObserver;
|
|
|
+ })();
|
|
|
|
|
|
-return index;
|
|
|
+ return index;
|
|
|
|
|
|
})));
|
