Remove the native SafeAreaView and the deprecated public export

`SafeAreaView` has been deprecated for several releases in favour of
`react-native-safe-area-context`, and the previous change moved the core
surfaces that cannot use the library onto a JavaScript implementation built
on the safe area insets prop. Nothing needs the native component now.

Removed: the C++ shadow node, state and component descriptor, the iOS
component view, the Android view and view manager, the codegen spec and every
registration of them, plus the long-deprecated public export from `index.js`,
the Flow and TypeScript surfaces, the deprecated type stubs, the Babel lazy
import list and the ESLint import map. The private component drops its
`_INTERNAL_DO_NOT_USE` suffix now that it is the only one left.

This is a breaking change for anyone still importing `SafeAreaView` from
`react-native`; the replacement is `react-native-safe-area-context`, or the
`experimental_onSafeAreaInsetsChange` prop directly.

Author: janicduplessis

packages/eslint-plugin-react-native/utils.js

@@ -109,10 +109,6 @@ const publicAPIMapping = {
       'RefreshControlPropsIOS',
     ],
   },
-  'Libraries/Components/SafeAreaView/SafeAreaView': {
-    default: 'SafeAreaView',
-    types: null,
-  },
   'Libraries/Components/ScrollView/ScrollView': {
     default: 'ScrollView',
     types: [

packages/react-native-babel-preset/src/configs/lazy-imports.js

@@ -29,7 +29,6 @@ module.exports = new Set([
   'Pressable',
   'ProgressBarAndroid',
   'ProgressViewIOS',
-  'SafeAreaView',
   'ScrollView',
   'SectionList',
   'Slider',

packages/react-native-compatibility-check/dist/ComparisonResult.d.ts

@@ -0,0 +1,182 @@
+/**
+ * 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,
+  NamedShape,
+  NativeModuleEnumMember,
+} from "@react-native/codegen/src/CodegenSchema";
+type TypeAnnotationComparisonError = {
+  type: "TypeAnnotationComparisonError";
+  message: string;
+  newerAnnotation: CompleteTypeAnnotation;
+  olderAnnotation: CompleteTypeAnnotation;
+  previousError?: TypeComparisonError | undefined;
+};
+type TypeInformationComparisonError = {
+  type: "TypeInformationComparisonError";
+  message: string;
+  newerAnnotation: CompleteTypeAnnotation;
+  olderAnnotation: CompleteTypeAnnotation;
+  previousError?: TypeComparisonError | undefined;
+};
+type PropertyComparisonError = {
+  type: "PropertyComparisonError";
+  message: string;
+  mismatchedProperties: Array<{
+    property: string;
+    fault?: TypeComparisonError | undefined;
+  }>;
+  previousError?: TypeComparisonError | undefined;
+};
+type PositionalComparisonError = {
+  type: "PositionalComparisonError";
+  message: string;
+  erroneousItems: Array<[number, CompleteTypeAnnotation]>;
+  previousError?: TypeComparisonError | undefined;
+};
+type MemberComparisonError = {
+  type: "MemberComparisonError";
+  message: string;
+  mismatchedMembers: Array<{
+    member: string;
+    fault?: TypeComparisonError | undefined;
+  }>;
+  previousError?: TypeComparisonError | undefined;
+};
+export type TypeComparisonError =
+  | TypeAnnotationComparisonError
+  | TypeInformationComparisonError
+  | PropertyComparisonError
+  | PositionalComparisonError
+  | MemberComparisonError;
+export type PositionalComparisonResult = {
+  typeKind: "stringUnion" | "union" | "intersection" | "parameter" | "tuple";
+  nestedChanges: Array<[number, number, ComparisonResult]>;
+  addedElements?: Array<[number, CompleteTypeAnnotation]> | undefined;
+  removedElements?: Array<[number, CompleteTypeAnnotation]> | undefined;
+};
+export type FunctionComparisonResult = {
+  returnType?: ComparisonResult | undefined;
+  parameterTypes?: PositionalComparisonResult | undefined;
+};
+export type PropertiesComparisonResult = {
+  addedProperties?:
+    ReadonlyArray<NamedShape<CompleteTypeAnnotation>> | undefined;
+  missingProperties?:
+    ReadonlyArray<NamedShape<CompleteTypeAnnotation>> | undefined;
+  errorProperties?:
+    | Array<{ property: string; fault?: TypeComparisonError | undefined }>
+    | undefined;
+  madeStrict?:
+    | Array<{ property: string; furtherChanges?: ComparisonResult | undefined }>
+    | undefined;
+  madeOptional?:
+    | Array<{ property: string; furtherChanges?: ComparisonResult | undefined }>
+    | undefined;
+  nestedPropertyChanges?: Array<[string, ComparisonResult]> | undefined;
+};
+export type EnumMembersComparisonResult = {
+  memberKind: "enum";
+  addedMembers?: Array<NativeModuleEnumMember> | undefined;
+  missingMembers?: Array<NativeModuleEnumMember> | undefined;
+  errorMembers?:
+    | Array<{ member: string; fault?: TypeComparisonError | undefined }>
+    | undefined;
+};
+export type UnionMembersComparisonResult = {
+  memberKind: "union";
+  addedMembers?: Array<CompleteTypeAnnotation> | undefined;
+  missingMembers?: Array<CompleteTypeAnnotation> | undefined;
+  errorMembers?:
+    | Array<{ member: string; fault?: TypeComparisonError | undefined }>
+    | undefined;
+};
+export type MembersComparisonResult =
+  EnumMembersComparisonResult | UnionMembersComparisonResult;
+export type NullableComparisonResult = {
+  typeRefined: boolean;
+  optionsReduced: boolean;
+  interiorLog: null | undefined | ComparisonResult;
+  newType: null | undefined | CompleteTypeAnnotation;
+  oldType: null | undefined | CompleteTypeAnnotation;
+};
+export type ComparisonResult =
+  | { status: "matching" }
+  | { status: "skipped" }
+  | {
+      status: "nullableChange";
+      nullableLog: NullableComparisonResult;
+      errorLog?: TypeComparisonError | undefined;
+    }
+  | {
+      status: "properties";
+      propertyLog: PropertiesComparisonResult;
+      errorLog?: TypeComparisonError | undefined;
+    }
+  | {
+      status: "members";
+      memberLog: MembersComparisonResult;
+      errorLog?: TypeComparisonError | undefined;
+    }
+  | {
+      status: "functionChange";
+      functionChangeLog: FunctionComparisonResult;
+      errorLog?: TypeComparisonError | undefined;
+    }
+  | {
+      status: "positionalTypeChange";
+      changeLog: PositionalComparisonResult;
+      errorLog?: TypeComparisonError | undefined;
+    }
+  | { status: "error"; errorLog: TypeComparisonError };
+export declare function isPropertyLogEmpty(
+  result: PropertiesComparisonResult,
+): boolean;
+export declare function isMemberLogEmpty(
+  result: MembersComparisonResult,
+): boolean;
+export declare function isFunctionLogEmpty(
+  result: FunctionComparisonResult,
+): boolean;
+export declare function makeError(error: TypeComparisonError): ComparisonResult;
+export declare function typeInformationComparisonError(
+  message: string,
+  newerAnnotation: CompleteTypeAnnotation,
+  olderAnnotation: CompleteTypeAnnotation,
+  previousError?: TypeComparisonError,
+): TypeComparisonError;
+export declare function typeAnnotationComparisonError(
+  message: string,
+  newerAnnotation: CompleteTypeAnnotation,
+  olderAnnotation: CompleteTypeAnnotation,
+  previousError?: TypeComparisonError,
+): TypeComparisonError;
+export declare function propertyComparisonError(
+  message: string,
+  mismatchedProperties: Array<{
+    property: string;
+    fault?: TypeComparisonError | undefined;
+  }>,
+  previousError?: TypeComparisonError,
+): TypeComparisonError;
+export declare function memberComparisonError(
+  message: string,
+  mismatchedMembers: Array<{
+    member: string;
+    fault?: TypeComparisonError | undefined;
+  }>,
+  previousError?: TypeComparisonError,
+): TypeComparisonError;
+export declare function positionalComparisonError(
+  message: string,
+  erroneousItems: Array<[number, CompleteTypeAnnotation]>,
+  previousError?: TypeComparisonError,
+): TypeComparisonError;

packages/react-native-compatibility-check/dist/ComparisonResult.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.isFunctionLogEmpty = isFunctionLogEmpty;
+exports.isMemberLogEmpty = isMemberLogEmpty;
+exports.isPropertyLogEmpty = isPropertyLogEmpty;
+exports.makeError = makeError;
+exports.memberComparisonError = memberComparisonError;
+exports.positionalComparisonError = positionalComparisonError;
+exports.propertyComparisonError = propertyComparisonError;
+exports.typeAnnotationComparisonError = typeAnnotationComparisonError;
+exports.typeInformationComparisonError = typeInformationComparisonError;
+function isPropertyLogEmpty(result) {
+  return !(
+    result.addedProperties ||
+    result.missingProperties ||
+    result.nestedPropertyChanges ||
+    result.madeStrict ||
+    result.madeOptional ||
+    result.errorProperties
+  );
+}
+function isMemberLogEmpty(result) {
+  return !(result.addedMembers || result.missingMembers || result.errorMembers);
+}
+function isFunctionLogEmpty(result) {
+  return !(result.returnType || result.parameterTypes);
+}
+function makeError(error) {
+  return {
+    status: "error",
+    errorLog: error,
+  };
+}
+function typeInformationComparisonError(
+  message,
+  newerAnnotation,
+  olderAnnotation,
+  previousError,
+) {
+  return {
+    type: "TypeInformationComparisonError",
+    message,
+    newerAnnotation,
+    olderAnnotation,
+    previousError,
+  };
+}
+function typeAnnotationComparisonError(
+  message,
+  newerAnnotation,
+  olderAnnotation,
+  previousError,
+) {
+  return {
+    type: "TypeAnnotationComparisonError",
+    message,
+    newerAnnotation,
+    olderAnnotation,
+    previousError,
+  };
+}
+function propertyComparisonError(message, mismatchedProperties, previousError) {
+  return {
+    type: "PropertyComparisonError",
+    message,
+    mismatchedProperties,
+    previousError,
+  };
+}
+function memberComparisonError(message, mismatchedMembers, previousError) {
+  return {
+    type: "MemberComparisonError",
+    message,
+    mismatchedMembers,
+    previousError,
+  };
+}
+function positionalComparisonError(message, erroneousItems, previousError) {
+  return {
+    type: "PositionalComparisonError",
+    message,
+    erroneousItems,
+    previousError,
+  };
+}