react-relay 11.0.0 → 13.0.0-rc.0

package/__flowtests__/__generated__/RelayModernFlowtest_user.graphql.js.flow

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<9c7b60dab9f7983c67f2c7e1138f0eee>>
+ * @flow
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+
+/* eslint-disable */
+
+'use strict';
+
+/*::
+import type { Fragment, ReaderFragment } from 'relay-runtime';
+import type { FragmentType } from "relay-runtime";
+declare export opaque type RelayModernFlowtest_user$fragmentType: FragmentType;
+export type RelayModernFlowtest_user$ref = RelayModernFlowtest_user$fragmentType;
+export type RelayModernFlowtest_user$data = {|
+  +name: ?string,
+  +$fragmentType: RelayModernFlowtest_user$fragmentType,
+|};
+export type RelayModernFlowtest_user = RelayModernFlowtest_user$data;
+export type RelayModernFlowtest_user$key = {
+  +$data?: RelayModernFlowtest_user$data,
+  +$fragmentSpreads: RelayModernFlowtest_user$fragmentType,
+  ...
+};
+*/
+
+var node/*: ReaderFragment*/ = {
+  "argumentDefinitions": [],
+  "kind": "Fragment",
+  "metadata": null,
+  "name": "RelayModernFlowtest_user",
+  "selections": [
+    {
+      "alias": null,
+      "args": null,
+      "kind": "ScalarField",
+      "name": "name",
+      "storageKey": null
+    }
+  ],
+  "type": "User",
+  "abstractKey": null
+};
+
+if (__DEV__) {
+  (node/*: any*/).hash = "18a730295ff54e88446f4f000f5fef7e";
+}
+
+module.exports = ((node/*: any*/)/*: Fragment<
+  RelayModernFlowtest_user$fragmentType,
+  RelayModernFlowtest_user$data,
+>*/);

package/__flowtests__/__generated__/RelayModernFlowtest_users.graphql.js.flow

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<d2e1d6f0352e992d909d6217160aab1e>>
+ * @flow
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+
+/* eslint-disable */
+
+'use strict';
+
+/*::
+import type { Fragment, ReaderFragment } from 'relay-runtime';
+import type { FragmentType } from "relay-runtime";
+declare export opaque type RelayModernFlowtest_users$fragmentType: FragmentType;
+export type RelayModernFlowtest_users$ref = RelayModernFlowtest_users$fragmentType;
+export type RelayModernFlowtest_users$data = $ReadOnlyArray<{|
+  +name: ?string,
+  +$fragmentType: RelayModernFlowtest_users$fragmentType,
+|}>;
+export type RelayModernFlowtest_users = RelayModernFlowtest_users$data;
+export type RelayModernFlowtest_users$key = $ReadOnlyArray<{
+  +$data?: RelayModernFlowtest_users$data,
+  +$fragmentSpreads: RelayModernFlowtest_users$fragmentType,
+  ...
+}>;
+*/
+
+var node/*: ReaderFragment*/ = {
+  "argumentDefinitions": [],
+  "kind": "Fragment",
+  "metadata": {
+    "plural": true
+  },
+  "name": "RelayModernFlowtest_users",
+  "selections": [
+    {
+      "alias": null,
+      "args": null,
+      "kind": "ScalarField",
+      "name": "name",
+      "storageKey": null
+    }
+  ],
+  "type": "User",
+  "abstractKey": null
+};
+
+if (__DEV__) {
+  (node/*: any*/).hash = "4e6f0e70d48ec58651c17e3150c63d05";
+}
+
+module.exports = ((node/*: any*/)/*: Fragment<
+  RelayModernFlowtest_users$fragmentType,
+  RelayModernFlowtest_users$data,
+>*/);

package/assertFragmentMap.js.flow

@@ -12,10 +12,10 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
 import type {GeneratedNodeMap} from './ReactRelayTypes';
 
+const invariant = require('invariant');
+
 /**
  * Fail fast if the user supplies invalid fragments as input.
  */

package/buildReactRelayContainer.js.flow

@@ -12,24 +12,21 @@
 
 'use strict';
 
-const React = require('react');
-const ReactRelayContext = require('./ReactRelayContext');
-const ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext');
+import type {GeneratedNodeMap} from './ReactRelayTypes';
+import type {FragmentMap} from 'relay-runtime';
 
 const assertFragmentMap = require('./assertFragmentMap');
-const invariant = require('invariant');
-const mapObject = require('mapObject');
-const readContext = require('./readContext');
-
 const {
   getComponentName,
   getContainerName,
 } = require('./ReactRelayContainerUtils');
+const ReactRelayContext = require('./ReactRelayContext');
+const ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext');
+const readContext = require('./readContext');
+const invariant = require('invariant');
+const React = require('react');
 const {getFragment} = require('relay-runtime');
 
-import type {GeneratedNodeMap} from './ReactRelayTypes';
-import type {FragmentMap} from 'relay-runtime';
-
 type ContainerCreator = (
   Component: React$ComponentType<any>,
   fragments: FragmentMap,
@@ -48,11 +45,17 @@ function buildReactRelayContainer<TBase: React$ComponentType<any>>(
   const containerName = getContainerName(ComponentClass);
   assertFragmentMap(getComponentName(ComponentClass), fragmentSpec);
 
-  const fragments = mapObject(fragmentSpec, getFragment);
+  const fragments = {};
+  for (const key in fragmentSpec) {
+    fragments[key] = getFragment(fragmentSpec[key]);
+  }
   const Container = createContainerWithFragments(ComponentClass, fragments);
   Container.displayName = containerName;
 
-  function forwardRef(props, ref) {
+  function forwardRef(
+    props: any,
+    ref: ((null | any) => mixed) | {current: null | any, ...},
+  ) {
     const context = readContext(ReactRelayContext);
     invariant(
       context != null,

package/getRootVariablesForFragments.js.flow

@@ -12,10 +12,10 @@
 
 'use strict';
 
-const {getSelector} = require('relay-runtime');
-
 import type {FragmentMap, Variables} from 'relay-runtime';
 
+const {getSelector} = require('relay-runtime');
+
 function getRootVariablesForFragments<TProps: {...}>(
   fragments: FragmentMap,
   props: TProps,
@@ -35,7 +35,6 @@ function getRootVariablesForFragments<TProps: {...}>(
     rootVariables = {
       // $FlowFixMe[exponential-spread]
       ...rootVariables,
-      // $FlowFixMe[exponential-spread]
       ...fragmentOwnerVariables,
     };
   });

package/hooks.js

@@ -1,5 +1,5 @@
 /**
- * Relay v11.0.0
+ * Relay v13.0.0-rc.0
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
  *

package/hooks.js.flow

@@ -13,10 +13,9 @@
 'use strict';
 
 const EntryPointContainer = require('./relay-hooks/EntryPointContainer.react');
-const RelayEnvironmentProvider = require('./relay-hooks/RelayEnvironmentProvider');
-const RelayRuntime = require('relay-runtime');
-
 const loadEntryPoint = require('./relay-hooks/loadEntryPoint');
+const {loadQuery} = require('./relay-hooks/loadQuery');
+const RelayEnvironmentProvider = require('./relay-hooks/RelayEnvironmentProvider');
 const useEntryPointLoader = require('./relay-hooks/useEntryPointLoader');
 const useFragment = require('./relay-hooks/useFragment');
 const useLazyLoadQuery = require('./relay-hooks/useLazyLoadQuery');
@@ -28,8 +27,7 @@ const useRefetchableFragment = require('./relay-hooks/useRefetchableFragment');
 const useRelayEnvironment = require('./relay-hooks/useRelayEnvironment');
 const useSubscribeToInvalidationState = require('./relay-hooks/useSubscribeToInvalidationState');
 const useSubscription = require('./relay-hooks/useSubscription');
-
-const {loadQuery} = require('./relay-hooks/loadQuery');
+const RelayRuntime = require('relay-runtime');
 
 export type * from './relay-hooks/EntryPointTypes.flow';
 export type {
@@ -37,7 +35,7 @@ export type {
   MatchPointer,
 } from './relay-hooks/MatchContainer';
 export type {ProfilerContextType} from './relay-hooks/ProfilerContext';
-export type {Direction, LoadMoreFn} from './relay-hooks/useLoadMoreFunction';
+export type {LoadMoreFn} from './relay-hooks/useLoadMoreFunction';
 export type {UseMutationConfig} from './relay-hooks/useMutation';
 export type {UseQueryLoaderLoadQueryOptions} from './relay-hooks/useQueryLoader';
 export type {
@@ -48,6 +46,7 @@ export type {
 export type {
   DataID,
   DeclarativeMutationConfig,
+  Direction,
   Disposable,
   // RelayRuntime has two environment exports: one interface, one concrete.
   IEnvironment as Environment,

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v11.0.0
+ * Relay v13.0.0-rc.0
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
  *

package/index.js.flow

@@ -12,17 +12,16 @@
 
 'use strict';
 
-const EntryPointContainer = require('./relay-hooks/EntryPointContainer.react');
 const ReactRelayContext = require('./ReactRelayContext');
 const ReactRelayFragmentContainer = require('./ReactRelayFragmentContainer');
 const ReactRelayLocalQueryRenderer = require('./ReactRelayLocalQueryRenderer');
 const ReactRelayPaginationContainer = require('./ReactRelayPaginationContainer');
 const ReactRelayQueryRenderer = require('./ReactRelayQueryRenderer');
 const ReactRelayRefetchContainer = require('./ReactRelayRefetchContainer');
-const RelayEnvironmentProvider = require('./relay-hooks/RelayEnvironmentProvider');
-const RelayRuntime = require('relay-runtime');
-
+const EntryPointContainer = require('./relay-hooks/EntryPointContainer.react');
 const loadEntryPoint = require('./relay-hooks/loadEntryPoint');
+const {loadQuery} = require('./relay-hooks/loadQuery');
+const RelayEnvironmentProvider = require('./relay-hooks/RelayEnvironmentProvider');
 const useEntryPointLoader = require('./relay-hooks/useEntryPointLoader');
 const useFragment = require('./relay-hooks/useFragment');
 const useLazyLoadQuery = require('./relay-hooks/useLazyLoadQuery');
@@ -34,8 +33,7 @@ const useRefetchableFragment = require('./relay-hooks/useRefetchableFragment');
 const useRelayEnvironment = require('./relay-hooks/useRelayEnvironment');
 const useSubscribeToInvalidationState = require('./relay-hooks/useSubscribeToInvalidationState');
 const useSubscription = require('./relay-hooks/useSubscription');
-
-const {loadQuery} = require('./relay-hooks/loadQuery');
+const RelayRuntime = require('relay-runtime');
 
 export type {
   $FragmentRef,
@@ -53,7 +51,7 @@ export type {
   MatchPointer,
 } from './relay-hooks/MatchContainer';
 export type {ProfilerContextType} from './relay-hooks/ProfilerContext';
-export type {Direction, LoadMoreFn} from './relay-hooks/useLoadMoreFunction';
+export type {LoadMoreFn} from './relay-hooks/useLoadMoreFunction';
 export type {UseMutationConfig} from './relay-hooks/useMutation';
 export type {UseQueryLoaderLoadQueryOptions} from './relay-hooks/useQueryLoader';
 export type {
@@ -64,6 +62,7 @@ export type {
 export type {
   DataID,
   DeclarativeMutationConfig,
+  Direction,
   Disposable,
   // RelayRuntime has two environment exports: one interface, one concrete.
   IEnvironment as Environment,

package/jest-react/enqueueTask.js.flow

@@ -0,0 +1,56 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @format
+ */
+
+// This file is sync'd from https://github.com/facebook/react/tree/main/packages/jest-react
+
+'use strict';
+
+let didWarnAboutMessageChannel = false;
+let enqueueTaskImpl = null;
+
+function enqueueTask(task: () => void) {
+  if (enqueueTaskImpl === null) {
+    try {
+      // read require off the module object to get around the bundlers.
+      // we don't want them to detect a require and bundle a Node polyfill.
+      const requireString = ('require' + Math.random()).slice(0, 7);
+      const nodeRequire = module && module[requireString];
+      // assuming we're in node, let's try to get node's
+      // version of setImmediate, bypassing fake timers if any.
+      enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
+    } catch {
+      // we're in a browser
+      // we can't use regular timers because they may still be faked
+      // so we try MessageChannel+postMessage instead
+      enqueueTaskImpl = function (callback: () => void) {
+        if (__DEV__) {
+          if (didWarnAboutMessageChannel === false) {
+            didWarnAboutMessageChannel = true;
+            if (typeof MessageChannel === 'undefined') {
+              console.error(
+                'This browser does not have a MessageChannel implementation, ' +
+                  'so enqueuing tasks via await act(async () => ...) will fail. ' +
+                  'Please file an issue at https://github.com/facebook/react/issues ' +
+                  'if you encounter this warning.',
+              );
+            }
+          }
+        }
+        /*global MessageChannel*/
+        const channel = new MessageChannel();
+        channel.port1.onmessage = callback;
+        channel.port2.postMessage(undefined);
+      };
+    }
+  }
+  return enqueueTaskImpl(task);
+}
+
+module.exports = enqueueTask;

package/jest-react/index.js.flow

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @format
+ */
+
+// This file is sync'd from https://github.com/facebook/react/tree/main/packages/jest-react
+export {act} from './internalAct';

package/jest-react/internalAct.js.flow

@@ -0,0 +1,139 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @format
+ *
+ */
+
+/* global jest */
+
+// This file is sync'd from https://github.com/facebook/react/tree/main/packages/jest-react
+
+// This version of `act` is only used by our tests. Unlike the public version
+// of `act`, it's designed to work identically in both production and
+// development. It may have slightly different behavior from the public
+// version, too, since our constraints in our test suite are not the same as
+// those of developers using React — we're testing React itself, as opposed to
+// building an app with React.
+
+'use strict';
+
+const enqueueTask = require('./enqueueTask');
+const Scheduler = require('scheduler/unstable_mock');
+
+// The subset of a Promise that React APIs rely on. This resolves a value.
+// This doesn't require a return value neither from the handler nor the
+// then function.
+interface Thenable<+R> {
+  then<U>(
+    onFulfill: (value: R) => void | Thenable<U> | U,
+    onReject: (error: mixed) => void | Thenable<U> | U,
+  ): void | Thenable<U>;
+}
+
+let actingUpdatesScopeDepth = 0;
+
+function act(scope: () => Thenable<mixed> | void) {
+  if (Scheduler.unstable_flushAllWithoutAsserting === undefined) {
+    throw Error(
+      'This version of `act` requires a special mock build of Scheduler.',
+    );
+  }
+  if (setTimeout._isMockFunction !== true) {
+    throw Error(
+      "This version of `act` requires Jest's timer mocks " +
+        '(i.e. jest.useFakeTimers).',
+    );
+  }
+
+  const previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
+  actingUpdatesScopeDepth++;
+
+  const unwind = () => {
+    actingUpdatesScopeDepth--;
+
+    if (__DEV__) {
+      if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
+        // if it's _less than_ previousActingUpdatesScopeDepth, then we can
+        // assume the 'other' one has warned
+        console.error(
+          'You seem to have overlapping act() calls, this is not supported. ' +
+            'Be sure to await previous act() calls before making a new one. ',
+        );
+      }
+    }
+  };
+
+  // TODO: This would be way simpler if 1) we required a promise to be
+  // returned and 2) we could use async/await. Since it's only our used in
+  // our test suite, we should be able to.
+  try {
+    const thenable = scope();
+    if (
+      typeof thenable === 'object' &&
+      thenable !== null &&
+      typeof thenable.then === 'function'
+    ) {
+      return {
+        then(resolve: () => void, reject: (error: mixed) => void) {
+          thenable.then(
+            () => {
+              flushActWork(
+                () => {
+                  unwind();
+                  resolve();
+                },
+                error => {
+                  unwind();
+                  reject(error);
+                },
+              );
+            },
+            error => {
+              unwind();
+              reject(error);
+            },
+          );
+        },
+      };
+    } else {
+      try {
+        // TODO: Let's not support non-async scopes at all in our tests. Need to
+        // migrate existing tests.
+        let didFlushWork;
+        do {
+          didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+        } while (didFlushWork);
+      } finally {
+        unwind();
+      }
+    }
+  } catch (error) {
+    unwind();
+    throw error;
+  }
+}
+
+function flushActWork(resolve, reject) {
+  // Flush suspended fallbacks
+  // $FlowFixMe: Flow doesn't know about global Jest object
+  jest.runOnlyPendingTimers();
+  enqueueTask(() => {
+    try {
+      const didFlushWork = Scheduler.unstable_flushAllWithoutAsserting();
+      if (didFlushWork) {
+        flushActWork(resolve, reject);
+      } else {
+        resolve();
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+exports.act = act;

package/legacy.js

@@ -1,5 +1,5 @@
 /**
- * Relay v11.0.0
+ * Relay v13.0.0-rc.0
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
  *

package/lib/ReactRelayFragmentContainer.js

@@ -22,20 +22,18 @@ var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inh
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var React = require('react');
-
-var areEqual = require("fbjs/lib/areEqual");
-
 var buildReactRelayContainer = require('./buildReactRelayContainer');
 
-var getRootVariablesForFragments = require('./getRootVariablesForFragments');
-
 var _require = require('./ReactRelayContainerUtils'),
     getContainerName = _require.getContainerName;
 
 var _require2 = require('./RelayContext'),
     assertRelayContext = _require2.assertRelayContext;
 
+var areEqual = require("fbjs/lib/areEqual");
+
+var React = require('react');
+
 var _require3 = require('relay-runtime'),
     createFragmentSpecResolver = _require3.createFragmentSpecResolver,
     getDataIDsFromObject = _require3.getDataIDsFromObject,
@@ -142,19 +140,17 @@ function createContainerWithFragments(Component, fragments) {
     var _proto = _class.prototype;
 
     _proto.componentDidMount = function componentDidMount() {
-      this._subscribeToNewResolver();
-
-      this._rerenderIfStoreHasChanged();
+      this._subscribeToNewResolverAndRerenderIfStoreHasChanged();
     };
 
     _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
       if (this.state.resolver !== prevState.resolver) {
         prevState.resolver.dispose();
 
-        this._subscribeToNewResolver();
+        this._subscribeToNewResolverAndRerenderIfStoreHasChanged();
+      } else {
+        this._rerenderIfStoreHasChanged();
       }
-
-      this._rerenderIfStoreHasChanged();
     };
 
     _proto.componentWillUnmount = function componentWillUnmount() {
@@ -207,11 +203,21 @@ function createContainerWithFragments(Component, fragments) {
       }
     };
 
-    _proto._subscribeToNewResolver = function _subscribeToNewResolver() {
-      var resolver = this.state.resolver; // Event listeners are only safe to add during the commit phase,
+    _proto._subscribeToNewResolverAndRerenderIfStoreHasChanged = function _subscribeToNewResolverAndRerenderIfStoreHasChanged() {
+      var _this$state2 = this.state,
+          data = _this$state2.data,
+          resolver = _this$state2.resolver;
+      var maybeNewData = resolver.resolve(); // Event listeners are only safe to add during the commit phase,
       // So they won't leak if render is interrupted or errors.
 
-      resolver.setCallback(this._handleFragmentDataUpdate);
+      resolver.setCallback(this.props, this._handleFragmentDataUpdate); // External values could change between render and commit.
+      // Check for this case, even though it requires an extra store read.
+
+      if (data !== maybeNewData) {
+        this.setState({
+          data: maybeNewData
+        });
+      }
     };
 
     _proto.render = function render() {

package/lib/ReactRelayFragmentMockRenderer.js

@@ -10,10 +10,10 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var React = require('react');
-
 var ReactRelayContext = require('./ReactRelayContext');
 
+var React = require('react');
+
 function ReactRelayFragmentMockRenderer(props) {
   return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {
     value: {

package/lib/ReactRelayLocalQueryRenderer.js

@@ -10,24 +10,23 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var React = require('react');
-
 var ReactRelayContext = require('./ReactRelayContext');
 
 var ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext');
 
-var useLayoutEffect = React.useLayoutEffect,
-    useState = React.useState,
-    useRef = React.useRef,
-    useMemo = React.useMemo;
+var areEqual = require("fbjs/lib/areEqual");
+
+var React = require('react');
 
 var _require = require('relay-runtime'),
     createOperationDescriptor = _require.createOperationDescriptor,
     deepFreeze = _require.deepFreeze,
     getRequest = _require.getRequest;
 
-var areEqual = require("fbjs/lib/areEqual");
-
+var useLayoutEffect = React.useLayoutEffect,
+    useState = React.useState,
+    useRef = React.useRef,
+    useMemo = React.useMemo;
 var queryRendererContext = {
   rootIsQueryRenderer: true
 };