relay-runtime 20.1.1 → 21.0.1

package/util/getPaginationVariables.js.flow

@@ -26,7 +26,7 @@ function getPaginationVariables(
   baseVariables: Variables,
   extraVariables: Variables,
   paginationMetadata: ReaderPaginationMetadata,
-): {[string]: mixed, ...} {
+): {[string]: unknown, ...} {
   const {backward: backwardMetadata, forward: forwardMetadata} =
     paginationMetadata;
 

package/util/getPendingOperationsForFragment.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type {Environment, RequestDescriptor} from '../store/RelayStoreTypes';
+import type { ReaderFragment } from './ReaderNode';
+
+export default function getPendingOperationsForFragment(
+    environment: Environment,
+    fragmentNode: ReaderFragment,
+    fragmentOwner: RequestDescriptor,
+): {
+    promise: Promise<void>;
+    pendingOperations: readonly RequestDescriptor[];
+} | null;

package/util/getPendingOperationsForFragment.js.flow

@@ -22,9 +22,9 @@ function getPendingOperationsForFragment(
   fragmentOwner: RequestDescriptor,
 ): {
   promise: Promise<void>,
-  pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+  pendingOperations: ReadonlyArray<RequestDescriptor>,
 } | null {
-  let pendingOperations: $ReadOnlyArray<RequestDescriptor> = [];
+  let pendingOperations: ReadonlyArray<RequestDescriptor> = [];
   let promise = getPromiseForActiveRequest(environment, fragmentOwner);
 
   if (promise != null) {

package/util/getRefetchMetadata.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {ReaderFragment, ReaderRefetchMetadata, RefetchableIdentifierInfo} from './ReaderNode';
+import { ConcreteRequest } from './RelayConcreteNode';
+
+export default function getRefetchMetadata(
+    fragmentNode: ReaderFragment,
+    componentDisplayName: string,
+): {
+    fragmentRefPathInResponse: ReadonlyArray<string | number>;
+    identifierInfo: RefetchableIdentifierInfo | null | undefined;
+    refetchableRequest: ConcreteRequest;
+    refetchMetadata: ReaderRefetchMetadata;
+};

package/util/getRefetchMetadata.js.flow

@@ -24,7 +24,7 @@ function getRefetchMetadata(
   fragmentNode: ReaderFragment,
   componentDisplayName: string,
 ): {
-  fragmentRefPathInResponse: $ReadOnlyArray<string | number>,
+  fragmentRefPathInResponse: ReadonlyArray<string | number>,
   identifierInfo: ?RefetchableIdentifierInfo,
   refetchableRequest: ConcreteRequest,
   refetchMetadata: ReaderRefetchMetadata,
@@ -50,10 +50,11 @@ function getRefetchMetadata(
   );
 
   // handle both commonjs and es modules
-  const refetchableRequest: ConcreteRequest | string =
-    (refetchMetadata: $FlowFixMe).operation.default
-      ? (refetchMetadata: $FlowFixMe).operation.default
-      : refetchMetadata.operation;
+  const refetchableRequest: ConcreteRequest | string = (
+    refetchMetadata as $FlowFixMe
+  ).operation.default
+    ? (refetchMetadata as $FlowFixMe).operation.default
+    : refetchMetadata.operation;
   const fragmentRefPathInResponse = refetchMetadata.fragmentPathInResult;
   invariant(
     typeof refetchableRequest !== 'string',

package/util/getRelayHandleKey.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default function getRelayHandleKey(handleName: string, key?: string | null, fieldName?: string | null): string;

package/util/getRequestIdentifier.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { RequestParameters } from './RelayConcreteNode';
+import { Variables } from './RelayRuntimeTypes';
+
+export type RequestIdentifier = string;
+
+/**
+ * Returns a stable identifier for the given pair of `RequestParameters` +
+ * variables.
+ */
+export default function getRequestIdentifier(parameters: RequestParameters, variables: Variables): RequestIdentifier;

package/util/getValueAtPath.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default function getValueAtPath(data: any, path: ReadonlyArray<string | number>): any;

package/util/getValueAtPath.js.flow

@@ -14,9 +14,9 @@
 const invariant = require('invariant');
 
 function getValueAtPath(
-  data: mixed,
-  path: $ReadOnlyArray<string | number>,
-): mixed {
+  data: unknown,
+  path: ReadonlyArray<string | number>,
+): unknown {
   let result = data;
   for (const key of path) {
     if (result == null) {

package/util/handlePotentialSnapshotErrors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {Environment, MissingRequiredFields, RelayResolverErrors} from '../store/RelayStoreTypes';
+
+export default function handlePotentialSnapshotErrors(
+    environment: Environment,
+    missingRequiredFields: MissingRequiredFields | null | undefined,
+    relayResolverErrors: RelayResolverErrors,
+): void;

package/util/handlePotentialSnapshotErrors.js.flow

@@ -22,7 +22,7 @@ const invariant = require('invariant');
 function handleFieldErrors(
   environment: IEnvironment,
   fieldErrors: FieldErrors,
-  loggingContext: mixed | void,
+  loggingContext: unknown | void,
 ) {
   for (const fieldError of fieldErrors) {
     // First we log all events. Note that the logger may opt to throw its own
@@ -67,7 +67,7 @@ function handleFieldErrors(
           // can't assert this via types.
           break;
         default:
-          (fieldError.kind: empty);
+          fieldError.kind as empty;
           invariant(false, 'Relay: Unexpected event kind: %s', fieldError.kind);
       }
     }
@@ -86,7 +86,7 @@ function eventShouldThrow(event: FieldError): boolean {
     case 'missing_expected_data.log':
       return false;
     default:
-      (event.kind: empty);
+      event.kind as empty;
       throw new Error('Relay: Unexpected event kind');
   }
 }
@@ -94,7 +94,7 @@ function eventShouldThrow(event: FieldError): boolean {
 function handlePotentialSnapshotErrors(
   environment: IEnvironment,
   fieldErrors: ?FieldErrors,
-  loggingContext: mixed | void,
+  loggingContext: unknown | void,
 ) {
   /**
    * Inside handleFieldErrors, we check for throwOnFieldError - but this fn logs the error anyway by default
@@ -106,6 +106,6 @@ function handlePotentialSnapshotErrors(
 }
 
 module.exports = {
-  handlePotentialSnapshotErrors,
   eventShouldThrow,
+  handlePotentialSnapshotErrors,
 };

package/util/isEmptyObject.js.flow

@@ -14,7 +14,7 @@
 // $FlowFixMe[method-unbinding] added when improving typing for this parameters
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-function isEmptyObject(obj: {+[key: string]: mixed}): boolean {
+function isEmptyObject(obj: {readonly [key: string]: unknown}): boolean {
   for (const key in obj) {
     if (hasOwnProperty.call(obj, key)) {
       return false;

package/util/isPromise.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default function isPromise(p: any): p is Promise<any>;

package/util/isPromise.js.flow

@@ -11,9 +11,9 @@
 
 'use strict';
 
-declare function isPromise<T>(p: mixed): p is Promise<T>;
+declare function isPromise<T>(p: unknown): p is Promise<T>;
 
-function isPromise(p: mixed) {
+function isPromise(p: unknown) {
   return p != null && typeof p === 'object' && typeof p.then === 'function';
 }
 

package/util/isScalarAndEqual.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default function isScalarAndEqual(valueA: unknown, valueB: unknown): boolean;

package/util/isScalarAndEqual.js.flow

@@ -18,7 +18,7 @@
  * - returns false for complex values, since these cannot be cheaply tested for
  *   equality (use `areEquals` instead)
  */
-function isScalarAndEqual(valueA: mixed, valueB: mixed): boolean {
+function isScalarAndEqual(valueA: unknown, valueB: unknown): boolean {
   return valueA === valueB && (valueA === null || typeof valueA !== 'object');
 }
 

package/util/recycleNodesInto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default function recycleNodesInto<T>(prevData: T, nextData: T): T;

package/util/recycleNodesInto.js.flow

@@ -38,8 +38,8 @@ function recycleNodesIntoImpl<T>(
   let canRecycle = false;
 
   // Assign local variables to preserve Flow type refinement.
-  const prevArray: ?Array<mixed> = Array.isArray(prevData) ? prevData : null;
-  const nextArray: ?Array<mixed> = Array.isArray(nextData) ? nextData : null;
+  const prevArray: ?Array<unknown> = Array.isArray(prevData) ? prevData : null;
+  const nextArray: ?Array<unknown> = Array.isArray(nextData) ? nextData : null;
   if (prevArray && nextArray) {
     const canMutateNext = canMutate && !Object.isFrozen(nextArray);
     canRecycle =

package/util/registerEnvironmentWithDevTools.js.flow

@@ -28,7 +28,7 @@ function registerEnvironmentWithDevTools(environment: IEnvironment): void {
   // $FlowFixMe[incompatible-use] D61394600
   const devToolsHook = _global && _global.__RELAY_DEVTOOLS_HOOK__;
   if (devToolsHook) {
-    // $FlowFixMe[incompatible-call] D61394600
+    // $FlowFixMe[incompatible-type] D61394600
     devToolsHook.registerEnvironment(environment);
   }
 }

package/util/shallowFreeze.js.flow

@@ -12,7 +12,7 @@
 'use strict';
 
 // Shallow freeze to prevent Relay from mutating the value in recycleNodesInto or deepFreezing the value
-module.exports = function shallowFreeze(value: mixed) {
+module.exports = function shallowFreeze(value: unknown) {
   if (
     typeof value === 'object' &&
     value != null &&

package/util/stableCopy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export default function stableCopy<T>(value: T): T;

package/util/stableCopy.js.flow

@@ -16,7 +16,7 @@
  * keys sorted such that equivalent values would have identical JSON.stringify
  * results.
  */
-function stableCopy<T: mixed>(value: T): T {
+function stableCopy<T extends unknown>(value: T): T {
   if (!value || typeof value !== 'object') {
     return value;
   }
@@ -24,17 +24,17 @@ function stableCopy<T: mixed>(value: T): T {
     return value.map(stableCopy);
   }
   const keys = Object.keys(value).sort();
-  const stable: {[string]: mixed} = {};
+  const stable: {[string]: unknown} = {};
   for (let i = 0; i < keys.length; i++) {
     stable[keys[i]] = stableCopy(value[keys[i]]);
   }
-  return (stable: any);
+  return stable as any;
 }
 
 // Detect if a data structure contains cycles. The logic here mirrors
 // `stableCopy` above and is intended to detect cycles early before they get
 // passed to `stableCopy` which would result in a stack overflow.
-function hasCycle(value: mixed, parents: Set<mixed> = new Set()): boolean {
+function hasCycle(value: unknown, parents: Set<unknown> = new Set()): boolean {
   // $FlowFixMe[sketchy-null-mixed]
   if (!value || typeof value !== 'object') {
     return false;
@@ -52,6 +52,6 @@ function hasCycle(value: mixed, parents: Set<mixed> = new Set()): boolean {
 }
 
 module.exports = {
-  stableCopy,
   hasCycle,
+  stableCopy,
 };

package/util/withProvidedVariables.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { ProvidedVariablesType } from './RelayConcreteNode';
+import { Variables } from './RelayRuntimeTypes';
+
+interface WithProvidedVariablesFn {
+    (
+        userSuppliedVariables: Variables,
+        providedVariables: ProvidedVariablesType | null | undefined,
+    ): Variables;
+    tests_only_resetDebugCache: undefined | (() => void);
+}
+declare const withProvidedVariables: WithProvidedVariablesFn;
+export default withProvidedVariables;

package/util/withProvidedVariables.js.flow

@@ -19,17 +19,19 @@ const warning = require('warning');
 
 const WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 let debugCache:
-  | Map<mixed, mixed>
-  | Map<() => mixed, mixed>
-  | WeakMap<interface {} | $ReadOnlyArray<mixed>, mixed>
-  | WeakMap<() => mixed, mixed> = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
+  | Map<unknown, unknown>
+  | Map<() => unknown, unknown>
+  | WeakMap<interface {} | ReadonlyArray<unknown>, unknown>
+  | WeakMap<() => unknown, unknown> = WEAKMAP_SUPPORTED
+  ? new WeakMap()
+  : new Map();
 
 function withProvidedVariables(
   userSuppliedVariables: Variables,
   providedVariables: ?ProvidedVariablesType,
 ): Variables {
   if (providedVariables != null) {
-    const operationVariables: {[string]: mixed} = {};
+    const operationVariables: {[string]: unknown} = {};
     // $FlowFixMe[unsafe-object-assign]
     Object.assign(operationVariables, userSuppliedVariables);
     Object.keys(providedVariables).forEach((varName: string) => {
@@ -64,10 +66,12 @@ function withProvidedVariables(
   }
 }
 
-withProvidedVariables.tests_only_resetDebugCache = ((__DEV__
-  ? () => {
-      debugCache = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
-    }
-  : undefined): void | (() => void));
+withProvidedVariables.tests_only_resetDebugCache = (
+  __DEV__
+    ? () => {
+        debugCache = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
+      }
+    : undefined
+) as void | (() => void);
 
 module.exports = withProvidedVariables;