jotai/optics.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var jotai = require('jotai');
var O = require('optics-ts');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

var O__namespace = /*#__PURE__*/_interopNamespace(O);

var getWeakCacheItem = function getWeakCacheItem(cache, deps) {
  var dep = deps[0],
      rest = deps.slice(1);
  var entry = cache.get(dep);

  if (!entry) {
    return;
  }

  if (!rest.length) {
    return entry[1];
  }

  return getWeakCacheItem(entry[0], rest);
};
var setWeakCacheItem = function setWeakCacheItem(cache, deps, item) {
  var dep = deps[0],
      rest = deps.slice(1);
  var entry = cache.get(dep);

  if (!entry) {
    entry = [new WeakMap()];
    cache.set(dep, entry);
  }

  if (!rest.length) {
    entry[1] = item;
    return;
  }

  setWeakCacheItem(entry[0], rest, item);
};

var focusAtomCache = new WeakMap();

var isFunction = function isFunction(x) {
  return typeof x === 'function';
};

function focusAtom(baseAtom, callback) {
  var deps = [baseAtom, callback];
  var cachedAtom = getWeakCacheItem(focusAtomCache, deps);

  if (cachedAtom) {
    return cachedAtom;
  }

  var focus = callback(O__namespace.optic());
  var derivedAtom = jotai.atom(function (get) {
    return getValueUsingOptic(focus, get(baseAtom));
  }, function (get, set, update) {
    var newValueProducer = isFunction(update) ? O__namespace.modify(focus)(update) : O__namespace.set(focus)(update);
    set(baseAtom, newValueProducer(get(baseAtom)));
  });
  derivedAtom.scope = baseAtom.scope;
  setWeakCacheItem(focusAtomCache, deps, derivedAtom);
  return derivedAtom;
}

var getValueUsingOptic = function getValueUsingOptic(focus, bigValue) {
  if (focus._tag === 'Traversal') {
    var values = O__namespace.collect(focus)(bigValue);
    return values;
  }

  if (focus._tag === 'Prism') {
    var _value = O__namespace.preview(focus)(bigValue);

    return _value;
  }

  var value = O__namespace.get(focus)(bigValue);
  return value;
};

exports.focusAtom = focusAtom;