relay-forms-nodeps 1.0.0

package/lib/es/relay/RelayReader.js

@@ -0,0 +1,86 @@
+/* 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
+ */
+import { RelayModernRecord } from './RelayModernRecord';
+import { LINKED_FIELD } from './RelayStoreUtils';
+export 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;
+}();

package/lib/es/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/es/relay/RelayRecordProxy.js

@@ -0,0 +1,57 @@
+/* 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';
+
+/**
+ * @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;
+}();
+export { RelayRecordProxy };

package/lib/es/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/es/relay/RelayRecordSource.js

@@ -0,0 +1,70 @@
+/**
+ * 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 { RelayRecordState } from './RelayStoreUtils';
+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;
+}();
+export { RelayRecordSource };

package/lib/es/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;
+}

package/lib/es/relay/RelayRecordSourceMutator.js

@@ -0,0 +1,75 @@
+/* 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
+ */
+import { RelayModernRecord } from './RelayModernRecord';
+/**
+ * @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;
+}();
+export { RelayRecordSourceMutator };

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

@@ -0,0 +1,25 @@
+/**
+ * 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 { RelayRecordSourceMutator } from './RelayRecordSourceMutator';
+import { RecordSourceProxy } from './RelayTypes';
+/**
+ * @internal
+ *
+ * A helper for manipulating a `RecordSource` via an imperative/OO-style API.
+ */
+export declare class RelayRecordSourceProxy implements RecordSourceProxy {
+    __mutator: RelayRecordSourceMutator;
+    _proxies: any;
+    constructor(mutator: any);
+    create(dataID: any): any;
+    delete(dataID: any): void;
+    get(dataID: any): any;
+    getRoot(): any;
+}

package/lib/es/relay/RelayRecordSourceProxy.js

@@ -0,0 +1,52 @@
+/* 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 { RelayRecordProxy } from './RelayRecordProxy';
+import { RelayStoreUtils, RelayRecordState } from './RelayStoreUtils';
+/**
+ * @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;
+}();
+export { RelayRecordSourceProxy };

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

@@ -0,0 +1,10 @@
+/**
+ * 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 mark(recordSource: any, selector: any, references: any): void;

package/lib/es/relay/RelayReferenceMarker.js

@@ -0,0 +1,54 @@
+/**
+ * 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 { RelayModernRecord } from './RelayModernRecord';
+import { LINKED_FIELD } from './RelayStoreUtils';
+export 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;
+}();

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Store } from './RelayTypes';
+export declare const StoreProvider: <TStore extends Store = Store>(props: {
+    children: React.ReactNode;
+    store: TStore;
+}) => JSX.Element;
+export declare function useStore<TStore extends Store = Store>(): TStore;

package/lib/es/relay/RelayStoreProvider.js

@@ -0,0 +1,16 @@
+import React from 'react';
+var ReactRelayContext = React.createContext(null);
+export var StoreProvider = function (props) {
+  var context = React.useMemo(function () {
+    return {
+      store: props.store
+    };
+  }, [props.store]);
+  return React.createElement(ReactRelayContext.Provider, {
+    value: context
+  }, props.children);
+};
+export function useStore() {
+  var store = React.useContext(ReactRelayContext).store;
+  return store;
+}

package/lib/es/relay/RelayStoreUtils.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
+ * @format
+ */
+export declare function isPromise(p: any): boolean;
+/**
+ * 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
+ */
+export declare function areEqual(a: any, b: any): boolean;
+/**
+ * Constants shared by all implementations of RecordSource/MutableRecordSource/etc.
+ */
+export declare const RelayStoreUtils: {
+    ID_KEY: string;
+    REF_KEY: string;
+    REFS_KEY: string;
+    ROOT_ID: string;
+};
+export declare enum RelayRecordState {
+    /**
+     * Record exists (either fetched from the server or produced by a local,
+     * optimistic update).
+     */
+    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).
+     */
+    NONEXISTENT = "NONEXISTENT",
+    /**
+     * Record State is unknown because it has not yet been fetched from the
+     * server.
+     */
+    UNKNOWN = "UNKNOWN"
+}
+export declare const LINKED_FIELD = "LinkedField";
+/**
+ * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
+ */
+export declare function recycleNodesInto<T>(prevData: T, nextData: T): T;
+export declare function hasOverlappingIDs(seenRecords: any, updatedRecordIDs: any): boolean;