relay-forms-nodeps 1.0.0

package/lib/relay/RelayRecordSourceMutator.js

@@ -0,0 +1,80 @@
+"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");
+/**
+ * @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_1.RelayModernRecord.create(dataID);
+      this._sink.set(dataID, sinkRecord);
+    }
+    return sinkRecord;
+  };
+  RelayRecordSourceMutator.prototype.create = function (dataID) {
+    var record = RelayModernRecord_1.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_1.RelayModernRecord.setValue(sinkRecord, storageKey, value);
+  };
+  RelayRecordSourceMutator.prototype.setLinkedRecordID = function (dataID, storageKey, linkedID) {
+    var sinkRecord = this._getSinkRecord(dataID);
+    RelayModernRecord_1.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_1.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_1.RelayModernRecord.setLinkedRecordIDs(sinkRecord, storageKey, linkedIDs);
+  };
+  return RelayRecordSourceMutator;
+}();
+exports.RelayRecordSourceMutator = RelayRecordSourceMutator;

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

@@ -0,0 +1,57 @@
+"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
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var RelayRecordProxy_1 = require("./RelayRecordProxy");
+var RelayStoreUtils_1 = require("./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 === RelayStoreUtils_1.RelayRecordState.EXISTENT) {
+        this._proxies[dataID] = new RelayRecordProxy_1.RelayRecordProxy(this, this.__mutator, dataID);
+      } else {
+        this._proxies[dataID] = status_1 === RelayStoreUtils_1.RelayRecordState.NONEXISTENT ? null : undefined;
+      }
+    }
+    return this._proxies[dataID];
+  };
+  RelayRecordSourceProxy.prototype.getRoot = function () {
+    var root = this.get(RelayStoreUtils_1.RelayStoreUtils.ROOT_ID);
+    if (!root) {
+      root = this.create(RelayStoreUtils_1.RelayStoreUtils.ROOT_ID);
+    }
+    return root;
+  };
+  return RelayRecordSourceProxy;
+}();
+exports.RelayRecordSourceProxy = RelayRecordSourceProxy;

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

@@ -0,0 +1,60 @@
+"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 RelayModernRecord_1 = require("./RelayModernRecord");
+var RelayStoreUtils_1 = require("./RelayStoreUtils");
+function mark(recordSource, selector, references) {
+  var dataID = selector.dataID,
+    node = selector.node;
+  var marker = new RelayReferenceMarker(recordSource, references);
+  marker.mark(node, dataID);
+}
+exports.mark = mark;
+/**
+ * @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 == RelayStoreUtils_1.LINKED_FIELD) {
+        if (selection.plural) {
+          var linkedIDs = RelayModernRecord_1.RelayModernRecord.getLinkedRecordIDs(record, name) || [];
+          linkedIDs.forEach(function (linkedID) {
+            _this._traverse(selection, linkedID);
+          });
+        } else {
+          var linkedID = RelayModernRecord_1.RelayModernRecord.getLinkedRecordID(record, name);
+          _this._traverse(selection, linkedID);
+        }
+      }
+    });
+  };
+  return RelayReferenceMarker;
+}();

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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var React = require("react");
+var ReactRelayContext = React.createContext(null);
+exports.StoreProvider = function (props) {
+  var context = React.useMemo(function () {
+    return {
+      store: props.store
+    };
+  }, [props.store]);
+  return React.createElement(ReactRelayContext.Provider, {
+    value: context
+  }, props.children);
+};
+function useStore() {
+  var store = React.useContext(ReactRelayContext).store;
+  return store;
+}
+exports.useStore = useStore;

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

package/lib/relay/RelayStoreUtils.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/* 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';
+}
+exports.isPromise = isPromise;
+'use strict';
+/**
+ * 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;
+}
+exports.areEqual = areEqual;
+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.
+ */
+exports.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 = exports.RelayRecordState || (exports.RelayRecordState = {}));
+exports.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;
+}
+exports.recycleNodesInto = recycleNodesInto;
+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;
+}
+exports.hasOverlappingIDs = hasOverlappingIDs;

package/lib/relay/RelayTypes.d.ts

@@ -0,0 +1,92 @@
+import { RelayRecordState } from './RelayStoreUtils';
+export declare type Disposable = {
+    dispose(): void;
+};
+export interface RecordProxy {
+    getDataID(): string;
+    getLinkedRecords(name: string): Array<RecordProxy | null | undefined> | null | undefined;
+    setLinkedRecord(record: RecordProxy, name: string): RecordProxy;
+    setLinkedRecords(records: Array<RecordProxy>, name: string): RecordProxy;
+    setValue(value: any, name: string): RecordProxy;
+}
+export interface RecordSourceProxy {
+    create(string: string): RecordProxy;
+    delete(string: string): void;
+    get(string: string): RecordProxy | null | undefined;
+    getRoot(): RecordProxy;
+}
+export declare type StoreUpdater = (store: RecordSourceProxy) => void;
+export declare type Record = {
+    [key: string]: any;
+};
+export declare type SelectorData = {
+    [key: string]: any;
+};
+export declare type RecordState = keyof typeof RelayRecordState;
+export interface RecordSource {
+    get(dataID: string): Record | null | undefined;
+    getRecordIDs(): Array<string>;
+    getStatus(dataID: string): RecordState;
+    has(dataID: string): boolean;
+    size(): number;
+    toJSON(): {
+        [key: string]: Record | null | undefined;
+    };
+}
+export declare type Snapshot = {
+    data: SelectorData | null | undefined;
+    seenRecords: Set<string>;
+    selector: any;
+};
+export declare type OperationDescriptor = {
+    fragment: any;
+    request: any;
+    root: any;
+};
+export interface Store {
+    /**
+     * Commit an updater to the environment. This mutation cannot be reverted and
+     * should therefore not be used for optimistic updates. This is mainly
+     * intended for updating fields from client schema extensions.
+     */
+    commitUpdate(updater: StoreUpdater): void;
+    /**
+     * Get a read-only view of the store's internal RecordSource.
+     */
+    getSource(): RecordSource;
+    /**
+     * Read the results of a selector from in-memory records in the store.
+     */
+    lookup(selector: any): Snapshot;
+    /**
+     * Notify subscribers (see `subscribe`) of any data that was published
+     * (`publish()`) since the last time `notify` was called.
+     * Optionally provide an OperationDescriptor indicating the source operation
+     * that was being processed to produce this run.
+     */
+    notify(sourceOperation?: OperationDescriptor, invalidateStore?: boolean): any;
+    /**
+     * Publish new information (e.g. from the network) to the store, updating its
+     * internal record source. Subscribers are not immediately notified - this
+     * occurs when `notify()` is called.
+     */
+    publish(source: RecordSource): void;
+    /**
+     * Ensure that all the records necessary to fulfill the given selector are
+     * retained in memory. The records will not be eligible for garbage collection
+     * until the returned reference is disposed.
+     */
+    retain(operation: OperationDescriptor): Disposable;
+    /**
+     * Subscribe to changes to the results of a selector. The callback is called
+     * when `notify()` is called *and* records have been published that affect the
+     * selector results relative to the last `notify()`.
+     */
+    subscribe(snapshot: Snapshot, callback: (snapshot: Snapshot) => void): Disposable;
+}
+export interface MutableRecordSource extends RecordSource {
+    clear(): void;
+    delete(dataID: string): void;
+    remove(dataID: string): void;
+    set(dataID: string, record: Record): void;
+}

package/lib/relay/RelayTypes.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});