@amazon-devices/react-native-worklets 1.0.1 → 1.0.2

package/lib/module/errors.js

@@ -1,69 +0,0 @@
-'use strict';
-
-import { WorkletsError } from './WorkletsError';
-const _workletStackDetails = new Map();
-export function registerWorkletStackDetails(hash, stackDetails) {
-  _workletStackDetails.set(hash, stackDetails);
-}
-function getBundleOffset(error) {
-  const frame = error.stack?.split('\n')?.[0];
-  if (frame) {
-    const parsedFrame = /@([^@]+):(\d+):(\d+)/.exec(frame);
-    if (parsedFrame) {
-      const [, file, line, col] = parsedFrame;
-      return [file, Number(line), Number(col)];
-    }
-  }
-  return ['unknown', 0, 0];
-}
-function processStack(stack) {
-  if (stack === '' || stack === undefined) {
-    return undefined;
-  }
-  const workletStackEntries = stack.match(/worklet_(\d+):(\d+):(\d+)/g);
-  let result = stack;
-  workletStackEntries?.forEach(match => {
-    const [, hash, origLine, origCol] = match.split(/:|_/).map(Number);
-    const errorDetails = _workletStackDetails.get(hash);
-    if (!errorDetails) {
-      return;
-    }
-    const [error, lineOffset, colOffset] = errorDetails;
-    const [bundleFile, bundleLine, bundleCol] = getBundleOffset(error);
-    const line = origLine + bundleLine + lineOffset;
-    const col = origCol + bundleCol + colOffset;
-    result = result.replace(match, `${bundleFile}:${line}:${col}`);
-  });
-  return result;
-}
-/**
- * Remote error is an error coming from a Worklet Runtime that we bubble up to
- * the RN Runtime.
- */
-export function reportFatalRemoteError({
-  message,
-  stack,
-  name,
-  jsEngine
-}, force) {
-  const error = new WorkletsError();
-  error.message = message;
-  error.stack = processStack(stack);
-  error.name = name;
-  error.jsEngine = jsEngine;
-  if (force) {
-    throw error;
-  } else {
-    // @ts-expect-error React Native's `ErrorUtils` are hidden from the global scope.
-    globalThis.ErrorUtils.reportFatalError(error);
-  }
-}
-
-/**
- * Registers `reportFatalRemoteError` function in global scope to allow to
- * invoke it from C++.
- */
-export function registerReportFatalRemoteError() {
-  globalThis.__reportFatalRemoteError = reportFatalRemoteError;
-}
-//# sourceMappingURL=errors.js.map

package/lib/module/featureFlags/index.js

@@ -1,48 +0,0 @@
-'use strict';
-
-import { logger } from '../logger';
-import { WorkletsModule } from '../WorkletsModule';
-export const DynamicFlags = {
-  EXAMPLE_DYNAMIC_FLAG: true,
-  init() {
-    Object.keys(DynamicFlags).forEach(key => {
-      if (key !== 'init' && key !== 'setFlag') {
-        WorkletsModule.setDynamicFeatureFlag(key, DynamicFlags[key]);
-      }
-    });
-  },
-  setFlag(name, value) {
-    if (name in DynamicFlags) {
-      DynamicFlags[name] = value;
-      WorkletsModule.setDynamicFeatureFlag(name, value);
-    } else {
-      logger.warn(`The feature flag: '${name}' no longer exists, you can safely remove invocation of \`setDynamicFeatureFlag('${name}')\` from your code.`);
-    }
-  }
-};
-DynamicFlags.init();
-// Public API function to update a feature flag
-export function setDynamicFeatureFlag(name, value) {
-  DynamicFlags.setFlag(name, value);
-}
-
-/**
- * This constant is needed for typechecking and preserving static typechecks in
- * generated .d.ts files. Without it, the static flags resolve to an object
- * without specific keys.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const DefaultStaticFeatureFlags = {
-  RUNTIME_TEST_FLAG: false,
-  IOS_DYNAMIC_FRAMERATE_ENABLED: false
-};
-const staticFeatureFlags = {};
-export function getStaticFeatureFlag(name) {
-  if (name in staticFeatureFlags) {
-    return staticFeatureFlags[name];
-  }
-  const featureFlagValue = WorkletsModule.getStaticFeatureFlag(name);
-  staticFeatureFlags[name] = featureFlagValue;
-  return featureFlagValue;
-}
-//# sourceMappingURL=index.js.map

package/lib/module/initializers.js

@@ -1,221 +0,0 @@
-'use strict';
-
-import { bundleValueUnpacker } from './bundleUnpacker';
-import { setupCallGuard } from './callGuard';
-import { registerReportFatalRemoteError } from './errors';
-import { IS_JEST, SHOULD_BE_USE_WEB } from './PlatformChecker';
-import { setupSetImmediate } from './runLoop/common/setImmediatePolyfill';
-import { setupSetInterval } from './runLoop/common/setIntervalPolyfill';
-import { mockedRequestAnimationFrame } from './runLoop/uiRuntime/mockedRequestAnimationFrame';
-import { setupRequestAnimationFrame } from './runLoop/uiRuntime/requestAnimationFrame';
-import { setupSetTimeout } from './runLoop/uiRuntime/setTimeoutPolyfill';
-import { RuntimeKind } from './runtimeKind';
-import { __installUnpacker as installSynchronizableUnpacker } from './synchronizableUnpacker';
-import { executeOnUIRuntimeSync, runOnJS, setupMicrotasks } from './threads';
-import { isWorkletFunction } from './workletFunction';
-import { registerWorkletsError, WorkletsError } from './WorkletsError';
-import { WorkletsModule } from './WorkletsModule';
-let capturableConsole;
-
-/**
- * Currently there seems to be a bug in the JSI layer which causes a crash when
- * we try to copy some of the console methods, i.e. `clear` or `dirxml`.
- *
- * The crash happens only in React Native 0.75. It's not reproducible in neither
- * 0.76 nor 0.74. It also happens only in the configuration of a debug app and
- * production bundle.
- *
- * I haven't yet discovered what exactly causes the crash. It's tied to the
- * console methods sometimes being `HostFunction`s. Therefore, as a workaround
- * we don't copy the methods as they are in the original console object, we copy
- * JavaScript wrappers instead.
- */
-export function getMemorySafeCapturableConsole() {
-  if (capturableConsole) {
-    return capturableConsole;
-  }
-  const consoleCopy = Object.fromEntries(Object.entries(console).map(([methodName, method]) => {
-    const methodWrapper = function methodWrapper(...args) {
-      return method(...args);
-    };
-    if (method.name) {
-      /**
-       * Set the original method name as the wrapper name if available.
-       *
-       * It might be unnecessary but if we want to fully mimic the console
-       * object we should take into the account the fact some code might rely
-       * on the method name.
-       */
-      Object.defineProperty(methodWrapper, 'name', {
-        value: method.name,
-        writable: false
-      });
-    }
-    return [methodName, methodWrapper];
-  }));
-  capturableConsole = consoleCopy;
-  return consoleCopy;
-}
-export function setupConsole(boundCapturableConsole) {
-  'worklet';
-
-  // @ts-ignore TypeScript doesn't like that there are missing methods in console object, but we don't provide all the methods for the UI runtime console version
-  globalThis.console = {
-    assert: runOnJS(boundCapturableConsole.assert),
-    debug: runOnJS(boundCapturableConsole.debug),
-    log: runOnJS(boundCapturableConsole.log),
-    warn: runOnJS(boundCapturableConsole.warn),
-    error: runOnJS(boundCapturableConsole.error),
-    info: runOnJS(boundCapturableConsole.info)
-  };
-}
-let initialized = false;
-export function init() {
-  if (initialized) {
-    return;
-  }
-  initialized = true;
-  if (globalThis.__RUNTIME_KIND === undefined) {
-    // The only runtime that doesn't have `__RUNTIME_KIND` preconfigured
-    // is the RN Runtime. We must set it as soon as possible.
-    globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
-  }
-  initializeRuntime();
-  if (SHOULD_BE_USE_WEB) {
-    initializeRuntimeOnWeb();
-  }
-  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
-    initializeWorkletRuntime();
-  } else {
-    initializeRNRuntime();
-    if (!SHOULD_BE_USE_WEB) {
-      installRNBindingsOnUIRuntime();
-    }
-  }
-}
-
-/** A function that should be run on any kind of runtime. */
-function initializeRuntime() {
-  if (globalThis._WORKLETS_BUNDLE_MODE) {
-    globalThis.__valueUnpacker = bundleValueUnpacker;
-  }
-  installSynchronizableUnpacker();
-}
-
-/** A function that should be run only on React Native runtime. */
-function initializeRNRuntime() {
-  if (__DEV__) {
-    const testWorklet = () => {
-      'worklet';
-    };
-    if (!isWorkletFunction(testWorklet)) {
-      throw new WorkletsError(`Failed to create a worklet. See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#failed-to-create-a-worklet for more details.`);
-    }
-  }
-  registerReportFatalRemoteError();
-}
-
-/** A function that should be run only on Worklet runtimes. */
-function initializeWorkletRuntime() {
-  if (globalThis._WORKLETS_BUNDLE_MODE) {
-    setupCallGuard();
-    if (__DEV__) {
-      /*
-       * Temporary workaround for Metro bundler. We must implement a dummy
-       * Refresh module to prevent Metro from throwing irrelevant errors.
-       */
-      const Refresh = new Proxy({}, {
-        get() {
-          return () => {};
-        }
-      });
-      globalThis.__r.Refresh = Refresh;
-
-      /* Gracefully handle unwanted imports from React Native. */
-      // @ts-expect-error type not exposed by Metro
-      const modules = require.getModules();
-      // @ts-expect-error type not exposed by Metro
-      const ReactNativeModuleId = require.resolveWeak('react-native');
-      const factory = function (_global, _require, _importDefault, _importAll, module, _exports, _dependencyMap) {
-        module.exports = new Proxy({}, {
-          get: function get(_target, prop) {
-            globalThis.console.warn(`You tried to import '${String(prop)}' from 'react-native' module on a Worklet Runtime. Using 'react-native' module on a Worklet Runtime is not allowed.`);
-            return {
-              get() {
-                return undefined;
-              }
-            };
-          }
-        });
-      };
-      const mod = {
-        dependencyMap: [],
-        factory,
-        hasError: false,
-        importedAll: {},
-        importedDefault: {},
-        isInitialized: false,
-        publicModule: {
-          exports: {}
-        }
-      };
-      modules.set(ReactNativeModuleId, mod);
-    }
-  }
-}
-
-/** A function that should be run only on RN Runtime in web implementation. */
-function initializeRuntimeOnWeb() {
-  globalThis._WORKLET = false;
-  globalThis._log = console.log;
-  globalThis._getAnimationTimestamp = () => performance.now();
-  if (IS_JEST) {
-    // requestAnimationFrame react-native jest's setup is incorrect as it polyfills
-    // the method directly using setTimeout, therefore the callback doesn't get the
-    // expected timestamp as the only argument: https://github.com/facebook/react-native/blob/main/packages/react-native/jest/setup.js#L28
-    // We override this setup here to make sure that callbacks get the proper timestamps
-    // when executed. For non-jest environments we define requestAnimationFrame in setupRequestAnimationFrame
-    // @ts-ignore TypeScript uses Node definition for rAF, setTimeout, etc which returns a Timeout object rather than a number
-    globalThis.requestAnimationFrame = mockedRequestAnimationFrame;
-  }
-}
-
-/**
- * A function that should be run on the RN Runtime to configure the UI Runtime
- * with callback bindings.
- */
-function installRNBindingsOnUIRuntime() {
-  if (!WorkletsModule) {
-    throw new WorkletsError('Worklets are trying to initialize the UI runtime without a valid WorkletsModule');
-  }
-  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
-  if (!globalThis._WORKLETS_BUNDLE_MODE) {
-    /** In bundle mode Runtimes setup their callGuard themselves. */
-    executeOnUIRuntimeSync(setupCallGuard)();
-
-    /**
-     * Register WorkletsError in the UI runtime global scope. (we are using
-     * `executeOnUIRuntimeSync` here to make sure that the changes are applied
-     * before any async operations are executed on the UI runtime).
-     *
-     * There's no need to register the error in bundle mode.
-     */
-    executeOnUIRuntimeSync(registerWorkletsError)();
-  }
-  executeOnUIRuntimeSync(() => {
-    'worklet';
-
-    setupConsole(runtimeBoundCapturableConsole);
-    /**
-     * TODO: Move `setupMicrotasks` and `setupRequestAnimationFrame` to a
-     * separate function once we have a better way to distinguish between
-     * Worklet Runtimes.
-     */
-    setupMicrotasks();
-    setupRequestAnimationFrame();
-    setupSetTimeout();
-    setupSetImmediate();
-    setupSetInterval();
-  })();
-}
-//# sourceMappingURL=initializers.js.map

package/lib/module/isSynchronizable.js

@@ -1,6 +0,0 @@
-'use strict';
-
-export function isSynchronizable(value) {
-  return typeof value === 'object' && value !== null && '__synchronizableRef' in value && value.__synchronizableRef === true;
-}
-//# sourceMappingURL=isSynchronizable.js.map

package/lib/module/logger.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const PREFIX = '[Worklets]';
-function formatMessage(message) {
-  return `${PREFIX} ${message}`;
-}
-export const logger = {
-  warn(message) {
-    console.warn(formatMessage(message));
-  },
-  error(message) {
-    console.error(formatMessage(message));
-  }
-};
-//# sourceMappingURL=logger.js.map

package/lib/module/privateGlobals.d.js

@@ -1,7 +0,0 @@
-/* eslint-disable reanimated/use-global-this */
-'use strict';
-
-// This file works by accident - currently Builder Bob doesn't move `.d.ts` files to output types.
-// If it ever breaks, we should address it so we'd not pollute the user's global namespace.
-export {};
-//# sourceMappingURL=privateGlobals.d.js.map

package/lib/module/publicGlobals.js

@@ -1,6 +0,0 @@
-'use strict';
-
-/* eslint-disable reanimated/use-global-this */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export {};
-//# sourceMappingURL=publicGlobals.js.map

package/lib/module/runLoop/common/setImmediatePolyfill.js

@@ -1,15 +0,0 @@
-'use strict';
-
-export function setupSetImmediate() {
-  'worklet';
-
-  const setImmediatePolyfill = (callback, ...args) => {
-    return setTimeout(callback, 0, ...args);
-  };
-  const clearImmediatePolyfill = immediateHandle => {
-    clearTimeout(immediateHandle);
-  };
-  globalThis.setImmediate = setImmediatePolyfill;
-  globalThis.clearImmediate = clearImmediatePolyfill;
-}
-//# sourceMappingURL=setImmediatePolyfill.js.map

package/lib/module/runLoop/common/setIntervalPolyfill.js

@@ -1,26 +0,0 @@
-'use strict';
-
-export function setupSetInterval() {
-  'worklet';
-
-  const intervalHandleToTimeoutHandle = new Map();
-  const setIntervalPolyfill = (callback, delay = 0, ...args) => {
-    let intervalHandle = 0;
-    const repeatingCallback = () => {
-      const timeoutHandle = setTimeout(repeatingCallback, delay);
-      intervalHandleToTimeoutHandle.set(intervalHandle, timeoutHandle);
-      callback(...args);
-    };
-    intervalHandle = setTimeout(repeatingCallback, delay);
-    intervalHandleToTimeoutHandle.set(intervalHandle, intervalHandle);
-    return intervalHandle;
-  };
-  const clearIntervalPolyfill = intervalHandle => {
-    const timeoutHandle = intervalHandleToTimeoutHandle.get(intervalHandle);
-    clearTimeout(timeoutHandle);
-    intervalHandleToTimeoutHandle.delete(intervalHandle);
-  };
-  globalThis.setInterval = setIntervalPolyfill;
-  globalThis.clearInterval = clearIntervalPolyfill;
-}
-//# sourceMappingURL=setIntervalPolyfill.js.map

package/lib/module/runLoop/uiRuntime/mockedRequestAnimationFrame.js

@@ -1,10 +0,0 @@
-'use strict';
-
-/**
- * This is Jest implementation of `requestAnimationFrame` that is required by
- * React Native for test purposes.
- */
-export function mockedRequestAnimationFrame(callback) {
-  return setTimeout(() => callback(performance.now()), 0);
-}
-//# sourceMappingURL=mockedRequestAnimationFrame.js.map

package/lib/module/runLoop/uiRuntime/requestAnimationFrame.js

@@ -1,52 +0,0 @@
-'use strict';
-
-import { callMicrotasks } from '../../threads';
-export function setupRequestAnimationFrame() {
-  'worklet';
-
-  const nativeRequestAnimationFrame = globalThis.requestAnimationFrame;
-  let queuedCallbacks = [];
-  let queuedCallbacksBegin = 0;
-  let queuedCallbacksEnd = 0;
-  let flushedCallbacks = queuedCallbacks;
-  let flushedCallbacksBegin = 0;
-  let flushedCallbacksEnd = 0;
-  let flushRequested = false;
-  globalThis.__flushAnimationFrame = timestamp => {
-    flushedCallbacks = queuedCallbacks;
-    queuedCallbacks = [];
-    flushedCallbacksBegin = queuedCallbacksBegin;
-    flushedCallbacksEnd = queuedCallbacksEnd;
-    queuedCallbacksBegin = queuedCallbacksEnd;
-    for (const callback of flushedCallbacks) {
-      callback(timestamp);
-    }
-    flushedCallbacksBegin = flushedCallbacksEnd;
-    callMicrotasks();
-  };
-  globalThis.requestAnimationFrame = callback => {
-    const handle = queuedCallbacksEnd++;
-    queuedCallbacks.push(callback);
-    if (!flushRequested) {
-      flushRequested = true;
-      nativeRequestAnimationFrame(timestamp => {
-        flushRequested = false;
-        globalThis.__frameTimestamp = timestamp;
-        globalThis.__flushAnimationFrame(timestamp);
-        globalThis.__frameTimestamp = undefined;
-      });
-    }
-    return handle;
-  };
-  globalThis.cancelAnimationFrame = handle => {
-    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
-      return;
-    }
-    if (handle < flushedCallbacksEnd) {
-      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
-    } else {
-      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
-    }
-  };
-}
-//# sourceMappingURL=requestAnimationFrame.js.map

package/lib/module/runLoop/uiRuntime/setTimeoutPolyfill.js

@@ -1,32 +0,0 @@
-'use strict';
-
-export function setupSetTimeout() {
-  'worklet';
-
-  const timeoutHandleToRafHandle = new Map();
-  const setTimeoutPolyfill = (callback, delay = 0, ...args) => {
-    const start = performance.now();
-    let timeoutHandle = 0;
-    const rafCallback = () => {
-      const now = performance.now();
-      if (now - start >= delay) {
-        callback(...args);
-        timeoutHandleToRafHandle.delete(timeoutHandle);
-      } else {
-        const rafHandle = requestAnimationFrame(rafCallback);
-        timeoutHandleToRafHandle.set(timeoutHandle, rafHandle);
-      }
-    };
-    timeoutHandle = requestAnimationFrame(rafCallback);
-    timeoutHandleToRafHandle.set(timeoutHandle, timeoutHandle);
-    return timeoutHandle;
-  };
-  const clearTimeoutPolyfill = timeoutHandle => {
-    const rafHandle = timeoutHandleToRafHandle.get(timeoutHandle);
-    timeoutHandleToRafHandle.delete(timeoutHandle);
-    cancelAnimationFrame(rafHandle);
-  };
-  globalThis.setTimeout = setTimeoutPolyfill;
-  globalThis.clearTimeout = clearTimeoutPolyfill;
-}
-//# sourceMappingURL=setTimeoutPolyfill.js.map

package/lib/module/runLoop/workletRuntime/index.js

@@ -1,19 +0,0 @@
-'use strict';
-
-import { setupSetImmediate } from '../common/setImmediatePolyfill';
-import { setupSetInterval } from '../common/setIntervalPolyfill';
-import { setupQueueMicrotask } from './queueMicrotask';
-import { setupRequestAnimationFrame } from './requestAnimationFramePolyfill';
-import { setupSetTimeout } from './setTimeout';
-import { setupTaskQueue } from './taskQueue';
-export function setupRunLoop(animationQueuePollingRate) {
-  'worklet';
-
-  setupTaskQueue();
-  setupQueueMicrotask();
-  setupSetTimeout();
-  setupRequestAnimationFrame(animationQueuePollingRate);
-  setupSetImmediate();
-  setupSetInterval();
-}
-//# sourceMappingURL=index.js.map

package/lib/module/runLoop/workletRuntime/queueMicrotask.js

@@ -1,11 +0,0 @@
-'use strict';
-
-import { pushMicrotask } from './taskQueue';
-export function setupQueueMicrotask() {
-  'worklet';
-
-  globalThis.queueMicrotask = function (callback, ...args) {
-    pushMicrotask(() => callback(...args));
-  };
-}
-//# sourceMappingURL=queueMicrotask.js.map

package/lib/module/runLoop/workletRuntime/requestAnimationFramePolyfill.js

@@ -1,48 +0,0 @@
-'use strict';
-
-export function setupRequestAnimationFrame(animationQueuePollingRate) {
-  'worklet';
-
-  const timeoutInterval = animationQueuePollingRate;
-  let queuedCallbacks = [];
-  let queuedCallbacksBegin = 0;
-  let queuedCallbacksEnd = 0;
-  let flushedCallbacks = queuedCallbacks;
-  let flushedCallbacksBegin = 0;
-  let flushedCallbacksEnd = 0;
-  let flushRequested = false;
-  function flushAnimationFrame() {
-    flushRequested = false;
-    const timestamp = performance.now();
-    flushedCallbacks = queuedCallbacks;
-    queuedCallbacks = [];
-    flushedCallbacksBegin = queuedCallbacksBegin;
-    flushedCallbacksEnd = queuedCallbacksEnd;
-    queuedCallbacksBegin = queuedCallbacksEnd;
-    for (const callback of flushedCallbacks) {
-      callback(timestamp);
-      globalThis.__flushMicrotasks();
-    }
-    flushedCallbacksBegin = flushedCallbacksEnd;
-  }
-  globalThis.requestAnimationFrame = callback => {
-    const handle = queuedCallbacksEnd++;
-    queuedCallbacks.push(callback);
-    if (!flushRequested) {
-      flushRequested = true;
-      setTimeout(flushAnimationFrame, timeoutInterval);
-    }
-    return handle;
-  };
-  globalThis.cancelAnimationFrame = handle => {
-    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
-      return;
-    }
-    if (handle < flushedCallbacksEnd) {
-      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
-    } else {
-      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
-    }
-  };
-}
-//# sourceMappingURL=requestAnimationFramePolyfill.js.map

package/lib/module/runLoop/workletRuntime/setTimeout.js

@@ -1,28 +0,0 @@
-'use strict';
-
-import { pushTask } from './taskQueue';
-export function setupSetTimeout() {
-  'worklet';
-
-  const pendingHandlers = new Set();
-  let ID = 0;
-  const setTimeoutPolyfill = (callback, delay = 0, ...args) => {
-    const handlerId = ID++;
-    const timeoutCallback = () => {
-      if (!pendingHandlers.has(handlerId)) {
-        return;
-      }
-      callback(...args);
-      pendingHandlers.delete(handlerId);
-    };
-    pendingHandlers.add(handlerId);
-    pushTask(timeoutCallback, handlerId, delay);
-    return handlerId;
-  };
-  const clearTimeoutPolyfill = timeoutHandle => {
-    pendingHandlers.delete(timeoutHandle);
-  };
-  globalThis.setTimeout = setTimeoutPolyfill;
-  globalThis.clearTimeout = clearTimeoutPolyfill;
-}
-//# sourceMappingURL=setTimeout.js.map

package/lib/module/runLoop/workletRuntime/taskQueue.js

@@ -1,37 +0,0 @@
-'use strict';
-
-export function setupTaskQueue() {
-  'worklet';
-
-  const queue = {
-    microtasks: [],
-    timeoutCallbacks: new Map()
-  };
-  globalThis._taskQueue = queue;
-  globalThis.__runTimeoutCallback = function (handlerId) {
-    const task = queue.timeoutCallbacks.get(handlerId);
-    task?.();
-    queue.timeoutCallbacks.delete(handlerId);
-    globalThis.__flushMicrotasks();
-  };
-  globalThis.__flushMicrotasks = function () {
-    for (let i = 0; i < queue.microtasks.length; i++) {
-      queue.microtasks[i]();
-    }
-    queue.microtasks = [];
-  };
-}
-export function pushMicrotask(callback) {
-  'worklet';
-
-  const queue = globalThis._taskQueue;
-  queue.microtasks.push(callback);
-}
-export function pushTask(callback, handlerId, delay) {
-  'worklet';
-
-  const queue = globalThis._taskQueue;
-  queue.timeoutCallbacks.set(handlerId, callback);
-  globalThis._scheduleTimeoutCallback(delay, handlerId);
-}
-//# sourceMappingURL=taskQueue.js.map