@atlaskit/insm 1.2.12 → 2.0.0

package/dist/cjs/period-measurers/afps.js

@@ -1,193 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AnimationFPSIM = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var AnimationFPSIM = exports.AnimationFPSIM = /*#__PURE__*/function () {
-  function AnimationFPSIM() {
-    (0, _classCallCheck2.default)(this, AnimationFPSIM);
-    /**
-     * AFPS stands for Animation Frames Per Second
-     */
-    (0, _defineProperty2.default)(this, "name", 'afps');
-    (0, _defineProperty2.default)(this, "monitor", new AnimationFPSMonitor());
-  }
-  return (0, _createClass2.default)(AnimationFPSIM, [{
-    key: "start",
-    value: function start(paused) {
-      var result = this.monitor.startNewWindow(paused);
-      return result;
-    }
-  }, {
-    key: "end",
-    value: function end() {
-      var result = this.monitor.end();
-      return result;
-    }
-  }, {
-    key: "pause",
-    value: function pause() {
-      this.monitor.pause();
-    }
-  }, {
-    key: "resume",
-    value: function resume() {
-      this.monitor.resume();
-    }
-  }]);
-}();
-var AnimationFPSMonitor = /*#__PURE__*/function () {
-  function AnimationFPSMonitor() {
-    (0, _classCallCheck2.default)(this, AnimationFPSMonitor);
-    (0, _defineProperty2.default)(this, "paused", false);
-    (0, _defineProperty2.default)(this, "currentState", {
-      numerator: 0,
-      denominator: 0,
-      max: 0,
-      average: 0,
-      min: 0
-    });
-    // Current measurement window
-    (0, _defineProperty2.default)(this, "windowFrameCount", 0);
-    (0, _defineProperty2.default)(this, "windowTotalTime", 0);
-    (0, _defineProperty2.default)(this, "currentFrameStart", 0);
-  }
-  return (0, _createClass2.default)(AnimationFPSMonitor, [{
-    key: "measureWindowFPS",
-    value: function measureWindowFPS() {
-      // Calculate FPS for this window
-      // Note: windowFrameCount and windowTotalTime is reset after each window measurement
-      var windowSeconds = this.windowTotalTime / 1000;
-      // frames / seconds
-      var windowFPS = this.windowFrameCount / windowSeconds;
-
-      // Update overall tracking
-      this.currentState.numerator += this.windowFrameCount;
-      // The denominator is seconds not ms
-      this.currentState.denominator += windowSeconds;
-
-      // Calculate overall average FPS: (total frames / total time measured in seconds
-      this.currentState.average = this.currentState.numerator / this.currentState.denominator;
-      if (this.currentState.max === 0 || windowFPS > this.currentState.max) {
-        this.currentState.max = windowFPS;
-      }
-      if (this.currentState.min === 0 || windowFPS < this.currentState.min) {
-        this.currentState.min = windowFPS;
-      }
-    }
-
-    /**
-     * If there is running tracking - it will be reset
-     */
-  }, {
-    key: "startWindowTracking",
-    value: function startWindowTracking() {
-      var _this = this;
-      // Clear any previous tracking state
-      this.resetOverallTracking();
-      var _measureFrame = function measureFrame() {
-        _this.currentFrameStart = global.performance.now();
-        _this.animationFrame = requestAnimationFrame(function () {
-          // While measurement is paused -- we don't count the animation frame towards the monitored
-          // period.
-          if (!_this.paused) {
-            var frameDuration = performance.now() - _this.currentFrameStart;
-
-            // Add frame to current window
-            _this.windowFrameCount++;
-            _this.windowTotalTime += frameDuration;
-
-            // Check if window is >= 1 second (1000ms)
-            // When the page is running smoothly it's expected this will not be hit frequently
-            if (_this.windowTotalTime >= 1000) {
-              _this.measureWindowFPS();
-              // Reset window for next measurement
-              _this.resetWindow();
-            }
-          }
-          _measureFrame();
-        });
-      };
-      _measureFrame();
-    }
-  }, {
-    key: "startNewWindow",
-    value: function startNewWindow(paused) {
-      var lastWindowResult = {
-        numerator: this.currentState.numerator,
-        denominator: this.currentState.denominator,
-        max: this.currentState.max,
-        min: this.currentState.min,
-        average: this.currentState.average
-      };
-      this.paused = paused;
-      this.startWindowTracking();
-      return lastWindowResult;
-    }
-  }, {
-    key: "resetWindow",
-    value: function resetWindow() {
-      this.windowFrameCount = 0;
-      this.windowTotalTime = 0;
-      // Note this.currentFrameStart is over ridden
-      // as part of tracking - so does not need to be
-      // reset.
-    }
-  }, {
-    key: "endWindowTracking",
-    value: function endWindowTracking() {
-      if (this.animationFrame) {
-        cancelAnimationFrame(this.animationFrame);
-      }
-    }
-  }, {
-    key: "resetOverallTracking",
-    value: function resetOverallTracking() {
-      this.resetWindow();
-      this.endWindowTracking();
-      this.currentState = {
-        numerator: 0,
-        denominator: 0,
-        max: 0,
-        min: 0,
-        average: 0
-      };
-    }
-  }, {
-    key: "end",
-    value: function end() {
-      try {
-        this.measureWindowFPS();
-        return this.currentState;
-      } finally {
-        this.resetOverallTracking();
-      }
-    }
-  }, {
-    key: "pause",
-    value: function pause() {
-      // Note - we leave the tracking animationFrame monitoring running, and on resume
-      // simply set the currentFrameStart and paused to true
-      // This works because the tracking builds windows of tracked time rather than
-      // basing itself off a window start time and time elapsed time since then.
-      this.paused = true;
-    }
-  }, {
-    key: "resume",
-    value: function resume() {
-      // Note - We don't need to handle the gap in measurement - as the raf logic builds/increments a window time
-      // based on the currentFrameStart (and any previous measurements which can only happen while the tracking
-      // is not paused).
-      this.currentFrameStart = performance.now();
-      this.paused = false;
-      if (!this.animationFrame) {
-        this.startWindowTracking();
-      }
-    }
-  }]);
-}();

package/dist/es2019/period-measurers/afps.js

@@ -1,153 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-export class AnimationFPSIM {
-  constructor() {
-    /**
-     * AFPS stands for Animation Frames Per Second
-     */
-    _defineProperty(this, "name", 'afps');
-    _defineProperty(this, "monitor", new AnimationFPSMonitor());
-  }
-  start(paused) {
-    const result = this.monitor.startNewWindow(paused);
-    return result;
-  }
-  end() {
-    const result = this.monitor.end();
-    return result;
-  }
-  pause() {
-    this.monitor.pause();
-  }
-  resume() {
-    this.monitor.resume();
-  }
-}
-class AnimationFPSMonitor {
-  constructor() {
-    _defineProperty(this, "paused", false);
-    _defineProperty(this, "currentState", {
-      numerator: 0,
-      denominator: 0,
-      max: 0,
-      average: 0,
-      min: 0
-    });
-    // Current measurement window
-    _defineProperty(this, "windowFrameCount", 0);
-    _defineProperty(this, "windowTotalTime", 0);
-    _defineProperty(this, "currentFrameStart", 0);
-  }
-  measureWindowFPS() {
-    // Calculate FPS for this window
-    // Note: windowFrameCount and windowTotalTime is reset after each window measurement
-    const windowSeconds = this.windowTotalTime / 1000;
-    // frames / seconds
-    const windowFPS = this.windowFrameCount / windowSeconds;
-
-    // Update overall tracking
-    this.currentState.numerator += this.windowFrameCount;
-    // The denominator is seconds not ms
-    this.currentState.denominator += windowSeconds;
-
-    // Calculate overall average FPS: (total frames / total time measured in seconds
-    this.currentState.average = this.currentState.numerator / this.currentState.denominator;
-    if (this.currentState.max === 0 || windowFPS > this.currentState.max) {
-      this.currentState.max = windowFPS;
-    }
-    if (this.currentState.min === 0 || windowFPS < this.currentState.min) {
-      this.currentState.min = windowFPS;
-    }
-  }
-
-  /**
-   * If there is running tracking - it will be reset
-   */
-  startWindowTracking() {
-    // Clear any previous tracking state
-    this.resetOverallTracking();
-    const measureFrame = () => {
-      this.currentFrameStart = global.performance.now();
-      this.animationFrame = requestAnimationFrame(() => {
-        // While measurement is paused -- we don't count the animation frame towards the monitored
-        // period.
-        if (!this.paused) {
-          const frameDuration = performance.now() - this.currentFrameStart;
-
-          // Add frame to current window
-          this.windowFrameCount++;
-          this.windowTotalTime += frameDuration;
-
-          // Check if window is >= 1 second (1000ms)
-          // When the page is running smoothly it's expected this will not be hit frequently
-          if (this.windowTotalTime >= 1000) {
-            this.measureWindowFPS();
-            // Reset window for next measurement
-            this.resetWindow();
-          }
-        }
-        measureFrame();
-      });
-    };
-    measureFrame();
-  }
-  startNewWindow(paused) {
-    const lastWindowResult = {
-      numerator: this.currentState.numerator,
-      denominator: this.currentState.denominator,
-      max: this.currentState.max,
-      min: this.currentState.min,
-      average: this.currentState.average
-    };
-    this.paused = paused;
-    this.startWindowTracking();
-    return lastWindowResult;
-  }
-  resetWindow() {
-    this.windowFrameCount = 0;
-    this.windowTotalTime = 0;
-    // Note this.currentFrameStart is over ridden
-    // as part of tracking - so does not need to be
-    // reset.
-  }
-  endWindowTracking() {
-    if (this.animationFrame) {
-      cancelAnimationFrame(this.animationFrame);
-    }
-  }
-  resetOverallTracking() {
-    this.resetWindow();
-    this.endWindowTracking();
-    this.currentState = {
-      numerator: 0,
-      denominator: 0,
-      max: 0,
-      min: 0,
-      average: 0
-    };
-  }
-  end() {
-    try {
-      this.measureWindowFPS();
-      return this.currentState;
-    } finally {
-      this.resetOverallTracking();
-    }
-  }
-  pause() {
-    // Note - we leave the tracking animationFrame monitoring running, and on resume
-    // simply set the currentFrameStart and paused to true
-    // This works because the tracking builds windows of tracked time rather than
-    // basing itself off a window start time and time elapsed time since then.
-    this.paused = true;
-  }
-  resume() {
-    // Note - We don't need to handle the gap in measurement - as the raf logic builds/increments a window time
-    // based on the currentFrameStart (and any previous measurements which can only happen while the tracking
-    // is not paused).
-    this.currentFrameStart = performance.now();
-    this.paused = false;
-    if (!this.animationFrame) {
-      this.startWindowTracking();
-    }
-  }
-}

package/dist/esm/period-measurers/afps.js

@@ -1,186 +0,0 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-export var AnimationFPSIM = /*#__PURE__*/function () {
-  function AnimationFPSIM() {
-    _classCallCheck(this, AnimationFPSIM);
-    /**
-     * AFPS stands for Animation Frames Per Second
-     */
-    _defineProperty(this, "name", 'afps');
-    _defineProperty(this, "monitor", new AnimationFPSMonitor());
-  }
-  return _createClass(AnimationFPSIM, [{
-    key: "start",
-    value: function start(paused) {
-      var result = this.monitor.startNewWindow(paused);
-      return result;
-    }
-  }, {
-    key: "end",
-    value: function end() {
-      var result = this.monitor.end();
-      return result;
-    }
-  }, {
-    key: "pause",
-    value: function pause() {
-      this.monitor.pause();
-    }
-  }, {
-    key: "resume",
-    value: function resume() {
-      this.monitor.resume();
-    }
-  }]);
-}();
-var AnimationFPSMonitor = /*#__PURE__*/function () {
-  function AnimationFPSMonitor() {
-    _classCallCheck(this, AnimationFPSMonitor);
-    _defineProperty(this, "paused", false);
-    _defineProperty(this, "currentState", {
-      numerator: 0,
-      denominator: 0,
-      max: 0,
-      average: 0,
-      min: 0
-    });
-    // Current measurement window
-    _defineProperty(this, "windowFrameCount", 0);
-    _defineProperty(this, "windowTotalTime", 0);
-    _defineProperty(this, "currentFrameStart", 0);
-  }
-  return _createClass(AnimationFPSMonitor, [{
-    key: "measureWindowFPS",
-    value: function measureWindowFPS() {
-      // Calculate FPS for this window
-      // Note: windowFrameCount and windowTotalTime is reset after each window measurement
-      var windowSeconds = this.windowTotalTime / 1000;
-      // frames / seconds
-      var windowFPS = this.windowFrameCount / windowSeconds;
-
-      // Update overall tracking
-      this.currentState.numerator += this.windowFrameCount;
-      // The denominator is seconds not ms
-      this.currentState.denominator += windowSeconds;
-
-      // Calculate overall average FPS: (total frames / total time measured in seconds
-      this.currentState.average = this.currentState.numerator / this.currentState.denominator;
-      if (this.currentState.max === 0 || windowFPS > this.currentState.max) {
-        this.currentState.max = windowFPS;
-      }
-      if (this.currentState.min === 0 || windowFPS < this.currentState.min) {
-        this.currentState.min = windowFPS;
-      }
-    }
-
-    /**
-     * If there is running tracking - it will be reset
-     */
-  }, {
-    key: "startWindowTracking",
-    value: function startWindowTracking() {
-      var _this = this;
-      // Clear any previous tracking state
-      this.resetOverallTracking();
-      var _measureFrame = function measureFrame() {
-        _this.currentFrameStart = global.performance.now();
-        _this.animationFrame = requestAnimationFrame(function () {
-          // While measurement is paused -- we don't count the animation frame towards the monitored
-          // period.
-          if (!_this.paused) {
-            var frameDuration = performance.now() - _this.currentFrameStart;
-
-            // Add frame to current window
-            _this.windowFrameCount++;
-            _this.windowTotalTime += frameDuration;
-
-            // Check if window is >= 1 second (1000ms)
-            // When the page is running smoothly it's expected this will not be hit frequently
-            if (_this.windowTotalTime >= 1000) {
-              _this.measureWindowFPS();
-              // Reset window for next measurement
-              _this.resetWindow();
-            }
-          }
-          _measureFrame();
-        });
-      };
-      _measureFrame();
-    }
-  }, {
-    key: "startNewWindow",
-    value: function startNewWindow(paused) {
-      var lastWindowResult = {
-        numerator: this.currentState.numerator,
-        denominator: this.currentState.denominator,
-        max: this.currentState.max,
-        min: this.currentState.min,
-        average: this.currentState.average
-      };
-      this.paused = paused;
-      this.startWindowTracking();
-      return lastWindowResult;
-    }
-  }, {
-    key: "resetWindow",
-    value: function resetWindow() {
-      this.windowFrameCount = 0;
-      this.windowTotalTime = 0;
-      // Note this.currentFrameStart is over ridden
-      // as part of tracking - so does not need to be
-      // reset.
-    }
-  }, {
-    key: "endWindowTracking",
-    value: function endWindowTracking() {
-      if (this.animationFrame) {
-        cancelAnimationFrame(this.animationFrame);
-      }
-    }
-  }, {
-    key: "resetOverallTracking",
-    value: function resetOverallTracking() {
-      this.resetWindow();
-      this.endWindowTracking();
-      this.currentState = {
-        numerator: 0,
-        denominator: 0,
-        max: 0,
-        min: 0,
-        average: 0
-      };
-    }
-  }, {
-    key: "end",
-    value: function end() {
-      try {
-        this.measureWindowFPS();
-        return this.currentState;
-      } finally {
-        this.resetOverallTracking();
-      }
-    }
-  }, {
-    key: "pause",
-    value: function pause() {
-      // Note - we leave the tracking animationFrame monitoring running, and on resume
-      // simply set the currentFrameStart and paused to true
-      // This works because the tracking builds windows of tracked time rather than
-      // basing itself off a window start time and time elapsed time since then.
-      this.paused = true;
-    }
-  }, {
-    key: "resume",
-    value: function resume() {
-      // Note - We don't need to handle the gap in measurement - as the raf logic builds/increments a window time
-      // based on the currentFrameStart (and any previous measurements which can only happen while the tracking
-      // is not paused).
-      this.currentFrameStart = performance.now();
-      this.paused = false;
-      if (!this.animationFrame) {
-        this.startWindowTracking();
-      }
-    }
-  }]);
-}();

package/dist/types/period-measurers/afps.d.ts

@@ -1,57 +0,0 @@
-import type { PeriodMeasurer } from '../types';
-export declare class AnimationFPSIM implements PeriodMeasurer {
-    /**
-     * AFPS stands for Animation Frames Per Second
-     */
-    name: string;
-    monitor: AnimationFPSMonitor;
-    start(paused: boolean): {
-        numerator: number;
-        denominator: number;
-        max: number;
-        min: number;
-        average: number;
-    };
-    end(): {
-        numerator: number;
-        denominator: number;
-        max: number;
-        min: number;
-        average: number;
-    };
-    pause(): void;
-    resume(): void;
-}
-declare class AnimationFPSMonitor {
-    paused: boolean;
-    private currentState;
-    private windowFrameCount;
-    private windowTotalTime;
-    private currentFrameStart;
-    animationFrame?: ReturnType<typeof requestAnimationFrame>;
-    private measureWindowFPS;
-    /**
-     * If there is running tracking - it will be reset
-     */
-    private startWindowTracking;
-    startNewWindow(paused: boolean): {
-        numerator: number;
-        denominator: number;
-        max: number;
-        min: number;
-        average: number;
-    };
-    private resetWindow;
-    private endWindowTracking;
-    private resetOverallTracking;
-    end(): {
-        numerator: number;
-        denominator: number;
-        max: number;
-        min: number;
-        average: number;
-    };
-    pause(): void;
-    resume(): void;
-}
-export {};