jotai/optics.js

'use strict';

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

function _interopNamespaceDefault(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__*/_interopNamespaceDefault(O);

var getWeakCacheItem = function getWeakCacheItem(cache, deps) {
  do {
    var _deps = deps,
      dep = _deps[0],
      rest = _deps.slice(1);
    var entry = cache.get(dep);
    if (!entry) {
      return;
    }
    if (!rest.length) {
      return entry[1];
    }
    cache = entry[0];
    deps = rest;
  } while (deps.length);
};
var setWeakCacheItem = function setWeakCacheItem(cache, deps, item) {
  do {
    var _deps2 = deps,
      dep = _deps2[0],
      rest = _deps2.slice(1);
    var entry = cache.get(dep);
    if (!entry) {
      entry = [new WeakMap()];
      cache.set(dep, entry);
    }
    if (!rest.length) {
      entry[1] = item;
      return;
    }
    cache = entry[0];
    deps = rest;
  } while (deps.length);
};
var createMemoizeAtom = function createMemoizeAtom() {
  var cache = new WeakMap();
  var memoizeAtom = function memoizeAtom(createAtom, deps) {
    var cachedAtom = getWeakCacheItem(cache, deps);
    if (cachedAtom) {
      return cachedAtom;
    }
    var createdAtom = createAtom();
    setWeakCacheItem(cache, deps, createdAtom);
    return createdAtom;
  };
  return memoizeAtom;
};

var memoizeAtom = createMemoizeAtom();
var isFunction = function isFunction(x) {
  return typeof x === 'function';
};
function focusAtom(baseAtom, callback) {
  return memoizeAtom(function () {
    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);
      return set(baseAtom, newValueProducer(get(baseAtom)));
    });
    return derivedAtom;
  }, [baseAtom, callback]);
}
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;