relay-runtime 9.0.0 → 9.1.0

package/util/deepFreeze.js.flow

@@ -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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * Recursively "deep" freezes the supplied object.
+ *
+ * For convenience, and for consistency with the behavior of `Object.freeze`,
+ * returns the now-frozen original object.
+ */
+function deepFreeze<T: {...}>(object: T): T {
+  Object.freeze(object);
+  Object.getOwnPropertyNames(object).forEach(name => {
+    const property = object[name];
+    if (
+      property &&
+      typeof property === 'object' &&
+      !Object.isFrozen(property)
+    ) {
+      deepFreeze(property);
+    }
+  });
+  return object;
+}
+
+module.exports = deepFreeze;

package/util/generateID.js.flow

@@ -0,0 +1,21 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+let id = 100000;
+
+function generateID(): number {
+  return id++;
+}
+
+module.exports = generateID;

package/util/getFragmentIdentifier.js.flow

@@ -0,0 +1,52 @@
+/**
+ * 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
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const stableCopy = require('./stableCopy');
+
+const {
+  getDataIDsFromFragment,
+  getVariablesFromFragment,
+  getSelector,
+} = require('../store/RelayModernSelector');
+
+import type {ReaderFragment} from './ReaderNode';
+
+function getFragmentIdentifier(
+  fragmentNode: ReaderFragment,
+  fragmentRef: mixed,
+): string {
+  const selector = getSelector(fragmentNode, fragmentRef);
+  const fragmentOwnerIdentifier =
+    selector == null
+      ? 'null'
+      : selector.kind === 'SingularReaderSelector'
+      ? selector.owner.identifier
+      : '[' +
+        selector.selectors.map(sel => sel.owner.identifier).join(',') +
+        ']';
+  const fragmentVariables = getVariablesFromFragment(fragmentNode, fragmentRef);
+  const dataIDs = getDataIDsFromFragment(fragmentNode, fragmentRef);
+  return (
+    fragmentOwnerIdentifier +
+    '/' +
+    fragmentNode.name +
+    '/' +
+    JSON.stringify(stableCopy(fragmentVariables)) +
+    '/' +
+    (JSON.stringify(dataIDs) ?? 'missing')
+  );
+}
+
+module.exports = getFragmentIdentifier;

package/util/getRelayHandleKey.js.flow

@@ -0,0 +1,41 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+const {DEFAULT_HANDLE_KEY} = require('./RelayDefaultHandleKey');
+
+/**
+ * @internal
+ *
+ * Helper to create a unique name for a handle field based on the handle name, handle key and
+ * source field.
+ */
+function getRelayHandleKey(
+  handleName: string,
+  key: ?string,
+  fieldName: ?string,
+): string {
+  if (key && key !== DEFAULT_HANDLE_KEY) {
+    return `__${key}_${handleName}`;
+  }
+
+  invariant(
+    fieldName != null,
+    'getRelayHandleKey: Expected either `fieldName` or `key` in `handle` to be provided',
+  );
+  return `__${fieldName}_${handleName}`;
+}
+
+module.exports = getRelayHandleKey;

package/util/getRequestIdentifier.js.flow

@@ -0,0 +1,41 @@
+/**
+ * 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';
+
+const invariant = require('invariant');
+const stableCopy = require('./stableCopy');
+
+import type {RequestParameters} from './RelayConcreteNode';
+import type {Variables} from './RelayRuntimeTypes';
+
+export opaque type RequestIdentifier: string = string;
+
+/**
+ * Returns a stable identifier for the given pair of `RequestParameters` +
+ * variables.
+ */
+function getRequestIdentifier(
+  parameters: RequestParameters,
+  variables: Variables,
+): RequestIdentifier {
+  const requestID = parameters.id != null ? parameters.id : parameters.text;
+  invariant(
+    requestID != null,
+    'getRequestIdentifier: Expected request `%s` to have either a ' +
+      'valid `id` or `text` property',
+    parameters.name,
+  );
+  return requestID + JSON.stringify(stableCopy(variables));
+}
+
+module.exports = getRequestIdentifier;

package/util/isPromise.js.flow

@@ -0,0 +1,21 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+declare function isPromise(p: mixed): boolean %checks(p instanceof Promise);
+
+function isPromise(p: $FlowFixMe): boolean {
+  return !!p && typeof p.then === 'function';
+}
+
+module.exports = isPromise;

package/util/isScalarAndEqual.js.flow

@@ -0,0 +1,26 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * A fast test to determine if two values are equal scalars:
+ * - compares scalars such as booleans, strings, numbers by value
+ * - compares functions by identity
+ * - returns false for complex values, since these cannot be cheaply tested for
+ *   equality (use `areEquals` instead)
+ */
+function isScalarAndEqual(valueA: mixed, valueB: mixed): boolean {
+  return valueA === valueB && (valueA === null || typeof valueA !== 'object');
+}
+
+module.exports = isScalarAndEqual;

package/util/recycleNodesInto.js.flow

@@ -0,0 +1,80 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
+ */
+function recycleNodesInto<T>(prevData: T, nextData: T): T {
+  if (
+    prevData === nextData ||
+    typeof prevData !== 'object' ||
+    !prevData ||
+    typeof nextData !== 'object' ||
+    !nextData
+  ) {
+    return nextData;
+  }
+  let canRecycle = false;
+
+  // Assign local variables to preserve Flow type refinement.
+  const prevArray = Array.isArray(prevData) ? prevData : null;
+  const nextArray = Array.isArray(nextData) ? nextData : null;
+  if (prevArray && nextArray) {
+    canRecycle =
+      nextArray.reduce((wasEqual, nextItem, ii) => {
+        const prevValue = prevArray[ii];
+        const nextValue = recycleNodesInto(prevValue, nextItem);
+        if (nextValue !== nextArray[ii]) {
+          if (__DEV__) {
+            if (!Object.isFrozen(nextArray)) {
+              nextArray[ii] = nextValue;
+            }
+          } else {
+            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.
+    const prevObject = prevData;
+    const nextObject = nextData;
+    const prevKeys = Object.keys(prevObject);
+    const nextKeys = Object.keys(nextObject);
+    canRecycle =
+      nextKeys.reduce((wasEqual, key) => {
+        const prevValue = prevObject[key];
+        const nextValue = recycleNodesInto(prevValue, nextObject[key]);
+        if (nextValue !== nextObject[key]) {
+          if (__DEV__) {
+            if (!Object.isFrozen(nextObject)) {
+              /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This
+               * comment suppresses an error found when Flow v0.98 was deployed.
+               * To see the error delete this comment and run Flow. */
+              nextObject[key] = nextValue;
+            }
+          } else {
+            /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
+             * suppresses an error found when Flow v0.98 was deployed. To see
+             * the error delete this comment and run Flow. */
+            nextObject[key] = nextValue;
+          }
+        }
+        return wasEqual && nextValue === prevObject[key];
+      }, true) && prevKeys.length === nextKeys.length;
+  }
+  return canRecycle ? prevData : nextData;
+}
+
+module.exports = recycleNodesInto;

package/util/resolveImmediate.js.flow

@@ -0,0 +1,30 @@
+/**
+ * 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 resolvedPromise = Promise.resolve();
+
+/**
+ * An alternative to setImmediate based on Promise.
+ */
+function resolveImmediate(callback: () => void) {
+  resolvedPromise.then(callback).catch(throwNext);
+}
+
+function throwNext(error) {
+  setTimeout(() => {
+    throw error;
+  }, 0);
+}
+
+module.exports = resolveImmediate;

package/util/stableCopy.js.flow

@@ -0,0 +1,35 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * Creates a copy of the provided value, ensuring any nested objects have their
+ * keys sorted such that equivalent values would have identical JSON.stringify
+ * results.
+ */
+function stableCopy<T: mixed>(value: T): T {
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(stableCopy);
+  }
+  const keys = Object.keys(value).sort();
+  const stable = {};
+  for (let i = 0; i < keys.length; i++) {
+    stable[keys[i]] = stableCopy(value[keys[i]]);
+  }
+  return (stable: any);
+}
+
+module.exports = stableCopy;