@react-native/compatibility-check 0.0.0 → 0.0.1

package/dist/DiffResults.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 {
+  PropertiesComparisonResult,
+  TypeComparisonError,
+} from "./ComparisonResult";
+import type { CompleteTypeAnnotation } from "@react-native/codegen/src/CodegenSchema";
+export type ErrorCode =
+  | "addedProps"
+  | "removedProps"
+  | "changedParams"
+  | "incompatibleTypes"
+  | "requiredProps"
+  | "optionalProps"
+  | "nonNullableOfNull"
+  | "nullableOfNonNull"
+  | "removedUnionCases"
+  | "addedUnionCases"
+  | "addedEnumCases"
+  | "removedEnumCases"
+  | "removedIntersectCases"
+  | "addedIntersectCases"
+  | "removedModule"
+  | "removedComponent";
+export type TypeStore = {
+  typeName: string;
+  typeInformation: CompleteTypeAnnotation;
+};
+export type ObjectTypeChangeStore = {
+  typeName: string;
+  newType: CompleteTypeAnnotation;
+  oldType: CompleteTypeAnnotation;
+  propertyChange: PropertiesComparisonResult;
+};
+export type ErrorStore = {
+  typeName: string;
+  errorCode: ErrorCode;
+  errorInformation: TypeComparisonError;
+};
+export type FormattedErrorStore = { message: string; errorCode: ErrorCode };
+export type NativeSpecErrorStore = {
+  nativeSpecName: string;
+  omitted: boolean;
+  errorCode: ErrorCode;
+  errorInformation?: TypeComparisonError;
+  changeInformation?: DiffSet;
+};
+export type ExportableNativeSpecErrorStore = {
+  nativeSpecName: string;
+  omitted: boolean;
+  errorCode: ErrorCode;
+  errorInformation?: TypeComparisonError;
+  changeInformation?: ExportableDiffSet;
+};
+export type DiffSet = {
+  newTypes: Set<TypeStore>;
+  deprecatedTypes: Set<TypeStore>;
+  objectTypeChanges: Set<ObjectTypeChangeStore>;
+  incompatibleChanges: Set<ErrorStore>;
+};
+type ExportableDiffSet = {
+  newTypes: Array<TypeStore>;
+  deprecatedTypes: Array<TypeStore>;
+  objectTypeChanges: Array<ObjectTypeChangeStore>;
+  incompatibleChanges: Array<ErrorStore>;
+};
+export type Framework = "ReactNative";
+export type SchemaDiffers = {
+  incompatibleSpecs: null | undefined | Set<NativeSpecErrorStore>;
+};
+type ExportableSchemaDiffers = {
+  incompatibleSpecs: null | undefined | Array<ExportableNativeSpecErrorStore>;
+};
+export type SchemaDiffCategory = "new" | "deprecated" | SchemaDiffers;
+type ExportableSchemaDiffCategory =
+  | "new"
+  | "deprecated"
+  | ExportableSchemaDiffers;
+export type SchemaDiff = {
+  name: string;
+  framework: Framework;
+  status: SchemaDiffCategory;
+};
+export type ExportableSchemaDiff = {
+  name: string;
+  framework: Framework;
+  status: ExportableSchemaDiffCategory;
+};
+export type Version = { device: "android" | "ios"; number: string };
+export type Incompatible = {
+  framework: Framework;
+  incompatibleSpecs?: Array<NativeSpecErrorStore>;
+};
+export type IncompatiblityReport = { [hasteModuleName: string]: Incompatible };
+export type DiffSummary = {
+  /** status records how the diff compares against older versions
+   * ok: there are no changes that impact older versions
+   * patchable: there are additions (or modifications) that are not suported
+   *            in older versions but is safe with an auto-generated patch
+   * incompatible: there are modifications that are not safe for use with older
+   *            versions and are not fixable with an auto-generated patchable
+   */
+  status: "ok" | "patchable" | "incompatible";
+  incompatibilityReport: IncompatiblityReport;
+};
+export type FormattedIncompatible = {
+  framework: Framework;
+  incompatibleSpecs?: Array<FormattedErrorStore>;
+};
+export type FormattedIncompatiblityReport = {
+  [hasteModuleName: string]: FormattedIncompatible;
+};
+export type FormattedDiffSummary = {
+  /** status records how the diff compares against older versions
+   * ok: there are no changes that impact older versions
+   * patchable: there are additions (or modifications) that are not suported
+   *            in older versions but is safe with an auto-generated patch
+   * incompatible: there are modifications that are not safe for use with older
+   *            versions and are not fixable with an auto-generated patchable
+   */
+  status: "ok" | "patchable" | "incompatible";
+  incompatibilityReport: FormattedIncompatiblityReport;
+};
+export declare function nativeSpecErrorExporter(
+  nativeSpecError: NativeSpecErrorStore
+): ExportableNativeSpecErrorStore;
+export declare function schemaDiffExporter(
+  schemaDiff: SchemaDiff
+): ExportableSchemaDiff;

package/dist/DiffResults.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.nativeSpecErrorExporter = nativeSpecErrorExporter;
+exports.schemaDiffExporter = schemaDiffExporter;
+function diffSetExporter(diffSet) {
+  return {
+    newTypes: Array.from(diffSet.newTypes),
+    deprecatedTypes: Array.from(diffSet.deprecatedTypes),
+    objectTypeChanges: Array.from(diffSet.objectTypeChanges),
+    incompatibleChanges: Array.from(diffSet.incompatibleChanges),
+  };
+}
+function nativeSpecErrorExporter(nativeSpecError) {
+  if (nativeSpecError.changeInformation) {
+    return {
+      nativeSpecName: nativeSpecError.nativeSpecName,
+      omitted: nativeSpecError.omitted,
+      errorCode: nativeSpecError.errorCode,
+      errorInformation: nativeSpecError.errorInformation,
+      changeInformation: diffSetExporter(nativeSpecError.changeInformation),
+    };
+  }
+  return {
+    nativeSpecName: nativeSpecError.nativeSpecName,
+    omitted: nativeSpecError.omitted,
+    errorCode: nativeSpecError.errorCode,
+    errorInformation: nativeSpecError.errorInformation,
+  };
+}
+function schemaDiffCategoryExporter(status) {
+  switch (status) {
+    case "new":
+    case "deprecated":
+      return status;
+    default:
+      return {
+        incompatibleSpecs: status.incompatibleSpecs
+          ? Array.from(status.incompatibleSpecs).map(nativeSpecErrorExporter)
+          : undefined,
+      };
+  }
+}
+function schemaDiffExporter(schemaDiff) {
+  return {
+    name: schemaDiff.name,
+    framework: schemaDiff.framework,
+    status: schemaDiffCategoryExporter(schemaDiff.status),
+  };
+}

package/dist/DiffResults.js.flow

@@ -0,0 +1,160 @@
+/**
+ * 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-local
+ * @format
+ */
+
+import type {
+  PropertiesComparisonResult,
+  TypeComparisonError,
+} from "./ComparisonResult";
+import type { CompleteTypeAnnotation } from "@react-native/codegen/src/CodegenSchema";
+
+export type ErrorCode =
+  | "addedProps"
+  | "removedProps"
+  | "changedParams"
+  | "incompatibleTypes"
+  | "requiredProps"
+  | "optionalProps"
+  | "nonNullableOfNull"
+  | "nullableOfNonNull"
+  | "removedUnionCases"
+  | "addedUnionCases"
+  | "addedEnumCases"
+  | "removedEnumCases"
+  | "removedIntersectCases"
+  | "addedIntersectCases"
+  | "removedModule"
+  | "removedComponent";
+
+export type TypeStore = {
+  typeName: string,
+  typeInformation: CompleteTypeAnnotation,
+  ...
+};
+// Stores object properties that are added or removed which could be patchable
+export type ObjectTypeChangeStore = {
+  typeName: string,
+  newType: CompleteTypeAnnotation,
+  oldType: CompleteTypeAnnotation,
+  propertyChange: PropertiesComparisonResult,
+};
+export type ErrorStore = {
+  typeName: string,
+  errorCode: ErrorCode,
+  errorInformation: TypeComparisonError,
+};
+export type FormattedErrorStore = {
+  message: string,
+  errorCode: ErrorCode,
+};
+export type NativeSpecErrorStore = {
+  nativeSpecName: string,
+  omitted: boolean,
+  errorCode: ErrorCode,
+  errorInformation?: TypeComparisonError,
+  changeInformation?: DiffSet,
+};
+export type ExportableNativeSpecErrorStore = {
+  nativeSpecName: string,
+  omitted: boolean,
+  errorCode: ErrorCode,
+  errorInformation?: TypeComparisonError,
+  changeInformation?: ExportableDiffSet,
+};
+export type DiffSet = {
+  newTypes: Set<TypeStore>,
+  deprecatedTypes: Set<TypeStore>,
+  objectTypeChanges: Set<ObjectTypeChangeStore>,
+  incompatibleChanges: Set<ErrorStore>,
+};
+type ExportableDiffSet = {
+  newTypes: Array<TypeStore>,
+  deprecatedTypes: Array<TypeStore>,
+  objectTypeChanges: Array<ObjectTypeChangeStore>,
+  incompatibleChanges: Array<ErrorStore>,
+};
+
+export type Framework = "ReactNative";
+export type SchemaDiffers = {
+  incompatibleSpecs: ?Set<NativeSpecErrorStore>,
+};
+type ExportableSchemaDiffers = {
+  incompatibleSpecs: ?Array<ExportableNativeSpecErrorStore>,
+};
+export type SchemaDiffCategory = "new" | "deprecated" | SchemaDiffers;
+type ExportableSchemaDiffCategory =
+  | "new"
+  | "deprecated"
+  | ExportableSchemaDiffers;
+export type SchemaDiff = {
+  name: string,
+  framework: Framework,
+  status: SchemaDiffCategory,
+};
+export type ExportableSchemaDiff = {
+  name: string,
+  framework: Framework,
+  status: ExportableSchemaDiffCategory,
+};
+
+export type Version = {
+  device: "android" | "ios",
+  number: string,
+  ...
+};
+
+export type Incompatible = {
+  framework: Framework,
+  incompatibleSpecs?: Array<NativeSpecErrorStore>,
+};
+export type IncompatiblityReport = {
+  [hasteModuleName: string]: Incompatible,
+};
+export type DiffSummary = {
+  /** status records how the diff compares against older versions
+   * ok: there are no changes that impact older versions
+   * patchable: there are additions (or modifications) that are not suported
+   *            in older versions but is safe with an auto-generated patch
+   * incompatible: there are modifications that are not safe for use with older
+   *            versions and are not fixable with an auto-generated patchable
+   */
+  status: "ok" | "patchable" | "incompatible",
+  // If there are incompatible changes, provide a record of them, otherwise {}
+  incompatibilityReport: IncompatiblityReport,
+};
+
+export type FormattedIncompatible = {
+  framework: Framework,
+  incompatibleSpecs?: Array<FormattedErrorStore>,
+};
+
+export type FormattedIncompatiblityReport = {
+  [hasteModuleName: string]: FormattedIncompatible,
+};
+
+export type FormattedDiffSummary = {
+  /** status records how the diff compares against older versions
+   * ok: there are no changes that impact older versions
+   * patchable: there are additions (or modifications) that are not suported
+   *            in older versions but is safe with an auto-generated patch
+   * incompatible: there are modifications that are not safe for use with older
+   *            versions and are not fixable with an auto-generated patchable
+   */
+  status: "ok" | "patchable" | "incompatible",
+  // If there are incompatible changes, provide a record of them, otherwise {}
+  incompatibilityReport: FormattedIncompatiblityReport,
+};
+
+declare export function nativeSpecErrorExporter(
+  nativeSpecError: NativeSpecErrorStore
+): ExportableNativeSpecErrorStore;
+
+declare export function schemaDiffExporter(
+  schemaDiff: SchemaDiff
+): ExportableSchemaDiff;

package/dist/ErrorFormatting.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { TypeComparisonError } from "./ComparisonResult";
+import type {
+  DiffSummary,
+  ErrorStore,
+  FormattedDiffSummary,
+  FormattedErrorStore,
+  NativeSpecErrorStore,
+} from "./DiffResults";
+export declare function formatErrorMessage(
+  error: TypeComparisonError,
+  indent: number
+): string;
+export declare function formatErrorStore(
+  errorStore: ErrorStore
+): FormattedErrorStore;
+export declare function formatNativeSpecErrorStore(
+  specError: NativeSpecErrorStore
+): Array<FormattedErrorStore>;
+export declare function formatDiffSet(
+  summary: DiffSummary
+): FormattedDiffSummary;

package/dist/ErrorFormatting.js

@@ -0,0 +1,272 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.formatDiffSet = formatDiffSet;
+exports.formatErrorMessage = formatErrorMessage;
+exports.formatErrorStore = formatErrorStore;
+exports.formatNativeSpecErrorStore = formatNativeSpecErrorStore;
+function indentedLineStart(indent) {
+  return "\n" + "  ".repeat(indent);
+}
+function formatErrorMessage(error, indent = 0) {
+  switch (error.type) {
+    case "PropertyComparisonError":
+      const formattedProperties = error.mismatchedProperties.map(
+        (individualPropertyError) =>
+          indentedLineStart(indent + 1) +
+          "-- " +
+          individualPropertyError.property +
+          (individualPropertyError.fault
+            ? ": " +
+              formatErrorMessage(individualPropertyError.fault, indent + 2)
+            : "")
+      );
+      return error.message + formattedProperties.join("");
+    case "PositionalComparisonError":
+      const formattedPositionalChanges = error.erroneousItems.map(
+        ([index, type]) =>
+          indentedLineStart(indent + 1) +
+          "-- position " +
+          index +
+          " " +
+          formatTypeAnnotation(type)
+      );
+      return error.message + formattedPositionalChanges.join("");
+    case "TypeAnnotationComparisonError":
+      const previousError = error.previousError;
+      return (
+        error.message +
+        indentedLineStart(indent + 1) +
+        "--new: " +
+        formatTypeAnnotation(error.newerAnnotation) +
+        indentedLineStart(indent + 1) +
+        "--old: " +
+        formatTypeAnnotation(error.olderAnnotation) +
+        (previousError != null
+          ? indentedLineStart(indent + 1) +
+            "" +
+            formatErrorMessage(previousError, indent + 2)
+          : "")
+      );
+    case "TypeInformationComparisonError":
+      return (
+        error.message +
+        indentedLineStart(indent + 1) +
+        "-- new: " +
+        formatTypeAnnotation(error.newerType) +
+        indentedLineStart(indent + 1) +
+        "-- old: " +
+        formatTypeAnnotation(error.olderType)
+      );
+    case "MemberComparisonError":
+      const formattedMembers = error.mismatchedMembers.map(
+        (individualMemberError) =>
+          indentedLineStart(indent + 1) +
+          "-- Member " +
+          individualMemberError.member +
+          (individualMemberError.fault
+            ? ": " + formatErrorMessage(individualMemberError.fault, indent + 2)
+            : "")
+      );
+      return error.message + formattedMembers.join("");
+    default:
+      error.type;
+      return "";
+  }
+}
+function formatTypeAnnotation(annotation) {
+  switch (annotation.type) {
+    case "AnyTypeAnnotation":
+      return "any";
+    case "ArrayTypeAnnotation":
+      return "Array<" + formatTypeAnnotation(annotation.elementType) + ">";
+    case "BooleanTypeAnnotation":
+      return "boolean";
+    case "EnumDeclaration": {
+      let shortHandType = "";
+      switch (annotation.memberType) {
+        case "StringTypeAnnotation":
+          shortHandType = "string";
+          break;
+        case "NumberTypeAnnotation":
+          shortHandType = "number";
+          break;
+        default:
+          annotation.memberType;
+          throw new Error("Unexpected enum memberType");
+      }
+      return `Enum<${shortHandType}>` + "";
+    }
+    case "EnumDeclarationWithMembers": {
+      let shortHandType = "";
+      switch (annotation.memberType) {
+        case "StringTypeAnnotation":
+          shortHandType = "string";
+          break;
+        case "NumberTypeAnnotation":
+          shortHandType = "number";
+          break;
+        default:
+          annotation.memberType;
+          throw new Error("Unexptected enum memberType");
+      }
+      return (
+        `Enum<${shortHandType}> {` +
+        annotation.members
+          .map(
+            (member) => `${member.name} = ${formatTypeAnnotation(member.value)}`
+          )
+          .join(", ") +
+        "}"
+      );
+    }
+    case "FunctionTypeAnnotation":
+      return (
+        "(" +
+        annotation.params
+          .map(
+            (param) =>
+              param.name +
+              (param.optional ? "?" : "") +
+              ": " +
+              formatTypeAnnotation(param.typeAnnotation)
+          )
+          .join(", ") +
+        ")" +
+        "=>" +
+        formatTypeAnnotation(annotation.returnTypeAnnotation)
+      );
+    case "NullableTypeAnnotation":
+      return "?" + formatTypeAnnotation(annotation.typeAnnotation);
+    case "NumberTypeAnnotation":
+      return "number";
+    case "DoubleTypeAnnotation":
+      return "double";
+    case "FloatTypeAnnotation":
+      return "float";
+    case "Int32TypeAnnotation":
+      return "int";
+    case "NumberLiteralTypeAnnotation":
+      return annotation.value.toString();
+    case "ObjectTypeAnnotation":
+      return (
+        "{" +
+        annotation.properties
+          .map(
+            (property) =>
+              property.name +
+              (property.optional ? "?" : "") +
+              ": " +
+              formatTypeAnnotation(property.typeAnnotation)
+          )
+          .join(", ") +
+        "}"
+      );
+    case "StringLiteralTypeAnnotation":
+      return parseInt(annotation.value, 10).toString() === annotation.value ||
+        annotation.value.includes(" ")
+        ? `'${annotation.value}'`
+        : annotation.value;
+    case "StringLiteralUnionTypeAnnotation":
+      return (
+        "(" +
+        annotation.types
+          .map((stringLit) => formatTypeAnnotation(stringLit))
+          .join(" | ") +
+        ")"
+      );
+    case "StringTypeAnnotation":
+      return "string";
+    case "UnionTypeAnnotation": {
+      const shortHandType =
+        annotation.memberType === "StringTypeAnnotation"
+          ? "string"
+          : annotation.memberType === "ObjectTypeAnnotation"
+          ? "Object"
+          : "number";
+      return `Union<${shortHandType}>`;
+    }
+    case "PromiseTypeAnnotation":
+      return "Promise<" + formatTypeAnnotation(annotation.elementType) + ">";
+    case "EventEmitterTypeAnnotation":
+      return (
+        "EventEmitter<" + formatTypeAnnotation(annotation.typeAnnotation) + ">"
+      );
+    case "TypeAliasTypeAnnotation":
+    case "ReservedTypeAnnotation":
+      return annotation.name;
+    case "VoidTypeAnnotation":
+      return "void";
+    case "MixedTypeAnnotation":
+      return "mixed";
+    case "GenericObjectTypeAnnotation":
+      if (annotation.dictionaryValueType) {
+        return `{[string]: ${formatTypeAnnotation(
+          annotation.dictionaryValueType
+        )}`;
+      }
+      return "Object";
+    default:
+      annotation.type;
+      return JSON.stringify(annotation);
+  }
+}
+function formatErrorStore(errorStore) {
+  return {
+    message:
+      errorStore.typeName +
+      ": " +
+      formatErrorMessage(errorStore.errorInformation),
+    errorCode: errorStore.errorCode,
+  };
+}
+function formatNativeSpecErrorStore(specError) {
+  if (specError.errorInformation) {
+    return [
+      {
+        message:
+          specError.nativeSpecName +
+          ": " +
+          formatErrorMessage(specError.errorInformation),
+        errorCode: specError.errorCode,
+      },
+    ];
+  }
+  if (specError.changeInformation?.incompatibleChanges != null) {
+    return Array.from(specError.changeInformation.incompatibleChanges).map(
+      (errorStore) => formatErrorStore(errorStore)
+    );
+  }
+  return [];
+}
+function formatDiffSet(summary) {
+  const summaryStatus = summary.status;
+  if (summaryStatus === "ok" || summaryStatus === "patchable") {
+    return summary;
+  }
+  const hasteModules = Object.keys(summary.incompatibilityReport);
+  const incompatibles = summary.incompatibilityReport;
+  const formattedIncompatibilities = {};
+  hasteModules.forEach((hasteModule) => {
+    const incompat = incompatibles[hasteModule];
+    const formattedIncompat = {
+      framework: incompat.framework,
+    };
+    if (incompat.incompatibleSpecs) {
+      formattedIncompat.incompatibleSpecs = incompat.incompatibleSpecs.reduce(
+        (formattedModuleErrors, specErrorStore) =>
+          formattedModuleErrors.concat(
+            formatNativeSpecErrorStore(specErrorStore)
+          ),
+        []
+      );
+    }
+    formattedIncompatibilities[hasteModule] = formattedIncompat;
+  });
+  return {
+    status: summaryStatus,
+    incompatibilityReport: formattedIncompatibilities,
+  };
+}

package/dist/ErrorFormatting.js.flow

@@ -0,0 +1,34 @@
+/**
+ * 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-local
+ * @format
+ */
+
+import type { TypeComparisonError } from "./ComparisonResult";
+import type {
+  DiffSummary,
+  ErrorStore,
+  FormattedDiffSummary,
+  FormattedErrorStore,
+  NativeSpecErrorStore,
+} from "./DiffResults";
+declare export function formatErrorMessage(
+  error: TypeComparisonError,
+  indent: number
+): string;
+
+declare export function formatErrorStore(
+  errorStore: ErrorStore
+): FormattedErrorStore;
+
+declare export function formatNativeSpecErrorStore(
+  specError: NativeSpecErrorStore
+): Array<FormattedErrorStore>;
+
+declare export function formatDiffSet(
+  summary: DiffSummary
+): FormattedDiffSummary;

package/dist/SortTypeAnnotations.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.
+ *
+ *
+ * @format
+ */
+
+import type { CompleteTypeAnnotation } from "@react-native/codegen/src/CodegenSchema";
+export declare function sortTypeAnnotations(
+  annotations: ReadonlyArray<CompleteTypeAnnotation>
+): Array<[number, CompleteTypeAnnotation]>;
+export declare function compareTypeAnnotationForSorting(
+  $$PARAM_0$$: [number, CompleteTypeAnnotation],
+  $$PARAM_1$$: [number, CompleteTypeAnnotation]
+): number;