@juggle/resize-observer - npm Package Compare versions

Comparing version 2.0.3 to 2.2.0-pre.0

lib/algorithms/broadcastActiveObservations.js

@@ -5,5 +5,5 @@ import { resizeObservers } from '../ResizeObserverController';
 import { calculateBoxSize } from './calculateBoxSize';
-const broadcastActiveObservations = () => {
-    let shallowestDepth = Infinity;
-    const callbacks = [];
+var broadcastActiveObservations = function () {
+    var shallowestDepth = Infinity;
+    var callbacks = [];
     resizeObservers.forEach(function processObserver(ro) {
@@ -13,6 +13,6 @@ if (ro.activeTargets.length === 0) {
         }
-        const entries = [];
+        var entries = [];
         ro.activeTargets.forEach(function processTarget(ot) {
-            const entry = new ResizeObserverEntry(ot.target);
-            const targetDepth = calculateDepthForNode(ot.target);
+            var entry = new ResizeObserverEntry(ot.target);
+            var targetDepth = calculateDepthForNode(ot.target);
             entries.push(entry);
@@ -24,6 +24,9 @@ ot.lastReportedSize = calculateBoxSize(ot.target, ot.observedBox);
         });
-        callbacks.push(function resizeObserverCallback() { ro.callback(entries, ro.observer); });
+        callbacks.push(function resizeObserverCallback() {
+            ro.callback.call(ro.observer, entries, ro.observer);
+        });
         ro.activeTargets.splice(0, ro.activeTargets.length);
     });
-    for (let callback of callbacks) {
+    for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
+        var callback = callbacks_1[_i];
         callback();
@@ -30,0 +33,0 @@ }

lib/algorithms/calculateBoxSize.js

 import { ResizeObserverBoxOptions } from '../ResizeObserverBoxOptions';
 import { DOMRectReadOnly } from '../DOMRectReadOnly';
 import { isSVG, isHidden } from '../utils/element';
-const cache = new Map();
-const scrollRegexp = /auto|scroll/;
-const IE = (/msie|trident/i).test(navigator.userAgent);
-const parseDimension = (pixel) => parseFloat(pixel || '0');
-const size = (inlineSize = 0, blockSize = 0) => {
-    return Object.freeze({ inlineSize, blockSize });
+var cache = new Map();
+var scrollRegexp = /auto|scroll/;
+var verticalRegexp = /^tb|vertical/;
+var IE = (/msie|trident/i).test(navigator.userAgent);
+var parseDimension = function (pixel) { return parseFloat(pixel || '0'); };
+var size = function (inlineSize, blockSize, switchSizes) {
+    if (inlineSize === void 0) { inlineSize = 0; }
+    if (blockSize === void 0) { blockSize = 0; }
+    if (switchSizes === void 0) { switchSizes = false; }
+    return Object.freeze({
+        inlineSize: (switchSizes ? blockSize : inlineSize) || 0,
+        blockSize: (switchSizes ? inlineSize : blockSize) || 0
+    });
 };
-const zeroBoxes = Object.freeze({
+var zeroBoxes = Object.freeze({
     borderBoxSize: size(),
@@ -16,3 +23,3 @@ contentBoxSize: size(),
 });
-const calculateBoxSizes = (target) => {
+var calculateBoxSizes = function (target) {
     if (cache.has(target)) {
@@ -25,30 +32,31 @@ return cache.get(target);
     }
-    const cs = getComputedStyle(target);
-    const svg = isSVG(target) && target.getBBox();
-    const removePadding = !IE && cs.boxSizing === 'border-box';
-    const canScrollVertically = !svg && scrollRegexp.test(cs.overflowY || '');
-    const canScrollHorizontally = !svg && scrollRegexp.test(cs.overflowX || '');
-    const paddingTop = svg ? 0 : parseDimension(cs.paddingTop);
-    const paddingRight = svg ? 0 : parseDimension(cs.paddingRight);
-    const paddingBottom = svg ? 0 : parseDimension(cs.paddingBottom);
-    const paddingLeft = svg ? 0 : parseDimension(cs.paddingLeft);
-    const borderTop = svg ? 0 : parseDimension(cs.borderTopWidth);
-    const borderRight = svg ? 0 : parseDimension(cs.borderRightWidth);
-    const borderBottom = svg ? 0 : parseDimension(cs.borderBottomWidth);
-    const borderLeft = svg ? 0 : parseDimension(cs.borderLeftWidth);
-    const horizontalPadding = paddingLeft + paddingRight;
-    const verticalPadding = paddingTop + paddingBottom;
-    const horizontalBorderArea = borderLeft + borderRight;
-    const verticalBorderArea = borderTop + borderBottom;
-    const horizontalScrollbarThickness = !canScrollHorizontally ? 0 : target.offsetHeight - verticalBorderArea - target.clientHeight;
-    const verticalScrollbarThickness = !canScrollVertically ? 0 : target.offsetWidth - horizontalBorderArea - target.clientWidth;
-    const widthReduction = removePadding ? horizontalPadding + horizontalBorderArea : 0;
-    const heightReduction = removePadding ? verticalPadding + verticalBorderArea : 0;
-    const contentWidth = svg ? svg.width : parseDimension(cs.width) - widthReduction - verticalScrollbarThickness;
-    const contentHeight = svg ? svg.height : parseDimension(cs.height) - heightReduction - horizontalScrollbarThickness;
-    const borderBoxWidth = contentWidth + horizontalPadding + verticalScrollbarThickness + horizontalBorderArea;
-    const borderBoxHeight = contentHeight + verticalPadding + horizontalScrollbarThickness + verticalBorderArea;
-    const boxes = Object.freeze({
-        borderBoxSize: size(borderBoxWidth, borderBoxHeight),
-        contentBoxSize: size(contentWidth, contentHeight),
+    var cs = getComputedStyle(target);
+    var svg = isSVG(target) && target.getBBox();
+    var removePadding = !IE && cs.boxSizing === 'border-box';
+    var switchSizes = verticalRegexp.test(cs.writingMode || '');
+    var canScrollVertically = !svg && scrollRegexp.test(cs.overflowY || '');
+    var canScrollHorizontally = !svg && scrollRegexp.test(cs.overflowX || '');
+    var paddingTop = svg ? 0 : parseDimension(cs.paddingTop);
+    var paddingRight = svg ? 0 : parseDimension(cs.paddingRight);
+    var paddingBottom = svg ? 0 : parseDimension(cs.paddingBottom);
+    var paddingLeft = svg ? 0 : parseDimension(cs.paddingLeft);
+    var borderTop = svg ? 0 : parseDimension(cs.borderTopWidth);
+    var borderRight = svg ? 0 : parseDimension(cs.borderRightWidth);
+    var borderBottom = svg ? 0 : parseDimension(cs.borderBottomWidth);
+    var borderLeft = svg ? 0 : parseDimension(cs.borderLeftWidth);
+    var horizontalPadding = paddingLeft + paddingRight;
+    var verticalPadding = paddingTop + paddingBottom;
+    var horizontalBorderArea = borderLeft + borderRight;
+    var verticalBorderArea = borderTop + borderBottom;
+    var horizontalScrollbarThickness = !canScrollHorizontally ? 0 : target.offsetHeight - verticalBorderArea - target.clientHeight;
+    var verticalScrollbarThickness = !canScrollVertically ? 0 : target.offsetWidth - horizontalBorderArea - target.clientWidth;
+    var widthReduction = removePadding ? horizontalPadding + horizontalBorderArea : 0;
+    var heightReduction = removePadding ? verticalPadding + verticalBorderArea : 0;
+    var contentWidth = svg ? svg.width : parseDimension(cs.width) - widthReduction - verticalScrollbarThickness;
+    var contentHeight = svg ? svg.height : parseDimension(cs.height) - heightReduction - horizontalScrollbarThickness;
+    var borderBoxWidth = contentWidth + horizontalPadding + verticalScrollbarThickness + horizontalBorderArea;
+    var borderBoxHeight = contentHeight + verticalPadding + horizontalScrollbarThickness + verticalBorderArea;
+    var boxes = Object.freeze({
+        borderBoxSize: size(borderBoxWidth, borderBoxHeight, switchSizes),
+        contentBoxSize: size(contentWidth, contentHeight, switchSizes),
         contentRect: new DOMRectReadOnly(paddingLeft, paddingTop, contentWidth, contentHeight)
@@ -59,6 +67,6 @@ });
 };
-const calculateBoxSize = (target, observedBox) => {
-    const { borderBoxSize, contentBoxSize } = calculateBoxSizes(target);
+var calculateBoxSize = function (target, observedBox) {
+    var _a = calculateBoxSizes(target), borderBoxSize = _a.borderBoxSize, contentBoxSize = _a.contentBoxSize;
     return observedBox === ResizeObserverBoxOptions.BORDER_BOX ? borderBoxSize : contentBoxSize;
 };
 export { calculateBoxSize, calculateBoxSizes, cache };

lib/algorithms/calculateDepthForNode.js

 import { isHidden } from '../utils/element';
-const calculateDepthForNode = (node) => {
+var calculateDepthForNode = function (node) {
     if (isHidden(node)) {
         return Infinity;
     }
-    let depth = 0;
-    let parent = node.parentNode;
+    var depth = 0;
+    var parent = node.parentNode;
     while (parent) {
@@ -9,0 +9,0 @@ depth += 1;

lib/algorithms/deliverResizeLoopError.js

@@ -1,4 +0,4 @@
-const msg = 'ResizeObserver loop completed with undelivered notifications.';
-const deliverResizeLoopError = () => {
-    let event;
+var msg = 'ResizeObserver loop completed with undelivered notifications.';
+var deliverResizeLoopError = function () {
+    var event;
     if (typeof ErrorEvent === 'function') {
@@ -5,0 +5,0 @@ event = new ErrorEvent('error', {

lib/algorithms/gatherActiveObservationsAtDepth.js

 import { resizeObservers } from '../ResizeObserverController';
 import { calculateDepthForNode } from './calculateDepthForNode';
 import { cache as sizeCache } from './calculateBoxSize';
-const gatherActiveObservationsAtDepth = (depth) => {
+var gatherActiveObservationsAtDepth = function (depth) {
     sizeCache.clear();
@@ -6,0 +6,0 @@ resizeObservers.forEach(function processObserver(ro) {

lib/algorithms/hasActiveObservations.js

 import { resizeObservers } from '../ResizeObserverController';
-const hasActiveObservations = () => {
-    return resizeObservers.some((ro) => ro.activeTargets.length > 0);
+var hasActiveObservations = function () {
+    return resizeObservers.some(function (ro) { return ro.activeTargets.length > 0; });
 };
 export { hasActiveObservations };

lib/algorithms/hasSkippedObservations.js

 import { resizeObservers } from '../ResizeObserverController';
-const hasSkippedObservations = () => {
-    return resizeObservers.some((ro) => ro.skippedTargets.length > 0);
+var hasSkippedObservations = function () {
+    return resizeObservers.some(function (ro) { return ro.skippedTargets.length > 0; });
 };
 export { hasSkippedObservations };

lib/DOMRectReadOnly.js

@@ -1,3 +0,3 @@
-class DOMRectReadOnly {
-    constructor(x, y, width, height) {
+var DOMRectReadOnly = (function () {
+    function DOMRectReadOnly(x, y, width, height) {
         this.x = x;
@@ -13,6 +13,7 @@ this.y = y;
     }
-    static fromRect(rectangle) {
+    DOMRectReadOnly.fromRect = function (rectangle) {
         return new DOMRectReadOnly(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
-    }
-}
+    };
+    return DOMRectReadOnly;
+}());
 export { DOMRectReadOnly };

lib/ResizeObservation.js

 import { ResizeObserverBoxOptions } from './ResizeObserverBoxOptions';
 import { calculateBoxSize } from './algorithms/calculateBoxSize';
-class ResizeObservation {
-    constructor(target, observedBox) {
+import { isSVG, isReplacedElement } from './utils/element';
+var skipNotifyOnElement = function (target) {
+    return !isSVG(target)
+        && !isReplacedElement(target)
+        && getComputedStyle(target).display === 'inline';
+};
+var ResizeObservation = (function () {
+    function ResizeObservation(target, observedBox) {
         this.target = target;
@@ -12,11 +18,15 @@ this.observedBox = observedBox || ResizeObserverBoxOptions.CONTENT_BOX;
     }
-    isActive() {
-        const last = this.lastReportedSize;
-        const size = calculateBoxSize(this.target, this.observedBox);
-        if (last.inlineSize !== size.inlineSize || last.blockSize !== size.blockSize) {
+    ResizeObservation.prototype.isActive = function () {
+        var size = calculateBoxSize(this.target, this.observedBox);
+        if (skipNotifyOnElement(this.target)) {
+            this.lastReportedSize = size;
+        }
+        if (this.lastReportedSize.inlineSize !== size.inlineSize
+            || this.lastReportedSize.blockSize !== size.blockSize) {
             return true;
         }
         return false;
-    }
-}
+    };
+    return ResizeObservation;
+}());
 export { ResizeObservation };

lib/ResizeObserver.js

 import { ResizeObserverController } from './ResizeObserverController';
 import { POLYFILL_CONSOLE_OUTPUT } from './utils/prettify';
-class ResizeObserver {
-    constructor(callback) {
+var ResizeObserver = (function () {
+    function ResizeObserver(callback) {
         if (arguments.length === 0) {
-            throw new TypeError(`Failed to construct 'ResizeObserver': 1 argument required, but only 0 present.`);
+            throw new TypeError("Failed to construct 'ResizeObserver': 1 argument required, but only 0 present.");
         }
         if (typeof callback !== 'function') {
-            throw new TypeError(`Failed to construct 'ResizeObserver': The callback provided as parameter 1 is not a function.`);
+            throw new TypeError("Failed to construct 'ResizeObserver': The callback provided as parameter 1 is not a function.");
         }
         ResizeObserverController.connect(this, callback);
     }
-    observe(target, options) {
+    ResizeObserver.prototype.observe = function (target, options) {
         if (arguments.length === 0) {
-            throw new TypeError(`Failed to execute 'observe' on 'ResizeObserver': 1 argument required, but only 0 present.`);
+            throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': 1 argument required, but only 0 present.");
         }
         if (target instanceof Element === false) {
-            throw new TypeError(`Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'Element`);
+            throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'Element");
         }
         ResizeObserverController.observe(this, target, options);
-    }
-    unobserve(target) {
+    };
+    ResizeObserver.prototype.unobserve = function (target) {
         if (arguments.length === 0) {
-            throw new TypeError(`Failed to execute 'unobserve' on 'ResizeObserver': 1 argument required, but only 0 present.`);
+            throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': 1 argument required, but only 0 present.");
         }
         if (target instanceof Element === false) {
-            throw new TypeError(`Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'Element`);
+            throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'Element");
         }
         ResizeObserverController.unobserve(this, target);
-    }
-    disconnect() {
+    };
+    ResizeObserver.prototype.disconnect = function () {
         ResizeObserverController.disconnect(this);
-    }
-    static toString() {
+    };
+    ResizeObserver.toString = function () {
         return POLYFILL_CONSOLE_OUTPUT;
-    }
-}
+    };
+    return ResizeObserver;
+}());
 export default ResizeObserver;
 export { ResizeObserver };

lib/ResizeObserverController.js

@@ -9,6 +9,6 @@ import { scheduler } from './utils/scheduler';
 import { gatherActiveObservationsAtDepth } from './algorithms/gatherActiveObservationsAtDepth';
-const resizeObservers = [];
-const observerMap = new Map();
-let watching = 0;
-const updateCount = (n) => {
+var resizeObservers = [];
+var observerMap = new Map();
+var watching = 0;
+var updateCount = function (n) {
     !watching && n > 0 && scheduler.start();
@@ -18,4 +18,4 @@ watching += n;
 };
-const getObservationIndex = (observationTargets, target) => {
-    for (let i = 0; i < observationTargets.length; i += 1) {
+var getObservationIndex = function (observationTargets, target) {
+    for (var i = 0; i < observationTargets.length; i += 1) {
         if (observationTargets[i].target === target) {
@@ -27,4 +27,4 @@ return i;
 };
-const process = () => {
-    let depth = 0;
+var process = function () {
+    var depth = 0;
     gatherActiveObservationsAtDepth(depth);
@@ -40,11 +40,13 @@ while (hasActiveObservations()) {
 };
-class ResizeObserverController {
-    static connect(resizeObserver, callback) {
-        const detail = new ResizeObserverDetail(resizeObserver, callback);
+var ResizeObserverController = (function () {
+    function ResizeObserverController() {
+    }
+    ResizeObserverController.connect = function (resizeObserver, callback) {
+        var detail = new ResizeObserverDetail(resizeObserver, callback);
         resizeObservers.push(detail);
         observerMap.set(resizeObserver, detail);
-    }
-    static observe(resizeObserver, target, options) {
+    };
+    ResizeObserverController.observe = function (resizeObserver, target, options) {
         if (observerMap.has(resizeObserver)) {
-            const detail = observerMap.get(resizeObserver);
+            var detail = observerMap.get(resizeObserver);
             if (getObservationIndex(detail.observationTargets, target) < 0) {
@@ -56,7 +58,7 @@ detail.observationTargets.push(new ResizeObservation(target, options && options.box));
         }
-    }
-    static unobserve(resizeObserver, target) {
+    };
+    ResizeObserverController.unobserve = function (resizeObserver, target) {
         if (observerMap.has(resizeObserver)) {
-            const detail = observerMap.get(resizeObserver);
-            const index = getObservationIndex(detail.observationTargets, target);
+            var detail = observerMap.get(resizeObserver);
+            var index = getObservationIndex(detail.observationTargets, target);
             if (index >= 0) {
@@ -67,6 +69,6 @@ detail.observationTargets.splice(index, 1);
         }
-    }
-    static disconnect(resizeObserver) {
+    };
+    ResizeObserverController.disconnect = function (resizeObserver) {
         if (observerMap.has(resizeObserver)) {
-            const detail = observerMap.get(resizeObserver);
+            var detail = observerMap.get(resizeObserver);
             resizeObservers.splice(resizeObservers.indexOf(detail), 1);
@@ -76,4 +78,5 @@ observerMap.delete(resizeObserver);
         }
-    }
-}
+    };
+    return ResizeObserverController;
+}());
 export { ResizeObserverController, resizeObservers, process };

lib/ResizeObserverDetail.js

@@ -1,3 +0,3 @@
-class ResizeObserverDetail {
-    constructor(resizeObserver, callback) {
+var ResizeObserverDetail = (function () {
+    function ResizeObserverDetail(resizeObserver, callback) {
         this.activeTargets = [];
@@ -9,3 +9,4 @@ this.skippedTargets = [];
     }
-}
+    return ResizeObserverDetail;
+}());
 export { ResizeObserverDetail };

lib/ResizeObserverEntry.js

 import { calculateBoxSizes } from './algorithms/calculateBoxSize';
-class ResizeObserverEntry {
-    constructor(target) {
-        const boxes = calculateBoxSizes(target);
+var ResizeObserverEntry = (function () {
+    function ResizeObserverEntry(target) {
+        var boxes = calculateBoxSizes(target);
         this.target = target;
@@ -10,3 +10,4 @@ this.contentRect = boxes.contentRect;
     }
-}
+    return ResizeObserverEntry;
+}());
 export { ResizeObserverEntry };

lib/utils/element.d.ts

 declare const isSVG: (target: Element) => boolean;
 declare const isHidden: (target: Element) => boolean;
-export { isSVG, isHidden };
+declare const isReplacedElement: (target: Element) => boolean;
+export { isSVG, isHidden, isReplacedElement };

lib/utils/element.js

@@ -1,10 +0,27 @@
-const isSVG = (target) => target instanceof SVGElement && 'getBBox' in target;
-const isHidden = (target) => {
+var isSVG = function (target) { return target instanceof SVGElement && 'getBBox' in target; };
+var isHidden = function (target) {
     if (isSVG(target)) {
-        const { width, height } = target.getBBox();
+        var _a = target.getBBox(), width = _a.width, height = _a.height;
         return !width && !height;
     }
-    const { offsetWidth, offsetHeight } = target;
+    var _b = target, offsetWidth = _b.offsetWidth, offsetHeight = _b.offsetHeight;
     return !(offsetWidth || offsetHeight || target.getClientRects().length);
 };
-export { isSVG, isHidden };
+var isReplacedElement = function (target) {
+    switch (target.tagName) {
+        case 'INPUT':
+            if (target.type !== 'image') {
+                break;
+            }
+        case 'VIDEO':
+        case 'AUDIO':
+        case 'EMBED':
+        case 'OBJECT':
+        case 'CANVAS':
+        case 'IFRAME':
+        case 'IMG':
+            return true;
+    }
+    return false;
+};
+export { isSVG, isHidden, isReplacedElement };

lib/utils/prettify.js

@@ -1,5 +0,5 @@
-const POLYFILL_CONSOLE_OUTPUT = 'function ResizeObserver () { [polyfill code] }';
-const prettifyConsoleOutput = (fn) => {
+var POLYFILL_CONSOLE_OUTPUT = 'function ResizeObserver () { [polyfill code] }';
+var prettifyConsoleOutput = function (fn) {
     Object.defineProperty(fn, 'toString', {
-        value: () => POLYFILL_CONSOLE_OUTPUT
+        value: function () { return POLYFILL_CONSOLE_OUTPUT; }
     });
@@ -6,0 +6,0 @@ return fn;

lib/utils/scheduler.js

 import { process } from '../ResizeObserverController';
 import { prettifyConsoleOutput } from './prettify';
-const CATCH_FRAMES = 60 / 5;
-const requestAnimationFrame = window.requestAnimationFrame;
-const observerConfig = { attributes: true, characterData: true, childList: true, subtree: true };
-const events = [
+var CATCH_FRAMES = 60 / 5;
+var requestAnimationFrame = window.requestAnimationFrame;
+var observerConfig = { attributes: true, characterData: true, childList: true, subtree: true };
+var events = [
     'resize',
@@ -22,6 +22,6 @@ 'load',
 ];
-const rafSlot = new Map();
-const resizeObserverSlot = new Map();
-let scheduled;
-const dispatchCallbacksOnNextFrame = () => {
+var rafSlot = new Map();
+var resizeObserverSlot = new Map();
+var scheduled;
+var dispatchCallbacksOnNextFrame = function () {
     if (scheduled) {
@@ -33,10 +33,11 @@ return;
         scheduled = false;
-        const frameCallbacks = [];
-        const resizeObserverCallbacks = [];
-        rafSlot.forEach((callback) => frameCallbacks.push(callback));
-        resizeObserverSlot.forEach((callback) => resizeObserverCallbacks.push(callback));
+        var frameCallbacks = [];
+        var resizeObserverCallbacks = [];
+        rafSlot.forEach(function (callback) { return frameCallbacks.push(callback); });
+        resizeObserverSlot.forEach(function (callback) { return resizeObserverCallbacks.push(callback); });
         rafSlot.clear();
         resizeObserverSlot.clear();
         try {
-            for (let callback of frameCallbacks) {
+            for (var _i = 0, frameCallbacks_1 = frameCallbacks; _i < frameCallbacks_1.length; _i++) {
+                var callback = frameCallbacks_1[_i];
                 callback(t);
@@ -46,3 +47,4 @@ }
         finally {
-            for (let callback of resizeObserverCallbacks) {
+            for (var _a = 0, resizeObserverCallbacks_1 = resizeObserverCallbacks; _a < resizeObserverCallbacks_1.length; _a++) {
+                var callback = resizeObserverCallbacks_1[_a];
                 callback(t);
@@ -55,11 +57,12 @@ }
 };
-class Scheduler {
-    constructor() {
+var Scheduler = (function () {
+    function Scheduler() {
+        var _this = this;
         this.stopped = true;
-        this.listener = () => this.schedule();
+        this.listener = function () { return _this.schedule(); };
     }
-    run(frames) {
-        const scheduler = this;
+    Scheduler.prototype.run = function (frames) {
+        var scheduler = this;
         resizeObserverSlot.set(this, function ResizeObserver() {
-            let elementsHaveResized = false;
+            var elementsHaveResized = false;
             try {
@@ -81,12 +84,14 @@ elementsHaveResized = process();
         dispatchCallbacksOnNextFrame();
-    }
-    schedule() {
+    };
+    Scheduler.prototype.schedule = function () {
         this.stop();
         this.run(CATCH_FRAMES);
-    }
-    observe() {
-        const cb = () => this.observer && this.observer.observe(document.body, observerConfig);
+    };
+    Scheduler.prototype.observe = function () {
+        var _this = this;
+        var cb = function () { return _this.observer && _this.observer.observe(document.body, observerConfig); };
         document.body ? cb() : window.addEventListener('DOMContentLoaded', cb);
-    }
-    start() {
+    };
+    Scheduler.prototype.start = function () {
+        var _this = this;
         if (this.stopped) {
@@ -98,15 +103,17 @@ this.stopped = false;
             }
-            events.forEach((name) => window.addEventListener(name, this.listener, true));
+            events.forEach(function (name) { return window.addEventListener(name, _this.listener, true); });
         }
-    }
-    stop() {
+    };
+    Scheduler.prototype.stop = function () {
+        var _this = this;
         if (!this.stopped) {
             this.observer && this.observer.disconnect();
-            events.forEach((name) => window.removeEventListener(name, this.listener, true));
+            events.forEach(function (name) { return window.removeEventListener(name, _this.listener, true); });
             this.stopped = true;
         }
-    }
-}
-const scheduler = new Scheduler();
-let rafIdBase = 0;
+    };
+    return Scheduler;
+}());
+var scheduler = new Scheduler();
+var rafIdBase = 0;
 window.requestAnimationFrame = function (callback) {
@@ -116,3 +123,3 @@ if (typeof callback !== 'function') {
     }
-    const handle = rafIdBase += 1;
+    var handle = rafIdBase += 1;
     rafSlot.set(handle, function AnimationFrame(t) { return callback(t); });
@@ -119,0 +126,0 @@ dispatchCallbacksOnNextFrame();

package.json

 {
   "name": "@juggle/resize-observer",
-  "version": "2.0.3",
+  "version": "2.2.0-pre.0",
   "description": "Polyfills the ResizeObserver API and supports box size options from the latest spec",
   "main": "./lib/ResizeObserver.js",
   "module": "./lib/ResizeObserver.js",
+  "source": "./lib/ResizeObserver.js",
   "files": [
@@ -50,17 +51,17 @@ "lib/**/*.{js,ts}"
   "devDependencies": {
-    "@types/jest": "^23.3.12",
-    "@typescript-eslint/eslint-plugin": "^1.1.1",
-    "@typescript-eslint/parser": "^1.1.1",
-    "core-js": "^3.1.3",
-    "coveralls": "^3.0.2",
+    "@types/jest": "^24.0.15",
+    "@typescript-eslint/eslint-plugin": "^1.11.0",
+    "@typescript-eslint/parser": "^1.11.0",
+    "core-js": "^3.1.4",
+    "coveralls": "^3.0.4",
     "cssnano": "^4.1.10",
-    "eslint": "^5.12.1",
-    "jest": "^23.6.0",
-    "jest-cli": "^23.6.0",
-    "jest-junit": "^6.0.1",
-    "jsdom": "^13.1.0",
+    "eslint": "^6.0.1",
+    "jest": "^24.8.0",
+    "jest-cli": "^24.8.0",
+    "jest-junit": "^6.4.0",
+    "jsdom": "^15.1.1",
     "parcel-bundler": "^1.12.3",
-    "ts-jest": "^23.10.5",
-    "typescript": "^3.2.2"
+    "ts-jest": "^24.0.2",
+    "typescript": "^3.5.2"
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

47782

increased by6.46%

Lines of code

656

increased by8.79%

Worsened metrics

Number of low quality alerts

1

increased byInfinity%

No dependency changes