@ardatan/relay-compiler 12.0.0

package/util/generateAbstractTypeRefinementKey.js.flow

@@ -0,0 +1,29 @@
+/**
+ * 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 {createCompilerError} = require('../core/CompilerError');
+
+import type {Schema, TypeID} from '../core/Schema';
+
+function generateAbstractTypeRefinementKey(
+  schema: Schema,
+  type: TypeID,
+): string {
+  if (!schema.isAbstractType(type)) {
+    throw createCompilerError('Expected an abstract type');
+  }
+  return `__is${schema.getTypeString(type)}`;
+}
+
+module.exports = generateAbstractTypeRefinementKey;

package/util/getDefinitionNodeHash.js.flow

@@ -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 strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const md5 = require('./md5');
+
+const {print} = require('graphql');
+
+import type {ExecutableDefinitionNode} from 'graphql';
+
+function getDefinitionNodeHash(node: ExecutableDefinitionNode): string {
+  return md5(print(node));
+}
+
+module.exports = getDefinitionNodeHash;

package/util/getModuleName.js.flow

@@ -0,0 +1,39 @@
+/**
+ * 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';
+
+const path = require('path');
+
+function getModuleName(filePath: string): string {
+  // index.js -> index
+  // index.js.flow -> index.js
+  let filename = path.basename(filePath, path.extname(filePath));
+
+  // index.js -> index (when extension has multiple segments)
+  // index.react -> index (when extension has multiple segments)
+  filename = filename.replace(/(\.(?!ios|android)[_a-zA-Z0-9\\-]+)+/g, '');
+
+  // /path/to/button/index.js -> button
+  let moduleName =
+    filename === 'index' ? path.basename(path.dirname(filePath)) : filename;
+
+  // foo-bar -> fooBar
+  // Relay compatibility mode splits on _, so we can't use that here.
+  moduleName = moduleName.replace(/[^a-zA-Z0-9]+(\w?)/g, (match, next) =>
+    next.toUpperCase(),
+  );
+
+  return moduleName;
+}
+
+module.exports = getModuleName;

package/util/joinArgumentDefinitions.js.flow

@@ -0,0 +1,105 @@
+/**
+ * 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 {createUserError} = require('../core/CompilerError');
+
+import type {ArgumentDefinition, Fragment} from '../core/IR';
+import type {Schema} from '../core/Schema';
+
+/**
+ * Attempts to join the argument definitions for a root fragment
+ * and any unmasked fragment spreads reachable from that root fragment,
+ * returning a combined list of arguments or throwing if the same
+ * variable(s) are used in incompatible ways in different fragments.
+ */
+function joinArgumentDefinitions(
+  schema: Schema,
+  fragment: Fragment,
+  reachableArguments: $ReadOnlyArray<ArgumentDefinition>,
+  directiveName: string,
+): $ReadOnlyArray<ArgumentDefinition> {
+  const joinedArgumentDefinitions = new Map();
+  fragment.argumentDefinitions.forEach(prevArgDef => {
+    joinedArgumentDefinitions.set(prevArgDef.name, prevArgDef);
+  });
+  reachableArguments.forEach(nextArgDef => {
+    const prevArgDef = joinedArgumentDefinitions.get(nextArgDef.name);
+    const joinedArgDef =
+      prevArgDef == null
+        ? nextArgDef
+        : joinArgumentDefinition(schema, prevArgDef, nextArgDef, directiveName);
+    joinedArgumentDefinitions.set(joinedArgDef.name, joinedArgDef);
+  });
+  return Array.from(joinedArgumentDefinitions.values());
+}
+
+/**
+ * @private
+ *
+ * Attempts to join two argument definitions, returning a single argument
+ * definition that is compatible with both of the inputs:
+ * - If the kind, name, or defaultValue is different then the arguments
+ *   cannot be joined, indicated by returning null.
+ * - If either of next/prev is a subtype of the other, return the one
+ *   that is the subtype: a more narrow type can flow into a more general
+ *   type but not the inverse.
+ * - Otherwise there is no subtyping relation between prev/next, so return
+ *   null to indicate they cannot be joined.
+ */
+function joinArgumentDefinition(
+  schema: Schema,
+  prevArgDef: ArgumentDefinition,
+  nextArgDef: ArgumentDefinition,
+  directiveName: string,
+): ArgumentDefinition {
+  if (prevArgDef.kind !== nextArgDef.kind) {
+    throw createUserError(
+      'Cannot combine global and local variables when applying ' +
+        `${directiveName}.`,
+      [prevArgDef.loc, nextArgDef.loc],
+    );
+  } else if (
+    prevArgDef.kind === 'LocalArgumentDefinition' &&
+    nextArgDef.kind === 'LocalArgumentDefinition' &&
+    prevArgDef.defaultValue !== nextArgDef.defaultValue
+  ) {
+    throw createUserError(
+      'Cannot combine local variables with different defaultValues when ' +
+        `applying ${directiveName}.`,
+      [prevArgDef.loc, nextArgDef.loc],
+    );
+  } else if (schema.isTypeSubTypeOf(nextArgDef.type, prevArgDef.type)) {
+    // prevArgDef is less strict than nextArgDef
+    return nextArgDef;
+  } else if (schema.isTypeSubTypeOf(prevArgDef.type, nextArgDef.type)) {
+    return prevArgDef;
+  } else {
+    const prevArgType =
+      prevArgDef.type != null
+        ? schema.getTypeString(prevArgDef.type)
+        : 'unknown';
+    const nextArgType =
+      nextArgDef.type != null
+        ? schema.getTypeString(nextArgDef.type)
+        : 'unknown';
+    throw createUserError(
+      'Cannot combine variables with incompatible types ' +
+        `${prevArgType} and ${nextArgType} ` +
+        `when applying ${directiveName}.`,
+      [prevArgDef.loc, nextArgDef.loc],
+    );
+  }
+}
+
+module.exports = joinArgumentDefinitions;

package/util/md5.js.flow

@@ -0,0 +1,22 @@
+/**
+ * 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';
+
+function md5(str: string): string {
+  return require('crypto')
+    .createHash('md5')
+    .update(str, 'utf8')
+    .digest('hex');
+}
+
+module.exports = md5;

package/util/murmurHash.js.flow

@@ -0,0 +1,94 @@
+/**
+ * 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
+
+/**
+ * Based on implementations by Gary Court and Austin Appleby, 2011, MIT.
+ * @preserve-header
+ */
+
+'use strict';
+
+const BASE62 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+/**
+ * @param {string} key A UTF-16 or ASCII string
+ * @return {string} a base62 murmur hash
+ */
+function murmurHash(str: string): string {
+  /* eslint-disable no-bitwise */
+  const length = str.length;
+  const rem = length & 3;
+  const len = length ^ rem;
+
+  let h = 0;
+  let i = 0;
+  let k;
+
+  while (i !== len) {
+    const ch4 = str.charCodeAt(i + 3);
+
+    k =
+      str.charCodeAt(i) ^
+      (str.charCodeAt(i + 1) << 8) ^
+      (str.charCodeAt(i + 2) << 16) ^
+      ((ch4 & 0xff) << 24) ^
+      ((ch4 & 0xff00) >> 8);
+
+    i += 4;
+
+    k = (k * 0x2d51 + (k & 0xffff) * 0xcc9e0000) >>> 0;
+    k = (k << 15) | (k >>> 17);
+    k = (k * 0x3593 + (k & 0xffff) * 0x1b870000) >>> 0;
+    h ^= k;
+    h = (h << 13) | (h >>> 19);
+    h = (h * 5 + 0xe6546b64) >>> 0;
+  }
+
+  k = 0;
+  switch (rem) {
+    /* eslint-disable no-fallthrough */
+    case 3:
+      k ^= str.charCodeAt(len + 2) << 16;
+    case 2:
+      k ^= str.charCodeAt(len + 1) << 8;
+    case 1:
+      k ^= str.charCodeAt(len);
+
+      k = (k * 0x2d51 + (k & 0xffff) * 0xcc9e0000) >>> 0;
+      k = (k << 15) | (k >>> 17);
+      k = (k * 0x3593 + (k & 0xffff) * 0x1b870000) >>> 0;
+      h ^= k;
+  }
+
+  h ^= length;
+  h ^= h >>> 16;
+  h = (h * 0xca6b + (h & 0xffff) * 0x85eb0000) >>> 0;
+  h ^= h >>> 13;
+  h = (h * 0xae35 + (h & 0xffff) * 0xc2b20000) >>> 0;
+  h ^= h >>> 16;
+
+  h >>>= 0;
+
+  if (!h) {
+    return '0';
+  }
+
+  let s = '';
+  while (h) {
+    const d = h % 62;
+    s = BASE62[d] + s;
+    h = (h - d) / 62;
+  }
+  return s;
+}
+
+module.exports = murmurHash;

package/util/nullthrowsOSS.js.flow

@@ -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 strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+function nullthrows<T>(
+  x: ?T,
+  message?: string = 'Got unexpected null or undefined',
+): T {
+  if (x == null) {
+    throw new Error(message);
+  }
+  return x;
+}
+
+module.exports = nullthrows;

package/util/orList.js.flow

@@ -0,0 +1,37 @@
+/**
+ * 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';
+
+const OR_LIST_MAX_LENGTH = 5;
+
+const {createCompilerError} = require('../core/CompilerError');
+
+function orList(items: $ReadOnlyArray<string>): string {
+  if (items.length === 0) {
+    throw createCompilerError('Expected an array of strings. Got empty array');
+  }
+
+  if (items.length === 1) {
+    return items[0];
+  }
+
+  if (items.length > OR_LIST_MAX_LENGTH) {
+    return items.slice(0, OR_LIST_MAX_LENGTH).join(', ') + ', ...';
+  }
+
+  const selected = items.slice();
+  const lastItem = selected.pop();
+  return selected.join(', ') + ' or ' + lastItem;
+}
+
+module.exports = orList;

package/util/partitionArray.js.flow

@@ -0,0 +1,37 @@
+/**
+ * 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';
+
+/**
+ * Partitions an array given a predicate. All elements satisfying the predicate
+ * are part of the first returned array, and all elements that don't are in the
+ * second.
+ */
+function partitionArray<Tv>(
+  array: $ReadOnlyArray<Tv>,
+  predicate: (value: Tv) => boolean,
+): [$ReadOnlyArray<Tv>, $ReadOnlyArray<Tv>] {
+  const first = [];
+  const second = [];
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    if (predicate(item)) {
+      first.push(item);
+    } else {
+      second.push(item);
+    }
+  }
+  return [first, second];
+}
+
+module.exports = partitionArray;