victory-vendor 36.4.0

package/lib-vendor/d3-timer/src/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "interval", {
+  enumerable: true,
+  get: function () {
+    return _interval.default;
+  }
+});
+Object.defineProperty(exports, "now", {
+  enumerable: true,
+  get: function () {
+    return _timer.now;
+  }
+});
+Object.defineProperty(exports, "timeout", {
+  enumerable: true,
+  get: function () {
+    return _timeout.default;
+  }
+});
+Object.defineProperty(exports, "timer", {
+  enumerable: true,
+  get: function () {
+    return _timer.timer;
+  }
+});
+Object.defineProperty(exports, "timerFlush", {
+  enumerable: true,
+  get: function () {
+    return _timer.timerFlush;
+  }
+});
+
+var _timer = require("./timer.js");
+
+var _timeout = _interopRequireDefault(require("./timeout.js"));
+
+var _interval = _interopRequireDefault(require("./interval.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib-vendor/d3-timer/src/interval.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _timer = require("./timer.js");
+
+function _default(callback, delay, time) {
+  var t = new _timer.Timer(),
+      total = delay;
+  if (delay == null) return t.restart(callback, delay, time), t;
+  t._restart = t.restart;
+
+  t.restart = function (callback, delay, time) {
+    delay = +delay, time = time == null ? (0, _timer.now)() : +time;
+
+    t._restart(function tick(elapsed) {
+      elapsed += total;
+
+      t._restart(tick, total += delay, time);
+
+      callback(elapsed);
+    }, delay, time);
+  };
+
+  t.restart(callback, delay, time);
+  return t;
+}

package/lib-vendor/d3-timer/src/timeout.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _timer = require("./timer.js");
+
+function _default(callback, delay, time) {
+  var t = new _timer.Timer();
+  delay = delay == null ? 0 : +delay;
+  t.restart(elapsed => {
+    t.stop();
+    callback(elapsed + delay);
+  }, delay, time);
+  return t;
+}

package/lib-vendor/d3-timer/src/timer.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Timer = Timer;
+exports.now = now;
+exports.timer = timer;
+exports.timerFlush = timerFlush;
+var frame = 0,
+    // is an animation frame pending?
+timeout = 0,
+    // is a timeout pending?
+interval = 0,
+    // are any timers active?
+pokeDelay = 1000,
+    // how frequently we check for clock skew
+taskHead,
+    taskTail,
+    clockLast = 0,
+    clockNow = 0,
+    clockSkew = 0,
+    clock = typeof performance === "object" && performance.now ? performance : Date,
+    setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function (f) {
+  setTimeout(f, 17);
+};
+
+function now() {
+  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+}
+
+function clearNow() {
+  clockNow = 0;
+}
+
+function Timer() {
+  this._call = this._time = this._next = null;
+}
+
+Timer.prototype = timer.prototype = {
+  constructor: Timer,
+  restart: function (callback, delay, time) {
+    if (typeof callback !== "function") throw new TypeError("callback is not a function");
+    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+
+    if (!this._next && taskTail !== this) {
+      if (taskTail) taskTail._next = this;else taskHead = this;
+      taskTail = this;
+    }
+
+    this._call = callback;
+    this._time = time;
+    sleep();
+  },
+  stop: function () {
+    if (this._call) {
+      this._call = null;
+      this._time = Infinity;
+      sleep();
+    }
+  }
+};
+
+function timer(callback, delay, time) {
+  var t = new Timer();
+  t.restart(callback, delay, time);
+  return t;
+}
+
+function timerFlush() {
+  now(); // Get the current time, if not already set.
+
+  ++frame; // Pretend we’ve set an alarm, if we haven’t already.
+
+  var t = taskHead,
+      e;
+
+  while (t) {
+    if ((e = clockNow - t._time) >= 0) t._call.call(undefined, e);
+    t = t._next;
+  }
+
+  --frame;
+}
+
+function wake() {
+  clockNow = (clockLast = clock.now()) + clockSkew;
+  frame = timeout = 0;
+
+  try {
+    timerFlush();
+  } finally {
+    frame = 0;
+    nap();
+    clockNow = 0;
+  }
+}
+
+function poke() {
+  var now = clock.now(),
+      delay = now - clockLast;
+  if (delay > pokeDelay) clockSkew -= delay, clockLast = now;
+}
+
+function nap() {
+  var t0,
+      t1 = taskHead,
+      t2,
+      time = Infinity;
+
+  while (t1) {
+    if (t1._call) {
+      if (time > t1._time) time = t1._time;
+      t0 = t1, t1 = t1._next;
+    } else {
+      t2 = t1._next, t1._next = null;
+      t1 = t0 ? t0._next = t2 : taskHead = t2;
+    }
+  }
+
+  taskTail = t0;
+  sleep(time);
+}
+
+function sleep(time) {
+  if (frame) return; // Soonest alarm already set, or will be.
+
+  if (timeout) timeout = clearTimeout(timeout);
+  var delay = time - clockNow; // Strictly less than if we recomputed clockNow.
+
+  if (delay > 24) {
+    if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
+    if (interval) interval = clearInterval(interval);
+  } else {
+    if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+    frame = 1, setFrame(wake);
+  }
+}

package/lib-vendor/internmap/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2021 Mike Bostock
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/lib-vendor/internmap/src/index.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InternSet = exports.InternMap = void 0;
+
+class InternMap extends Map {
+  constructor(entries, key = keyof) {
+    super();
+    Object.defineProperties(this, {
+      _intern: {
+        value: new Map()
+      },
+      _key: {
+        value: key
+      }
+    });
+    if (entries != null) for (const [key, value] of entries) this.set(key, value);
+  }
+
+  get(key) {
+    return super.get(intern_get(this, key));
+  }
+
+  has(key) {
+    return super.has(intern_get(this, key));
+  }
+
+  set(key, value) {
+    return super.set(intern_set(this, key), value);
+  }
+
+  delete(key) {
+    return super.delete(intern_delete(this, key));
+  }
+
+}
+
+exports.InternMap = InternMap;
+
+class InternSet extends Set {
+  constructor(values, key = keyof) {
+    super();
+    Object.defineProperties(this, {
+      _intern: {
+        value: new Map()
+      },
+      _key: {
+        value: key
+      }
+    });
+    if (values != null) for (const value of values) this.add(value);
+  }
+
+  has(value) {
+    return super.has(intern_get(this, value));
+  }
+
+  add(value) {
+    return super.add(intern_set(this, value));
+  }
+
+  delete(value) {
+    return super.delete(intern_delete(this, value));
+  }
+
+}
+
+exports.InternSet = InternSet;
+
+function intern_get({
+  _intern,
+  _key
+}, value) {
+  const key = _key(value);
+
+  return _intern.has(key) ? _intern.get(key) : value;
+}
+
+function intern_set({
+  _intern,
+  _key
+}, value) {
+  const key = _key(value);
+
+  if (_intern.has(key)) return _intern.get(key);
+
+  _intern.set(key, value);
+
+  return value;
+}
+
+function intern_delete({
+  _intern,
+  _key
+}, value) {
+  const key = _key(value);
+
+  if (_intern.has(key)) {
+    value = _intern.get(key);
+
+    _intern.delete(key);
+  }
+
+  return value;
+}
+
+function keyof(value) {
+  return value !== null && typeof value === "object" ? value.valueOf() : value;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "victory-vendor",
+  "version": "36.4.0",
+  "description": "Vendored dependencies for Victory",
+  "keywords": [
+    "data visualization",
+    "React",
+    "d3",
+    "charting"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/formidablelabs/victory.git"
+  },
+  "homepage": "https://formidable.com/open-source/victory",
+  "author": "Formidable",
+  "license": "MIT AND ISC",
+  "exports": {
+    "./d3-*": {
+      "import": "./es/d3-*.js",
+      "default": "./lib/d3-*.js"
+    }
+  },
+  "scripts": {
+    "version": "yarn run build",
+    "build": "node ./scripts/build.js"
+  },
+  "dependencies": {
+    "d3-array": "^3.1.6",
+    "d3-ease": "^3.0.1",
+    "d3-interpolate": "^3.0.1",
+    "d3-scale": "^4.0.2",
+    "d3-shape": "^3.1.0",
+    "d3-time": "^3.0.0",
+    "d3-timer": "^3.0.1"
+  },
+  "devDependencies": {
+    "execa": "^6.1.0",
+    "rimraf": "^3.0.2"
+  },
+  "sideEffects": false,
+  "gitHead": "2e05481eeb34f9801a90023a131a21aa7deff082"
+}