relay-forms-nodeps 1.0.0

package/lib/relay/RelayModernStore.js

@@ -0,0 +1,359 @@
+/* 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
+    };
+  }
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var RelayModernRecord_1 = require("./RelayModernRecord");
+var RelayReader_1 = require("./RelayReader");
+var RelayRecordSource_1 = require("./RelayRecordSource");
+var RelayRecordSourceMutator_1 = require("./RelayRecordSourceMutator");
+var RelayRecordSourceProxy_1 = require("./RelayRecordSourceProxy");
+var RelayReferenceMarker_1 = require("./RelayReferenceMarker");
+var RelayStoreUtils_1 = require("./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_1.RelayStoreUtils.ROOT_ID;
+function createStore() {
+  return new RelayModernStore(new RelayRecordSource_1.RelayRecordSource());
+}
+exports.createStore = createStore;
+/**
+ * @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_1.RelayRecordSource();
+    var mutator = new RelayRecordSourceMutator_1.RelayRecordSourceMutator(this.getSource(), sink);
+    var recordSourceProxy = new RelayRecordSourceProxy_1.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 RelayReader_1.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 && RelayStoreUtils_1.hasOverlappingIDs(snapshot.seenRecords, updatedRecordIDs);
+    if (hasOverlappingUpdates) {
+      var nextSnapshot = RelayReader_1.relayRead(source, snapshot.selector);
+      var nextData = RelayStoreUtils_1.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;
+          RelayReferenceMarker_1.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;
+}();
+exports.RelayModernStore = RelayModernStore;
+function initializeRecordSource(target) {
+  if (!target.has(ROOT_ID)) {
+    var rootRecord = RelayModernRecord_1.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_1.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/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;
+};

package/lib/relay/RelayReader.js

@@ -0,0 +1,92 @@
+"use strict";
+
+/* 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
+ */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var RelayModernRecord_1 = require("./RelayModernRecord");
+var RelayStoreUtils_1 = require("./RelayStoreUtils");
+function relayRead(recordSource, selector) {
+  var reader = new RelayReader(recordSource, selector);
+  return reader.read();
+}
+exports.relayRead = relayRead;
+/**
+ * @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 == RelayStoreUtils_1.LINKED_FIELD) {
+        if (selection.plural) {
+          var ids = RelayModernRecord_1.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_1.RelayModernRecord.getLinkedRecordID(record, name_1);
+          value = this_1._traverse(selection, id, prevData);
+        }
+      } else {
+        // relay-forms, now default scalar
+        value = RelayModernRecord_1.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;
+}();

package/lib/relay/RelayRecordProxy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { RelayRecordSourceMutator } from './RelayRecordSourceMutator';
+import { RecordProxy } from './RelayTypes';
+/**
+ * @internal
+ *
+ * A helper class for manipulating a given record from a record source via an
+ * imperative/OO-style API.
+ */
+export declare class RelayRecordProxy implements RecordProxy {
+    _dataID: any;
+    _mutator: RelayRecordSourceMutator;
+    _source: any;
+    constructor(source: any, mutator: any, dataID: any);
+    getDataID(): string;
+    setValue(value: any, name: string): this;
+    setLinkedRecord(record: RecordProxy, name: string): this;
+    getLinkedRecords(name: string): Array<RecordProxy | null | undefined> | null | undefined;
+    setLinkedRecords(records: any, name: string): RecordProxy;
+}

package/lib/relay/RelayRecordProxy.js

@@ -0,0 +1,60 @@
+/* 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';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/**
+ * @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;
+}();
+exports.RelayRecordProxy = RelayRecordProxy;

package/lib/relay/RelayRecordSource.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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, Record, RecordState } from './RelayTypes';
+/**
+ * An implementation of the `MutableRecordSource` interface (defined in
+ * `RelayStoreTypes`) that holds all records in memory (JS Map).
+ */
+export declare class RelayRecordSource implements MutableRecordSource {
+    _records: any;
+    constructor(records?: any);
+    clear(): void;
+    delete(dataID: any): void;
+    get(dataID: any): Record | null | undefined;
+    getRecordIDs(): Array<string>;
+    getStatus(dataID: any): RecordState;
+    has(dataID: any): boolean;
+    remove(dataID: any): void;
+    set(dataID: any, record: any): void;
+    size(): number;
+    toJSON(): any;
+}

package/lib/relay/RelayRecordSource.js

@@ -0,0 +1,75 @@
+"use strict";
+
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var RelayStoreUtils_1 = require("./RelayStoreUtils");
+var EXISTENT = RelayStoreUtils_1.RelayRecordState.EXISTENT,
+  NONEXISTENT = RelayStoreUtils_1.RelayRecordState.NONEXISTENT,
+  UNKNOWN = RelayStoreUtils_1.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;
+}();
+exports.RelayRecordSource = RelayRecordSource;

package/lib/relay/RelayRecordSourceMutator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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, Record, RecordSource } from './RelayTypes';
+/**
+ * @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.
+ */
+export declare class RelayRecordSourceMutator {
+    __sources: Array<RecordSource>;
+    _base: RecordSource;
+    _sink: MutableRecordSource;
+    constructor(base: any, sink: any);
+    _getSinkRecord(dataID: any): Record;
+    create(dataID: any): void;
+    delete(dataID: any): void;
+    getStatus(dataID: any): "EXISTENT" | "NONEXISTENT" | "UNKNOWN";
+    setValue(dataID: any, storageKey: string, value: any): void;
+    setLinkedRecordID(dataID: any, storageKey: any, linkedID: any): void;
+    getLinkedRecordIDs(dataID: any, storageKey: string): any;
+    setLinkedRecordIDs(dataID: any, storageKey: string, linkedIDs: any): void;
+}