@expo/cli 0.0.0-bisect-20240612-0

package/static/canary/scheduler/cjs/scheduler-unstable_mock.production.js

@@ -0,0 +1,415 @@
+/**
+ * @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_continueExecution = function () {
+  isHostCallbackScheduled ||
+    isPerformingWork ||
+    ((isHostCallbackScheduled = !0), (scheduledCallback = flushWork));
+};
+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_getFirstCallbackNode = function () {
+  return peek(taskQueue);
+};
+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_pauseExecution = function () {};
+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;
+    }
+  };
+};

package/static/canary/scheduler/cjs/scheduler-unstable_post_task.development.js

@@ -0,0 +1,208 @@
+/**
+ * @license React
+ * scheduler-unstable_post_task.development.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';
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+'use strict';
+
+// TODO: Use symbols?
+var ImmediatePriority = 1;
+var UserBlockingPriority = 2;
+var NormalPriority = 3;
+var LowPriority = 4;
+var IdlePriority = 5;
+
+var perf = window.performance;
+var setTimeout = window.setTimeout; // Use experimental Chrome Scheduler postTask API.
+
+var scheduler = global.scheduler;
+var getCurrentTime = perf.now.bind(perf);
+var unstable_now = getCurrentTime; // Scheduler periodically yields in case there is other work on the main
+// thread, like user events. By default, it yields multiple times per frame.
+// It does not attempt to align with frame boundaries, since most tasks don't
+// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+var yieldInterval = 5;
+var deadline = 0;
+var currentPriorityLevel_DEPRECATED = NormalPriority; // Always yield at the end of the frame.
+
+function unstable_shouldYield() {
+  return getCurrentTime() >= deadline;
+}
+function unstable_requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect.
+}
+function unstable_scheduleCallback(priorityLevel, callback, options) {
+  var postTaskPriority;
+
+  switch (priorityLevel) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+      postTaskPriority = 'user-blocking';
+      break;
+
+    case LowPriority:
+    case NormalPriority:
+      postTaskPriority = 'user-visible';
+      break;
+
+    case IdlePriority:
+      postTaskPriority = 'background';
+      break;
+
+    default:
+      postTaskPriority = 'user-visible';
+      break;
+  }
+
+  var controller = new TaskController({
+    priority: postTaskPriority
+  });
+  var postTaskOptions = {
+    delay: typeof options === 'object' && options !== null ? options.delay : 0,
+    signal: controller.signal
+  };
+  var node = {
+    _controller: controller
+  };
+  scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, callback), postTaskOptions).catch(handleAbortError);
+  return node;
+}
+
+function runTask(priorityLevel, postTaskPriority, node, callback) {
+  deadline = getCurrentTime() + yieldInterval;
+
+  try {
+    currentPriorityLevel_DEPRECATED = priorityLevel;
+    var didTimeout_DEPRECATED = false;
+    var result = callback(didTimeout_DEPRECATED);
+
+    if (typeof result === 'function') {
+      // Assume this is a continuation
+      var continuation = result;
+      var continuationOptions = {
+        signal: node._controller.signal
+      };
+      var nextTask = runTask.bind(null, priorityLevel, postTaskPriority, node, continuation);
+
+      if (scheduler.yield !== undefined) {
+        scheduler.yield(continuationOptions).then(nextTask).catch(handleAbortError);
+      } else {
+        scheduler.postTask(nextTask, continuationOptions).catch(handleAbortError);
+      }
+    }
+  } catch (error) {
+    // We're inside a `postTask` promise. If we don't handle this error, then it
+    // will trigger an "Unhandled promise rejection" error. We don't want that,
+    // but we do want the default error reporting behavior that normal
+    // (non-Promise) tasks get for unhandled errors.
+    //
+    // So we'll re-throw the error inside a regular browser task.
+    setTimeout(function () {
+      throw error;
+    });
+  } finally {
+    currentPriorityLevel_DEPRECATED = NormalPriority;
+  }
+}
+
+function handleAbortError(error) {// Abort errors are an implementation detail. We don't expose the
+  // TaskController to the user, nor do we expose the promise that is returned
+  // from `postTask`. So we should suppress them, since there's no way for the
+  // user to handle them.
+}
+
+function unstable_cancelCallback(node) {
+  var controller = node._controller;
+  controller.abort();
+}
+function unstable_runWithPriority(priorityLevel, callback) {
+  var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+  currentPriorityLevel_DEPRECATED = priorityLevel;
+
+  try {
+    return callback();
+  } finally {
+    currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+  }
+}
+function unstable_getCurrentPriorityLevel() {
+  return currentPriorityLevel_DEPRECATED;
+}
+function unstable_next(callback) {
+  var priorityLevel;
+
+  switch (currentPriorityLevel_DEPRECATED) {
+    case ImmediatePriority:
+    case UserBlockingPriority:
+    case NormalPriority:
+      // Shift down to normal priority
+      priorityLevel = NormalPriority;
+      break;
+
+    default:
+      // Anything lower than normal priority should remain at the current level.
+      priorityLevel = currentPriorityLevel_DEPRECATED;
+      break;
+  }
+
+  var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+  currentPriorityLevel_DEPRECATED = priorityLevel;
+
+  try {
+    return callback();
+  } finally {
+    currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+  }
+}
+function unstable_wrapCallback(callback) {
+  var parentPriorityLevel = currentPriorityLevel_DEPRECATED;
+  return function () {
+    var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
+    currentPriorityLevel_DEPRECATED = parentPriorityLevel;
+
+    try {
+      return callback();
+    } finally {
+      currentPriorityLevel_DEPRECATED = previousPriorityLevel;
+    }
+  };
+}
+function unstable_forceFrameRate() {}
+function unstable_pauseExecution() {}
+function unstable_continueExecution() {}
+function unstable_getFirstCallbackNode() {
+  return null;
+} // Currently no profiling build
+
+var unstable_Profiling = null;
+
+exports.unstable_IdlePriority = IdlePriority;
+exports.unstable_ImmediatePriority = ImmediatePriority;
+exports.unstable_LowPriority = LowPriority;
+exports.unstable_NormalPriority = NormalPriority;
+exports.unstable_Profiling = unstable_Profiling;
+exports.unstable_UserBlockingPriority = UserBlockingPriority;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_forceFrameRate = unstable_forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_now = unstable_now;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = unstable_requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_shouldYield = unstable_shouldYield;
+exports.unstable_wrapCallback = unstable_wrapCallback;
+  })();
+}