react-native-worklets 0.0.1-alpha → 0.1.0

package/lib/module/logger/logger.js

@@ -0,0 +1,137 @@
+'use strict';
+
+import { addLogBoxLog } from "./LogBox.js";
+const DOCS_URL = 'https://docs.swmansion.com/react-native-reanimated/docs/debugging/logger-configuration';
+const DOCS_REFERENCE = `If you don't want to see this message, you can disable the \`strict\` mode. Refer to:\n${DOCS_URL} for more details.`;
+export let LogLevel = /*#__PURE__*/function (LogLevel) {
+  LogLevel[LogLevel["warn"] = 1] = "warn";
+  LogLevel[LogLevel["error"] = 2] = "error";
+  return LogLevel;
+}({});
+function logToConsole(data) {
+  'worklet';
+
+  switch (data.level) {
+    case 'warn':
+      console.warn(data.message.content);
+      break;
+    case 'error':
+    case 'fatal':
+    case 'syntax':
+      console.error(data.message.content);
+      break;
+  }
+}
+export const DEFAULT_LOGGER_CONFIG = {
+  logFunction: logToConsole,
+  level: LogLevel.warn,
+  strict: true
+};
+function formatMessage(message) {
+  'worklet';
+
+  return `[Worklets] ${message}`;
+}
+function createLog(level, message) {
+  'worklet';
+
+  const formattedMessage = formatMessage(message);
+  return {
+    level,
+    message: {
+      content: formattedMessage,
+      substitutions: []
+    },
+    category: formattedMessage,
+    componentStack: [],
+    componentStackType: null,
+    // eslint-disable-next-line reanimated/use-worklets-error
+    stack: new Error().stack
+  };
+}
+
+/**
+ * Function that logs to LogBox and console. Used to replace the default console
+ * logging with logging to LogBox on the UI thread when runOnJS is available.
+ *
+ * @param data - The details of the log.
+ */
+export function logToLogBoxAndConsole(data) {
+  addLogBoxLog(data);
+  logToConsole(data);
+}
+
+/**
+ * Registers the logger configuration. use it only for Worklet runtimes.
+ *
+ * @param config - The config to register.
+ */
+export function registerLoggerConfig(config) {
+  'worklet';
+
+  global.__workletsLoggerConfig = config;
+}
+
+/**
+ * Replaces the default log function with a custom implementation.
+ *
+ * @param logFunction - The custom log function.
+ */
+export function replaceLoggerImplementation(logFunction) {
+  'worklet';
+
+  registerLoggerConfig({
+    ...global.__workletsLoggerConfig,
+    logFunction
+  });
+}
+
+/**
+ * Updates logger configuration.
+ *
+ * @param options - The new logger configuration to apply.
+ *
+ *   - Level: The minimum log level to display.
+ *   - Strict: Whether to log warnings and errors that are not strict. Defaults to
+ *       false.
+ */
+export function updateLoggerConfig(options) {
+  'worklet';
+
+  registerLoggerConfig({
+    ...global.__workletsLoggerConfig,
+    // Don't reuse previous level and strict values from the global config
+    level: options?.level ?? DEFAULT_LOGGER_CONFIG.level,
+    strict: options?.strict ?? DEFAULT_LOGGER_CONFIG.strict
+  });
+}
+function handleLog(level, message, options) {
+  'worklet';
+
+  const config = global.__workletsLoggerConfig;
+  if (
+  // Don't log if the log is marked as strict-only and the config doesn't
+  // enable strict logging
+  options.strict && !config.strict ||
+  // Don't log if the log level is below the minimum configured level
+  LogLevel[level] < config.level) {
+    return;
+  }
+  if (options.strict) {
+    message += `\n\n${DOCS_REFERENCE}`;
+  }
+  config.logFunction(createLog(level, message));
+}
+export const logger = {
+  warn(message, options = {}) {
+    'worklet';
+
+    handleLog('warn', message, options);
+  },
+  error(message, options = {}) {
+    'worklet';
+
+    handleLog('error', message, options);
+  }
+};
+//# sourceMappingURL=logger.js.map

package/lib/module/logger/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["addLogBoxLog","DOCS_URL","DOCS_REFERENCE","LogLevel","logToConsole","data","level","console","warn","message","content","error","DEFAULT_LOGGER_CONFIG","logFunction","strict","formatMessage","createLog","formattedMessage","substitutions","category","componentStack","componentStackType","stack","Error","logToLogBoxAndConsole","registerLoggerConfig","config","global","__workletsLoggerConfig","replaceLoggerImplementation","updateLoggerConfig","options","handleLog","logger"],"sourceRoot":"../../../src","sources":["logger/logger.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/privateGlobals.d.js

@@ -0,0 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-var */
+'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/privateGlobals.d.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["privateGlobals.d.ts"],"mappings":"AAAA;AACA;AACA,YAAY;;AAEZ;AACA;AAAA","ignoreList":[]}

package/lib/module/runtimes.js

@@ -0,0 +1,63 @@
+'use strict';
+
+import { setupCallGuard, setupConsole } from "./initializers.js";
+import { registerLoggerConfig } from "./logger/index.js";
+import { shouldBeUseWeb } from "./PlatformChecker.js";
+import { makeShareableCloneOnUIRecursive, makeShareableCloneRecursive } from "./shareables.js";
+import { isWorkletFunction } from "./workletFunction.js";
+import { registerWorkletsError, WorkletsError } from "./WorkletsError.js";
+import { WorkletsModule } from "./WorkletsModule/index.js";
+const SHOULD_BE_USE_WEB = shouldBeUseWeb();
+
+/**
+ * Lets you create a new JS runtime which can be used to run worklets possibly
+ * on different threads than JS or UI thread.
+ *
+ * @param name - A name used to identify the runtime which will appear in
+ *   devices list in Chrome DevTools.
+ * @param initializer - An optional worklet that will be run synchronously on
+ *   the same thread immediately after the runtime is created.
+ * @returns WorkletRuntime which is a
+ *   `jsi::HostObject<worklets::WorkletRuntime>` - {@link WorkletRuntime}
+ * @see https://docs.swmansion.com/react-native-reanimated/docs/threading/createWorkletRuntime
+ */
+// @ts-expect-error Check `runOnUI` overload.
+
+export function createWorkletRuntime(name, initializer) {
+  // Assign to a different variable as __workletsLoggerConfig is not a captured
+  // identifier in the Worklet runtime.
+  const config = __workletsLoggerConfig;
+  return WorkletsModule.createWorkletRuntime(name, makeShareableCloneRecursive(() => {
+    'worklet';
+
+    registerWorkletsError();
+    registerLoggerConfig(config);
+    setupCallGuard();
+    setupConsole();
+    initializer?.();
+  }));
+}
+
+// @ts-expect-error Check `runOnUI` overload.
+
+/** Schedule a worklet to execute on the background queue. */
+export function runOnRuntime(workletRuntime, worklet) {
+  'worklet';
+
+  if (__DEV__ && !SHOULD_BE_USE_WEB && !isWorkletFunction(worklet)) {
+    throw new WorkletsError('The function passed to `runOnRuntime` is not a worklet.' + (_WORKLET ? ' Please make sure that `processNestedWorklets` option in Reanimated Babel plugin is enabled.' : ''));
+  }
+  if (_WORKLET) {
+    return (...args) => global._scheduleOnRuntime(workletRuntime, makeShareableCloneOnUIRecursive(() => {
+      'worklet';
+
+      worklet(...args);
+    }));
+  }
+  return (...args) => WorkletsModule.scheduleOnRuntime(workletRuntime, makeShareableCloneRecursive(() => {
+    'worklet';
+
+    worklet(...args);
+  }));
+}
+//# sourceMappingURL=runtimes.js.map

package/lib/module/runtimes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["setupCallGuard","setupConsole","registerLoggerConfig","shouldBeUseWeb","makeShareableCloneOnUIRecursive","makeShareableCloneRecursive","isWorkletFunction","registerWorkletsError","WorkletsError","WorkletsModule","SHOULD_BE_USE_WEB","createWorkletRuntime","name","initializer","config","__workletsLoggerConfig","runOnRuntime","workletRuntime","worklet","__DEV__","_WORKLET","args","global","_scheduleOnRuntime","scheduleOnRuntime"],"sourceRoot":"../../src","sources":["runtimes.ts"],"mappings":"AAAA,YAAY;;AAEZ,SAASA,cAAc,EAAEC,YAAY,QAAQ,mBAAgB;AAC7D,SAASC,oBAAoB,QAAQ,mBAAU;AAC/C,SAASC,cAAc,QAAQ,sBAAmB;AAClD,SACEC,+BAA+B,EAC/BC,2BAA2B,QACtB,iBAAc;AACrB,SAASC,iBAAiB,QAAQ,sBAAmB;AACrD,SAASC,qBAAqB,EAAEC,aAAa,QAAQ,oBAAiB;AACtE,SAASC,cAAc,QAAQ,2BAAkB;AAGjD,MAAMC,iBAAiB,GAAGP,cAAc,CAAC,CAAC;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMA,OAAO,SAASQ,oBAAoBA,CAClCC,IAAY,EACZC,WAAuC,EACvB;EAChB;EACA;EACA,MAAMC,MAAM,GAAGC,sBAAsB;EACrC,OAAON,cAAc,CAACE,oBAAoB,CACxCC,IAAI,EACJP,2BAA2B,CAAC,MAAM;IAChC,SAAS;;IACTE,qBAAqB,CAAC,CAAC;IACvBL,oBAAoB,CAACY,MAAM,CAAC;IAC5Bd,cAAc,CAAC,CAAC;IAChBC,YAAY,CAAC,CAAC;IACdY,WAAW,GAAG,CAAC;EACjB,CAAC,CACH,CAAC;AACH;;AAEA;;AAKA;AACA,OAAO,SAASG,YAAYA,CAC1BC,cAA8B,EAC9BC,OAA2C,EAClB;EACzB,SAAS;;EACT,IAAIC,OAAO,IAAI,CAACT,iBAAiB,IAAI,CAACJ,iBAAiB,CAACY,OAAO,CAAC,EAAE;IAChE,MAAM,IAAIV,aAAa,CACrB,yDAAyD,IACtDY,QAAQ,GACL,8FAA8F,GAC9F,EAAE,CACV,CAAC;EACH;EACA,IAAIA,QAAQ,EAAE;IACZ,OAAO,CAAC,GAAGC,IAAI,KACbC,MAAM,CAACC,kBAAkB,CACvBN,cAAc,EACdb,+BAA+B,CAAC,MAAM;MACpC,SAAS;;MACTc,OAAO,CAAC,GAAGG,IAAI,CAAC;IAClB,CAAC,CACH,CAAC;EACL;EACA,OAAO,CAAC,GAAGA,IAAI,KACbZ,cAAc,CAACe,iBAAiB,CAC9BP,cAAc,EACdZ,2BAA2B,CAAC,MAAM;IAChC,SAAS;;IACTa,OAAO,CAAC,GAAGG,IAAI,CAAC;EAClB,CAAC,CACH,CAAC;AACL","ignoreList":[]}

package/lib/module/shareableMappingCache.js

@@ -0,0 +1,39 @@
+'use strict';
+
+import { shouldBeUseWeb } from "./PlatformChecker.js";
+const SHOULD_BE_USE_WEB = shouldBeUseWeb();
+
+/**
+ * This symbol is used to represent a mapping from the value to itself.
+ *
+ * It's used to prevent converting a shareable that's already converted - for
+ * example a Shared Value that's in worklet's closure.
+ */
+export const shareableMappingFlag = Symbol('shareable flag');
+
+/*
+During a fast refresh, React holds the same instance of a Mutable
+(that's guaranteed by `useRef`) but `shareableCache` gets regenerated and thus
+becoming empty. This happens when editing the file that contains the definition of this cache.
+
+Because of it, `makeShareableCloneRecursive` can't find given mapping
+in `shareableCache` for the Mutable and tries to clone it as if it was a regular JS object.
+During cloning we use `Object.entries` to iterate over the keys which throws an error on accessing `_value`.
+For convenience we moved this cache to a separate file so it doesn't scare us with red squiggles.
+*/
+
+const cache = SHOULD_BE_USE_WEB ? null : new WeakMap();
+export const shareableMappingCache = SHOULD_BE_USE_WEB ? {
+  set() {
+    // NOOP
+  },
+  get() {
+    return null;
+  }
+} : {
+  set(shareable, shareableRef) {
+    cache.set(shareable, shareableRef || shareableMappingFlag);
+  },
+  get: cache.get.bind(cache)
+};
+//# sourceMappingURL=shareableMappingCache.js.map

package/lib/module/shareableMappingCache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["shouldBeUseWeb","SHOULD_BE_USE_WEB","shareableMappingFlag","Symbol","cache","WeakMap","shareableMappingCache","set","get","shareable","shareableRef","bind"],"sourceRoot":"../../src","sources":["shareableMappingCache.ts"],"mappings":"AAAA,YAAY;;AACZ,SAASA,cAAc,QAAQ,sBAAmB;AAGlD,MAAMC,iBAAiB,GAAGD,cAAc,CAAC,CAAC;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAME,oBAAoB,GAAGC,MAAM,CAAC,gBAAgB,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,MAAMC,KAAK,GAAGH,iBAAiB,GAC3B,IAAI,GACJ,IAAII,OAAO,CAAgC,CAAC;AAEhD,OAAO,MAAMC,qBAAqB,GAAGL,iBAAiB,GAClD;EACEM,GAAGA,CAAA,EAAG;IACJ;EAAA,CACD;EACDC,GAAGA,CAAA,EAAG;IACJ,OAAO,IAAI;EACb;AACF,CAAC,GACD;EACED,GAAGA,CAACE,SAAiB,EAAEC,YAA2B,EAAQ;IACxDN,KAAK,CAAEG,GAAG,CAACE,SAAS,EAAEC,YAAY,IAAIR,oBAAoB,CAAC;EAC7D,CAAC;EACDM,GAAG,EAAEJ,KAAK,CAAEI,GAAG,CAACG,IAAI,CAACP,KAAK;AAC5B,CAAC","ignoreList":[]}

package/lib/module/shareables.js

@@ -0,0 +1,417 @@
+'use strict';
+
+import { registerWorkletStackDetails } from "./errors.js";
+import { logger } from "./logger/index.js";
+import { shouldBeUseWeb } from "./PlatformChecker.js";
+import { shareableMappingCache, shareableMappingFlag } from "./shareableMappingCache.js";
+import { isWorkletFunction } from "./workletFunction.js";
+import { WorkletsError } from "./WorkletsError.js";
+import { WorkletsModule } from "./WorkletsModule/index.js";
+// for web/chrome debugger/jest environments this file provides a stub implementation
+// where no shareable references are used. Instead, the objects themselves are used
+// instead of shareable references, because of the fact that we don't have to deal with
+// running the code on separate VMs.
+const SHOULD_BE_USE_WEB = shouldBeUseWeb();
+const MAGIC_KEY = 'REANIMATED_MAGIC_KEY';
+function isHostObject(value) {
+  'worklet';
+
+  // We could use JSI to determine whether an object is a host object, however
+  // the below workaround works well and is way faster than an additional JSI call.
+  // We use the fact that host objects have broken implementation of `hasOwnProperty`
+  // and hence return true for all `in` checks regardless of the key we ask for.
+  return MAGIC_KEY in value;
+}
+function isPlainJSObject(object) {
+  return Object.getPrototypeOf(object) === Object.prototype;
+}
+function getFromCache(value) {
+  const cached = shareableMappingCache.get(value);
+  if (cached === shareableMappingFlag) {
+    // This means that `value` was already a clone and we should return it as is.
+    return value;
+  }
+  return cached;
+}
+
+// The below object is used as a replacement for objects that cannot be transferred
+// as shareable values. In makeShareableCloneRecursive we detect if an object is of
+// a plain Object.prototype and only allow such objects to be transferred. This lets
+// us avoid all sorts of react internals from leaking into the UI runtime. To make it
+// possible to catch errors when someone actually tries to access such object on the UI
+// runtime, we use the below Proxy object which is instantiated on the UI runtime and
+// throws whenever someone tries to access its fields.
+const INACCESSIBLE_OBJECT = {
+  __init: () => {
+    'worklet';
+
+    return new Proxy({}, {
+      get: (_, prop) => {
+        if (prop === '_isReanimatedSharedValue' || prop === '__remoteFunction') {
+          // not very happy about this check here, but we need to allow for
+          // "inaccessible" objects to be tested with isSharedValue check
+          // as it is being used in the mappers when extracting inputs recursively
+          // as well as with isRemoteFunction when cloning objects recursively.
+          // Apparently we can't check if a key exists there as HostObjects always
+          // return true for such tests, so the only possibility for us is to
+          // actually access that key and see if it is set to true. We therefore
+          // need to allow for this key to be accessed here.
+          return false;
+        }
+        throw new WorkletsError(`Trying to access property \`${String(prop)}\` of an object which cannot be sent to the UI runtime.`);
+      },
+      set: () => {
+        throw new WorkletsError('Trying to write to an object which cannot be sent to the UI runtime.');
+      }
+    });
+  }
+};
+const VALID_ARRAY_VIEWS_NAMES = ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array', 'DataView'];
+const DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD = 30;
+// Below variable stores object that we process in makeShareableCloneRecursive at the specified depth.
+// We use it to check if later on the function reenters with the same object
+let processedObjectAtThresholdDepth;
+function makeShareableCloneRecursiveWeb(value) {
+  return value;
+}
+function makeShareableCloneRecursiveNative(value, shouldPersistRemote = false, depth = 0) {
+  detectCyclicObject(value, depth);
+  const isObject = typeof value === 'object';
+  const isFunction = typeof value === 'function';
+  if (!isObject && !isFunction || value === null) {
+    return clonePrimitive(value, shouldPersistRemote);
+  }
+  const cached = getFromCache(value);
+  if (cached !== undefined) {
+    return cached;
+  }
+  if (Array.isArray(value)) {
+    return cloneArray(value, shouldPersistRemote, depth);
+  }
+  if (isFunction && !isWorkletFunction(value)) {
+    return cloneRemoteFunction(value, shouldPersistRemote);
+  }
+  if (isHostObject(value)) {
+    return cloneHostObject(value, shouldPersistRemote);
+  }
+  if (isPlainJSObject(value) && value.__workletContextObjectFactory) {
+    return cloneContextObject(value);
+  }
+  if ((isPlainJSObject(value) || isFunction) && isWorkletFunction(value)) {
+    return cloneWorklet(value, shouldPersistRemote, depth);
+  }
+  if (isPlainJSObject(value) || isFunction) {
+    return clonePlainJSObject(value, shouldPersistRemote, depth);
+  }
+  if (value instanceof RegExp) {
+    return cloneRegExp(value);
+  }
+  if (value instanceof Error) {
+    return cloneError(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return cloneArrayBuffer(value, shouldPersistRemote);
+  }
+  if (ArrayBuffer.isView(value)) {
+    // typed array (e.g. Int32Array, Uint8ClampedArray) or DataView
+    return cloneArrayBufferView(value);
+  }
+  return inaccessibleObject(value);
+}
+export const makeShareableCloneRecursive = SHOULD_BE_USE_WEB ? makeShareableCloneRecursiveWeb : makeShareableCloneRecursiveNative;
+function detectCyclicObject(value, depth) {
+  if (depth >= DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {
+    // if we reach certain recursion depth we suspect that we are dealing with a cyclic object.
+    // this type of objects are not supported and cannot be transferred as shareable, so we
+    // implement a simple detection mechanism that remembers the value at a given depth and
+    // tests whether we try reenter this method later on with the same value. If that happens
+    // we throw an appropriate error.
+    if (depth === DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {
+      processedObjectAtThresholdDepth = value;
+    } else if (value === processedObjectAtThresholdDepth) {
+      throw new WorkletsError('Trying to convert a cyclic object to a shareable. This is not supported.');
+    }
+  } else {
+    processedObjectAtThresholdDepth = undefined;
+  }
+}
+function clonePrimitive(value, shouldPersistRemote) {
+  return WorkletsModule.makeShareableClone(value, shouldPersistRemote);
+}
+function cloneArray(value, shouldPersistRemote, depth) {
+  const clonedElements = value.map(element => makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1));
+  const clone = WorkletsModule.makeShareableClone(clonedElements, shouldPersistRemote, value);
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneRemoteFunction(value, shouldPersistRemote) {
+  const clone = WorkletsModule.makeShareableClone(value, shouldPersistRemote, value);
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneHostObject(value, shouldPersistRemote) {
+  // for host objects we pass the reference to the object as shareable and
+  // then recreate new host object wrapping the same instance on the UI thread.
+  // there is no point of iterating over keys as we do for regular objects.
+  const clone = WorkletsModule.makeShareableClone(value, shouldPersistRemote, value);
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+  return clone;
+}
+function cloneWorklet(value, shouldPersistRemote, depth) {
+  if (__DEV__) {
+    // TODO: Restore this once we reimplement JS version checking
+    // const babelVersion = (value as WorkletFunctionDev).__initData.version;
+    //     if (babelVersion !== undefined && babelVersion !== jsVersion) {
+    //       throw new Error(`[Reanimated] Mismatch between JavaScript code version and Reanimated Babel plugin version (${jsVersion} vs. ${babelVersion}).
+    // See \`https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#mismatch-between-javascript-code-version-and-reanimated-babel-plugin-version\` for more details.
+    // Offending code was: \`${getWorkletCode(value)}\``);
+    //     }
+    registerWorkletStackDetails(value.__workletHash, value.__stackDetails);
+  }
+  if (value.__stackDetails) {
+    // `Error` type of value cannot be copied to the UI thread, so we
+    // remove it after we handled it in dev mode or delete it to ignore it in production mode.
+    // Not removing this would cause an infinite loop in production mode and it just
+    // seems more elegant to handle it this way.
+    delete value.__stackDetails;
+  }
+  // to save on transferring static __initData field of worklet structure
+  // we request shareable value to persist its UI counterpart. This means
+  // that the __initData field that contains long strings represeting the
+  // worklet code, source map, and location, will always be
+  // serialized/deserialized once.
+  const clonedProps = {};
+  clonedProps.__initData = makeShareableCloneRecursive(value.__initData, true, depth + 1);
+  for (const [key, element] of Object.entries(value)) {
+    if (key === '__initData' && clonedProps.__initData !== undefined) {
+      continue;
+    }
+    clonedProps[key] = makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1);
+  }
+  const clone = WorkletsModule.makeShareableClone(clonedProps,
+  // retain all worklets
+  true, value);
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneContextObject(value) {
+  const workletContextObjectFactory = value.__workletContextObjectFactory;
+  const handle = makeShareableCloneRecursive({
+    __init: () => {
+      'worklet';
+
+      return workletContextObjectFactory();
+    }
+  });
+  shareableMappingCache.set(value, handle);
+  return handle;
+}
+function clonePlainJSObject(value, shouldPersistRemote, depth) {
+  const clonedProps = {};
+  for (const [key, element] of Object.entries(value)) {
+    if (key === '__initData' && clonedProps.__initData !== undefined) {
+      continue;
+    }
+    clonedProps[key] = makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1);
+  }
+  const clone = WorkletsModule.makeShareableClone(clonedProps, shouldPersistRemote, value);
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneRegExp(value) {
+  const pattern = value.source;
+  const flags = value.flags;
+  const handle = makeShareableCloneRecursive({
+    __init: () => {
+      'worklet';
+
+      return new RegExp(pattern, flags);
+    }
+  });
+  shareableMappingCache.set(value, handle);
+  return handle;
+}
+function cloneError(value) {
+  const {
+    name,
+    message,
+    stack
+  } = value;
+  const handle = makeShareableCloneRecursive({
+    __init: () => {
+      'worklet';
+
+      // eslint-disable-next-line reanimated/use-worklets-error
+      const error = new Error();
+      error.name = name;
+      error.message = message;
+      error.stack = stack;
+      return error;
+    }
+  });
+  shareableMappingCache.set(value, handle);
+  return handle;
+}
+function cloneArrayBuffer(value, shouldPersistRemote) {
+  const clone = WorkletsModule.makeShareableClone(value, shouldPersistRemote, value);
+  shareableMappingCache.set(value, clone);
+  shareableMappingCache.set(clone);
+  return clone;
+}
+function cloneArrayBufferView(value) {
+  const buffer = value.buffer;
+  const typeName = value.constructor.name;
+  const handle = makeShareableCloneRecursive({
+    __init: () => {
+      'worklet';
+
+      if (!VALID_ARRAY_VIEWS_NAMES.includes(typeName)) {
+        throw new WorkletsError(`Invalid array view name \`${typeName}\`.`);
+      }
+      const constructor = global[typeName];
+      if (constructor === undefined) {
+        throw new WorkletsError(`Constructor for \`${typeName}\` not found.`);
+      }
+      return new constructor(buffer);
+    }
+  });
+  shareableMappingCache.set(value, handle);
+  return handle;
+}
+function inaccessibleObject(value) {
+  // This is reached for object types that are not of plain Object.prototype.
+  // We don't support such objects from being transferred as shareables to
+  // the UI runtime and hence we replace them with "inaccessible object"
+  // which is implemented as a Proxy object that throws on any attempt
+  // of accessing its fields. We argue that such objects can sometimes leak
+  // as attributes of objects being captured by worklets but should never
+  // be used on the UI runtime regardless. If they are being accessed, the user
+  // will get an appropriate error message.
+  const clone = makeShareableCloneRecursive(INACCESSIBLE_OBJECT);
+  shareableMappingCache.set(value, clone);
+  return clone;
+}
+const WORKLET_CODE_THRESHOLD = 255;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function getWorkletCode(value) {
+  const code = value?.__initData?.code;
+  if (!code) {
+    return 'unknown';
+  }
+  if (code.length > WORKLET_CODE_THRESHOLD) {
+    return `${code.substring(0, WORKLET_CODE_THRESHOLD)}...`;
+  }
+  return code;
+}
+function isRemoteFunction(value) {
+  'worklet';
+
+  return !!value.__remoteFunction;
+}
+
+/**
+ * We freeze
+ *
+ * - Arrays,
+ * - Remote functions,
+ * - Plain JS objects,
+ *
+ * That are transformed to a shareable with a meaningful warning. This should
+ * help detect issues when someone modifies data after it's been converted.
+ * Meaning that they may be doing a faulty assumption in their code expecting
+ * that the updates are going to automatically propagate to the object sent to
+ * the UI thread. If the user really wants some objects to be mutable they
+ * should use shared values instead.
+ */
+function freezeObjectInDev(value) {
+  if (!__DEV__) {
+    return;
+  }
+  Object.entries(value).forEach(([key, element]) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.configurable) {
+      return;
+    }
+    Object.defineProperty(value, key, {
+      get() {
+        return element;
+      },
+      set() {
+        logger.warn(`Tried to modify key \`${key}\` of an object which has been already passed to a worklet. See
+        https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-modify-key-of-an-object-which-has-been-converted-to-a-shareable
+        for more details.`);
+      }
+    });
+  });
+  Object.preventExtensions(value);
+}
+export function makeShareableCloneOnUIRecursive(value) {
+  'worklet';
+
+  if (SHOULD_BE_USE_WEB) {
+    // @ts-ignore web is an interesting place where we don't run a secondary VM on the UI thread
+    // see more details in the comment where USE_STUB_IMPLEMENTATION is defined.
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  function cloneRecursive(value) {
+    if (typeof value === 'object' && value !== null || typeof value === 'function') {
+      if (isHostObject(value)) {
+        // We call `_makeShareableClone` to wrap the provided HostObject
+        // inside ShareableJSRef.
+        return global._makeShareableClone(value, undefined);
+      }
+      if (isRemoteFunction(value)) {
+        // RemoteFunctions are created by us therefore they are
+        // a Shareable out of the box and there is no need to
+        // call `_makeShareableClone`.
+        return value.__remoteFunction;
+      }
+      if (Array.isArray(value)) {
+        return global._makeShareableClone(value.map(cloneRecursive), undefined);
+      }
+      const toAdapt = {};
+      for (const [key, element] of Object.entries(value)) {
+        toAdapt[key] = cloneRecursive(element);
+      }
+      return global._makeShareableClone(toAdapt, value);
+    }
+    return global._makeShareableClone(value, undefined);
+  }
+  return cloneRecursive(value);
+}
+function makeShareableJS(value) {
+  return value;
+}
+function makeShareableNative(value) {
+  if (shareableMappingCache.get(value)) {
+    return value;
+  }
+  const handle = makeShareableCloneRecursive({
+    __init: () => {
+      'worklet';
+
+      return value;
+    }
+  });
+  shareableMappingCache.set(value, handle);
+  return value;
+}
+
+/**
+ * This function creates a value on UI with persistent state - changes to it on
+ * the UI thread will be seen by all worklets. Use it when you want to create a
+ * value that is read and written only on the UI thread.
+ */
+export const makeShareable = SHOULD_BE_USE_WEB ? makeShareableJS : makeShareableNative;
+//# sourceMappingURL=shareables.js.map