react-native-reanimated 3.0.0-rc.7 → 3.0.0-rc.8

package/lib/commonjs/reanimated2/mappers.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMapperRegistry = createMapperRegistry;
+exports.startMapper = startMapper;
+exports.stopMapper = stopMapper;
+
+var _threads = require("./threads");
+
+function createMapperRegistry() {
+  'worklet';
+
+  const mappers = new Map();
+  let sortedMappers = [];
+  let frameRequested = false;
+
+  function updateMappersOrder() {
+    // sort mappers topologically
+    // the algorithm here takes adventage of a fact that the topological order
+    // of a transposed graph is a reverse topological order of the original graph
+    // The graph in our case consists of mappers and an edge between two mappers
+    // A and B exists if there is a shared value that's on A's output lists and on
+    // B's input list.
+    //
+    // We don't need however to calculate that graph as it is easier to work with
+    // the transposed version of it that can be calculated ad-hoc. For the transposed
+    // version to be traversed we use "pre" map that maps share value to mappers that
+    // output that shared value. Then we can infer all the outgoing edges for a given
+    // mapper simply by scanning it's input list and checking if any of the shared values
+    // from that list exists in the "pre" map. If they do, then we have an edge between
+    // that mapper and the mappers from the "pre" list for the given shared value.
+    //
+    // For topological sorting we use a dfs-based approach that requires the graph to
+    // be traversed in dfs order and each node after being processed lands at the
+    // beginning of the topological order list. Since we traverse a transposed graph,
+    // instead of reversing that order we can use a normal array and push processed
+    // mappers to the end. There is no need to reverse that array after we are done.
+    const pre = new Map(); // map from sv -> mapper that outputs that sv
+
+    mappers.forEach(mapper => {
+      if (mapper.outputs) {
+        for (const output of mapper.outputs) {
+          const preMappers = pre.get(output);
+
+          if (preMappers === undefined) {
+            pre.set(output, [mapper]);
+          } else {
+            preMappers.push(mapper);
+          }
+        }
+      }
+    });
+    const visited = new Set();
+    const newOrder = [];
+
+    function dfs(mapper) {
+      visited.add(mapper);
+
+      for (const input of mapper.inputs) {
+        const preMappers = pre.get(input);
+
+        if (preMappers) {
+          for (const preMapper of preMappers) {
+            if (!visited.has(preMapper)) {
+              dfs(preMapper);
+            }
+          }
+        }
+      }
+
+      newOrder.push(mapper);
+    }
+
+    mappers.forEach(mapper => {
+      if (!visited.has(mapper)) {
+        dfs(mapper);
+      }
+    });
+    sortedMappers = newOrder;
+  }
+
+  function mapperFrame() {
+    frameRequested = false;
+
+    if (mappers.size !== sortedMappers.length) {
+      updateMappersOrder();
+    }
+
+    for (const mapper of sortedMappers) {
+      if (mapper.dirty) {
+        mapper.dirty = false;
+        mapper.worklet();
+      }
+    }
+  }
+
+  function maybeRequestUpdates() {
+    if (!frameRequested) {
+      requestAnimationFrame(mapperFrame);
+      frameRequested = true;
+    }
+  }
+
+  function extractInputs(inputs, resultArray) {
+    if (Array.isArray(inputs)) {
+      for (const input of inputs) {
+        input && extractInputs(input, resultArray);
+      }
+    } else if (inputs.addListener) {
+      resultArray.push(inputs);
+    } else if (typeof inputs === 'object') {
+      for (const element of Object.values(inputs)) {
+        element && extractInputs(element, resultArray);
+      }
+    }
+
+    return resultArray;
+  }
+
+  return {
+    start: (mapperID, worklet, inputs, outputs) => {
+      const mapper = {
+        id: mapperID,
+        dirty: true,
+        worklet,
+        inputs: extractInputs(inputs, []),
+        outputs
+      };
+      mappers.set(mapper.id, mapper);
+      sortedMappers = [];
+
+      for (const sv of mapper.inputs) {
+        sv.addListener(mapper.id, () => {
+          mapper.dirty = true;
+          maybeRequestUpdates();
+        });
+      }
+
+      maybeRequestUpdates();
+    },
+    stop: mapperID => {
+      const mapper = mappers.get(mapperID);
+
+      if (mapper) {
+        mappers.delete(mapper.id);
+        sortedMappers = [];
+
+        for (const sv of mapper.inputs) {
+          sv.removeListener(mapper.id);
+        }
+      }
+    }
+  };
+}
+
+let MAPPER_ID = 9999;
+
+function startMapper(worklet) {
+  let inputs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  let outputs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  const mapperID = MAPPER_ID += 1;
+  (0, _threads.runOnUI)(() => {
+    'worklet';
+
+    let mapperRegistry = global.__mapperRegistry;
+
+    if (mapperRegistry === undefined) {
+      mapperRegistry = global.__mapperRegistry = createMapperRegistry();
+    }
+
+    mapperRegistry.start(mapperID, worklet, inputs, outputs);
+  })();
+  return mapperID;
+}
+
+function stopMapper(mapperID) {
+  (0, _threads.runOnUI)(() => {
+    'worklet';
+
+    const mapperRegistry = global.__mapperRegistry;
+    mapperRegistry === null || mapperRegistry === void 0 ? void 0 : mapperRegistry.stop(mapperID);
+  })();
+}
+//# sourceMappingURL=mappers.js.map

package/lib/commonjs/reanimated2/mappers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createMapperRegistry","mappers","Map","sortedMappers","frameRequested","updateMappersOrder","pre","forEach","mapper","outputs","output","preMappers","get","undefined","set","push","visited","Set","newOrder","dfs","add","input","inputs","preMapper","has","mapperFrame","size","length","dirty","worklet","maybeRequestUpdates","requestAnimationFrame","extractInputs","resultArray","Array","isArray","addListener","element","Object","values","start","mapperID","id","sv","stop","delete","removeListener","MAPPER_ID","startMapper","runOnUI","mapperRegistry","global","__mapperRegistry","stopMapper"],"sources":["mappers.ts"],"sourcesContent":["import { SharedValue } from './commonTypes';\nimport { runOnUI } from './threads';\n\nexport type Mapper = {\n  id: number;\n  dirty: boolean;\n  worklet: () => void;\n  inputs: SharedValue<any>[];\n  outputs?: SharedValue<any>[];\n};\n\nexport function createMapperRegistry() {\n  'worklet';\n  const mappers = new Map();\n  let sortedMappers: Mapper[] = [];\n\n  let frameRequested = false;\n\n  function updateMappersOrder() {\n    // sort mappers topologically\n    // the algorithm here takes adventage of a fact that the topological order\n    // of a transposed graph is a reverse topological order of the original graph\n    // The graph in our case consists of mappers and an edge between two mappers\n    // A and B exists if there is a shared value that's on A's output lists and on\n    // B's input list.\n    //\n    // We don't need however to calculate that graph as it is easier to work with\n    // the transposed version of it that can be calculated ad-hoc. For the transposed\n    // version to be traversed we use \"pre\" map that maps share value to mappers that\n    // output that shared value. Then we can infer all the outgoing edges for a given\n    // mapper simply by scanning it's input list and checking if any of the shared values\n    // from that list exists in the \"pre\" map. If they do, then we have an edge between\n    // that mapper and the mappers from the \"pre\" list for the given shared value.\n    //\n    // For topological sorting we use a dfs-based approach that requires the graph to\n    // be traversed in dfs order and each node after being processed lands at the\n    // beginning of the topological order list. Since we traverse a transposed graph,\n    // instead of reversing that order we can use a normal array and push processed\n    // mappers to the end. There is no need to reverse that array after we are done.\n    const pre = new Map(); // map from sv -> mapper that outputs that sv\n    mappers.forEach((mapper) => {\n      if (mapper.outputs) {\n        for (const output of mapper.outputs) {\n          const preMappers = pre.get(output);\n          if (preMappers === undefined) {\n            pre.set(output, [mapper]);\n          } else {\n            preMappers.push(mapper);\n          }\n        }\n      }\n    });\n    const visited = new Set();\n    const newOrder: Mapper[] = [];\n    function dfs(mapper: Mapper) {\n      visited.add(mapper);\n      for (const input of mapper.inputs) {\n        const preMappers = pre.get(input);\n        if (preMappers) {\n          for (const preMapper of preMappers) {\n            if (!visited.has(preMapper)) {\n              dfs(preMapper);\n            }\n          }\n        }\n      }\n      newOrder.push(mapper);\n    }\n    mappers.forEach((mapper) => {\n      if (!visited.has(mapper)) {\n        dfs(mapper);\n      }\n    });\n    sortedMappers = newOrder;\n  }\n\n  function mapperFrame() {\n    frameRequested = false;\n    if (mappers.size !== sortedMappers.length) {\n      updateMappersOrder();\n    }\n    for (const mapper of sortedMappers) {\n      if (mapper.dirty) {\n        mapper.dirty = false;\n        mapper.worklet();\n      }\n    }\n  }\n\n  function maybeRequestUpdates() {\n    if (!frameRequested) {\n      requestAnimationFrame(mapperFrame);\n      frameRequested = true;\n    }\n  }\n\n  function extractInputs(\n    inputs: any,\n    resultArray: SharedValue<any>[]\n  ): SharedValue<any>[] {\n    if (Array.isArray(inputs)) {\n      for (const input of inputs) {\n        input && extractInputs(input, resultArray);\n      }\n    } else if (inputs.addListener) {\n      resultArray.push(inputs);\n    } else if (typeof inputs === 'object') {\n      for (const element of Object.values(inputs)) {\n        element && extractInputs(element, resultArray);\n      }\n    }\n    return resultArray;\n  }\n\n  return {\n    start: (\n      mapperID: number,\n      worklet: () => void,\n      inputs: SharedValue<any>[],\n      outputs?: SharedValue<any>[]\n    ) => {\n      const mapper = {\n        id: mapperID,\n        dirty: true,\n        worklet,\n        inputs: extractInputs(inputs, []),\n        outputs,\n      };\n      mappers.set(mapper.id, mapper);\n      sortedMappers = [];\n      for (const sv of mapper.inputs) {\n        sv.addListener(mapper.id, () => {\n          mapper.dirty = true;\n          maybeRequestUpdates();\n        });\n      }\n      maybeRequestUpdates();\n    },\n    stop: (mapperID: number) => {\n      const mapper = mappers.get(mapperID);\n      if (mapper) {\n        mappers.delete(mapper.id);\n        sortedMappers = [];\n        for (const sv of mapper.inputs) {\n          sv.removeListener(mapper.id);\n        }\n      }\n    },\n  };\n}\n\nlet MAPPER_ID = 9999;\n\nexport function startMapper(\n  worklet: () => void,\n  inputs: any[] = [],\n  outputs: any[] = []\n): number {\n  const mapperID = (MAPPER_ID += 1);\n\n  runOnUI(() => {\n    'worklet';\n    let mapperRegistry = global.__mapperRegistry;\n    if (mapperRegistry === undefined) {\n      mapperRegistry = global.__mapperRegistry = createMapperRegistry();\n    }\n    mapperRegistry.start(mapperID, worklet, inputs, outputs);\n  })();\n\n  return mapperID;\n}\n\nexport function stopMapper(mapperID: number): void {\n  runOnUI(() => {\n    'worklet';\n    const mapperRegistry = global.__mapperRegistry;\n    mapperRegistry?.stop(mapperID);\n  })();\n}\n"],"mappings":"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"}

package/lib/commonjs/reanimated2/mutables.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeMutable = makeMutable;
+exports.makeRemote = makeRemote;
+exports.makeUIMutable = makeUIMutable;
+Object.defineProperty(exports, "stopMapper", {
+  enumerable: true,
+  get: function () {
+    return _mappers.stopMapper;
+  }
+});
+
+var _NativeReanimated = _interopRequireDefault(require("./NativeReanimated"));
+
+var _shareables = require("./shareables");
+
+var _threads = require("./threads");
+
+var _valueSetter = require("./valueSetter");
+
+var _mappers = require("./mappers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function makeUIMutable(initial, syncDataHolder) {
+  'worklet';
+
+  const listeners = new Map();
+  let value = initial;
+  const self = {
+    set value(newValue) {
+      (0, _valueSetter.valueSetter)(self, newValue);
+    },
+
+    get value() {
+      return value;
+    },
+
+    /**
+     * _value prop should only be accessed by the valueSetter implementation
+     * which may make the decision about updating the mutable value depending
+     * on the provided new value. All other places should only attempt to modify
+     * the mutable by assigning to value prop directly.
+     */
+    set _value(newValue) {
+      value = newValue;
+
+      if (syncDataHolder) {
+        _updateDataSynchronously(syncDataHolder, (0, _shareables.makeShareableCloneOnUIRecursive)(newValue));
+      }
+
+      listeners.forEach(listener => {
+        listener(newValue);
+      });
+    },
+
+    get _value() {
+      return value;
+    },
+
+    addListener: (id, listener) => {
+      listeners.set(id, listener);
+    },
+    removeListener: id => {
+      listeners.delete(id);
+    },
+    _animation: null
+  };
+  return self;
+}
+
+function makeMutable(initial) {
+  let oneWayReadsOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  let value = initial;
+  let syncDataHolder;
+
+  if (!oneWayReadsOnly && _NativeReanimated.default.native) {
+    // updates are always synchronous when running on web or in Jest environment
+    syncDataHolder = _NativeReanimated.default.makeSynchronizedDataHolder((0, _shareables.makeShareableCloneRecursive)(value));
+    (0, _shareables.registerShareableMapping)(syncDataHolder);
+  }
+
+  const handle = (0, _shareables.makeShareableCloneRecursive)({
+    __init: () => {
+      'worklet';
+
+      return makeUIMutable(initial, syncDataHolder);
+    }
+  }); // listeners can only work on JS thread on Web and jest environments
+
+  const listeners = _NativeReanimated.default.native ? undefined : new Map();
+  const mutable = {
+    set value(newValue) {
+      if (_NativeReanimated.default.native) {
+        (0, _threads.runOnUI)(() => {
+          'worklet';
+
+          mutable.value = newValue;
+        })();
+      } else {
+        (0, _valueSetter.valueSetter)(mutable, newValue);
+      }
+    },
+
+    get value() {
+      if (syncDataHolder) {
+        return _NativeReanimated.default.getDataSynchronously(syncDataHolder);
+      }
+
+      return value;
+    },
+
+    set _value(newValue) {
+      if (_NativeReanimated.default.native) {
+        throw new Error('Setting `_value` directly is only possible on the UI runtime');
+      }
+
+      value = newValue;
+      listeners.forEach(listener => {
+        listener(newValue);
+      });
+    },
+
+    get _value() {
+      if (_NativeReanimated.default.native) {
+        throw new Error('Reading from `_value` directly is only possible on the UI runtime');
+      }
+
+      return value;
+    },
+
+    modify: modifier => {
+      (0, _threads.runOnUI)(() => {
+        'worklet';
+
+        mutable.value = modifier(mutable.value);
+      })();
+    },
+    addListener: (id, listener) => {
+      if (_NativeReanimated.default.native) {
+        throw new Error('adding listeners is only possible on the UI runtime');
+      }
+
+      listeners.set(id, listener);
+    },
+    removeListener: id => {
+      if (_NativeReanimated.default.native) {
+        throw new Error('removing listeners is only possible on the UI runtime');
+      }
+
+      listeners.delete(id);
+    }
+  };
+  (0, _shareables.registerShareableMapping)(mutable, handle);
+  return mutable;
+}
+
+function makeRemote() {
+  let initial = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const handle = (0, _shareables.makeShareableCloneRecursive)({
+    __init: () => {
+      'worklet';
+
+      return initial;
+    }
+  });
+  (0, _shareables.registerShareableMapping)(initial, handle);
+  return initial;
+}
+//# sourceMappingURL=mutables.js.map

package/lib/commonjs/reanimated2/mutables.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["makeUIMutable","initial","syncDataHolder","listeners","Map","value","self","newValue","valueSetter","_value","_updateDataSynchronously","makeShareableCloneOnUIRecursive","forEach","listener","addListener","id","set","removeListener","delete","_animation","makeMutable","oneWayReadsOnly","NativeReanimatedModule","native","makeSynchronizedDataHolder","makeShareableCloneRecursive","registerShareableMapping","handle","__init","undefined","mutable","runOnUI","getDataSynchronously","Error","modify","modifier","makeRemote"],"sources":["mutables.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { SharedValue, ShareableSyncDataHolderRef } from './commonTypes';\nimport {\n  makeShareableCloneOnUIRecursive,\n  makeShareableCloneRecursive,\n  registerShareableMapping,\n} from './shareables';\nimport { runOnUI } from './threads';\nimport { valueSetter } from './valueSetter';\nexport { stopMapper } from './mappers';\n\nexport function makeUIMutable<T>(\n  initial: T,\n  syncDataHolder?: ShareableSyncDataHolderRef<T>\n) {\n  'worklet';\n\n  const listeners = new Map();\n  let value = initial;\n\n  const self = {\n    set value(newValue) {\n      valueSetter(self, newValue);\n    },\n    get value() {\n      return value;\n    },\n    /**\n     * _value prop should only be accessed by the valueSetter implementation\n     * which may make the decision about updating the mutable value depending\n     * on the provided new value. All other places should only attempt to modify\n     * the mutable by assigning to value prop directly.\n     */\n    set _value(newValue: T) {\n      value = newValue;\n      if (syncDataHolder) {\n        _updateDataSynchronously(\n          syncDataHolder,\n          makeShareableCloneOnUIRecursive(newValue)\n        );\n      }\n      listeners.forEach((listener) => {\n        listener(newValue);\n      });\n    },\n    get _value(): T {\n      return value;\n    },\n    addListener: (id: number, listener: (newValue: T) => void) => {\n      listeners.set(id, listener);\n    },\n    removeListener: (id: number) => {\n      listeners.delete(id);\n    },\n    _animation: null,\n  };\n  return self;\n}\n\nexport function makeMutable<T>(\n  initial: T,\n  oneWayReadsOnly = false\n): SharedValue<T> {\n  let value: T = initial;\n  let syncDataHolder: ShareableSyncDataHolderRef<T> | undefined;\n  if (!oneWayReadsOnly && NativeReanimatedModule.native) {\n    // updates are always synchronous when running on web or in Jest environment\n    syncDataHolder = NativeReanimatedModule.makeSynchronizedDataHolder(\n      makeShareableCloneRecursive(value)\n    );\n    registerShareableMapping(syncDataHolder);\n  }\n  const handle = makeShareableCloneRecursive({\n    __init: () => {\n      'worklet';\n      return makeUIMutable(initial, syncDataHolder);\n    },\n  });\n  // listeners can only work on JS thread on Web and jest environments\n  const listeners = NativeReanimatedModule.native ? undefined : new Map();\n  const mutable = {\n    set value(newValue) {\n      if (NativeReanimatedModule.native) {\n        runOnUI(() => {\n          'worklet';\n          mutable.value = newValue;\n        })();\n      } else {\n        valueSetter(mutable, newValue);\n      }\n    },\n    get value() {\n      if (syncDataHolder) {\n        return NativeReanimatedModule.getDataSynchronously(syncDataHolder);\n      }\n      return value;\n    },\n    set _value(newValue: T) {\n      if (NativeReanimatedModule.native) {\n        throw new Error(\n          'Setting `_value` directly is only possible on the UI runtime'\n        );\n      }\n      value = newValue;\n      listeners!.forEach((listener) => {\n        listener(newValue);\n      });\n    },\n    get _value(): T {\n      if (NativeReanimatedModule.native) {\n        throw new Error(\n          'Reading from `_value` directly is only possible on the UI runtime'\n        );\n      }\n      return value;\n    },\n    modify: (modifier: (value: T) => T) => {\n      runOnUI(() => {\n        'worklet';\n        mutable.value = modifier(mutable.value);\n      })();\n    },\n    addListener: (id: number, listener: (value: T) => void) => {\n      if (NativeReanimatedModule.native) {\n        throw new Error('adding listeners is only possible on the UI runtime');\n      }\n      listeners!.set(id, listener);\n    },\n    removeListener: (id: number) => {\n      if (NativeReanimatedModule.native) {\n        throw new Error(\n          'removing listeners is only possible on the UI runtime'\n        );\n      }\n      listeners!.delete(id);\n    },\n  };\n  registerShareableMapping(mutable, handle);\n  return mutable;\n}\n\nexport function makeRemote<T extends object>(initial: T = {} as T): T {\n  const handle = makeShareableCloneRecursive({\n    __init: () => {\n      'worklet';\n      return initial;\n    },\n  });\n  registerShareableMapping(initial, handle);\n  return initial;\n}\n"],"mappings":"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"}

package/lib/commonjs/reanimated2/shareables.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeShareable = makeShareable;
+exports.makeShareableCloneOnUIRecursive = makeShareableCloneOnUIRecursive;
+exports.makeShareableCloneRecursive = makeShareableCloneRecursive;
+exports.makeShareableShadowNodeWrapper = makeShareableShadowNodeWrapper;
+exports.registerShareableMapping = registerShareableMapping;
+
+var _NativeReanimated = _interopRequireDefault(require("./NativeReanimated"));
+
+var _PlatformChecker = require("./PlatformChecker");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// 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
+// runnning the code on separate VMs.
+const USE_STUB_IMPLEMENTATION = (0, _PlatformChecker.shouldBeUseWeb)();
+
+const _shareableCache = new WeakMap(); // the below symbol is used to represent a mapping from the value to itself
+// this is used to allow for a converted shareable to be passed to makeShareableClone
+
+
+const _shareableFlag = Symbol('shareable flag');
+
+function registerShareableMapping(shareable, shareableRef) {
+  if (USE_STUB_IMPLEMENTATION) {
+    return;
+  }
+
+  _shareableCache.set(shareable, shareableRef || _shareableFlag);
+}
+
+function makeShareableShadowNodeWrapper(shadowNodeWrapper) {
+  const adoptedSNW = _NativeReanimated.default.makeShareableClone(shadowNodeWrapper);
+
+  registerShareableMapping(shadowNodeWrapper, adoptedSNW);
+  return shadowNodeWrapper;
+}
+
+function makeShareableCloneRecursive(value) {
+  if (USE_STUB_IMPLEMENTATION) {
+    return value;
+  } // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread
+
+
+  const type = typeof value;
+
+  if ((type === 'object' || type === 'function') && value !== null) {
+    const cached = _shareableCache.get(value);
+
+    if (cached === _shareableFlag) {
+      return value;
+    } else if (cached !== undefined) {
+      return cached;
+    } else {
+      let toAdapt;
+
+      if (Array.isArray(value)) {
+        toAdapt = value.map(element => makeShareableCloneRecursive(element));
+      } else if (type === 'function' && value.__workletHash === undefined) {
+        // this is a remote function
+        toAdapt = value;
+      } else {
+        toAdapt = {};
+
+        for (const [key, element] of Object.entries(value)) {
+          toAdapt[key] = makeShareableCloneRecursive(element);
+        }
+      }
+
+      if (__DEV__) {
+        // we freeze objects that are transformed to shareable. This should help
+        // detect issues when someone modifies data after it's been converted to
+        // shareable. Meaning that they may be doing a faulty assumption in their
+        // code expecting that the updates are going to automatically populate to
+        // the object sent to the UI thread. If the user really wants some objects
+        // to be mutable they should use share values instead.
+        Object.freeze(value);
+      }
+
+      const adopted = _NativeReanimated.default.makeShareableClone(toAdapt);
+
+      _shareableCache.set(value, adopted);
+
+      _shareableCache.set(adopted, _shareableFlag);
+
+      return adopted;
+    }
+  }
+
+  return _NativeReanimated.default.makeShareableClone(value);
+}
+
+function makeShareableCloneOnUIRecursive(value) {
+  'worklet';
+
+  if (USE_STUB_IMPLEMENTATION) {
+    // @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;
+  }
+
+  function cloneRecursive(value) {
+    const type = typeof value;
+
+    if ((type === 'object' || type === 'function') && value !== null) {
+      let toAdapt;
+
+      if (Array.isArray(value)) {
+        toAdapt = value.map(element => cloneRecursive(element));
+      } else {
+        toAdapt = {};
+
+        for (const [key, element] of Object.entries(value)) {
+          toAdapt[key] = cloneRecursive(element);
+        }
+      }
+
+      if (__DEV__) {
+        // See the reasoning behind freezing in the other comment above.
+        Object.freeze(value);
+      }
+
+      return _makeShareableClone(toAdapt);
+    }
+
+    return _makeShareableClone(value);
+  }
+
+  return cloneRecursive(value);
+}
+
+function makeShareable(value) {
+  if (USE_STUB_IMPLEMENTATION) {
+    return value;
+  }
+
+  const handle = makeShareableCloneRecursive({
+    __init: () => {
+      'worklet';
+
+      return value;
+    }
+  });
+  registerShareableMapping(value, handle);
+  return value;
+}
+//# sourceMappingURL=shareables.js.map

package/lib/commonjs/reanimated2/shareables.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["USE_STUB_IMPLEMENTATION","shouldBeUseWeb","_shareableCache","WeakMap","_shareableFlag","Symbol","registerShareableMapping","shareable","shareableRef","set","makeShareableShadowNodeWrapper","shadowNodeWrapper","adoptedSNW","NativeReanimatedModule","makeShareableClone","makeShareableCloneRecursive","value","type","cached","get","undefined","toAdapt","Array","isArray","map","element","__workletHash","key","Object","entries","__DEV__","freeze","adopted","makeShareableCloneOnUIRecursive","cloneRecursive","_makeShareableClone","makeShareable","handle","__init"],"sources":["shareables.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { ShareableRef } from './commonTypes';\nimport { shouldBeUseWeb } from './PlatformChecker';\n\n// for web/chrome debugger/jest environments this file provides a stub implementation\n// where no shareable references are used. Instead, the objects themselves are used\n// instead of shareable references, because of the fact that we don't have to deal with\n// runnning the code on separate VMs.\nconst USE_STUB_IMPLEMENTATION = shouldBeUseWeb();\n\nconst _shareableCache = new WeakMap<\n  Record<string, unknown>,\n  ShareableRef<any> | symbol\n>();\n// the below symbol is used to represent a mapping from the value to itself\n// this is used to allow for a converted shareable to be passed to makeShareableClone\nconst _shareableFlag = Symbol('shareable flag');\n\nexport function registerShareableMapping(\n  shareable: any,\n  shareableRef?: ShareableRef<any>\n): void {\n  if (USE_STUB_IMPLEMENTATION) {\n    return;\n  }\n  _shareableCache.set(shareable, shareableRef || _shareableFlag);\n}\n\nexport function makeShareableShadowNodeWrapper<T>(shadowNodeWrapper: T): T {\n  const adoptedSNW =\n    NativeReanimatedModule.makeShareableClone(shadowNodeWrapper);\n  registerShareableMapping(shadowNodeWrapper, adoptedSNW);\n  return shadowNodeWrapper;\n}\n\nexport function makeShareableCloneRecursive<T>(value: any): ShareableRef<T> {\n  if (USE_STUB_IMPLEMENTATION) {\n    return value;\n  }\n  // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread\n  const type = typeof value;\n  if ((type === 'object' || type === 'function') && value !== null) {\n    const cached = _shareableCache.get(value);\n    if (cached === _shareableFlag) {\n      return value;\n    } else if (cached !== undefined) {\n      return cached as ShareableRef<T>;\n    } else {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) => makeShareableCloneRecursive(element));\n      } else if (type === 'function' && value.__workletHash === undefined) {\n        // this is a remote function\n        toAdapt = value;\n      } else {\n        toAdapt = {};\n        for (const [key, element] of Object.entries(value)) {\n          toAdapt[key] = makeShareableCloneRecursive(element);\n        }\n      }\n      if (__DEV__) {\n        // we freeze objects that are transformed to shareable. This should help\n        // detect issues when someone modifies data after it's been converted to\n        // shareable. Meaning that they may be doing a faulty assumption in their\n        // code expecting that the updates are going to automatically populate to\n        // the object sent to the UI thread. If the user really wants some objects\n        // to be mutable they should use share values instead.\n        Object.freeze(value);\n      }\n      const adopted = NativeReanimatedModule.makeShareableClone(toAdapt);\n      _shareableCache.set(value, adopted);\n      _shareableCache.set(adopted, _shareableFlag);\n      return adopted;\n    }\n  }\n  return NativeReanimatedModule.makeShareableClone(value);\n}\n\nexport function makeShareableCloneOnUIRecursive<T>(value: T): ShareableRef<T> {\n  'worklet';\n  if (USE_STUB_IMPLEMENTATION) {\n    // @ts-ignore web is an interesting place where we don't run a secondary VM on the UI thread\n    // see more details in the comment where USE_STUB_IMPLEMENTATION is defined.\n    return value;\n  }\n  function cloneRecursive<T>(value: T): ShareableRef<T> {\n    const type = typeof value;\n    if ((type === 'object' || type === 'function') && value !== null) {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) => cloneRecursive(element));\n      } else {\n        toAdapt = {};\n        for (const [key, element] of Object.entries(value)) {\n          toAdapt[key] = cloneRecursive(element);\n        }\n      }\n      if (__DEV__) {\n        // See the reasoning behind freezing in the other comment above.\n        Object.freeze(value);\n      }\n      return _makeShareableClone(toAdapt);\n    }\n    return _makeShareableClone(value);\n  }\n  return cloneRecursive(value);\n}\n\nexport function makeShareable<T>(value: T): T {\n  if (USE_STUB_IMPLEMENTATION) {\n    return value;\n  }\n  const handle = makeShareableCloneRecursive({\n    __init: () => {\n      'worklet';\n      return value;\n    },\n  });\n  registerShareableMapping(value, handle);\n  return value;\n}\n"],"mappings":"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"}

package/lib/commonjs/reanimated2/threads.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runOnJS = runOnJS;
+exports.runOnUI = runOnUI;
+
+var _NativeReanimated = _interopRequireDefault(require("./NativeReanimated"));
+
+var _shareables = require("./shareables");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function runOnUI(worklet) {
+  if (__DEV__) {
+    if (worklet.__workletHash === undefined) {
+      throw new Error('runOnUI() can only be used on worklets');
+    }
+  }
+
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _NativeReanimated.default.scheduleOnUI((0, _shareables.makeShareableCloneRecursive)(() => {
+      'worklet';
+
+      return worklet(...args);
+    }));
+  };
+}
+
+function runOnJS(fun) {
+  'worklet';
+
+  if (fun.__remoteFunction) {
+    // in development mode the function provided as `fun` throws an error message
+    // such that when someone accidently calls it directly on the UI runtime, they
+    // see that they should use `runOnJS` instead. To facilitate that we purt the
+    // reference to the original remote function in the `__remoteFunction` property.
+    fun = fun.__remoteFunction;
+  }
+
+  if (!_WORKLET) {
+    return fun;
+  }
+
+  return function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    _scheduleOnJS(fun, args.length > 0 ? (0, _shareables.makeShareableCloneOnUIRecursive)(args) : undefined);
+  };
+}
+//# sourceMappingURL=threads.js.map

package/lib/commonjs/reanimated2/threads.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["runOnUI","worklet","__DEV__","__workletHash","undefined","Error","args","NativeReanimatedModule","scheduleOnUI","makeShareableCloneRecursive","runOnJS","fun","__remoteFunction","_WORKLET","_scheduleOnJS","length","makeShareableCloneOnUIRecursive"],"sources":["threads.ts"],"sourcesContent":["import NativeReanimatedModule from './NativeReanimated';\nimport { ComplexWorkletFunction } from './commonTypes';\nimport {\n  makeShareableCloneOnUIRecursive,\n  makeShareableCloneRecursive,\n} from './shareables';\n\nexport function runOnUI<A extends any[], R>(\n  worklet: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  if (__DEV__) {\n    if (worklet.__workletHash === undefined) {\n      throw new Error('runOnUI() can only be used on worklets');\n    }\n  }\n  return (...args) => {\n    NativeReanimatedModule.scheduleOnUI(\n      makeShareableCloneRecursive(() => {\n        'worklet';\n        return worklet(...args);\n      })\n    );\n  };\n}\n\nexport function runOnJS<A extends any[], R>(\n  fun: ComplexWorkletFunction<A, R>\n): (...args: A) => void {\n  'worklet';\n  if (fun.__remoteFunction) {\n    // in development mode the function provided as `fun` throws an error message\n    // such that when someone accidently calls it directly on the UI runtime, they\n    // see that they should use `runOnJS` instead. To facilitate that we purt the\n    // reference to the original remote function in the `__remoteFunction` property.\n    fun = fun.__remoteFunction;\n  }\n  if (!_WORKLET) {\n    return fun;\n  }\n  return (...args) => {\n    _scheduleOnJS(\n      fun,\n      args.length > 0 ? makeShareableCloneOnUIRecursive(args) : undefined\n    );\n  };\n}\n"],"mappings":";;;;;;;;AAAA;;AAEA;;;;AAKO,SAASA,OAAT,CACLC,OADK,EAEiB;EACtB,IAAIC,OAAJ,EAAa;IACX,IAAID,OAAO,CAACE,aAAR,KAA0BC,SAA9B,EAAyC;MACvC,MAAM,IAAIC,KAAJ,CAAU,wCAAV,CAAN;IACD;EACF;;EACD,OAAO,YAAa;IAAA,kCAATC,IAAS;MAATA,IAAS;IAAA;;IAClBC,yBAAA,CAAuBC,YAAvB,CACE,IAAAC,uCAAA,EAA4B,MAAM;MAChC;;MACA,OAAOR,OAAO,CAAC,GAAGK,IAAJ,CAAd;IACD,CAHD,CADF;EAMD,CAPD;AAQD;;AAEM,SAASI,OAAT,CACLC,GADK,EAEiB;EACtB;;EACA,IAAIA,GAAG,CAACC,gBAAR,EAA0B;IACxB;IACA;IACA;IACA;IACAD,GAAG,GAAGA,GAAG,CAACC,gBAAV;EACD;;EACD,IAAI,CAACC,QAAL,EAAe;IACb,OAAOF,GAAP;EACD;;EACD,OAAO,YAAa;IAAA,mCAATL,IAAS;MAATA,IAAS;IAAA;;IAClBQ,aAAa,CACXH,GADW,EAEXL,IAAI,CAACS,MAAL,GAAc,CAAd,GAAkB,IAAAC,2CAAA,EAAgCV,IAAhC,CAAlB,GAA0DF,SAF/C,CAAb;EAID,CALD;AAMD"}