@amazon-devices/react-native-worklets 1.0.0-rn-83

package/lib/module/specs/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+import { RuntimeKind } from '../runtimeKind';
+import RNWorkletsTurboModule from './NativeWorkletsModule';
+export const WorkletsTurboModule = globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative ? RNWorkletsTurboModule :
+// In Bundle Mode, on Worklet Runtimes `RNWorkletsTurboModule` isn't
+// available and shouldn't be accessed. We return null here
+// to keep the same codebase for the Bundle Mode and legacy behavior.
+null;
+//# sourceMappingURL=index.js.map

package/lib/module/specs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RuntimeKind","RNWorkletsTurboModule","WorkletsTurboModule","globalThis","__RUNTIME_KIND","ReactNative"],"sourceRoot":"../../../src","sources":["specs/index.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,WAAW,QAAQ,gBAAgB;AAE5C,OAAOC,qBAAqB,MAAM,wBAAwB;AAE1D,OAAO,MAAMC,mBAAgC,GAC3CC,UAAU,CAACC,cAAc,KAAKJ,WAAW,CAACK,WAAW,GACjDJ,qBAAqB;AACrB;AACA;AACA;AACA,IAAI","ignoreList":[]}

package/lib/module/synchronizable.js

@@ -0,0 +1,9 @@
+'use strict';
+
+import { createSerializable } from './serializable';
+import { WorkletsModule } from './WorkletsModule';
+export function createSynchronizable(initialValue) {
+  const synchronizableRef = WorkletsModule.createSynchronizable(createSerializable(initialValue));
+  return globalThis.__synchronizableUnpacker(synchronizableRef);
+}
+//# sourceMappingURL=synchronizable.js.map

package/lib/module/synchronizable.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createSerializable","WorkletsModule","createSynchronizable","initialValue","synchronizableRef","globalThis","__synchronizableUnpacker"],"sourceRoot":"../../src","sources":["synchronizable.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,kBAAkB,QAAQ,gBAAgB;AACnD,SAASC,cAAc,QAAQ,kBAAkB;AAGjD,OAAO,SAASC,oBAAoBA,CAClCC,YAAoB,EACI;EACxB,MAAMC,iBAAiB,GAAGH,cAAc,CAACC,oBAAoB,CAC3DF,kBAAkB,CAACG,YAAY,CACjC,CAAC;EAED,OAAOE,UAAU,CAACC,wBAAwB,CACxCF,iBACF,CAAC;AACH","ignoreList":[]}

package/lib/module/synchronizableUnpacker.js

@@ -0,0 +1,42 @@
+'use strict';
+
+import { createSerializable } from './serializable';
+export function __installUnpacker() {
+  // TODO: Add cache for synchronizables.
+  const serializer = !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE ? (value, _) => createSerializable(value) : globalThis._createSerializable;
+  function synchronizableUnpacker(synchronizableRef) {
+    const synchronizable = synchronizableRef;
+    const proxy = globalThis.__workletsModuleProxy;
+    synchronizable.__synchronizableRef = true;
+    synchronizable.getDirty = () => {
+      return proxy.synchronizableGetDirty(synchronizable);
+    };
+    synchronizable.getBlocking = () => {
+      return proxy.synchronizableGetBlocking(synchronizable);
+    };
+    synchronizable.setBlocking = valueOrFunction => {
+      let newValue;
+      if (typeof valueOrFunction === 'function') {
+        const func = valueOrFunction;
+        synchronizable.lock();
+        const prev = synchronizable.getBlocking();
+        newValue = func(prev);
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, undefined));
+        synchronizable.unlock();
+      } else {
+        const value = valueOrFunction;
+        newValue = value;
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, undefined));
+      }
+    };
+    synchronizable.lock = () => {
+      proxy.synchronizableLock(synchronizable);
+    };
+    synchronizable.unlock = () => {
+      proxy.synchronizableUnlock(synchronizable);
+    };
+    return synchronizable;
+  }
+  globalThis.__synchronizableUnpacker = synchronizableUnpacker;
+}
+//# sourceMappingURL=synchronizableUnpacker.js.map

package/lib/module/synchronizableUnpacker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createSerializable","__installUnpacker","serializer","globalThis","_WORKLET","_WORKLETS_BUNDLE_MODE","value","_","_createSerializable","synchronizableUnpacker","synchronizableRef","synchronizable","proxy","__workletsModuleProxy","__synchronizableRef","getDirty","synchronizableGetDirty","getBlocking","synchronizableGetBlocking","setBlocking","valueOrFunction","newValue","func","lock","prev","synchronizableSetBlocking","undefined","unlock","synchronizableLock","synchronizableUnlock","__synchronizableUnpacker"],"sourceRoot":"../../src","sources":["synchronizableUnpacker.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,kBAAkB,QAAQ,gBAAgB;AAGnD,OAAO,SAASC,iBAAiBA,CAAA,EAAG;EAClC;EACA,MAAMC,UAAU,GACd,CAACC,UAAU,CAACC,QAAQ,IAAID,UAAU,CAACE,qBAAqB,GACpD,CAACC,KAAc,EAAEC,CAAU,KAAKP,kBAAkB,CAACM,KAAK,CAAC,GACzDH,UAAU,CAACK,mBAAmB;EAEpC,SAASC,sBAAsBA,CAC7BC,iBAA4C,EACpB;IACxB,MAAMC,cAAc,GAClBD,iBAAsD;IACxD,MAAME,KAAK,GAAGT,UAAU,CAACU,qBAAsB;IAE/CF,cAAc,CAACG,mBAAmB,GAAG,IAAI;IACzCH,cAAc,CAACI,QAAQ,GAAG,MAAM;MAC9B,OAAOH,KAAK,CAACI,sBAAsB,CAACL,cAAc,CAAC;IACrD,CAAC;IACDA,cAAc,CAACM,WAAW,GAAG,MAAM;MACjC,OAAOL,KAAK,CAACM,yBAAyB,CAACP,cAAc,CAAC;IACxD,CAAC;IACDA,cAAc,CAACQ,WAAW,GACxBC,eAAoD,IACjD;MACH,IAAIC,QAAgB;MACpB,IAAI,OAAOD,eAAe,KAAK,UAAU,EAAE;QACzC,MAAME,IAAI,GAAGF,eAA2C;QACxDT,cAAc,CAACY,IAAI,CAAC,CAAC;QACrB,MAAMC,IAAI,GAAGb,cAAc,CAACM,WAAW,CAAC,CAAC;QACzCI,QAAQ,GAAGC,IAAI,CAACE,IAAI,CAAC;QAErBZ,KAAK,CAACa,yBAAyB,CAC7Bd,cAAc,EACdT,UAAU,CAACmB,QAAQ,EAAEK,SAAS,CAChC,CAAC;QAEDf,cAAc,CAACgB,MAAM,CAAC,CAAC;MACzB,CAAC,MAAM;QACL,MAAMrB,KAAK,GAAGc,eAAe;QAC7BC,QAAQ,GAAGf,KAAK;QAChBM,KAAK,CAACa,yBAAyB,CAC7Bd,cAAc,EACdT,UAAU,CAACmB,QAAQ,EAAEK,SAAS,CAChC,CAAC;MACH;IACF,CAAC;IACDf,cAAc,CAACY,IAAI,GAAG,MAAM;MAC1BX,KAAK,CAACgB,kBAAkB,CAACjB,cAAc,CAAC;IAC1C,CAAC;IACDA,cAAc,CAACgB,MAAM,GAAG,MAAM;MAC5Bf,KAAK,CAACiB,oBAAoB,CAAClB,cAAc,CAAC;IAC5C,CAAC;IAED,OAAOA,cAAc;EACvB;EAEAR,UAAU,CAAC2B,wBAAwB,GAAGrB,sBAAsB;AAC9D","ignoreList":[]}

package/lib/module/threads.js

@@ -0,0 +1,347 @@
+'use strict';
+
+import { IS_JEST, SHOULD_BE_USE_WEB } from './PlatformChecker';
+import { RuntimeKind } from './runtimeKind';
+import { createSerializable, makeShareableCloneOnUIRecursive } from './serializable';
+import { serializableMappingCache } from './serializableMappingCache';
+import { isWorkletFunction } from './workletFunction';
+import { WorkletsError } from './WorkletsError';
+import { WorkletsModule } from './WorkletsModule';
+let runOnUIQueue = [];
+export function setupMicrotasks() {
+  'worklet';
+
+  let microtasksQueue = [];
+  let isExecutingMicrotasksQueue = false;
+  global.queueMicrotask = callback => {
+    microtasksQueue.push(callback);
+  };
+  global._microtaskQueueFinalizers = [];
+  global.__callMicrotasks = () => {
+    if (isExecutingMicrotasksQueue) {
+      return;
+    }
+    try {
+      isExecutingMicrotasksQueue = true;
+      for (let index = 0; index < microtasksQueue.length; index += 1) {
+        // we use classic 'for' loop because the size of the currentTasks array may change while executing some of the callbacks due to queueMicrotask calls
+        microtasksQueue[index]();
+      }
+      microtasksQueue = [];
+      global._microtaskQueueFinalizers.forEach(finalizer => finalizer());
+    } finally {
+      isExecutingMicrotasksQueue = false;
+    }
+  };
+}
+function callMicrotasksOnUIThread() {
+  'worklet';
+
+  global.__callMicrotasks();
+}
+export const callMicrotasks = SHOULD_BE_USE_WEB ? () => {
+  // on web flushing is a noop as immediates are handled by the browser
+} : callMicrotasksOnUIThread;
+
+/**
+ * Lets you schedule a function to be executed on the [UI
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime).
+ *
+ * - The callback executes asynchronously and doesn't return a value.
+ * - Passed function and args are automatically
+ *   [workletized](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#to-workletize)
+ *   and serialized.
+ * - This function cannot be called from the [UI
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime)
+ *   or [Worker
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#worker-worklet-runtime---worker-runtime),
+ *   unless you have the [Bundle Mode](/docs/experimental/bundleMode) enabled.
+ *
+ * @param fun - A reference to a function you want to schedule on the [UI
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime).
+ * @param args - Arguments to pass to the function.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/threading/scheduleOnUI
+ */
+export function scheduleOnUI(worklet, ...args) {
+  runOnUI(worklet)(...args);
+}
+
+/**
+ * Lets you asynchronously run
+ * [workletized](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#to-workletize)
+ * functions on the [UI
+ * thread](https://docs.swmansion.com/react-native-worklets/docs/threading/runOnUI/).
+ *
+ * This method does not schedule the work immediately but instead waits for
+ * other worklets to be scheduled within the same JS loop. It uses
+ * queueMicrotask to schedule all the worklets at once making sure they will run
+ * within the same frame boundaries on the UI thread.
+ *
+ * @param fun - A reference to a function you want to execute on the [UI
+ *   thread](https://docs.swmansion.com/react-native-worklets/docs/threading/runOnUI/)
+ *   from the [JavaScript
+ *   thread](https://docs.swmansion.com/react-native-worklets/docs/threading/runOnUI/).
+ * @returns A function that accepts arguments for the function passed as the
+ *   first argument.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/threading/runOnUI @deprecated Use `scheduleOnUI` instead.
+ */
+// @ts-expect-error This overload is correct since it's what user sees in his code
+// before it's transformed by Reanimated Babel plugin.
+
+export function runOnUI(worklet) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorkletFunction(worklet) && !worklet.__bundleData) {
+    throw new WorkletsError('`runOnUI` can only be used with worklets.');
+  }
+  return (...args) => {
+    if (IS_JEST) {
+      // Mocking time in Jest is tricky as both requestAnimationFrame and queueMicrotask
+      // callbacks run on the same queue and can be interleaved. There is no way
+      // to flush particular queue in Jest and the only control over mocked timers
+      // is by using jest.advanceTimersByTime() method which advances all types
+      // of timers including immediate and animation callbacks. Ideally we'd like
+      // to have some way here to schedule work along with React updates, but
+      // that's not possible, and hence in Jest environment instead of using scheduling
+      // mechanism we just schedule the work ommiting the queue. This is ok for the
+      // uses that we currently have but may not be ok for future tests that we write.
+      WorkletsModule.scheduleOnUI(createSerializable(() => {
+        'worklet';
+
+        worklet(...args);
+      }));
+      return;
+    }
+    if (__DEV__) {
+      // in DEV mode we call serializable conversion here because in case the object
+      // can't be converted, we will get a meaningful stack-trace as opposed to the
+      // situation when conversion is only done via microtask queue. This does not
+      // make the app particularily less efficient as converted objects are cached
+      // and for a given worklet the conversion only happens once.
+      createSerializable(worklet);
+      createSerializable(args);
+    }
+    enqueueUI(worklet, args);
+  };
+}
+if (__DEV__) {
+  function runOnUIWorklet() {
+    'worklet';
+
+    throw new WorkletsError('`runOnUI` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.');
+  }
+  const serializableRunOnUIWorklet = createSerializable(runOnUIWorklet);
+  serializableMappingCache.set(runOnUI, serializableRunOnUIWorklet);
+}
+
+/**
+ * Lets you run a function synchronously on the [UI
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime)
+ * from the [RN
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#react-native-runtime-rn-runtime).
+ * Passed function and args are automatically
+ * [workletized](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#to-workletize)
+ * and serialized.
+ *
+ * - This function cannot be called from the [UI
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime).
+ * - This function cannot be called from a [Worker
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#worker-worklet-runtime---worker-runtime).
+ *
+ * @param fun - A reference to a function you want to execute on the [UI
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime).
+ * @param args - Arguments to pass to the function.
+ * @returns The return value of the function passed as the first argument.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/threading/runOnUISync
+ */
+export function runOnUISync(worklet, ...args) {
+  return executeOnUIRuntimeSync(worklet)(...args);
+}
+
+// @ts-expect-error Check `executeOnUIRuntimeSync` overload above.
+
+export function executeOnUIRuntimeSync(worklet) {
+  return (...args) => {
+    return WorkletsModule.executeOnUIRuntimeSync(createSerializable(() => {
+      'worklet';
+
+      const result = worklet(...args);
+      return makeShareableCloneOnUIRecursive(result);
+    }));
+  };
+}
+function runWorkletOnJS(worklet, ...args) {
+  // remote function that calls a worklet synchronously on the JS runtime
+  worklet(...args);
+}
+
+/**
+ * Lets you asynchronously run
+ * non-[workletized](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#to-workletize)
+ * functions that couldn't otherwise run on the [UI
+ * thread](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-thread).
+ * This applies to most external libraries as they don't have their functions
+ * marked with "worklet"; directive.
+ *
+ * @param fun - A reference to a function you want to execute on the JavaScript
+ *   thread from the UI thread.
+ * @returns A function that accepts arguments for the function passed as the
+ *   first argument.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/threading/runOnJS
+ */
+/** @deprecated Use `scheduleOnRN` instead. */
+export function runOnJS(fun) {
+  'worklet';
+
+  if (SHOULD_BE_USE_WEB || globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative) {
+    // if we are already on the JS thread, we just schedule the worklet on the JS queue
+    return (...args) => queueMicrotask(args.length ? () => fun(...args) : fun);
+  }
+  if (isWorkletFunction(fun)) {
+    // If `fun` is a worklet, we schedule a call of a remote function `runWorkletOnJS`
+    // and pass the worklet as a first argument followed by original arguments.
+
+    return (...args) => runOnJS(runWorkletOnJS)(fun, ...args);
+  }
+  if (fun.__remoteFunction) {
+    // In development mode the function provided as `fun` throws an error message
+    // such that when someone accidentally calls it directly on the UI runtime, they
+    // see that they should use `runOnJS` instead. To facilitate that we put the
+    // reference to the original remote function in the `__remoteFunction` property.
+    fun = fun.__remoteFunction;
+  }
+  const scheduleOnJS = typeof fun === 'function' ? global._scheduleHostFunctionOnJS : global._scheduleRemoteFunctionOnJS;
+  return (...args) => {
+    scheduleOnJS(fun, args.length > 0 ? makeShareableCloneOnUIRecursive(args) : undefined);
+  };
+}
+
+/**
+ * Lets you schedule a function to be executed on the RN runtime from any
+ * runtime. Check
+ * {@link https://docs.swmansion.com/react-native-worklets/docs/fundamentals/runtimeKinds}
+ * for more information about the different runtime kinds.
+ *
+ * Scheduling function from the RN Runtime (we are already on RN Runtime) simply
+ * uses `queueMicrotask`.
+ *
+ * When functions need to be scheduled from the UI Runtime, first function and
+ * args are serialized and then the system passes the scheduling responsibility
+ * to the JSScheduler. The JSScheduler then uses the RN CallInvoker to schedule
+ * the function asynchronously on the JavaScript thread by calling
+ * `jsCallInvoker_->invokeAsync()`.
+ *
+ * When called from a Worker Runtime, it uses the same JSScheduler mechanism.
+ *
+ * @param fun - A function you want to schedule on the RN runtime. A function
+ *   can be a worklet, a remote function or a regular function.
+ * @param args - Arguments to pass to the function.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/threading/scheduleOnRN
+ */
+export function scheduleOnRN(fun, ...args) {
+  'worklet';
+
+  runOnJS(fun)(...args);
+}
+
+/**
+ * Lets you asynchronously run
+ * [workletized](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#to-workletize)
+ * functions on the [UI
+ * Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime).
+ *
+ * This method does not schedule the work immediately but instead waits for
+ * other worklets to be scheduled within the same JS loop. It uses
+ * queueMicrotask to schedule all the worklets at once making sure they will run
+ * within the same frame boundaries on the UI thread.
+ *
+ * @param fun - A reference to a function you want to execute on the [UI
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#ui-runtime).
+ *   from the [JavaScript
+ *   Runtime](https://docs.swmansion.com/react-native-worklets/docs/fundamentals/glossary#javascript-runtime).
+ * @returns A promise that resolves to the return value of the function passed
+ *   as the first argument.
+ * @see https://docs.swmansion.com/react-native-worklets/docs/threading/runOnUIAsync
+ */
+export function runOnUIAsync(worklet) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorkletFunction(worklet)) {
+    throw new WorkletsError('`runOnUIAsync` can only be used with worklets.');
+  }
+  return (...args) => {
+    return new Promise(resolve => {
+      if (IS_JEST) {
+        // Mocking time in Jest is tricky as both requestAnimationFrame and queueMicrotask
+        // callbacks run on the same queue and can be interleaved. There is no way
+        // to flush particular queue in Jest and the only control over mocked timers
+        // is by using jest.advanceTimersByTime() method which advances all types
+        // of timers including immediate and animation callbacks. Ideally we'd like
+        // to have some way here to schedule work along with React updates, but
+        // that's not possible, and hence in Jest environment instead of using scheduling
+        // mechanism we just schedule the work ommiting the queue. This is ok for the
+        // uses that we currently have but may not be ok for future tests that we write.
+        WorkletsModule.scheduleOnUI(createSerializable(() => {
+          'worklet';
+
+          worklet(...args);
+        }));
+        return;
+      }
+      if (__DEV__) {
+        // in DEV mode we call serializable conversion here because in case the object
+        // can't be converted, we will get a meaningful stack-trace as opposed to the
+        // situation when conversion is only done via microtask queue. This does not
+        // make the app particularily less efficient as converted objects are cached
+        // and for a given worklet the conversion only happens once.
+        createSerializable(worklet);
+        createSerializable(args);
+      }
+      enqueueUI(worklet, args, resolve);
+    });
+  };
+}
+if (__DEV__) {
+  function runOnUIAsyncWorklet() {
+    'worklet';
+
+    throw new WorkletsError('`runOnUIAsync` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.');
+  }
+  const serializableRunOnUIAsyncWorklet = createSerializable(runOnUIAsyncWorklet);
+  serializableMappingCache.set(runOnUIAsync, serializableRunOnUIAsyncWorklet);
+}
+function enqueueUI(worklet, args, resolve) {
+  const job = [worklet, args, resolve];
+  runOnUIQueue.push(job);
+  if (runOnUIQueue.length === 1) {
+    flushUIQueue();
+  }
+}
+function flushUIQueue() {
+  queueMicrotask(() => {
+    const queue = runOnUIQueue;
+    runOnUIQueue = [];
+    WorkletsModule.scheduleOnUI(createSerializable(() => {
+      'worklet';
+
+      queue.forEach(([workletFunction, workletArgs, jobResolve]) => {
+        const result = workletFunction(...workletArgs);
+        if (jobResolve) {
+          runOnJS(jobResolve)(result);
+        }
+      });
+      callMicrotasks();
+    }));
+  });
+}
+
+/**
+ * Added temporarily for integration with `react-native-audio-api`. Don't depend
+ * on this API as it may change without notice.
+ */
+// eslint-disable-next-line camelcase
+export function unstable_eventLoopTask(worklet) {
+  return (...args) => {
+    'worklet';
+
+    worklet(...args);
+    callMicrotasks();
+  };
+}
+//# sourceMappingURL=threads.js.map

package/lib/module/threads.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IS_JEST","SHOULD_BE_USE_WEB","RuntimeKind","createSerializable","makeShareableCloneOnUIRecursive","serializableMappingCache","isWorkletFunction","WorkletsError","WorkletsModule","runOnUIQueue","setupMicrotasks","microtasksQueue","isExecutingMicrotasksQueue","global","queueMicrotask","callback","push","_microtaskQueueFinalizers","__callMicrotasks","index","length","forEach","finalizer","callMicrotasksOnUIThread","callMicrotasks","scheduleOnUI","worklet","args","runOnUI","__DEV__","__bundleData","enqueueUI","runOnUIWorklet","serializableRunOnUIWorklet","set","runOnUISync","executeOnUIRuntimeSync","result","runWorkletOnJS","runOnJS","fun","globalThis","__RUNTIME_KIND","ReactNative","__remoteFunction","scheduleOnJS","_scheduleHostFunctionOnJS","_scheduleRemoteFunctionOnJS","undefined","scheduleOnRN","runOnUIAsync","Promise","resolve","runOnUIAsyncWorklet","serializableRunOnUIAsyncWorklet","job","flushUIQueue","queue","workletFunction","workletArgs","jobResolve","unstable_eventLoopTask"],"sourceRoot":"../../src","sources":["threads.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/utils/checkCppVersion.js

@@ -0,0 +1,30 @@
+'use strict';
+
+import { logger } from '../logger';
+import { WorkletsError } from '../WorkletsError';
+import { jsVersion } from './jsVersion';
+export function checkCppVersion() {
+  const cppVersion = global._WORKLETS_VERSION_CPP;
+  if (cppVersion === undefined) {
+    logger.warn(`Couldn't determine the version of the native part of Worklets.
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#couldnt-determine-the-version-of-the-native-part-of-worklets\` for more details.`);
+    return;
+  }
+  const ok = matchVersion(jsVersion, cppVersion);
+  if (!ok) {
+    throw new WorkletsError(`Mismatch between JavaScript part and native part of Worklets (${jsVersion} vs ${cppVersion}).
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#mismatch-between-javascript-part-and-native-part-of-worklets\` for more details.`);
+  }
+}
+export function matchVersion(version1, version2) {
+  if (version1.match(/^\d+\.\d+\.\d+$/) && version2.match(/^\d+\.\d+\.\d+$/)) {
+    // x.y.z, compare only major and minor, skip patch
+    const [major1, minor1] = version1.split('.');
+    const [major2, minor2] = version2.split('.');
+    return major1 === major2 && minor1 === minor2;
+  } else {
+    // alpha, beta or rc, compare everything
+    return version1 === version2;
+  }
+}
+//# sourceMappingURL=checkCppVersion.js.map

package/lib/module/utils/checkCppVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["logger","WorkletsError","jsVersion","checkCppVersion","cppVersion","global","_WORKLETS_VERSION_CPP","undefined","warn","ok","matchVersion","version1","version2","match","major1","minor1","split","major2","minor2"],"sourceRoot":"../../../src","sources":["utils/checkCppVersion.ts"],"mappings":"AAAA,YAAY;;AACZ,SAASA,MAAM,QAAQ,WAAW;AAClC,SAASC,aAAa,QAAQ,kBAAkB;AAChD,SAASC,SAAS,QAAQ,aAAa;AAEvC,OAAO,SAASC,eAAeA,CAAA,EAAG;EAChC,MAAMC,UAAU,GAAGC,MAAM,CAACC,qBAAqB;EAC/C,IAAIF,UAAU,KAAKG,SAAS,EAAE;IAC5BP,MAAM,CAACQ,IAAI,CACT;AACN,wKACI,CAAC;IACD;EACF;EACA,MAAMC,EAAE,GAAGC,YAAY,CAACR,SAAS,EAAEE,UAAU,CAAC;EAC9C,IAAI,CAACK,EAAE,EAAE;IACP,MAAM,IAAIR,aAAa,CACrB,iEAAiEC,SAAS,OAAOE,UAAU;AACjG,wKACI,CAAC;EACH;AACF;AAEA,OAAO,SAASM,YAAYA,CAACC,QAAgB,EAAEC,QAAgB,EAAE;EAC/D,IAAID,QAAQ,CAACE,KAAK,CAAC,iBAAiB,CAAC,IAAID,QAAQ,CAACC,KAAK,CAAC,iBAAiB,CAAC,EAAE;IAC1E;IACA,MAAM,CAACC,MAAM,EAAEC,MAAM,CAAC,GAAGJ,QAAQ,CAACK,KAAK,CAAC,GAAG,CAAC;IAC5C,MAAM,CAACC,MAAM,EAAEC,MAAM,CAAC,GAAGN,QAAQ,CAACI,KAAK,CAAC,GAAG,CAAC;IAC5C,OAAOF,MAAM,KAAKG,MAAM,IAAIF,MAAM,KAAKG,MAAM;EAC/C,CAAC,MAAM;IACL;IACA,OAAOP,QAAQ,KAAKC,QAAQ;EAC9B;AACF","ignoreList":[]}

package/lib/module/utils/jsVersion.js

@@ -0,0 +1,9 @@
+'use strict';
+
+/**
+ * We hardcode the version of Worklets here in order to compare it with the
+ * version used to build the native part of the library in runtime. Remember to
+ * keep this in sync with the version declared in `package.json`
+ */
+export const jsVersion = '1.0.0+0.6.0';
+//# sourceMappingURL=jsVersion.js.map

package/lib/module/utils/jsVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["jsVersion"],"sourceRoot":"../../../src","sources":["utils/jsVersion.ts"],"mappings":"AAAA,YAAY;;AACZ;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,SAAS,GAAG,aAAa","ignoreList":[]}

package/lib/module/valueUnpacker.js

@@ -0,0 +1,60 @@
+'use strict';
+
+function __installUnpacker() {
+  const workletsCache = new Map();
+  const handleCache = new WeakMap();
+  function valueUnpacker(objectToUnpack, category, remoteFunctionName) {
+    'use strict';
+
+    const workletHash = objectToUnpack.__workletHash;
+    if (workletHash !== undefined) {
+      let workletFun = workletsCache.get(workletHash);
+      if (workletFun === undefined) {
+        const initData = objectToUnpack.__initData;
+        if (globalThis.evalWithSourceMap) {
+          // if the runtime (hermes only for now) supports loading source maps
+          // we want to use the proper filename for the location as it guarantees
+          // that debugger understands and loads the source code of the file where
+          // the worklet is defined.
+          workletFun = globalThis.evalWithSourceMap('(' + initData.code + '\n)', initData.location, initData.sourceMap);
+        } else if (globalThis.evalWithSourceUrl) {
+          // if the runtime doesn't support loading source maps, in dev mode we
+          // can pass source url when evaluating the worklet. Now, instead of using
+          // the actual file location we use worklet hash, as it the allows us to
+          // properly symbolicate traces (see errors.ts for details)
+          workletFun = globalThis.evalWithSourceUrl('(' + initData.code + '\n)', `worklet_${workletHash}`);
+        } else {
+          // in release we use the regular eval to save on JSI calls
+          // eslint-disable-next-line no-eval
+          workletFun = eval('(' + initData.code + '\n)');
+        }
+        workletsCache.set(workletHash, workletFun);
+      }
+      const functionInstance = workletFun.bind(objectToUnpack);
+      objectToUnpack._recur = functionInstance;
+      return functionInstance;
+    } else if (objectToUnpack.__init !== undefined) {
+      let value = handleCache.get(objectToUnpack);
+      if (value === undefined) {
+        value = objectToUnpack.__init();
+        handleCache.set(objectToUnpack, value);
+      }
+      return value;
+    } else if (category === 'RemoteFunction') {
+      const fun = () => {
+        const label = remoteFunctionName ? `function \`${remoteFunctionName}\`` : 'anonymous function';
+        // eslint-disable-next-line reanimated/use-worklets-error
+        throw new Error(`[Worklets] Tried to synchronously call a non-worklet ${label} on the UI thread.
+See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-synchronously-call-a-non-worklet-function-on-the-ui-thread for more details.`);
+      };
+      fun.__remoteFunction = objectToUnpack;
+      return fun;
+    } else {
+      // eslint-disable-next-line reanimated/use-worklets-error
+      throw new Error(`[Worklets] Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(objectToUnpack)}".`);
+    }
+  }
+  globalThis.__valueUnpacker = valueUnpacker;
+}
+export {};
+//# sourceMappingURL=valueUnpacker.js.map

package/lib/module/valueUnpacker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__installUnpacker","workletsCache","Map","handleCache","WeakMap","valueUnpacker","objectToUnpack","category","remoteFunctionName","workletHash","__workletHash","undefined","workletFun","get","initData","__initData","globalThis","evalWithSourceMap","code","location","sourceMap","evalWithSourceUrl","eval","set","functionInstance","bind","_recur","__init","value","fun","label","Error","__remoteFunction","_toString","__valueUnpacker"],"sourceRoot":"../../src","sources":["valueUnpacker.ts"],"mappings":"AAAA,YAAY;;AAYZ,SAASA,iBAAiBA,CAAA,EAAG;EAC3B,MAAMC,aAAa,GAAG,IAAIC,GAAG,CAAwB,CAAC;EACtD,MAAMC,WAAW,GAAG,IAAIC,OAAO,CAAkB,CAAC;EAElD,SAASC,aAAaA,CACpBC,cAA8B,EAC9BC,QAAiB,EACjBC,kBAA2B,EAClB;IACT,YAAY;;IACZ,MAAMC,WAAW,GAAGH,cAAc,CAACI,aAAa;IAChD,IAAID,WAAW,KAAKE,SAAS,EAAE;MAC7B,IAAIC,UAAU,GAAGX,aAAa,CAACY,GAAG,CAACJ,WAAW,CAAC;MAC/C,IAAIG,UAAU,KAAKD,SAAS,EAAE;QAC5B,MAAMG,QAAQ,GAAGR,cAAc,CAACS,UAAU;QAC1C,IAAIC,UAAU,CAACC,iBAAiB,EAAE;UAChC;UACA;UACA;UACA;UACAL,UAAU,GAAGI,UAAU,CAACC,iBAAiB,CACvC,GAAG,GAAGH,QAAQ,CAAEI,IAAI,GAAG,KAAK,EAC5BJ,QAAQ,CAAEK,QAAQ,EAClBL,QAAQ,CAAEM,SACZ,CAAC;QACH,CAAC,MAAM,IAAIJ,UAAU,CAACK,iBAAiB,EAAE;UACvC;UACA;UACA;UACA;UACAT,UAAU,GAAGI,UAAU,CAACK,iBAAiB,CACvC,GAAG,GAAGP,QAAQ,CAAEI,IAAI,GAAG,KAAK,EAC5B,WAAWT,WAAW,EACxB,CAAC;QACH,CAAC,MAAM;UACL;UACA;UACAG,UAAU,GAAGU,IAAI,CAAC,GAAG,GAAGR,QAAQ,CAAEI,IAAI,GAAG,KAAK,CAAC;QACjD;QACAjB,aAAa,CAACsB,GAAG,CAACd,WAAW,EAAEG,UAAW,CAAC;MAC7C;MACA,MAAMY,gBAAgB,GAAGZ,UAAU,CAAEa,IAAI,CAACnB,cAAc,CAAC;MACzDA,cAAc,CAACoB,MAAM,GAAGF,gBAAgB;MACxC,OAAOA,gBAAgB;IACzB,CAAC,MAAM,IAAIlB,cAAc,CAACqB,MAAM,KAAKhB,SAAS,EAAE;MAC9C,IAAIiB,KAAK,GAAGzB,WAAW,CAACU,GAAG,CAACP,cAAc,CAAC;MAC3C,IAAIsB,KAAK,KAAKjB,SAAS,EAAE;QACvBiB,KAAK,GAAGtB,cAAc,CAACqB,MAAM,CAAC,CAAC;QAC/BxB,WAAW,CAACoB,GAAG,CAACjB,cAAc,EAAEsB,KAAK,CAAC;MACxC;MACA,OAAOA,KAAK;IACd,CAAC,MAAM,IAAIrB,QAAQ,KAAK,gBAAgB,EAAE;MACxC,MAAMsB,GAAG,GAAGA,CAAA,KAAM;QAChB,MAAMC,KAAK,GAAGtB,kBAAkB,GAC5B,cAAcA,kBAAkB,IAAI,GACpC,oBAAoB;QACxB;QACA,MAAM,IAAIuB,KAAK,CAAC,wDAAwDD,KAAK;AACrF,yKAAyK,CAAC;MACpK,CAAC;MACDD,GAAG,CAACG,gBAAgB,GAAG1B,cAAc;MACrC,OAAOuB,GAAG;IACZ,CAAC,MAAM;MACL;MACA,MAAM,IAAIE,KAAK,CACb,qCAAqCxB,QAAQ,wCAAwCS,UAAU,CAACiB,SAAS,CACvG3B,cACF,CAAC,IACH,CAAC;IACH;EACF;EAEAU,UAAU,CAACkB,eAAe,GAAG7B,aAA8B;AAC7D;AAAC","ignoreList":[]}

package/lib/module/workletFunction.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * This function allows you to determine if a given function is a worklet. It
+ * only works with Reanimated Babel plugin enabled. Unless you are doing
+ * something with internals of Reanimated you shouldn't need to use this
+ * function.
+ *
+ * ### Note
+ *
+ * Do not call it before the worklet is declared, as it will always return false
+ * then. E.g.:
+ *
+ * ```ts
+ * isWorkletFunction(myWorklet); // Will always return false.
+ *
+ * function myWorklet() {
+ *   'worklet';
+ * }
+ * ```
+ *
+ * ### Maintainer note
+ *
+ * This function is supposed to be used only in the React Runtime. It always
+ * returns `false` in Worklet Runtimes.
+ */
+export function isWorkletFunction(value) {
+  'worklet';
+
+  // Since host objects always return true for `in` operator, we have to use dot notation to check if the property exists.
+  // See https://github.com/facebook/hermes/blob/340726ef8cf666a7cce75bc60b02fa56b3e54560/lib/VM/JSObject.cpp#L1276.
+  return (
+    // `__workletHash` isn't extracted in Worklet Runtimes.
+    typeof value === 'function' && !!value.__workletHash
+  );
+}
+//# sourceMappingURL=workletFunction.js.map

package/lib/module/workletFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isWorkletFunction","value","__workletHash"],"sourceRoot":"../../src","sources":["workletFunction.ts"],"mappings":"AAAA,YAAY;;AAIZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,iBAAiBA,CAG/BC,KAAc,EAA+C;EAC7D,SAAS;;EACT;EACA;EAEA;IACE;IACA,OAAOA,KAAK,KAAK,UAAU,IAC3B,CAAC,CAAEA,KAAK,CAAwCC;EAAa;AAEjE","ignoreList":[]}

package/lib/module/workletRuntimeEntry.js

@@ -0,0 +1,32 @@
+'use strict';
+
+import { init } from './initializers';
+import { SHOULD_BE_USE_WEB } from './PlatformChecker';
+import { RuntimeKind } from './runtimeKind';
+import { WorkletsError } from './WorkletsError';
+
+/**
+ * This function is an entry point for Worklet Runtimes. We can use it to setup
+ * necessary tools, like the ValueUnpacker.
+ *
+ * We must throw an error at the end of this function to prevent the bundle to
+ * continue executing. This is because the next module to be ran would be the
+ * React Native one, and it would break the Worklet Runtime if initialized. The
+ * error is caught in C++ code.
+ *
+ * This function has no effect on the RN Runtime beside setting the
+ * `_WORKLETS_BUNDLE_MODE` flag.
+ */
+export function bundleModeInit() {
+  globalThis._WORKLETS_BUNDLE_MODE = true;
+  if (!SHOULD_BE_USE_WEB && globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    /**
+     * We shouldn't call `init()` on RN Runtime here, as it would initialize our
+     * module before React Native has configured the RN Runtime.
+     */
+    init();
+    throw new WorkletsError('Worklets initialized successfully');
+  }
+}
+bundleModeInit();
+//# sourceMappingURL=workletRuntimeEntry.js.map

package/lib/module/workletRuntimeEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["init","SHOULD_BE_USE_WEB","RuntimeKind","WorkletsError","bundleModeInit","globalThis","_WORKLETS_BUNDLE_MODE","__RUNTIME_KIND","ReactNative"],"sourceRoot":"../../src","sources":["workletRuntimeEntry.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,IAAI,QAAQ,gBAAgB;AACrC,SAASC,iBAAiB,QAAQ,mBAAmB;AACrD,SAASC,WAAW,QAAQ,eAAe;AAC3C,SAASC,aAAa,QAAQ,iBAAiB;;AAE/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAAA,EAAG;EAC/BC,UAAU,CAACC,qBAAqB,GAAG,IAAI;EACvC,IACE,CAACL,iBAAiB,IAClBI,UAAU,CAACE,cAAc,KAAKL,WAAW,CAACM,WAAW,EACrD;IACA;AACJ;AACA;AACA;IACIR,IAAI,CAAC,CAAC;IACN,MAAM,IAAIG,aAAa,CAAC,mCAAmC,CAAC;EAC9D;AACF;AAEAC,cAAc,CAAC,CAAC","ignoreList":[]}

package/lib/module/workletTypes.js

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * The below type is used for HostObjects returned by the JSI API that don't
+ * have any accessible fields or methods but can carry data that is accessed
+ * from the c++ side. We add a field to the type to make it possible for
+ * typescript to recognize which JSI methods accept those types as arguments and
+ * to be able to correctly type check other methods that may use them. However,
+ * this field is not actually defined nor should be used for anything else as
+ * assigning any data to those objects will throw an error.
+ */
+//# sourceMappingURL=workletTypes.js.map