@veritone-ce/design-system 2.8.14-next.2.0 → 2.8.14

package/dist/cjs/bundled_modules/@react-spring/rafz/dist/react-spring_rafz.modern.js

@@ -0,0 +1,160 @@
+'use strict';
+
+// src/index.ts
+var updateQueue = makeQueue();
+var raf = (fn) => schedule(fn, updateQueue);
+var writeQueue = makeQueue();
+raf.write = (fn) => schedule(fn, writeQueue);
+var onStartQueue = makeQueue();
+raf.onStart = (fn) => schedule(fn, onStartQueue);
+var onFrameQueue = makeQueue();
+raf.onFrame = (fn) => schedule(fn, onFrameQueue);
+var onFinishQueue = makeQueue();
+raf.onFinish = (fn) => schedule(fn, onFinishQueue);
+var timeouts = [];
+raf.setTimeout = (handler, ms) => {
+  const time = raf.now() + ms;
+  const cancel = () => {
+    const i = timeouts.findIndex((t) => t.cancel == cancel);
+    if (~i) timeouts.splice(i, 1);
+    pendingCount -= ~i ? 1 : 0;
+  };
+  const timeout = { time, handler, cancel };
+  timeouts.splice(findTimeout(time), 0, timeout);
+  pendingCount += 1;
+  start();
+  return timeout;
+};
+var findTimeout = (time) => ~(~timeouts.findIndex((t) => t.time > time) || ~timeouts.length);
+raf.cancel = (fn) => {
+  onStartQueue.delete(fn);
+  onFrameQueue.delete(fn);
+  onFinishQueue.delete(fn);
+  updateQueue.delete(fn);
+  writeQueue.delete(fn);
+};
+raf.sync = (fn) => {
+  sync = true;
+  raf.batchedUpdates(fn);
+  sync = false;
+};
+raf.throttle = (fn) => {
+  let lastArgs;
+  function queuedFn() {
+    try {
+      fn(...lastArgs);
+    } finally {
+      lastArgs = null;
+    }
+  }
+  function throttled(...args) {
+    lastArgs = args;
+    raf.onStart(queuedFn);
+  }
+  throttled.handler = fn;
+  throttled.cancel = () => {
+    onStartQueue.delete(queuedFn);
+    lastArgs = null;
+  };
+  return throttled;
+};
+var nativeRaf = typeof window != "undefined" ? window.requestAnimationFrame : (
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  () => {
+  }
+);
+raf.use = (impl) => nativeRaf = impl;
+raf.now = typeof performance != "undefined" ? () => performance.now() : Date.now;
+raf.batchedUpdates = (fn) => fn();
+raf.catch = console.error;
+raf.frameLoop = "always";
+raf.advance = () => {
+  if (raf.frameLoop !== "demand") {
+    console.warn(
+      "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand"
+    );
+  } else {
+    update();
+  }
+};
+var ts = -1;
+var pendingCount = 0;
+var sync = false;
+function schedule(fn, queue) {
+  if (sync) {
+    queue.delete(fn);
+    fn(0);
+  } else {
+    queue.add(fn);
+    start();
+  }
+}
+function start() {
+  if (ts < 0) {
+    ts = 0;
+    if (raf.frameLoop !== "demand") {
+      nativeRaf(loop);
+    }
+  }
+}
+function stop() {
+  ts = -1;
+}
+function loop() {
+  if (~ts) {
+    nativeRaf(loop);
+    raf.batchedUpdates(update);
+  }
+}
+function update() {
+  const prevTs = ts;
+  ts = raf.now();
+  const count = findTimeout(ts);
+  if (count) {
+    eachSafely(timeouts.splice(0, count), (t) => t.handler());
+    pendingCount -= count;
+  }
+  if (!pendingCount) {
+    stop();
+    return;
+  }
+  onStartQueue.flush();
+  updateQueue.flush(prevTs ? Math.min(64, ts - prevTs) : 16.667);
+  onFrameQueue.flush();
+  writeQueue.flush();
+  onFinishQueue.flush();
+}
+function makeQueue() {
+  let next = /* @__PURE__ */ new Set();
+  let current = next;
+  return {
+    add(fn) {
+      pendingCount += current == next && !next.has(fn) ? 1 : 0;
+      next.add(fn);
+    },
+    delete(fn) {
+      pendingCount -= current == next && next.has(fn) ? 1 : 0;
+      return next.delete(fn);
+    },
+    flush(arg) {
+      if (current.size) {
+        next = /* @__PURE__ */ new Set();
+        pendingCount -= current.size;
+        eachSafely(current, (fn) => fn(arg) && next.add(fn));
+        pendingCount += next.size;
+        current = next;
+      }
+    }
+  };
+}
+function eachSafely(values, each) {
+  values.forEach((value) => {
+    try {
+      each(value);
+    } catch (e) {
+      raf.catch(e);
+    }
+  });
+}
+
+exports.raf = raf;