next/dist/compiled/scheduler-experimental/cjs/scheduler-unstable_mock.production.js

The React Framework

/**
 * @license React
 * scheduler-unstable_mock.production.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

"use strict";
function push(heap, node) {
  var index = heap.length;
  heap.push(node);
  a: for (; 0 < index; ) {
    var parentIndex = (index - 1) >>> 1,
      parent = heap[parentIndex];
    if (0 < compare(parent, node))
      (heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
    else break a;
  }
}
function peek(heap) {
  return 0 === heap.length ? null : heap[0];
}
function pop(heap) {
  if (0 === heap.length) return null;
  var first = heap[0],
    last = heap.pop();
  if (last !== first) {
    heap[0] = last;
    a: for (
      var index = 0, length = heap.length, halfLength = length >>> 1;
      index < halfLength;

    ) {
      var leftIndex = 2 * (index + 1) - 1,
        left = heap[leftIndex],
        rightIndex = leftIndex + 1,
        right = heap[rightIndex];
      if (0 > compare(left, last))
        rightIndex < length && 0 > compare(right, left)
          ? ((heap[index] = right),
            (heap[rightIndex] = last),
            (index = rightIndex))
          : ((heap[index] = left),
            (heap[leftIndex] = last),
            (index = leftIndex));
      else if (rightIndex < length && 0 > compare(right, last))
        (heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
      else break a;
    }
  }
  return first;
}
function compare(a, b) {
  var diff = a.sortIndex - b.sortIndex;
  return 0 !== diff ? diff : a.id - b.id;
}
var taskQueue = [],
  timerQueue = [],
  taskIdCounter = 1,
  currentTask = null,
  currentPriorityLevel = 3,
  isPerformingWork = !1,
  isHostCallbackScheduled = !1,
  isHostTimeoutScheduled = !1,
  currentMockTime = 0,
  scheduledCallback = null,
  scheduledTimeout = null,
  timeoutTime = -1,
  yieldedValues = null,
  expectedNumberOfYields = -1,
  didStop = !1,
  isFlushing = !1,
  needsPaint = !1,
  shouldYieldForPaint = !1,
  disableYieldValue = !1;
function advanceTimers(currentTime) {
  for (var timer = peek(timerQueue); null !== timer; ) {
    if (null === timer.callback) pop(timerQueue);
    else if (timer.startTime <= currentTime)
      pop(timerQueue),
        (timer.sortIndex = timer.expirationTime),
        push(taskQueue, timer);
    else break;
    timer = peek(timerQueue);
  }
}
function handleTimeout(currentTime) {
  isHostTimeoutScheduled = !1;
  advanceTimers(currentTime);
  if (!isHostCallbackScheduled)
    if (null !== peek(taskQueue))
      (isHostCallbackScheduled = !0), (scheduledCallback = flushWork);
    else {
      var firstTimer = peek(timerQueue);
      null !== firstTimer &&
        ((currentTime = firstTimer.startTime - currentTime),
        (scheduledTimeout = handleTimeout),
        (timeoutTime = currentMockTime + currentTime));
    }
}
function flushWork(hasTimeRemaining, initialTime) {
  isHostCallbackScheduled = !1;
  isHostTimeoutScheduled &&
    ((isHostTimeoutScheduled = !1),
    (scheduledTimeout = null),
    (timeoutTime = -1));
  isPerformingWork = !0;
  var previousPriorityLevel = currentPriorityLevel;
  try {
    a: {
      advanceTimers(initialTime);
      for (
        currentTask = peek(taskQueue);
        null !== currentTask &&
        (!(currentTask.expirationTime > initialTime) ||
          (hasTimeRemaining && !shouldYieldToHost()));

      ) {
        var callback = currentTask.callback;
        if ("function" === typeof callback) {
          currentTask.callback = null;
          currentPriorityLevel = currentTask.priorityLevel;
          var continuationCallback = callback(
            currentTask.expirationTime <= initialTime
          );
          initialTime = currentMockTime;
          if ("function" === typeof continuationCallback) {
            if (
              ((currentTask.callback = continuationCallback),
              advanceTimers(initialTime),
              shouldYieldForPaint)
            ) {
              var JSCompiler_inline_result = (needsPaint = !0);
              break a;
            }
          } else
            currentTask === peek(taskQueue) && pop(taskQueue),
              advanceTimers(initialTime);
        } else pop(taskQueue);
        currentTask = peek(taskQueue);
      }
      if (null !== currentTask) JSCompiler_inline_result = !0;
      else {
        var firstTimer = peek(timerQueue);
        if (null !== firstTimer) {
          var ms = firstTimer.startTime - initialTime;
          scheduledTimeout = handleTimeout;
          timeoutTime = currentMockTime + ms;
        }
        JSCompiler_inline_result = !1;
      }
    }
    return JSCompiler_inline_result;
  } finally {
    (currentTask = null),
      (currentPriorityLevel = previousPriorityLevel),
      (isPerformingWork = !1);
  }
}
function shouldYieldToHost() {
  return (0 === expectedNumberOfYields && null === yieldedValues) ||
    (-1 !== expectedNumberOfYields &&
      null !== yieldedValues &&
      yieldedValues.length >= expectedNumberOfYields) ||
    (shouldYieldForPaint && needsPaint)
    ? (didStop = !0)
    : !1;
}
function unstable_flushAllWithoutAsserting() {
  if (isFlushing) throw Error("Already flushing work.");
  if (null !== scheduledCallback) {
    var cb = scheduledCallback;
    isFlushing = !0;
    try {
      var hasMoreWork = !0;
      do hasMoreWork = cb(!0, currentMockTime);
      while (hasMoreWork);
      hasMoreWork || (scheduledCallback = null);
      return !0;
    } finally {
      isFlushing = !1;
    }
  } else return !1;
}
exports.log = function (value) {
  "disabledLog" === console.log.name ||
    disableYieldValue ||
    (null === yieldedValues
      ? (yieldedValues = [value])
      : yieldedValues.push(value));
};
exports.reset = function () {
  if (isFlushing) throw Error("Cannot reset while already flushing work.");
  currentMockTime = 0;
  scheduledTimeout = scheduledCallback = null;
  timeoutTime = -1;
  yieldedValues = null;
  expectedNumberOfYields = -1;
  needsPaint = isFlushing = didStop = !1;
};
exports.unstable_IdlePriority = 5;
exports.unstable_ImmediatePriority = 1;
exports.unstable_LowPriority = 4;
exports.unstable_NormalPriority = 3;
exports.unstable_Profiling = null;
exports.unstable_UserBlockingPriority = 2;
exports.unstable_advanceTime = function (ms) {
  "disabledLog" === console.log.name ||
    disableYieldValue ||
    ((currentMockTime += ms),
    null !== scheduledTimeout &&
      timeoutTime <= currentMockTime &&
      (scheduledTimeout(currentMockTime),
      (timeoutTime = -1),
      (scheduledTimeout = null)));
};
exports.unstable_cancelCallback = function (task) {
  task.callback = null;
};
exports.unstable_clearLog = function () {
  if (null === yieldedValues) return [];
  var values = yieldedValues;
  yieldedValues = null;
  return values;
};
exports.unstable_flushAll = function () {
  if (null !== yieldedValues)
    throw Error(
      "Log is not empty. Assert on the log of yielded values before flushing additional work."
    );
  unstable_flushAllWithoutAsserting();
  if (null !== yieldedValues)
    throw Error(
      "While flushing work, something yielded a value. Use an assertion helper to assert on the log of yielded values, e.g. expect(Scheduler).toFlushAndYield([...])"
    );
};
exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
exports.unstable_flushExpired = function () {
  if (isFlushing) throw Error("Already flushing work.");
  if (null !== scheduledCallback) {
    isFlushing = !0;
    try {
      scheduledCallback(!1, currentMockTime) || (scheduledCallback = null);
    } finally {
      isFlushing = !1;
    }
  }
};
exports.unstable_flushNumberOfYields = function (count) {
  if (isFlushing) throw Error("Already flushing work.");
  if (null !== scheduledCallback) {
    var cb = scheduledCallback;
    expectedNumberOfYields = count;
    isFlushing = !0;
    try {
      count = !0;
      do count = cb(!0, currentMockTime);
      while (count && !didStop);
      count || (scheduledCallback = null);
    } finally {
      (expectedNumberOfYields = -1), (isFlushing = didStop = !1);
    }
  }
};
exports.unstable_flushUntilNextPaint = function () {
  if (isFlushing) throw Error("Already flushing work.");
  if (null !== scheduledCallback) {
    var cb = scheduledCallback;
    shouldYieldForPaint = !0;
    needsPaint = !1;
    isFlushing = !0;
    try {
      var hasMoreWork = !0;
      do hasMoreWork = cb(!0, currentMockTime);
      while (hasMoreWork && !didStop);
      hasMoreWork || (scheduledCallback = null);
    } finally {
      isFlushing = didStop = shouldYieldForPaint = !1;
    }
  }
  return !1;
};
exports.unstable_forceFrameRate = function () {};
exports.unstable_getCurrentPriorityLevel = function () {
  return currentPriorityLevel;
};
exports.unstable_hasPendingWork = function () {
  return null !== scheduledCallback;
};
exports.unstable_next = function (eventHandler) {
  switch (currentPriorityLevel) {
    case 1:
    case 2:
    case 3:
      var priorityLevel = 3;
      break;
    default:
      priorityLevel = currentPriorityLevel;
  }
  var previousPriorityLevel = currentPriorityLevel;
  currentPriorityLevel = priorityLevel;
  try {
    return eventHandler();
  } finally {
    currentPriorityLevel = previousPriorityLevel;
  }
};
exports.unstable_now = function () {
  return currentMockTime;
};
exports.unstable_requestPaint = function () {
  needsPaint = !0;
};
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
  switch (priorityLevel) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      break;
    default:
      priorityLevel = 3;
  }
  var previousPriorityLevel = currentPriorityLevel;
  currentPriorityLevel = priorityLevel;
  try {
    return eventHandler();
  } finally {
    currentPriorityLevel = previousPriorityLevel;
  }
};
exports.unstable_scheduleCallback = function (
  priorityLevel,
  callback,
  options
) {
  var currentTime = currentMockTime;
  "object" === typeof options && null !== options
    ? ((options = options.delay),
      (options =
        "number" === typeof options && 0 < options
          ? currentTime + options
          : currentTime))
    : (options = currentTime);
  switch (priorityLevel) {
    case 1:
      var timeout = -1;
      break;
    case 2:
      timeout = 250;
      break;
    case 5:
      timeout = 1073741823;
      break;
    case 4:
      timeout = 1e4;
      break;
    default:
      timeout = 5e3;
  }
  timeout = options + timeout;
  priorityLevel = {
    id: taskIdCounter++,
    callback: callback,
    priorityLevel: priorityLevel,
    startTime: options,
    expirationTime: timeout,
    sortIndex: -1
  };
  options > currentTime
    ? ((priorityLevel.sortIndex = options),
      push(timerQueue, priorityLevel),
      null === peek(taskQueue) &&
        priorityLevel === peek(timerQueue) &&
        (isHostTimeoutScheduled
          ? ((scheduledTimeout = null), (timeoutTime = -1))
          : (isHostTimeoutScheduled = !0),
        (scheduledTimeout = handleTimeout),
        (timeoutTime = currentMockTime + (options - currentTime))))
    : ((priorityLevel.sortIndex = timeout),
      push(taskQueue, priorityLevel),
      isHostCallbackScheduled ||
        isPerformingWork ||
        ((isHostCallbackScheduled = !0), (scheduledCallback = flushWork)));
  return priorityLevel;
};
exports.unstable_setDisableYieldValue = function (newValue) {
  disableYieldValue = newValue;
};
exports.unstable_shouldYield = shouldYieldToHost;
exports.unstable_wrapCallback = function (callback) {
  var parentPriorityLevel = currentPriorityLevel;
  return function () {
    var previousPriorityLevel = currentPriorityLevel;
    currentPriorityLevel = parentPriorityLevel;
    try {
      return callback.apply(this, arguments);
    } finally {
      currentPriorityLevel = previousPriorityLevel;
    }
  };
};