react-native-reanimated/lib/commonjs/reanimated2/mutables.js

More powerful alternative to Animated library for React Native.

"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,
    _isReanimatedSharedValue: true
  };
  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);
    },
    _isReanimatedSharedValue: true
  };
  (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