relay-forms-nodeps 1.0.0

package/lib/umd/relay-forms-nodeps.js

@@ -0,0 +1,1478 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
+typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["relay-forms-nodeps"] = {}, global.React));
+})(this, (function (exports, React) { 'use strict';
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+var ReactRelayContext = React__default["default"].createContext(null);
+var StoreProvider = function (props) {
+  var context = React__default["default"].useMemo(function () {
+    return {
+      store: props.store
+    };
+  }, [props.store]);
+  return React__default["default"].createElement(ReactRelayContext.Provider, {
+    value: context
+  }, props.children);
+};
+function useStore() {
+  var store = React__default["default"].useContext(ReactRelayContext).store;
+  return store;
+}
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+function isPromise(p) {
+  return !!p && typeof p.then === 'function';
+}
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ */
+var aStackPool = [];
+var bStackPool = [];
+/**
+ * Checks if two values are equal. Values may be primitives, arrays, or objects.
+ * Returns true if both arguments have the same keys and values.
+ *
+ * @see http://underscorejs.org
+ * @copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+ * @license MIT
+ */
+function areEqual(a, b) {
+  var aStack = aStackPool.length ? aStackPool.pop() : [];
+  var bStack = bStackPool.length ? bStackPool.pop() : [];
+  var result = eq(a, b, aStack, bStack);
+  aStack.length = 0;
+  bStack.length = 0;
+  aStackPool.push(aStack);
+  bStackPool.push(bStack);
+  return result;
+}
+function eq(a, b, aStack, bStack) {
+  if (a === b) {
+    // Identical objects are equal. `0 === -0`, but they aren't identical.
+    return a !== 0 || 1 / a == 1 / b;
+  }
+  if (a == null || b == null) {
+    // a or b can be `null` or `undefined`
+    return false;
+  }
+  if (typeof a != 'object' || typeof b != 'object') {
+    return false;
+  }
+  var objToStr = Object.prototype.toString;
+  var className = objToStr.call(a);
+  if (className != objToStr.call(b)) {
+    return false;
+  }
+  switch (className) {
+    case '[object String]':
+      return a == String(b);
+    case '[object Number]':
+      return isNaN(a) || isNaN(b) ? false : a == Number(b);
+    case '[object Date]':
+    case '[object Boolean]':
+      return +a == +b;
+    case '[object RegExp]':
+      return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;
+  } // Assume equality for cyclic structures.
+  var length = aStack.length;
+  // eslint-disable-next-line no-plusplus
+  while (length--) {
+    if (aStack[length] == a) {
+      return bStack[length] == b;
+    }
+  }
+  aStack.push(a);
+  bStack.push(b);
+  var size = 0; // Recursively compare objects and arrays.
+  if (className === '[object Array]') {
+    size = a.length;
+    if (size !== b.length) {
+      return false;
+    } // Deep compare the contents, ignoring non-numeric properties.
+    // eslint-disable-next-line no-plusplus
+    while (size--) {
+      if (!eq(a[size], b[size], aStack, bStack)) {
+        return false;
+      }
+    }
+  } else {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (a.hasOwnProperty('valueOf') && b.hasOwnProperty('valueOf')) {
+      return a.valueOf() == b.valueOf();
+    }
+    var keys = Object.keys(a);
+    if (keys.length != Object.keys(b).length) {
+      return false;
+    }
+    for (var i = 0; i < keys.length; i++) {
+      if (!eq(a[keys[i]], b[keys[i]], aStack, bStack)) {
+        return false;
+      }
+    }
+  }
+  aStack.pop();
+  bStack.pop();
+  return true;
+}
+/**
+ * Constants shared by all implementations of RecordSource/MutableRecordSource/etc.
+ */
+var RelayStoreUtils = {
+  ID_KEY: '__id',
+  REF_KEY: '__ref',
+  REFS_KEY: '__refs',
+  ROOT_ID: 'client:root'
+};
+var RelayRecordState;
+(function (RelayRecordState) {
+  /**
+   * Record exists (either fetched from the server or produced by a local,
+   * optimistic update).
+   */
+  RelayRecordState["EXISTENT"] = "EXISTENT";
+  /**
+   * Record is known not to exist (either as the result of a mutation, or
+   * because the server returned `null` when queried for the record).
+   */
+  RelayRecordState["NONEXISTENT"] = "NONEXISTENT";
+  /**
+   * Record State is unknown because it has not yet been fetched from the
+   * server.
+   */
+  RelayRecordState["UNKNOWN"] = "UNKNOWN";
+})(RelayRecordState || (RelayRecordState = {}));
+var LINKED_FIELD = 'LinkedField';
+//const hasWeakSetDefined = typeof WeakSet !== 'undefined';
+//const hasWeakMapDefined = typeof WeakMap !== 'undefined';
+function checkRecycleData(data) {
+  return typeof data !== 'object' || data instanceof Set || data instanceof Map ||
+  //(hasWeakSetDefined && nextData instanceof WeakSet) ||
+  //(hasWeakMapDefined && nextData instanceof WeakMap) ||
+  !data;
+}
+/**
+ * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
+ */
+function recycleNodesInto(prevData, nextData) {
+  if (prevData === nextData || checkRecycleData(prevData) || checkRecycleData(nextData)) {
+    return nextData;
+  }
+  var canRecycle = false;
+  // Assign local variables to preserve Flow type refinement.
+  var prevArray = Array.isArray(prevData) ? prevData : null;
+  var nextArray = Array.isArray(nextData) ? nextData : null;
+  if (prevArray && nextArray) {
+    canRecycle = nextArray.reduce(function (wasEqual, nextItem, ii) {
+      var prevValue = prevArray[ii];
+      var nextValue = recycleNodesInto(prevValue, nextItem);
+      if (nextValue !== nextArray[ii]) {
+        nextArray[ii] = nextValue;
+      }
+      return wasEqual && nextValue === prevArray[ii];
+    }, true) && prevArray.length === nextArray.length;
+  } else if (!prevArray && !nextArray) {
+    // Assign local variables to preserve Flow type refinement.
+    var prevObject_1 = prevData;
+    var nextObject_1 = nextData;
+    var prevKeys = Object.keys(prevObject_1);
+    var nextKeys = Object.keys(nextObject_1);
+    canRecycle = nextKeys.reduce(function (wasEqual, key) {
+      var prevValue = prevObject_1[key];
+      var nextValue = recycleNodesInto(prevValue, nextObject_1[key]);
+      if (nextValue !== nextObject_1[key]) {
+        nextObject_1[key] = nextValue;
+      }
+      return wasEqual && nextValue === prevObject_1[key];
+    }, true) && prevKeys.length === nextKeys.length;
+  }
+  return canRecycle ? prevData : nextData;
+}
+var ITERATOR_KEY = Symbol.iterator;
+function hasOverlappingIDs(seenRecords, updatedRecordIDs) {
+  // $FlowFixMe: Set is an iterable type, accessing its iterator is allowed.
+  var iterator = seenRecords[ITERATOR_KEY]();
+  var next = iterator.next();
+  while (!next.done) {
+    var key = next.value;
+    if (updatedRecordIDs.has(key)) {
+      return true;
+    }
+    next = iterator.next();
+  }
+  return false;
+}
+
+function useForceUpdate() {
+  var _a = React.useReducer(function (x) {
+      return x + 1;
+    }, 0),
+    forceUpdate = _a[1];
+  return forceUpdate;
+}
+
+var id = {
+  name: 'id'
+};
+var key = {
+  name: 'key'
+};
+var check = {
+  name: 'check'
+};
+var error = {
+  name: 'error'
+};
+var value = {
+  name: 'value'
+};
+var kindFragment = 'Fragment';
+var QueryErrors = {
+  id: '1',
+  fragment: {
+    kind: kindFragment,
+    name: 'queryErrors',
+    selections: [{
+      kind: LINKED_FIELD,
+      name: 'form',
+      plural: false,
+      selections: [{
+        name: 'isSubmitting'
+      }, {
+        name: 'isValidating'
+      }, {
+        kind: LINKED_FIELD,
+        name: 'entries',
+        plural: true,
+        selections: [id, key, error, check]
+      }]
+    }] /*: any*/
+  }
+};
+
+var QueryFields = {
+  id: '0',
+  fragment: {
+    kind: kindFragment,
+    name: 'queryFields',
+    selections: [{
+      kind: LINKED_FIELD,
+      name: 'form',
+      plural: false,
+      selections: [{
+        kind: LINKED_FIELD,
+        name: 'entries',
+        plural: true,
+        selections: [id, key, value, error, check]
+      }]
+    }]
+  }
+};
+var FragmentSet = {
+  kind: kindFragment,
+  name: 'fragmentSet',
+  selections: [id, check]
+};
+var FragmentValue = {
+  kind: kindFragment,
+  name: 'fragmentValue',
+  selections: [id, value, error]
+};
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+var ID_KEY$1 = RelayStoreUtils.ID_KEY;
+function createReaderSelector(node, dataID) {
+  return {
+    //kind: 'SingularReaderSelector',
+    dataID: dataID,
+    node: node
+  };
+}
+function getSingularSelector(fragment, item) {
+  return createReaderSelector(fragment, item[ID_KEY$1]);
+}
+function createOperationDescriptor(request) {
+  var operationDescriptor = {
+    fragment: createReaderSelector(request.fragment, RelayStoreUtils.ROOT_ID),
+    identifier: request.identifier
+  };
+  return operationDescriptor;
+}
+
+var PREFIX_LOCAL_FORM = 'local:form';
+var internalCommitLocalUpdate = function (environment, updater) {
+  environment.commitUpdate(function (store) {
+    var localForm = store.get(PREFIX_LOCAL_FORM);
+    if (!localForm) {
+      localForm = store.create(PREFIX_LOCAL_FORM).setLinkedRecords([], 'entries');
+      store.getRoot().setLinkedRecord(localForm, 'form');
+    }
+    updater(store, localForm);
+  });
+};
+function getFieldId(key) {
+  return PREFIX_LOCAL_FORM + '.' + key;
+}
+function getSnapshot(environment, fragment, key) {
+  var item = {
+    __id: getFieldId(key)
+  };
+  return environment.lookup(getSingularSelector(fragment, item));
+}
+var commitResetIntoRelay = function (entries, environment) {
+  internalCommitLocalUpdate(environment, function (store, form) {
+    form.setValue(false, 'isSubmitting');
+    form.setValue(false, 'isValidating');
+    entries.forEach(function (entry) {
+      return store.get(getFieldId(entry.key)).setValue('RESET', 'check');
+    });
+  });
+};
+var commitValidateIntoRelay = function (entries, isSubmitting, environment) {
+  internalCommitLocalUpdate(environment, function (store, form) {
+    form.setValue(isSubmitting, 'isSubmitting');
+    form.setValue(true, 'isValidating');
+    entries.forEach(function (entry) {
+      return store.get(getFieldId(entry.key)).setValue('START', 'check');
+    });
+  });
+};
+var commitSubmitEndRelay = function (environment) {
+  internalCommitLocalUpdate(environment, function (_, form) {
+    form.setValue(false, 'isSubmitting');
+  });
+};
+var commitValidateEndRelay = function (environment) {
+  internalCommitLocalUpdate(environment, function (_, form) {
+    form.setValue(false, 'isValidating');
+  });
+};
+var commitResetField = function (environment, key) {
+  var id = getFieldId(key);
+  internalCommitLocalUpdate(environment, function (store, form) {
+    var entriesArray = form.getLinkedRecords('entries');
+    var newEntries = entriesArray.filter(function (value) {
+      return value.getDataID() != id;
+    });
+    form.setLinkedRecords(newEntries, 'entries');
+    store.delete(id);
+  });
+};
+var commitValue = function (key, value, check, environment) {
+  var id = getFieldId(key);
+  internalCommitLocalUpdate(environment, function (store, form) {
+    var field = store.get(id);
+    if (!field) {
+      field = store.create(id);
+      var entriesArray = form.getLinkedRecords('entries');
+      entriesArray.push(field);
+      form.setLinkedRecords(entriesArray, 'entries');
+    }
+    field.setValue(id, 'id').setValue(key, 'key').setValue(check, 'check').setValue(value, 'value');
+  });
+};
+var commitErrorIntoRelay = function (key, error, environment) {
+  internalCommitLocalUpdate(environment, function (store) {
+    store.get(getFieldId(key)).setValue(error, 'error').setValue('DONE', 'check');
+  });
+};
+var operationQueryForm = createOperationDescriptor(QueryFields);
+var operationQueryErrorsForm = createOperationDescriptor(QueryErrors);
+
+var useFormState = function () {
+  var ref = React__default["default"].useRef({
+    errors: undefined,
+    isValidating: false,
+    isSubmitting: false,
+    isValid: false
+  });
+  var forceUpdate = useForceUpdate();
+  var environment = useStore();
+  React__default["default"].useEffect(function () {
+    function checkError(s) {
+      var data = s.data;
+      var form = data.form;
+      var entries = form.entries;
+      var current = ref.current;
+      var entryErrors = entries.filter(function (value) {
+        return !!value.error;
+      });
+      var entryValidated = entries.filter(function (value) {
+        return value.check === 'DONE';
+      });
+      var errors = entryErrors.length > 0 ? entryErrors : undefined;
+      var isValidating = form.isValidating;
+      var isSubmitting = form.isSubmitting;
+      var isValid = entries.length === entryValidated.length && (!errors || Object.keys(errors).length === 0);
+      var newState = {
+        errors: errors,
+        isValid: isValid,
+        isValidating: isValidating,
+        isSubmitting: isSubmitting
+      };
+      if (!areEqual(current, newState)) {
+        ref.current = newState;
+        forceUpdate();
+      }
+    }
+    var snapshot = environment.lookup(operationQueryErrorsForm.fragment);
+    checkError(snapshot);
+    return environment.subscribe(snapshot, function (s) {
+      checkError(s);
+    }).dispose;
+  }, [environment, forceUpdate]);
+  return ref.current;
+};
+
+var useFormSubmit = function (_a) {
+  var onSubmit = _a.onSubmit;
+  var environment = useStore();
+  React__default["default"].useEffect(function () {
+    return environment.retain(operationQueryForm).dispose;
+  }, [environment]);
+  var ref = React__default["default"].useRef({
+    isSubmitting: false,
+    isValidating: false,
+    error: undefined,
+    subscription: undefined
+  });
+  var internalValidate = React__default["default"].useCallback(function (snapshot, isSubmitting) {
+    ref.current.isValidating = true;
+    var data = snapshot.data;
+    var filtered = data.form.entries.filter(function (value) {
+      return value.check === 'INIT';
+    });
+    commitValidateIntoRelay(filtered, isSubmitting, environment);
+  }, [environment]);
+  var execute = React__default["default"].useCallback(function (environment, snapshot, dispose, onSubmit) {
+    var data = snapshot.data;
+    var entries = data.form.entries;
+    var filtered = entries.filter(function (value) {
+      return value.check === 'DONE';
+    });
+    if (filtered.length === entries.length) {
+      var errors = entries.filter(function (value) {
+        return !!value.error;
+      });
+      commitValidateEndRelay(environment);
+      ref.current.isValidating = false;
+      var internalDispose = function () {
+        dispose();
+        if (ref.current.isSubmitting) {
+          ref.current.isSubmitting = false;
+          commitSubmitEndRelay(environment);
+        }
+      };
+      if (ref.current.isSubmitting && onSubmit && errors.length === 0) {
+        var result_1 = {};
+        entries.forEach(function (entry) {
+          result_1[entry.key] = entry.value;
+        });
+        var submit_1 = onSubmit(result_1);
+        if (isPromise(submit_1)) {
+          submit_1.then(internalDispose).catch(internalDispose);
+          return;
+        }
+      }
+      internalDispose();
+    }
+  }, []);
+  var reset = React__default["default"].useCallback(function () {
+    var snapshot = environment.lookup(operationQueryForm.fragment);
+    if (ref.current.isValidating && ref.current.isSubmitting) {
+      return;
+    }
+    var data = snapshot.data;
+    commitResetIntoRelay(data.form.entries, environment);
+  }, [environment]);
+  var subscribe = React__default["default"].useCallback(function (submit) {
+    if (submit === void 0) {
+      submit = false;
+    }
+    var snapshot = environment.lookup(operationQueryForm.fragment);
+    var subscription = ref.current.subscription;
+    subscription && subscription.dispose();
+    function dispose() {
+      subscription && subscription.dispose();
+      ref.current.subscription = null;
+    }
+    ref.current.subscription = environment.subscribe(snapshot, function (s) {
+      return execute(environment, s, dispose, onSubmit);
+    });
+    internalValidate(snapshot, submit);
+    execute(environment, snapshot, dispose, onSubmit);
+  }, [environment, internalValidate, execute, onSubmit]);
+  var validate = React__default["default"].useCallback(function () {
+    if (!ref.current.isValidating) {
+      subscribe(false);
+    }
+  }, [subscribe]);
+  var submit = React__default["default"].useCallback(function (event) {
+    if (event) {
+      event.preventDefault();
+    }
+    if (!ref.current.isSubmitting) {
+      ref.current.isSubmitting = true;
+      subscribe(true);
+    }
+  }, [subscribe]);
+  var result = React__default["default"].useMemo(function () {
+    return {
+      submit: submit,
+      validate: validate,
+      reset: reset
+    };
+  }, [submit, validate, reset]);
+  return result;
+};
+
+function useFormSetValue(_a) {
+  var key = _a.key,
+    initialValue = _a.initialValue,
+    validate = _a.validate,
+    validateOnChange = _a.validateOnChange;
+  var forceUpdate = useForceUpdate();
+  var environment = useStore();
+  var ref = React__default["default"].useRef({
+    value: initialValue,
+    error: undefined,
+    check: validate ? 'INIT' : 'DONE',
+    isChecking: false
+  });
+  var setValue = React__default["default"].useCallback(function (newValue) {
+    ref.current.value = newValue;
+    if (ref.current.check === 'DONE' && validate) {
+      ref.current.check = 'START';
+    }
+    commitValue(key, newValue, ref.current.check, environment);
+    forceUpdate();
+  }, [environment, key, validate, forceUpdate]);
+  React__default["default"].useEffect(function () {
+    //commitResetField(environment, key);
+    commitValue(key, initialValue, ref.current.check, environment);
+    var snapshot = getSnapshot(environment, FragmentSet, key);
+    var disposeSubscrition = environment.subscribe(snapshot, function (s) {
+      var check = s.data.check;
+      var isStart = check === 'START';
+      var isReset = check === 'RESET';
+      ref.current.check = check;
+      if (isReset) {
+        ref.current.check = validate ? 'INIT' : 'DONE';
+        setValue(initialValue);
+      } else {
+        if (!validate) {
+          commitErrorIntoRelay(key, undefined, environment);
+          return;
+        }
+        if (isStart && !ref.current.isChecking) {
+          internalValidate(ref.current.value);
+        }
+      }
+    }).dispose;
+    var dispose = function () {
+      disposeSubscrition();
+      commitResetField(environment, key);
+    };
+    function finalizeCheck(error) {
+      ref.current.isChecking = false;
+      if (ref.current.error !== error) {
+        ref.current.error = error;
+        forceUpdate();
+      }
+      commitErrorIntoRelay(key, error, environment);
+    }
+    function internalValidate(value) {
+      ref.current.isChecking = true;
+      var result = validate(value);
+      function internalFinalize(error) {
+        if (value !== ref.current.value) {
+          internalValidate(ref.current.value);
+          return;
+        }
+        finalizeCheck(error);
+      }
+      if (isPromise(result)) {
+        result.then(internalFinalize).catch(internalFinalize);
+      } else {
+        internalFinalize(result);
+      }
+    }
+    if (validateOnChange) {
+      internalValidate(initialValue);
+    }
+    return dispose;
+  }, [environment, initialValue, key, setValue, validate, validateOnChange, forceUpdate]);
+  return [ref.current, setValue];
+}
+
+function useFormValue(key) {
+  var environment = useStore();
+  var snapshot = React__default["default"].useMemo(function () {
+    return getSnapshot(environment, FragmentValue, key);
+  }, [key, environment]);
+  var _a = React__default["default"].useState(snapshot.data),
+    data = _a[0],
+    setData = _a[1];
+  React__default["default"].useEffect(function () {
+    return environment.subscribe(snapshot, function (s) {
+      setData(s.data);
+    }).dispose;
+  }, [environment, snapshot, setData]);
+  return data;
+}
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var ID_KEY = RelayStoreUtils.ID_KEY,
+  REF_KEY = RelayStoreUtils.REF_KEY,
+  REFS_KEY = RelayStoreUtils.REFS_KEY;
+/**
+ * @public
+ *
+ * Low-level record manipulation methods.
+ *
+ * A note about perf: we use long-hand property access rather than computed
+ * properties in this file for speed ie.
+ *
+ *    const object = {};
+ *    object[KEY] = value;
+ *    record[storageKey] = object;
+ *
+ * instead of:
+ *
+ *    record[storageKey] = {
+ *      [KEY]: value,
+ *    };
+ *
+ * The latter gets transformed by Babel into something like:
+ *
+ *    function _defineProperty(obj, key, value) {
+ *      if (key in obj) {
+ *        Object.defineProperty(obj, key, {
+ *          value: value,
+ *          enumerable: true,
+ *          configurable: true,
+ *          writable: true,
+ *        });
+ *      } else {
+ *        obj[key] = value;
+ *      }
+ *      return obj;
+ *    }
+ *
+ *    record[storageKey] = _defineProperty({}, KEY, value);
+ *
+ * A quick benchmark shows that computed property access is an order of
+ * magnitude slower (times in seconds for 100,000 iterations):
+ *
+ *               best     avg     sd
+ *    computed 0.02175 0.02292 0.00113
+ *      manual 0.00110 0.00123 0.00008
+ */
+/**
+ * @public
+ *
+ * Create a new record.
+ */
+function create(dataID) {
+  // See perf note above for why we aren't using computed property access.
+  var record = {};
+  record[ID_KEY] = dataID;
+  return record;
+}
+/**
+ * @public
+ *
+ * Get a scalar (non-link) field value.
+ */
+function getValue(record, storageKey) {
+  return record[storageKey];
+}
+/**
+ * @private
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+function getLinkedRecordKey(record, storageKey, key) {
+  var link = record[storageKey];
+  if (link == null) {
+    return link;
+  }
+  return link[key];
+}
+/**
+ * @public
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+function getLinkedRecordID(record, storageKey) {
+  return getLinkedRecordKey(record, storageKey, REF_KEY);
+}
+/**
+ * @public
+ *
+ * Get the value of a field as a list of references to other records. Throws if
+ * the field has a different type.
+ */
+function getLinkedRecordIDs(record, storageKey) {
+  return getLinkedRecordKey(record, storageKey, REFS_KEY);
+}
+/**
+ * @public
+ *
+ * Compares the fields of a previous and new record, returning either the
+ * previous record if all fields are equal or a new record (with merged fields)
+ * if any fields have changed.
+ */
+function update(prevRecord, nextRecord) {
+  var updated = null;
+  var keys = Object.keys(nextRecord);
+  for (var ii = 0; ii < keys.length; ii++) {
+    var key = keys[ii];
+    if (updated || !areEqual(prevRecord[key], nextRecord[key])) {
+      updated = updated !== null ? updated : __assign({}, prevRecord);
+      updated[key] = nextRecord[key];
+    }
+  }
+  return updated !== null ? updated : prevRecord;
+}
+/**
+ * @public
+ *
+ * Set the value of a storageKey to a scalar.
+ * YES
+ */
+function setValue(record, storageKey, value) {
+  record[storageKey] = value;
+}
+/**
+ * @private
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+function setLinkedRecordKey(record, storageKey, linkedID, key) {
+  // See perf note above for why we aren't using computed property access.
+  var link = {};
+  link[key] = linkedID;
+  record[storageKey] = link;
+}
+/**
+ * @public
+ *
+ * Set the value of a field to a reference to another record.
+ */
+function setLinkedRecordID(record, storageKey, linkedID) {
+  setLinkedRecordKey(record, storageKey, linkedID, REF_KEY);
+}
+/**
+ * @public
+ *
+ * Set the value of a field to a list of references other records.
+ */
+function setLinkedRecordIDs(record, storageKey, linkedIDs) {
+  setLinkedRecordKey(record, storageKey, linkedIDs, REFS_KEY);
+}
+var RelayModernRecord = {
+  create: create,
+  getLinkedRecordID: getLinkedRecordID,
+  getLinkedRecordIDs: getLinkedRecordIDs,
+  getValue: getValue,
+  setValue: setValue,
+  setLinkedRecordID: setLinkedRecordID,
+  setLinkedRecordIDs: setLinkedRecordIDs,
+  update: update
+};
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+function relayRead(recordSource, selector) {
+  var reader = new RelayReader(recordSource, selector);
+  return reader.read();
+}
+/**
+ * @private
+ */
+var RelayReader = /** @class */function () {
+  function RelayReader(recordSource, selector) {
+    this._recordSource = recordSource;
+    this._seenRecords = new Set();
+    this._selector = selector;
+  }
+  RelayReader.prototype.read = function () {
+    var _a = this._selector,
+      node = _a.node,
+      dataID = _a.dataID;
+    var data = this._traverse(node, dataID, null);
+    return {
+      data: data,
+      seenRecords: this._seenRecords,
+      selector: this._selector
+    };
+  };
+  RelayReader.prototype._traverse = function (node, dataID, prevData) {
+    if (dataID == null) {
+      return dataID;
+    }
+    var record = this._recordSource.get(dataID);
+    this._seenRecords.add(dataID);
+    if (record == null) {
+      return record;
+    }
+    var data = prevData || {};
+    this._traverseSelections(node.selections, record, data);
+    return data;
+  };
+  RelayReader.prototype._traverseSelections = function (selections, record, data) {
+    var _this = this;
+    var _loop_1 = function (i) {
+      var selection = selections[i];
+      var name_1 = selection.name;
+      var prevData = data[name_1];
+      var value = null;
+      if (selection.kind == LINKED_FIELD) {
+        if (selection.plural) {
+          var ids = RelayModernRecord.getLinkedRecordIDs(record, name_1);
+          if (ids != null) {
+            var linkedArray_1 = prevData || [];
+            ids.forEach(function (linkedID, nextIndex) {
+              var prevItem = linkedArray_1[nextIndex];
+              linkedArray_1[nextIndex] = _this._traverse(selection, linkedID, prevItem);
+            });
+            value = linkedArray_1;
+          }
+        } else {
+          var id = RelayModernRecord.getLinkedRecordID(record, name_1);
+          value = this_1._traverse(selection, id, prevData);
+        }
+      } else {
+        // relay-forms, now default scalar
+        value = RelayModernRecord.getValue(record, name_1);
+        //this._readScalar(selection, record, data);
+      }
+
+      data[name_1] = value;
+    };
+    var this_1 = this;
+    for (var i = 0; i < selections.length; i++) {
+      _loop_1(i);
+    }
+  };
+  return RelayReader;
+}();
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+var EXISTENT = RelayRecordState.EXISTENT,
+  NONEXISTENT = RelayRecordState.NONEXISTENT,
+  UNKNOWN = RelayRecordState.UNKNOWN;
+/**
+ * An implementation of the `MutableRecordSource` interface (defined in
+ * `RelayStoreTypes`) that holds all records in memory (JS Map).
+ */
+var RelayRecordSource = /** @class */function () {
+  function RelayRecordSource(records) {
+    var _this = this;
+    this._records = new Map();
+    if (records != null) {
+      Object.keys(records).forEach(function (key) {
+        _this._records.set(key, records[key]);
+      });
+    }
+  }
+  RelayRecordSource.prototype.clear = function () {
+    this._records = new Map();
+  };
+  RelayRecordSource.prototype.delete = function (dataID) {
+    this._records.set(dataID, null);
+  };
+  RelayRecordSource.prototype.get = function (dataID) {
+    return this._records.get(dataID);
+  };
+  RelayRecordSource.prototype.getRecordIDs = function () {
+    return Array.from(this._records.keys());
+  };
+  RelayRecordSource.prototype.getStatus = function (dataID) {
+    if (!this._records.has(dataID)) {
+      return UNKNOWN;
+    }
+    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;
+  };
+  RelayRecordSource.prototype.has = function (dataID) {
+    return this._records.has(dataID);
+  };
+  RelayRecordSource.prototype.remove = function (dataID) {
+    this._records.delete(dataID);
+  };
+  RelayRecordSource.prototype.set = function (dataID, record) {
+    this._records.set(dataID, record);
+  };
+  RelayRecordSource.prototype.size = function () {
+    return this._records.size;
+  };
+  RelayRecordSource.prototype.toJSON = function () {
+    var obj = {};
+    for (var _i = 0, _a = this._records.entries(); _i < _a.length; _i++) {
+      var _b = _a[_i],
+        key = _b[0],
+        value = _b[1];
+      obj[key] = value;
+    }
+    return obj;
+  };
+  return RelayRecordSource;
+}();
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/**
+ * @internal
+ *
+ * Wrapper API that is an amalgam of the `RelayModernRecord` API and
+ * `MutableRecordSource` interface, implementing copy-on-write semantics for records
+ * in a record source.
+ *
+ * Modifications are applied to fresh copies of records:
+ * - Records in `base` are never modified.
+ * - Modifications cause a fresh version of a record to be created in `sink`.
+ *   These sink records contain only modified fields.
+ */
+var RelayRecordSourceMutator = /** @class */function () {
+  function RelayRecordSourceMutator(base, sink) {
+    this.__sources = [sink, base];
+    this._base = base;
+    this._sink = sink;
+  }
+  RelayRecordSourceMutator.prototype._getSinkRecord = function (dataID) {
+    var sinkRecord = this._sink.get(dataID);
+    if (!sinkRecord) {
+      sinkRecord = RelayModernRecord.create(dataID);
+      this._sink.set(dataID, sinkRecord);
+    }
+    return sinkRecord;
+  };
+  RelayRecordSourceMutator.prototype.create = function (dataID) {
+    var record = RelayModernRecord.create(dataID);
+    this._sink.set(dataID, record);
+  };
+  RelayRecordSourceMutator.prototype.delete = function (dataID) {
+    this._sink.delete(dataID);
+  };
+  RelayRecordSourceMutator.prototype.getStatus = function (dataID) {
+    return this._sink.has(dataID) ? this._sink.getStatus(dataID) : this._base.getStatus(dataID);
+  };
+  RelayRecordSourceMutator.prototype.setValue = function (dataID, storageKey, value) {
+    var sinkRecord = this._getSinkRecord(dataID);
+    RelayModernRecord.setValue(sinkRecord, storageKey, value);
+  };
+  RelayRecordSourceMutator.prototype.setLinkedRecordID = function (dataID, storageKey, linkedID) {
+    var sinkRecord = this._getSinkRecord(dataID);
+    RelayModernRecord.setLinkedRecordID(sinkRecord, storageKey, linkedID);
+  };
+  RelayRecordSourceMutator.prototype.getLinkedRecordIDs = function (dataID, storageKey) {
+    for (var ii = 0; ii < this.__sources.length; ii++) {
+      var record = this.__sources[ii].get(dataID);
+      if (record) {
+        var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);
+        if (linkedIDs !== undefined) {
+          return linkedIDs;
+        }
+      } else if (record === null) {
+        return null;
+      }
+    }
+  };
+  RelayRecordSourceMutator.prototype.setLinkedRecordIDs = function (dataID, storageKey, linkedIDs) {
+    var sinkRecord = this._getSinkRecord(dataID);
+    RelayModernRecord.setLinkedRecordIDs(sinkRecord, storageKey, linkedIDs);
+  };
+  return RelayRecordSourceMutator;
+}();
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+
+/**
+ * @internal
+ *
+ * A helper class for manipulating a given record from a record source via an
+ * imperative/OO-style API.
+ */
+var RelayRecordProxy = /** @class */function () {
+  function RelayRecordProxy(source, mutator, dataID) {
+    this._dataID = dataID;
+    this._mutator = mutator;
+    this._source = source;
+  }
+  RelayRecordProxy.prototype.getDataID = function () {
+    return this._dataID;
+  };
+  RelayRecordProxy.prototype.setValue = function (value, name) {
+    this._mutator.setValue(this._dataID, name, value);
+    return this;
+  };
+  RelayRecordProxy.prototype.setLinkedRecord = function (record, name) {
+    var linkedID = record.getDataID();
+    this._mutator.setLinkedRecordID(this._dataID, name, linkedID);
+    return this;
+  };
+  RelayRecordProxy.prototype.getLinkedRecords = function (name) {
+    var _this = this;
+    var linkedIDs = this._mutator.getLinkedRecordIDs(this._dataID, name);
+    if (linkedIDs == null) {
+      return linkedIDs;
+    }
+    return linkedIDs.map(function (linkedID) {
+      return linkedID != null ? _this._source.get(linkedID) : linkedID;
+    });
+  };
+  RelayRecordProxy.prototype.setLinkedRecords = function (records, name) {
+    var linkedIDs = records.map(function (record) {
+      return record && record.getDataID();
+    });
+    this._mutator.setLinkedRecordIDs(this._dataID, name, linkedIDs);
+    return this;
+  };
+  return RelayRecordProxy;
+}();
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/**
+ * @internal
+ *
+ * A helper for manipulating a `RecordSource` via an imperative/OO-style API.
+ */
+var RelayRecordSourceProxy = /** @class */function () {
+  function RelayRecordSourceProxy(mutator) {
+    this.__mutator = mutator;
+    this._proxies = {};
+  }
+  RelayRecordSourceProxy.prototype.create = function (dataID) {
+    this.__mutator.create(dataID);
+    delete this._proxies[dataID];
+    return this.get(dataID);
+  };
+  RelayRecordSourceProxy.prototype.delete = function (dataID) {
+    delete this._proxies[dataID];
+    this.__mutator.delete(dataID);
+  };
+  RelayRecordSourceProxy.prototype.get = function (dataID) {
+    if (!this._proxies.hasOwnProperty(dataID)) {
+      var status_1 = this.__mutator.getStatus(dataID);
+      if (status_1 === RelayRecordState.EXISTENT) {
+        this._proxies[dataID] = new RelayRecordProxy(this, this.__mutator, dataID);
+      } else {
+        this._proxies[dataID] = status_1 === RelayRecordState.NONEXISTENT ? null : undefined;
+      }
+    }
+    return this._proxies[dataID];
+  };
+  RelayRecordSourceProxy.prototype.getRoot = function () {
+    var root = this.get(RelayStoreUtils.ROOT_ID);
+    if (!root) {
+      root = this.create(RelayStoreUtils.ROOT_ID);
+    }
+    return root;
+  };
+  return RelayRecordSourceProxy;
+}();
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+function mark(recordSource, selector, references) {
+  var dataID = selector.dataID,
+    node = selector.node;
+  var marker = new RelayReferenceMarker(recordSource, references);
+  marker.mark(node, dataID);
+}
+/**
+ * @private
+ */
+var RelayReferenceMarker = /** @class */function () {
+  function RelayReferenceMarker(recordSource, references) {
+    this._recordSource = recordSource;
+    this._references = references;
+  }
+  RelayReferenceMarker.prototype.mark = function (node, dataID) {
+    this._traverse(node, dataID);
+  };
+  RelayReferenceMarker.prototype._traverse = function (node, dataID) {
+    if (dataID != null) {
+      this._references.add(dataID);
+      var record = this._recordSource.get(dataID);
+      record != null && this._traverseSelections(node.selections, record);
+    }
+  };
+  RelayReferenceMarker.prototype._traverseSelections = function (selections, record) {
+    var _this = this;
+    selections.forEach(function (selection) {
+      var name = selection.name;
+      if (selection.kind == LINKED_FIELD) {
+        if (selection.plural) {
+          var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, name) || [];
+          linkedIDs.forEach(function (linkedID) {
+            _this._traverse(selection, linkedID);
+          });
+        } else {
+          var linkedID = RelayModernRecord.getLinkedRecordID(record, name);
+          _this._traverse(selection, linkedID);
+        }
+      }
+    });
+  };
+  return RelayReferenceMarker;
+}();
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+var resolvedPromise = Promise.resolve();
+/**
+ * An alternative to setImmediate based on Promise.
+ */
+function resolveImmediate(callback) {
+  resolvedPromise.then(callback).catch(throwNext);
+}
+function throwNext(error) {
+  setTimeout(function () {
+    throw error;
+  }, 0);
+}
+var ROOT_ID = RelayStoreUtils.ROOT_ID;
+function createStore() {
+  return new RelayModernStore(new RelayRecordSource());
+}
+/**
+ * @public
+ *
+ * An implementation of the `Store` interface defined in `RelayStoreTypes`.
+ *
+ * Note that a Store takes ownership of all records provided to it: other
+ * objects may continue to hold a reference to such records but may not mutate
+ * them. The static Relay core is architected to avoid mutating records that may have been
+ * passed to a store: operations that mutate records will either create fresh
+ * records or clone existing records and modify the clones. Record immutability
+ * is also enforced in development mode by freezing all records passed to a store.
+ */
+var RelayModernStore = /** @class */function () {
+  function RelayModernStore(source) {
+    var _this = this;
+    this._gcStep = function () {
+      if (_this._gcRun) {
+        if (_this._gcRun.next().done) {
+          _this._gcRun = null;
+        } else {
+          resolveImmediate(_this._gcStep);
+        }
+      }
+    };
+    this._currentWriteEpoch = 0;
+    this._gcRun = null;
+    this._recordSource = source;
+    this._roots = new Map();
+    this._updatedRecordIDs = new Set();
+    this._subs = new Set();
+    initializeRecordSource(this._recordSource);
+  }
+  RelayModernStore.prototype.getSource = function () {
+    return this._recordSource;
+  };
+  RelayModernStore.prototype.commitUpdate = function (updater) {
+    var sink = new RelayRecordSource();
+    var mutator = new RelayRecordSourceMutator(this.getSource(), sink);
+    var recordSourceProxy = new RelayRecordSourceProxy(mutator);
+    updater(recordSourceProxy);
+    this.publish(sink);
+    this.notify();
+  };
+  RelayModernStore.prototype.retain = function (operation) {
+    var _this = this;
+    var id = operation.identifier;
+    var disposed = false;
+    var dispose = function () {
+      // Ensure each retain can only dispose once
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      // For Flow: guard against the entry somehow not existing
+      var rootEntry = _this._roots.get(id);
+      if (rootEntry == null) {
+        return;
+      }
+      // Decrement the ref count: if it becomes zero it is eligible
+      // for release.
+      rootEntry.refCount -= 1;
+      if (rootEntry.refCount === 0) {
+        _this._roots.delete(id);
+        _this.scheduleGC();
+      }
+    };
+    var rootEntry = this._roots.get(id);
+    if (rootEntry != null) {
+      // If we've previously retained this operation, increment the refCount
+      rootEntry.refCount += 1;
+    } else {
+      // Otherwise create a new entry for the operation
+      this._roots.set(id, {
+        operation: operation,
+        refCount: 1
+      });
+    }
+    return {
+      dispose: dispose
+    };
+  };
+  RelayModernStore.prototype.lookup = function (selector) {
+    var source = this.getSource();
+    return relayRead(source, selector);
+  };
+  // This method will return a list of updated owners from the subscriptions
+  RelayModernStore.prototype.notify = function () {
+    var _this = this;
+    this._currentWriteEpoch += 1;
+    var updateIds = this._updatedRecordIDs;
+    var hasUpdatedRecords = updateIds.size !== 0;
+    var source = this.getSource();
+    this._subs.forEach(function (subscription) {
+      _this._updateSub(source, subscription, updateIds, hasUpdatedRecords);
+    });
+    this._updatedRecordIDs.clear();
+  };
+  RelayModernStore.prototype._updateSub = function (source, subscription, updatedRecordIDs, hasUpdatedRecords) {
+    var callback = subscription.callback,
+      snapshot = subscription.snapshot;
+    var hasOverlappingUpdates = hasUpdatedRecords && hasOverlappingIDs(snapshot.seenRecords, updatedRecordIDs);
+    if (hasOverlappingUpdates) {
+      var nextSnapshot = relayRead(source, snapshot.selector);
+      var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
+      nextSnapshot = {
+        data: nextData,
+        seenRecords: nextSnapshot.seenRecords,
+        selector: nextSnapshot.selector
+      };
+      subscription.snapshot = nextSnapshot;
+      if (nextSnapshot.data !== snapshot.data) {
+        callback(nextSnapshot);
+      }
+    }
+  };
+  RelayModernStore.prototype.publish = function (source) {
+    var target = this.getSource();
+    updateTargetFromSource(target, source, this._updatedRecordIDs);
+  };
+  RelayModernStore.prototype.subscribe = function (snapshot, callback) {
+    var _this = this;
+    var subscription = {
+      callback: callback,
+      snapshot: snapshot
+    };
+    var dispose = function () {
+      _this._subs.delete(subscription);
+    };
+    this._subs.add(subscription);
+    return {
+      dispose: dispose
+    };
+  };
+  RelayModernStore.prototype.scheduleGC = function () {
+    if (this._gcRun) {
+      return;
+    }
+    this._gcRun = this._collect();
+    resolveImmediate(this._gcStep);
+  };
+  RelayModernStore.prototype._collect = function () {
+    var startEpoch, references, _i, _a, operation, storeIDs, ii, dataID;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          startEpoch = this._currentWriteEpoch;
+          references = new Set();
+          _i = 0, _a = this._roots.values();
+          _b.label = 1;
+        case 1:
+          if (!(_i < _a.length)) return [3 /*break*/, 4];
+          operation = _a[_i].operation;
+          mark(this._recordSource, operation.fragment, references);
+          // Yield for other work after each operation
+          return [4 /*yield*/];
+        case 2:
+          // Yield for other work after each operation
+          _b.sent();
+          // If the store was updated, restart
+          if (startEpoch !== this._currentWriteEpoch) {
+            return [3 /*break*/, 0];
+          }
+          _b.label = 3;
+        case 3:
+          _i++;
+          return [3 /*break*/, 1];
+        case 4:
+          // Sweep records without references
+          if (references.size === 0) {
+            // Short-circuit if *nothing* is referenced
+            this._recordSource.clear();
+          } else {
+            storeIDs = this._recordSource.getRecordIDs();
+            for (ii = 0; ii < storeIDs.length; ii++) {
+              dataID = storeIDs[ii];
+              if (!references.has(dataID)) {
+                this._recordSource.remove(dataID);
+              }
+            }
+          }
+          return [2 /*return*/];
+        case 5:
+          return [2 /*return*/];
+      }
+    });
+  };
+
+  return RelayModernStore;
+}();
+function initializeRecordSource(target) {
+  if (!target.has(ROOT_ID)) {
+    var rootRecord = RelayModernRecord.create(ROOT_ID);
+    target.set(ROOT_ID, rootRecord);
+  }
+}
+/**
+ * Updates the target with information from source, also updating a mapping of
+ * which records in the target were changed as a result.
+ * Additionally, will mark records as invalidated at the current write epoch
+ * given the set of record ids marked as stale in this update.
+ */
+function updateTargetFromSource(target, source, updatedRecordIDs) {
+  // Update the target based on the changes present in source
+  var dataIDs = source.getRecordIDs();
+  for (var ii = 0; ii < dataIDs.length; ii++) {
+    var dataID = dataIDs[ii];
+    var sourceRecord = source.get(dataID);
+    var targetRecord = target.get(dataID);
+    if (sourceRecord && targetRecord) {
+      // ReactFlightClientResponses are lazy and only materialize when readRoot
+      // is called when we read the field, so if the record is a Flight field
+      // we always use the new record's data regardless of whether
+      // it actually changed. Let React take care of reconciliation instead.
+      var nextRecord = RelayModernRecord.update(targetRecord, sourceRecord);
+      if (nextRecord !== targetRecord) {
+        updatedRecordIDs.add(dataID);
+        target.set(dataID, nextRecord);
+      }
+    } else if (sourceRecord === null) {
+      target.delete(dataID);
+      if (targetRecord !== null) {
+        updatedRecordIDs.add(dataID);
+      }
+    } else if (sourceRecord) {
+      target.set(dataID, sourceRecord);
+      updatedRecordIDs.add(dataID);
+    } // don't add explicit undefined
+  }
+}
+
+exports.RecordSource = RelayRecordSource;
+exports.Store = RelayModernStore;
+exports.StoreProvider = StoreProvider;
+exports.createStore = createStore;
+exports.useFormSetValue = useFormSetValue;
+exports.useFormState = useFormState;
+exports.useFormSubmit = useFormSubmit;
+exports.useFormValue = useFormValue;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=relay-forms-nodeps.js.map