@camstack/addon-pipeline-orchestrator 0.1.16 → 0.1.17

package/dist/index-BxLvm_gu.mjs

@@ -0,0 +1,267 @@
+var scheduler = { exports: {} };
+var scheduler_production = {};
+/**
+ * @license React
+ * scheduler.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.
+ */
+(function(exports) {
+  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;
+  }
+  exports.unstable_now = void 0;
+  if ("object" === typeof performance && "function" === typeof performance.now) {
+    var localPerformance = performance;
+    exports.unstable_now = function() {
+      return localPerformance.now();
+    };
+  } else {
+    var localDate = Date, initialTime = localDate.now();
+    exports.unstable_now = function() {
+      return localDate.now() - initialTime;
+    };
+  }
+  var taskQueue = [], timerQueue = [], taskIdCounter = 1, currentTask = null, currentPriorityLevel = 3, isPerformingWork = false, isHostCallbackScheduled = false, isHostTimeoutScheduled = false, needsPaint = false, localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null, localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
+  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 = false;
+    advanceTimers(currentTime);
+    if (!isHostCallbackScheduled)
+      if (null !== peek(taskQueue))
+        isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline());
+      else {
+        var firstTimer = peek(timerQueue);
+        null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+  }
+  var isMessageLoopRunning = false, taskTimeoutID = -1, frameInterval = 5, startTime = -1;
+  function shouldYieldToHost() {
+    return needsPaint ? true : exports.unstable_now() - startTime < frameInterval ? false : true;
+  }
+  function performWorkUntilDeadline() {
+    needsPaint = false;
+    if (isMessageLoopRunning) {
+      var currentTime = exports.unstable_now();
+      startTime = currentTime;
+      var hasMoreWork = true;
+      try {
+        a: {
+          isHostCallbackScheduled = false;
+          isHostTimeoutScheduled && (isHostTimeoutScheduled = false, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
+          isPerformingWork = true;
+          var previousPriorityLevel = currentPriorityLevel;
+          try {
+            b: {
+              advanceTimers(currentTime);
+              for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost()); ) {
+                var callback = currentTask.callback;
+                if ("function" === typeof callback) {
+                  currentTask.callback = null;
+                  currentPriorityLevel = currentTask.priorityLevel;
+                  var continuationCallback = callback(
+                    currentTask.expirationTime <= currentTime
+                  );
+                  currentTime = exports.unstable_now();
+                  if ("function" === typeof continuationCallback) {
+                    currentTask.callback = continuationCallback;
+                    advanceTimers(currentTime);
+                    hasMoreWork = true;
+                    break b;
+                  }
+                  currentTask === peek(taskQueue) && pop(taskQueue);
+                  advanceTimers(currentTime);
+                } else pop(taskQueue);
+                currentTask = peek(taskQueue);
+              }
+              if (null !== currentTask) hasMoreWork = true;
+              else {
+                var firstTimer = peek(timerQueue);
+                null !== firstTimer && requestHostTimeout(
+                  handleTimeout,
+                  firstTimer.startTime - currentTime
+                );
+                hasMoreWork = false;
+              }
+            }
+            break a;
+          } finally {
+            currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = false;
+          }
+          hasMoreWork = void 0;
+        }
+      } finally {
+        hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = false;
+      }
+    }
+  }
+  var schedulePerformWorkUntilDeadline;
+  if ("function" === typeof localSetImmediate)
+    schedulePerformWorkUntilDeadline = function() {
+      localSetImmediate(performWorkUntilDeadline);
+    };
+  else if ("undefined" !== typeof MessageChannel) {
+    var channel = new MessageChannel(), port = channel.port2;
+    channel.port1.onmessage = performWorkUntilDeadline;
+    schedulePerformWorkUntilDeadline = function() {
+      port.postMessage(null);
+    };
+  } else
+    schedulePerformWorkUntilDeadline = function() {
+      localSetTimeout(performWorkUntilDeadline, 0);
+    };
+  function requestHostTimeout(callback, ms) {
+    taskTimeoutID = localSetTimeout(function() {
+      callback(exports.unstable_now());
+    }, ms);
+  }
+  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_cancelCallback = function(task) {
+    task.callback = null;
+  };
+  exports.unstable_forceFrameRate = function(fps) {
+    0 > fps || 125 < fps ? console.error(
+      "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
+    ) : frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5;
+  };
+  exports.unstable_getCurrentPriorityLevel = function() {
+    return currentPriorityLevel;
+  };
+  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_requestPaint = function() {
+    needsPaint = true;
+  };
+  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 = exports.unstable_now();
+    "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,
+      priorityLevel,
+      startTime: options,
+      expirationTime: timeout,
+      sortIndex: -1
+    };
+    options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = true, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline())));
+    return priorityLevel;
+  };
+  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;
+      }
+    };
+  };
+})(scheduler_production);
+{
+  scheduler.exports = scheduler_production;
+}
+var schedulerExports = scheduler.exports;
+export {
+  schedulerExports as s
+};