relay-forms-nodeps 1.0.0

package/lib/es/relay/RelayModernRecord.js

@@ -0,0 +1,183 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (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);
+};
+/* 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
+ */
+import { areEqual, RelayStoreUtils } from './RelayStoreUtils';
+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);
+}
+export var RelayModernRecord = {
+  create: create,
+  getLinkedRecordID: getLinkedRecordID,
+  getLinkedRecordIDs: getLinkedRecordIDs,
+  getValue: getValue,
+  setValue: setValue,
+  setLinkedRecordID: setLinkedRecordID,
+  setLinkedRecordIDs: setLinkedRecordIDs,
+  update: update
+};

package/lib/es/relay/RelayModernSelector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export declare function getSingularSelector(fragment: any, item: any): any;
+export declare function createOperationDescriptor(request: any): any;

package/lib/es/relay/RelayModernSelector.js

@@ -0,0 +1,29 @@
+/**
+ * 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
+ */
+// flowlint ambiguous-object-type:error
+import { RelayStoreUtils } from './RelayStoreUtils';
+var ID_KEY = RelayStoreUtils.ID_KEY;
+function createReaderSelector(node, dataID) {
+  return {
+    //kind: 'SingularReaderSelector',
+    dataID: dataID,
+    node: node
+  };
+}
+export function getSingularSelector(fragment, item) {
+  return createReaderSelector(fragment, item[ID_KEY]);
+}
+export function createOperationDescriptor(request) {
+  var operationDescriptor = {
+    fragment: createReaderSelector(request.fragment, RelayStoreUtils.ROOT_ID),
+    identifier: request.identifier
+  };
+  return operationDescriptor;
+}

package/lib/es/relay/RelayModernStore.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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
+ */
+import { MutableRecordSource, Store } from './RelayTypes';
+export declare function createStore(): RelayModernStore;
+/**
+ * @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.
+ */
+export declare class RelayModernStore implements Store {
+    _gcRun: any;
+    _recordSource: MutableRecordSource;
+    _roots: any;
+    _updatedRecordIDs: any;
+    _currentWriteEpoch: any;
+    _subs: any;
+    constructor(source: MutableRecordSource);
+    getSource(): MutableRecordSource;
+    commitUpdate(updater: any): void;
+    retain(operation: any): {
+        dispose: () => void;
+    };
+    lookup(selector: any): {
+        data: any;
+        seenRecords: any;
+        selector: any;
+    };
+    notify(): void;
+    _updateSub(source: any, subscription: any, updatedRecordIDs: any, hasUpdatedRecords: boolean): void;
+    publish(source: any): void;
+    subscribe(snapshot: any, callback: (snapshot: any) => void): {
+        dispose: () => void;
+    };
+    scheduleGC(): void;
+    _gcStep: () => void;
+    _collect(): Generator<void, void, void>;
+}

package/lib/es/relay/RelayModernStore.js

@@ -0,0 +1,355 @@
+/* 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 strict-local
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var __generator = this && this.__generator || function (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
+    };
+  }
+};
+import { RelayModernRecord } from './RelayModernRecord';
+import { relayRead } from './RelayReader';
+import { RelayRecordSource } from './RelayRecordSource';
+import { RelayRecordSourceMutator } from './RelayRecordSourceMutator';
+import { RelayRecordSourceProxy } from './RelayRecordSourceProxy';
+import { mark } from './RelayReferenceMarker';
+import { hasOverlappingIDs, recycleNodesInto, RelayStoreUtils } from './RelayStoreUtils';
+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;
+export 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:
+          if (!true) return [3 /*break*/, 5];
+          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;
+}();
+export { 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
+  }
+}

package/lib/es/relay/RelayReader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+export declare function relayRead(recordSource: any, selector: any): {
+    data: any;
+    seenRecords: any;
+    selector: any;
+};