@react-native/compatibility-check 0.0.0 → 0.0.1

package/dist/SortTypeAnnotations.js

@@ -0,0 +1,300 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.compareTypeAnnotationForSorting = compareTypeAnnotationForSorting;
+exports.sortTypeAnnotations = sortTypeAnnotations;
+var _invariant = _interopRequireDefault(require("invariant"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function sortTypeAnnotations(annotations) {
+  const sortableArray = annotations.map((a, i) => [i, a]);
+  return sortableArray.sort(compareTypeAnnotationForSorting);
+}
+const EQUALITY_MSG = "typeA and typeB differ despite check";
+function compareTypeAnnotationForSorting(
+  [originalPositionA, typeA],
+  [originalPositionB, typeB]
+) {
+  if (typeA.type !== typeB.type) {
+    if (typeA.type === "NullableTypeAnnotation") {
+      return compareTypeAnnotationForSorting(
+        [originalPositionA, typeA.typeAnnotation],
+        [originalPositionB, typeB]
+      );
+    }
+    if (typeB.type === "NullableTypeAnnotation") {
+      return compareTypeAnnotationForSorting(
+        [originalPositionA, typeA],
+        [originalPositionB, typeB.typeAnnotation]
+      );
+    }
+    return (
+      typeAnnotationArbitraryOrder(typeA) - typeAnnotationArbitraryOrder(typeB)
+    );
+  }
+  switch (typeA.type) {
+    case "AnyTypeAnnotation":
+      return 0;
+    case "ArrayTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "ArrayTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return compareTypeAnnotationForSorting(
+        [originalPositionA, typeA.elementType],
+        [originalPositionB, typeB.elementType]
+      );
+    case "BooleanTypeAnnotation":
+      return originalPositionA - originalPositionB;
+    case "EnumDeclaration":
+      (0, _invariant.default)(typeB.type === "EnumDeclaration", EQUALITY_MSG);
+      return typeA.memberType.localeCompare(typeB.memberType);
+    case "EnumDeclarationWithMembers":
+      (0, _invariant.default)(
+        typeB.type === "EnumDeclarationWithMembers",
+        EQUALITY_MSG
+      );
+      return compareNameAnnotationArraysForSorting(
+        [originalPositionA, typeA.members.map((m) => [m.name, m.value])],
+        [originalPositionB, typeB.members.map((m) => [m.name, m.value])]
+      );
+    case "FunctionTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "FunctionTypeAnnotation",
+        EQUALITY_MSG
+      );
+      const parmComparison = compareAnnotationArraysForSorting(
+        [originalPositionA, typeA.params.map((p) => p.typeAnnotation)],
+        [originalPositionB, typeB.params.map((p) => p.typeAnnotation)]
+      );
+      if (parmComparison === 0) {
+        return compareTypeAnnotationForSorting(
+          [originalPositionA, typeA.returnTypeAnnotation],
+          [originalPositionB, typeB.returnTypeAnnotation]
+        );
+      }
+      return parmComparison;
+    case "EventEmitterTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "EventEmitterTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return compareTypeAnnotationForSorting(
+        [originalPositionA, typeA.typeAnnotation],
+        [originalPositionB, typeB.typeAnnotation]
+      );
+    case "GenericObjectTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "GenericObjectTypeAnnotation",
+        EQUALITY_MSG
+      );
+      if (
+        typeA.dictionaryValueType == null &&
+        typeB.dictionaryValueType == null
+      ) {
+        return 0;
+      } else if (
+        typeA.dictionaryValueType != null &&
+        typeB.dictionaryValueType != null
+      ) {
+        return compareTypeAnnotationForSorting(
+          [originalPositionA, typeA.dictionaryValueType],
+          [originalPositionB, typeB.dictionaryValueType]
+        );
+      } else {
+        return typeA.dictionaryValueType == null ? -1 : 1;
+      }
+    case "NullableTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "NullableTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return compareTypeAnnotationForSorting(
+        [originalPositionA, typeA.typeAnnotation],
+        [originalPositionB, typeB.typeAnnotation]
+      );
+    case "NumberTypeAnnotation":
+    case "Int32TypeAnnotation":
+    case "FloatTypeAnnotation":
+    case "DoubleTypeAnnotation":
+      return 0;
+    case "NumberLiteralTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "NumberLiteralTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return typeA.value - typeB.value;
+    case "ObjectTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "ObjectTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return compareNameAnnotationArraysForSorting(
+        [
+          originalPositionA,
+          typeA.properties.map((p) => [p.name, p.typeAnnotation]),
+        ],
+        [
+          originalPositionB,
+          typeB.properties.map((p) => [p.name, p.typeAnnotation]),
+        ]
+      );
+    case "StringTypeAnnotation":
+      return originalPositionA - originalPositionB;
+    case "StringLiteralTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "StringLiteralTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return typeA.value.localeCompare(typeB.value);
+    case "StringLiteralUnionTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "StringLiteralUnionTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return compareAnnotationArraysForSorting(
+        [originalPositionA, typeA.types],
+        [originalPositionB, typeB.types]
+      );
+    case "UnionTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "UnionTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return 0;
+    case "VoidTypeAnnotation":
+      return 0;
+    case "ReservedTypeAnnotation":
+      return 0;
+    case "PromiseTypeAnnotation":
+      (0, _invariant.default)(
+        typeB.type === "PromiseTypeAnnotation",
+        EQUALITY_MSG
+      );
+      return compareTypeAnnotationForSorting(
+        [originalPositionA, typeA.elementType],
+        [originalPositionB, typeB.elementType]
+      );
+    case "TypeAliasTypeAnnotation":
+      return 0;
+    case "MixedTypeAnnotation":
+      return 0;
+    default:
+      typeA.type;
+      return -1;
+  }
+}
+function nameComparison([nameA], [nameB]) {
+  if (nameA === nameB) {
+    return 0;
+  } else if (nameA < nameB) {
+    return -1;
+  }
+  return 1;
+}
+function compareNameAnnotationArraysForSorting(
+  [originalPositionA, arrayA],
+  [originalPositionB, arrayB]
+) {
+  if (arrayA.length - arrayB.length !== 0) {
+    return arrayA.length - arrayB.length;
+  }
+  const nameSortedA = arrayA.sort(nameComparison);
+  const nameSortedB = arrayB.sort(nameComparison);
+  for (let i = 0; i < nameSortedA.length; i++) {
+    if (nameSortedA[i][0] === nameSortedB[i][0]) {
+      const compared = compareTypeAnnotationForSorting(
+        [originalPositionA, nameSortedA[i][1]],
+        [originalPositionB, nameSortedB[i][1]]
+      );
+      if (compared !== 0) {
+        return compared;
+      }
+      continue;
+    }
+    if (nameSortedA[i][0] < nameSortedB[i][0]) {
+      return -1;
+    }
+    return 1;
+  }
+  return 0;
+}
+function compareAnnotationArraysForSorting(
+  [originalPositionA, arrayA],
+  [originalPositionB, arrayB]
+) {
+  if (arrayA.length - arrayB.length !== 0) {
+    return arrayA.length - arrayB.length;
+  }
+  for (let i = 0; i < arrayA.length; i++) {
+    const compared = compareTypeAnnotationForSorting(
+      [originalPositionA, arrayA[i]],
+      [originalPositionB, arrayB[i]]
+    );
+    if (compared !== 0) {
+      return compared;
+    }
+    continue;
+  }
+  return 0;
+}
+function typeAnnotationArbitraryOrder(annotation) {
+  switch (annotation.type) {
+    case "AnyTypeAnnotation":
+      return 0;
+    case "ArrayTypeAnnotation":
+      return 1;
+    case "BooleanTypeAnnotation":
+      return 2;
+    case "FunctionTypeAnnotation":
+      return 3;
+    case "EventEmitterTypeAnnotation":
+      return 4;
+    case "PromiseTypeAnnotation":
+      return 5;
+    case "GenericObjectTypeAnnotation":
+      return 6;
+    case "NullableTypeAnnotation":
+      return 9;
+    case "NumberTypeAnnotation":
+      return 10;
+    case "Int32TypeAnnotation":
+      return 11;
+    case "DoubleTypeAnnotation":
+      return 12;
+    case "FloatTypeAnnotation":
+      return 13;
+    case "NumberLiteralTypeAnnotation":
+      return 14;
+    case "ObjectTypeAnnotation":
+      return 15;
+    case "StringLiteralUnionTypeAnnotation":
+      return 17;
+    case "StringTypeAnnotation":
+      return 18;
+    case "StringLiteralTypeAnnotation":
+      return 19;
+    case "VoidTypeAnnotation":
+      return 20;
+    case "EnumDeclaration":
+      return 21;
+    case "EnumDeclarationWithMembers":
+      return 22;
+    case "GenericObjectTypeAnnotation":
+      return 25;
+    case "TypeAliasTypeAnnotation":
+      return 26;
+    case "MixedTypeAnnotation":
+      return 27;
+    case "ReservedTypeAnnotation":
+      return 28;
+    case "UnionTypeAnnotation":
+      return 30;
+    default:
+      annotation.type;
+      return -1;
+  }
+}

package/dist/SortTypeAnnotations.js.flow

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type { CompleteTypeAnnotation } from "@react-native/codegen/src/CodegenSchema";
+
+declare export function sortTypeAnnotations(
+  annotations: $ReadOnlyArray<CompleteTypeAnnotation>
+): Array<[number, CompleteTypeAnnotation]>;
+
+declare export function compareTypeAnnotationForSorting(
+  [number, CompleteTypeAnnotation],
+  [number, CompleteTypeAnnotation]
+): number;

package/dist/TypeDiffing.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+import type {
+  ComparisonResult,
+  MembersComparisonResult,
+} from "./ComparisonResult";
+import type {
+  CompleteTypeAnnotation,
+  NamedShape,
+  NativeModuleAliasMap,
+  NativeModuleEnumDeclaration,
+  NativeModuleEnumDeclarationWithMembers,
+  NativeModuleEnumMap,
+  NativeModuleEnumMember,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleGenericObjectTypeAnnotation,
+  NativeModulePromiseTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
+  NumberLiteralTypeAnnotation,
+  StringLiteralTypeAnnotation,
+  StringLiteralUnionTypeAnnotation,
+} from "@react-native/codegen/src/CodegenSchema";
+export declare function compareTypes(
+  newerType: CompleteTypeAnnotation,
+  olderType: null | undefined | CompleteTypeAnnotation,
+  newerTypesReg: null | undefined | NativeModuleAliasMap,
+  olderTypesReg: null | undefined | NativeModuleAliasMap,
+  newerEnumMap: null | undefined | NativeModuleEnumMap,
+  olderEnumMap: null | undefined | NativeModuleEnumMap
+): ComparisonResult;
+export declare function compareTypeAnnotation(
+  originalNewerAnnotation: CompleteTypeAnnotation,
+  originalOlderAnnotation: CompleteTypeAnnotation
+): ComparisonResult;
+export declare function compareObjectTypes<T extends CompleteTypeAnnotation>(
+  newerPropertyTypes: ReadonlyArray<NamedShape<T>>,
+  olderPropertyTypes: ReadonlyArray<NamedShape<T>>
+): ComparisonResult;
+export declare function compareEnumDeclarations(
+  newerDeclaration: NativeModuleEnumDeclaration,
+  olderDeclaration: NativeModuleEnumDeclaration
+): ComparisonResult;
+export declare function compareEnumDeclarationMemberArrays(
+  newer: Array<NativeModuleEnumMember>,
+  older: Array<NativeModuleEnumMember>
+): MembersComparisonResult;
+export declare function compareEnumDeclarationWithMembers(
+  newerDeclaration: NativeModuleEnumDeclarationWithMembers,
+  olderDeclaration: NativeModuleEnumDeclarationWithMembers
+): ComparisonResult;
+export declare function compareUnionTypes(
+  newerType: NativeModuleUnionTypeAnnotation,
+  olderType: NativeModuleUnionTypeAnnotation
+): ComparisonResult;
+export declare function comparePromiseTypes(
+  newerType: NativeModulePromiseTypeAnnotation,
+  olderType: NativeModulePromiseTypeAnnotation
+): ComparisonResult;
+export declare function compareGenericObjectTypes(
+  newerType: NativeModuleGenericObjectTypeAnnotation,
+  olderType: NativeModuleGenericObjectTypeAnnotation
+): ComparisonResult;
+export declare function compareNumberLiteralTypes(
+  newerType: NumberLiteralTypeAnnotation,
+  olderType: NumberLiteralTypeAnnotation
+): ComparisonResult;
+export declare function compareStringLiteralTypes(
+  newerType: StringLiteralTypeAnnotation,
+  olderType: StringLiteralTypeAnnotation
+): ComparisonResult;
+export declare function compareStringLiteralUnionTypes(
+  newerType: StringLiteralUnionTypeAnnotation,
+  olderType: StringLiteralUnionTypeAnnotation
+): ComparisonResult;
+export declare function compareFunctionTypes(
+  newerType: NativeModuleFunctionTypeAnnotation,
+  olderType: NativeModuleFunctionTypeAnnotation
+): ComparisonResult;