react-native-reanimated 3.4.1 → 3.4.2

package/src/reanimated2/js-reanimated/Mapper.ts

@@ -1,94 +0,0 @@
-import type { NestedObjectValues } from '../commonTypes';
-import { shouldBeUseWeb } from '../PlatformChecker';
-import type { JSReanimated } from './commonTypes';
-import MutableValue from './MutableValue';
-
-export default class Mapper<T> {
-  static MAPPER_ID = 1;
-  id: number;
-  inputs: MutableValue<T>[];
-  outputs: MutableValue<T>[];
-  mapper: () => void;
-
-  dirty = true;
-
-  constructor(
-    module: JSReanimated,
-    mapper: () => void,
-    inputs: NestedObjectValues<MutableValue<T>>[] = [],
-    outputs: NestedObjectValues<MutableValue<T>>[] = []
-  ) {
-    this.id = Mapper.MAPPER_ID++;
-    this.inputs = this.extractMutablesFromArray(inputs);
-    this.outputs = this.extractMutablesFromArray(outputs);
-    this.mapper = mapper;
-
-    const markDirty = () => {
-      this.dirty = true;
-      module.maybeRequestRender();
-    };
-
-    this.inputs.forEach((input) => {
-      input.addListener(markDirty);
-    });
-  }
-
-  execute(): void {
-    this.dirty = false;
-    this.mapper();
-  }
-
-  extractMutablesFromArray<T>(
-    array: NestedObjectValues<MutableValue<T>>
-  ): MutableValue<T>[] {
-    const res: MutableValue<T>[] = [];
-
-    function extractMutables(value: NestedObjectValues<MutableValue<T>>) {
-      if (value == null) {
-        // return;
-      } else if (value instanceof MutableValue) {
-        res.push(value);
-      } else if (Array.isArray(value)) {
-        value.forEach((v) => extractMutables(v));
-      } else if (isWebDomElement(value)) {
-        // do nothing on dom elements
-        // without this check, we get a "Maximum call size exceeded error"
-      } else if (typeof value === 'object') {
-        Object.keys(value).forEach((key) => {
-          extractMutables(value[key]);
-        });
-      }
-    }
-
-    extractMutables(array);
-    return res;
-  }
-}
-
-function isWebDomElement(value: any) {
-  if (!shouldBeUseWeb()) {
-    return false;
-  }
-
-  // https://stackoverflow.com/a/384380/7869175
-  function isWebNode(o: any) {
-    return typeof Node === 'object'
-      ? o instanceof Node
-      : o &&
-          typeof o === 'object' &&
-          typeof o.nodeType === 'number' &&
-          typeof o.nodeName === 'string';
-  }
-
-  function isWebElement(o: any) {
-    return typeof HTMLElement === 'object'
-      ? o instanceof HTMLElement // DOM2
-      : o &&
-          typeof o === 'object' &&
-          o !== null &&
-          o.nodeType === 1 &&
-          typeof o.nodeName === 'string';
-  }
-
-  return isWebNode(value) || isWebElement(value);
-}

package/src/reanimated2/js-reanimated/MapperRegistry.ts

@@ -1,133 +0,0 @@
-import type { JSReanimated } from './commonTypes';
-import type Mapper from './Mapper';
-
-export default class MapperRegistry<T> {
-  sortedMappers: Mapper<T>[] = [];
-  mappers: Map<number, Mapper<T>> = new Map();
-  _module: JSReanimated;
-
-  updatedSinceLastExecute = false;
-
-  constructor(module: JSReanimated) {
-    this._module = module;
-  }
-
-  startMapper(mapper: Mapper<T>): number {
-    this.mappers.set(mapper.id, mapper);
-    this.updatedSinceLastExecute = true;
-    return mapper.id;
-  }
-
-  stopMapper(id: number): void {
-    this.mappers.delete(id);
-    this.updatedSinceLastExecute = true;
-  }
-
-  execute(): void {
-    if (this.updatedSinceLastExecute) {
-      this.updateOrder();
-      this.updatedSinceLastExecute = false;
-    }
-
-    for (let i = 0, len = this.sortedMappers.length; i < len; ++i) {
-      const mapper = this.sortedMappers[i];
-      if (mapper.dirty) {
-        mapper.execute();
-      }
-    }
-  }
-
-  updateOrder(): void {
-    const nodes = [...this.mappers.values()].map((mapper) => new Node(mapper));
-
-    const mappersById: Record<number, Mapper<T>> = {};
-    this.mappers.forEach((mapper) => {
-      mappersById[mapper.id] = mapper;
-    });
-
-    // create a graph from array of nodes
-    for (let i = 0, nodesLen = nodes.length; i < nodesLen; ++i) {
-      const node = nodes[i];
-      if (node.mapper.outputs.length === 0) {
-        continue;
-      }
-      for (let j = 0; j < nodesLen; ++j) {
-        const restNode = nodes[j];
-        if (i === j || restNode.mapper.inputs.length === 0) {
-          continue;
-        }
-        for (
-          let outi = 0, outputsLen = node.mapper.outputs.length;
-          outi < outputsLen;
-          ++outi
-        ) {
-          for (
-            let resti = 0, restLen = restNode.mapper.inputs.length;
-            resti < restLen;
-            ++resti
-          ) {
-            if (
-              node.mapper.outputs[outi]._id ===
-              restNode.mapper.inputs[resti]._id
-            ) {
-              node.children.push(restNode);
-            }
-          }
-        }
-      }
-    }
-
-    const post: Record<number, number> = {};
-    let postCounter = 1;
-    const dfs = (node: Node<T>) => {
-      const index = nodes.indexOf(node);
-      if (index === -1) {
-        // this node has already been handled
-        return;
-      }
-      ++postCounter;
-      nodes.splice(index, 1);
-      if (node.children.length === 0 && nodes.length > 0) {
-        post[node.mapper.id] = postCounter++;
-        dfs(nodes[0]);
-        return;
-      }
-      for (let i = 0, len = node.children.length; i < len; ++i) {
-        dfs(node.children[i]);
-      }
-      post[node.mapper.id] = postCounter++;
-    };
-
-    while (nodes.length) dfs(nodes[0]);
-
-    const postArray = Object.keys(post).map((key) => {
-      const num = parseInt(key);
-      return [num, post[num]];
-    });
-    postArray.sort((a, b) => {
-      return b[1] - a[1];
-    });
-
-    // clear sorted mappers
-    this.sortedMappers = [];
-
-    for (let i = 0, len = postArray.length; i < len; ++i) {
-      const [id] = postArray[i];
-      this.sortedMappers.push(mappersById[id]);
-    }
-  }
-
-  get needRunOnRender(): boolean {
-    return this.updatedSinceLastExecute;
-  }
-}
-
-class Node<T> {
-  mapper: Mapper<T>;
-  children: Node<T>[];
-
-  constructor(mapper: Mapper<T>, children = []) {
-    this.mapper = mapper;
-    this.children = children;
-  }
-}