@gsc-basic/utils 1.0.0 → 1.0.1

package/node_modules/resize-observer-polyfill/dist/ResizeObserver.js.flow

@@ -0,0 +1,32 @@
+// @flow
+
+class DOMRectReadOnly {
+    +x: number;
+    +y: number;
+    +width: number;
+    +height: number;
+    +top: number;
+    +right: number;
+    +bottom: number;
+    +left: number;
+}
+
+class ResizeObserverEntry {
+    +target: Element;
+    +contentRect: DOMRectReadOnly;
+}
+
+type Entries = $ReadOnlyArray<ResizeObserverEntry>;
+
+type ResizeObserverCallback = {
+    (entries: Entries, observer: ResizeObserver): void
+};
+
+declare class ResizeObserver {
+    constructor(ResizeObserverCallback): ResizeObserver;
+    observe(target: Element): void;
+    unobserve(target: Element): void;
+    disconnect(): void;
+};
+
+declare export default typeof ResizeObserver;

package/node_modules/resize-observer-polyfill/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "resize-observer-polyfill",
+    "author": "Denis Rul <que.etc@gmail.com>",
+    "version": "1.5.1",
+    "description": "A polyfill for the Resize Observer API",
+    "main": "dist/ResizeObserver.js",
+    "module": "dist/ResizeObserver.es.js",
+    "scripts": {
+        "build": "rollup -c && cpy src/index.js.flow dist --rename=ResizeObserver.js.flow",
+        "test": "npm run test:lint && npm run test:spec",
+        "test:ci": "npm run test:lint && npm run test:spec:sauce && npm run test:spec:node",
+        "test:ci:pull": "npm run test:lint && karma start --browsers Firefox && npm run test:spec:node",
+        "test:lint": "node ./node_modules/eslint/bin/eslint.js \"**/*.js\" --ignore-pattern \"/dist/\"",
+        "test:spec": "karma start --browsers Chrome && npm run test:spec:node",
+        "test:spec:sauce": "karma start --sauce=windows && karma start --sauce=linux && karma start --sauce=osx",
+        "test:spec:node": "npm run build && node tests/node/index.js",
+        "test:spec:custom": "karma start --no-browsers",
+        "test:spec:native": "karma start --no-browsers --native"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/que-etc/resize-observer-polyfill.git"
+    },
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/que-etc/resize-observer-polyfill/issues"
+    },
+    "types": "src/index.d.ts",
+    "files": [
+        "src/",
+        "dist/"
+    ],
+    "keywords": [
+        "ResizeObserver",
+        "resize",
+        "observer",
+        "util",
+        "client",
+        "browser",
+        "polyfill",
+        "ponyfill"
+    ],
+    "homepage": "https://github.com/que-etc/resize-observer-polyfill",
+    "devDependencies": {
+        "babel-eslint": "10.0.1",
+        "cpy-cli": "2.0.0",
+        "eslint": "5.10.0",
+        "jasmine": "2.8.0",
+        "jasmine-core": "2.8.0",
+        "karma": "3.1.3",
+        "karma-chrome-launcher": "2.2.0",
+        "karma-firefox-launcher": "1.1.0",
+        "karma-jasmine": "1.1.2",
+        "karma-jasmine-html-reporter": "0.2.2",
+        "karma-rollup-preprocessor": "6.1.1",
+        "karma-sauce-launcher": "1.2.0",
+        "karma-sourcemap-loader": "0.3.7",
+        "karma-spec-reporter": "0.0.32",
+        "promise-polyfill": "8.1.0",
+        "rollup": "0.67.4",
+        "rollup-plugin-typescript": "1.0.0",
+        "typescript": "3.2.2"
+    }
+}

package/node_modules/resize-observer-polyfill/src/ResizeObservation.js

@@ -0,0 +1,76 @@
+import {createRectInit, getContentRect} from './utils/geometry.js';
+
+/**
+ * Class that is responsible for computations of the content rectangle of
+ * provided DOM element and for keeping track of it's changes.
+ */
+export default class ResizeObservation {
+    /**
+     * Reference to the observed element.
+     *
+     * @type {Element}
+     */
+    target;
+
+    /**
+     * Broadcasted width of content rectangle.
+     *
+     * @type {number}
+     */
+    broadcastWidth = 0;
+
+    /**
+     * Broadcasted height of content rectangle.
+     *
+     * @type {number}
+     */
+    broadcastHeight = 0;
+
+    /**
+     * Reference to the last observed content rectangle.
+     *
+     * @private {DOMRectInit}
+     */
+    contentRect_ = createRectInit(0, 0, 0, 0);
+
+    /**
+     * Creates an instance of ResizeObservation.
+     *
+     * @param {Element} target - Element to be observed.
+     */
+    constructor(target) {
+        this.target = target;
+    }
+
+    /**
+     * Updates content rectangle and tells whether it's width or height properties
+     * have changed since the last broadcast.
+     *
+     * @returns {boolean}
+     */
+    isActive() {
+        const 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.
+     */
+    broadcastRect() {
+        const rect = this.contentRect_;
+
+        this.broadcastWidth = rect.width;
+        this.broadcastHeight = rect.height;
+
+        return rect;
+    }
+}

package/node_modules/resize-observer-polyfill/src/ResizeObserver.js

@@ -0,0 +1,47 @@
+import {Map} from './shims/es6-collections.js';
+import ResizeObserverController from './ResizeObserverController.js';
+import ResizeObserverSPI from './ResizeObserverSPI.js';
+
+// 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.
+const observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new Map();
+
+/**
+ * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
+ * exposing only those methods and properties that are defined in the spec.
+ */
+class ResizeObserver {
+    /**
+     * Creates a new instance of ResizeObserver.
+     *
+     * @param {ResizeObserverCallback} callback - Callback that is invoked when
+     *      dimensions of the observed elements change.
+     */
+    constructor(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.');
+        }
+
+        const controller = ResizeObserverController.getInstance();
+        const observer = new ResizeObserverSPI(callback, controller, this);
+
+        observers.set(this, observer);
+    }
+}
+
+// Expose public methods of ResizeObserver.
+[
+    'observe',
+    'unobserve',
+    'disconnect'
+].forEach(method => {
+    ResizeObserver.prototype[method] = function () {
+        return observers.get(this)[method](...arguments);
+    };
+});
+
+export default ResizeObserver;

package/node_modules/resize-observer-polyfill/src/ResizeObserverController.js

@@ -0,0 +1,238 @@
+import isBrowser from './utils/isBrowser.js';
+import throttle from './utils/throttle.js';
+
+// Minimum delay before invoking the update of observers.
+const REFRESH_DELAY = 20;
+
+// A list of substrings of CSS properties used to find transition events that
+// might affect dimensions of observed elements.
+const transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
+
+// Check if MutationObserver is available.
+const mutationObserverSupported = typeof MutationObserver !== 'undefined';
+
+/**
+ * Singleton controller class which handles updates of ResizeObserver instances.
+ */
+export default class ResizeObserverController {
+    /**
+     * Indicates whether DOM listeners have been added.
+     *
+     * @private {boolean}
+     */
+    connected_ = false;
+
+    /**
+     * Tells that controller has subscribed for Mutation Events.
+     *
+     * @private {boolean}
+     */
+    mutationEventsAdded_ = false;
+
+    /**
+     * Keeps reference to the instance of MutationObserver.
+     *
+     * @private {MutationObserver}
+     */
+    mutationsObserver_ = null;
+
+    /**
+     * A list of connected observers.
+     *
+     * @private {Array<ResizeObserverSPI>}
+     */
+    observers_ = [];
+
+    /**
+     * Holds reference to the controller's instance.
+     *
+     * @private {ResizeObserverController}
+     */
+    static instance_ = null;
+
+    /**
+     * Creates a new instance of ResizeObserverController.
+     *
+     * @private
+     */
+    constructor() {
+        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}
+     */
+    addObserver(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}
+     */
+    removeObserver(observer) {
+        const observers = this.observers_;
+        const 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}
+     */
+    refresh() {
+        const 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.
+     */
+    updateObservers_() {
+        // Collect observers that have active observations.
+        const activeObservers = this.observers_.filter(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(observer => observer.broadcastActive());
+
+        return activeObservers.length > 0;
+    }
+
+    /**
+     * Initializes DOM listeners.
+     *
+     * @private
+     * @returns {void}
+     */
+    connect_() {
+        // 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}
+     */
+    disconnect_() {
+        // 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;
+    }
+
+    /**
+     * "Transitionend" event handler.
+     *
+     * @private
+     * @param {TransitionEvent} event
+     * @returns {void}
+     */
+    onTransitionEnd_({propertyName = ''}) {
+        // Detect whether transition may affect dimensions of an element.
+        const isReflowProperty = transitionKeys.some(key => {
+            return !!~propertyName.indexOf(key);
+        });
+
+        if (isReflowProperty) {
+            this.refresh();
+        }
+    }
+
+    /**
+     * Returns instance of the ResizeObserverController.
+     *
+     * @returns {ResizeObserverController}
+     */
+    static getInstance() {
+        if (!this.instance_) {
+            this.instance_ = new ResizeObserverController();
+        }
+
+        return this.instance_;
+    }
+}

package/node_modules/resize-observer-polyfill/src/ResizeObserverEntry.js

@@ -0,0 +1,40 @@
+import {createReadOnlyRect} from './utils/geometry.js';
+import defineConfigurable from './utils/defineConfigurable.js';
+
+export default class ResizeObserverEntry {
+    /**
+     * Element size of which has changed.
+     * Spec: https://wicg.github.io/ResizeObserver/#dom-resizeobserverentry-target
+     *
+     * @readonly
+     * @type {Element}
+     */
+    target;
+
+    /**
+     * Element's content rectangle.
+     * Spec: https://wicg.github.io/ResizeObserver/#dom-resizeobserverentry-contentrect
+     *
+     * @readonly
+     * @type {DOMRectReadOnly}
+     */
+    contentRect;
+
+    /**
+     * Creates an instance of ResizeObserverEntry.
+     *
+     * @param {Element} target - Element that is being observed.
+     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.
+     */
+    constructor(target, rectInit) {
+        const 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, contentRect});
+    }
+}

package/node_modules/resize-observer-polyfill/src/ResizeObserverSPI.js

@@ -0,0 +1,203 @@
+import {Map} from './shims/es6-collections.js';
+import ResizeObservation from './ResizeObservation.js';
+import ResizeObserverEntry from './ResizeObserverEntry.js';
+import getWindowOf from './utils/getWindowOf.js';
+
+export default class ResizeObserverSPI {
+    /**
+     * Collection of resize observations that have detected changes in dimensions
+     * of elements.
+     *
+     * @private {Array<ResizeObservation>}
+     */
+    activeObservations_ = [];
+
+    /**
+     * Reference to the callback function.
+     *
+     * @private {ResizeObserverCallback}
+     */
+    callback_;
+
+    /**
+     * Public ResizeObserver instance which will be passed to the callback
+     * function and used as a value of it's "this" binding.
+     *
+     * @private {ResizeObserver}
+     */
+    callbackCtx_;
+
+    /**
+     * Reference to the associated ResizeObserverController.
+     *
+     * @private {ResizeObserverController}
+     */
+    controller_;
+
+    /**
+     * Registry of the ResizeObservation instances.
+     *
+     * @private {Map<Element, ResizeObservation>}
+     */
+    observations_ = new Map();
+
+    /**
+     * 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.
+     */
+    constructor(callback, controller, callbackCtx) {
+        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}
+     */
+    observe(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".');
+        }
+
+        const 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}
+     */
+    unobserve(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".');
+        }
+
+        const 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}
+     */
+    disconnect() {
+        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}
+     */
+    gatherActive() {
+        this.clearActive();
+
+        this.observations_.forEach(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}
+     */
+    broadcastActive() {
+        // Do nothing if observer doesn't have active observations.
+        if (!this.hasActive()) {
+            return;
+        }
+
+        const ctx = this.callbackCtx_;
+
+        // Create ResizeObserverEntry instance for every active observation.
+        const entries = this.activeObservations_.map(observation => {
+            return new ResizeObserverEntry(
+                observation.target,
+                observation.broadcastRect()
+            );
+        });
+
+        this.callback_.call(ctx, entries, ctx);
+        this.clearActive();
+    }
+
+    /**
+     * Clears the collection of active observations.
+     *
+     * @returns {void}
+     */
+    clearActive() {
+        this.activeObservations_.splice(0);
+    }
+
+    /**
+     * Tells whether observer has active observations.
+     *
+     * @returns {boolean}
+     */
+    hasActive() {
+        return this.activeObservations_.length > 0;
+    }
+}