react-native-windows 0.80.1 → 0.81.0-preview.1

package/src/private/webapis/structuredClone/structuredClone.js

@@ -0,0 +1,233 @@
+/**
+ * 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 DOMException from '../errors/DOMException';
+import {
+  getPlatformObjectClone,
+  isPlatformObject,
+} from '../webidl/PlatformObjects';
+
+const VALID_ERROR_NAMES = new Set([
+  'Error',
+  'EvalError',
+  'RangeError',
+  'ReferenceError',
+  'SyntaxError',
+  'TypeError',
+  'URIError',
+]);
+
+const BASIC_CONSTRUCTORS = [Number, String, Boolean, Date];
+
+const ObjectPrototype = Object.prototype;
+
+// Technicall the memory value should be a parameter in
+// `structuredCloneInternal` but as an optimization we can reuse the same map
+// and avoid allocating a new one in every call to `structuredClone`.
+// This is safe because we don't invoke user code in `structuredClone`, so at
+// any given point we only have one memory object alive anyway.
+const memory: Map<mixed, mixed> = new Map();
+
+function structuredCloneInternal<T>(value: T): T {
+  // Handles `null` and `undefined`.
+  if (value == null) {
+    return value;
+  }
+
+  // Handles remaining primitive values.
+  switch (typeof value) {
+    case 'boolean':
+    case 'number':
+    case 'string':
+    case 'bigint':
+      return value;
+  }
+
+  // Handles unsupported types (symbols and functions).
+  if (typeof value !== 'object') {
+    // value is symbol or function
+    throw new DOMException(
+      `Failed to execute 'structuredClone' on 'Window': ${String(value)} could not be cloned.`,
+      'DataCloneError',
+    );
+  }
+
+  // Handles circular references.
+  if (memory.has(value)) {
+    // $FlowExpectedError[incompatible-return] we know memory.get(value) is T
+    return memory.get(value);
+  }
+
+  // Handles arrays.
+  if (Array.isArray(value)) {
+    const result = [];
+    memory.set(value, result);
+
+    for (const key of Object.keys(value)) {
+      result[key] = structuredCloneInternal(value[key]);
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // Simple object fast path
+  // $FlowIssue[prop-missing] Why doesn't Flow know about Object.prototype?
+  if (Object.getPrototypeOf(value) === ObjectPrototype) {
+    const result = {};
+    memory.set(value, result);
+
+    for (const key of Object.keys(value)) {
+      // $FlowExpectedError[prop-missing]
+      result[key] = structuredCloneInternal(value[key]);
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // Handles complex types (typeof === 'object').
+
+  for (const Cls of BASIC_CONSTRUCTORS) {
+    if (value instanceof Cls) {
+      const result = new Cls(value);
+      memory.set(value, result);
+      // $FlowExpectedError[incompatible-return] we know result is T
+      return result;
+    }
+  }
+
+  if (value instanceof Map) {
+    const result = new Map<mixed, mixed>();
+    memory.set(value, result);
+
+    for (const [innerKey, innerValue] of value) {
+      result.set(
+        structuredCloneInternal(innerKey),
+        structuredCloneInternal(innerValue),
+      );
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  if (value instanceof Set) {
+    const result = new Set<mixed>();
+    memory.set(value, result);
+
+    for (const innerValue of value) {
+      result.add(structuredCloneInternal(innerValue));
+    }
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  if (value instanceof RegExp) {
+    const result = new RegExp(value.source, value.flags);
+    memory.set(value, result);
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // We need to check platform objects before `Error` because `DOMException`
+  // is a platform object AND an `Error` subclass.
+  const clone = getPlatformObjectClone(value);
+  if (clone != null) {
+    const result = clone(value);
+    memory.set(value, result);
+    return result;
+  }
+
+  if (value instanceof Error) {
+    const result = value.cause
+      ? new Error(value.message, {cause: value.cause})
+      : new Error(value.message);
+    memory.set(value, result);
+
+    if (VALID_ERROR_NAMES.has(value.name)) {
+      result.name = value.name;
+    } else {
+      result.name = 'Error';
+    }
+
+    result.stack = value.stack;
+
+    // $FlowExpectedError[incompatible-return] we know result is T
+    return result;
+  }
+
+  // Known non-serializable objects.
+  if (isNonSerializableObject(value) || isPlatformObject(value)) {
+    throw new DOMException(
+      `Failed to execute 'structuredClone' on 'Window': ${String(value)} could not be cloned.`,
+      'DataCloneError',
+    );
+  }
+
+  // Arbitrary object slow path
+  const result = {};
+  memory.set(value, result);
+
+  // We need to use Object.keys instead of iterating by indices because we
+  // also need to copy arbitrary fields set in the array.
+  for (const key of Object.keys(value)) {
+    // $FlowExpectedError[prop-missing]
+    result[key] = structuredCloneInternal(value[key]);
+  }
+
+  // $FlowExpectedError[incompatible-return] we know result is T
+  return result;
+}
+
+/**
+ * Basic implementation of `structuredClone`.
+ * See:
+ * - https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone.
+ * - https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+ * - https://html.spec.whatwg.org/multipage/structured-data.html#structured-cloning
+ *
+ * Supports cloning all built-in types supported by the spec, circular
+ * references and referential equality of the same objects found in the
+ * structure.
+ *
+ * Shortcuts:
+ * - This implementation does NOT serialize and deserialize the value
+ *   but implements the cloning in a single step.
+ *
+ * Known limitations:
+ * - It does not support transfering values.
+ */
+export default function structuredClone<T>(value: T): T {
+  try {
+    return structuredCloneInternal(value);
+  } finally {
+    memory.clear();
+  }
+}
+
+const NON_SERIALIZABLE_OBJECT_KEY = Symbol('nonSerializableObject');
+
+function isNonSerializableObject<T: interface {}>(obj: T): boolean {
+  // $FlowExpectedError[invalid-in-lhs]
+  return NON_SERIALIZABLE_OBJECT_KEY in obj;
+}
+
+function markClassAsNonSerializable<T>(cls: Class<T>): void {
+  // $FlowExpectedError[incompatible-use]
+  cls.prototype[NON_SERIALIZABLE_OBJECT_KEY] = true;
+}
+
+// Non-serializable built-ins.
+markClassAsNonSerializable(WeakMap);
+markClassAsNonSerializable(WeakSet);
+markClassAsNonSerializable(Promise);

package/src/private/webapis/utils/ArrayLikeUtils.js

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 /**

package/src/private/webapis/webidl/PlatformObjects.js

@@ -0,0 +1,59 @@
+/**
+ * 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
+ */
+
+const IS_PLATFORM_OBJECT_KEY = Symbol('isPlatformObject');
+const CLONE_PLATFORM_OBJECT_KEY = Symbol('clonePlatformObject');
+
+/**
+ * Marks the given object or instances of the given class as platform objects.
+ *
+ * Optionally, it sets the clone function for that platform object, which is a
+ * simplification of the serializable attribute of the Web interface.
+ */
+export const setPlatformObject: (<T: interface {}>(
+  obj: Class<T>,
+  options?: {clone: T => T},
+) => void) &
+  (<T: interface {}>(obj: T, options?: {clone: T => T}) => void) =
+  function setPlatformObject(obj, options) {
+    if (typeof obj === 'function') {
+      // $FlowExpectedError[prop-missing]
+      obj.prototype[IS_PLATFORM_OBJECT_KEY] = true;
+      if (options) {
+        // $FlowExpectedError[prop-missing]
+        obj.prototype[CLONE_PLATFORM_OBJECT_KEY] = options.clone;
+      }
+    } else {
+      // $FlowExpectedError[prop-missing]
+      obj[IS_PLATFORM_OBJECT_KEY] = true;
+      if (options) {
+        // $FlowExpectedError[prop-missing]
+        obj[CLONE_PLATFORM_OBJECT_KEY] = options.clone;
+      }
+    }
+  };
+
+/**
+ * Indicates if the given object is a platform object.
+ */
+export function isPlatformObject<T: interface {}>(obj: T): boolean {
+  // $FlowExpectedError[invalid-in-lhs]
+  return IS_PLATFORM_OBJECT_KEY in obj;
+}
+
+/**
+ * Returns the clone function for the given platform object, if it was set.
+ */
+export function getPlatformObjectClone<T: interface {}>(
+  obj: T,
+): (T => T) | void {
+  // $FlowExpectedError[prop-missing]
+  return obj[CLONE_PLATFORM_OBJECT_KEY];
+}

package/templates/cpp-lib/example/metro.config.js

@@ -33,7 +33,7 @@ const config = {
   // We need to make sure that only one version is loaded for peerDependencies
   // So we block them at the root, and alias them to the versions in example's node_modules
   resolver: {
-    blocklistRE: exclusionList(
+    blockList: exclusionList(
       modules.map(
         (m) =>
           new RegExp(`^${escape(path.join(root, 'node_modules', m))}\\/.*$`)

package/templates/cpp-lib/template.config.js

@@ -93,6 +93,24 @@ async function getFileMappings(config = {}, options = {}) {
       .replace('}', '') ?? crypto.randomUUID();
   const currentUser = username.sync(); // Gets the current username depending on the platform.
 
+  // Check for existing codegen spec files
+  const codegenPath = path.join(projectRoot, 'windows', projectName, 'codegen');
+  let existingSpecFiles = [];
+  let firstSpecName = null;
+  if (existsSync(codegenPath)) {
+    try {
+      const specFiles = await glob('*Spec.g.h', {cwd: codegenPath});
+      existingSpecFiles = specFiles;
+      if (specFiles.length > 0) {
+        // Extract the spec name from filename (e.g., "NativeMyModuleSpec.g.h" -> "MyModuleSpec")
+        const firstFile = specFiles[0];
+        firstSpecName = firstFile.replace(/^Native/, '').replace(/\.g\.h$/, '');
+      }
+    } catch (e) {
+      // If we can't read the codegen directory, continue with empty array
+    }
+  }
+
   const cppNugetPackages = [];
 
   const replacements = {
@@ -104,6 +122,12 @@ async function getFileMappings(config = {}, options = {}) {
     namespace: namespace,
     namespaceCpp: namespaceCpp,
 
+    // Codegen spec files information
+    existingSpecFiles: existingSpecFiles,
+    hasExistingSpecFiles: existingSpecFiles.length > 0,
+    firstSpecFile: existingSpecFiles.length > 0 ? existingSpecFiles[0] : null,
+    firstSpecName: firstSpecName,
+
     rnwVersion: rnwVersion,
     rnwPathFromProjectRoot: path
       .relative(projectRoot, rnwPath)

package/templates/cpp-lib/windows/MyLib/MyLib.h

@@ -6,7 +6,17 @@
 #if __has_include("codegen/Native{{ pascalName }}DataTypes.g.h")
   #include "codegen/Native{{ pascalName }}DataTypes.g.h"
 #endif
-#include "codegen/Native{{ pascalName }}Spec.g.h"
+// Note: The following lines use Mustache template syntax which will be processed during
+// project generation to produce standard C++ code. If existing codegen spec files are found,
+// use the actual filename; otherwise use conditional includes.
+{{#hasExistingSpecFiles}}
+#include "codegen/{{ firstSpecFile }}"
+{{/hasExistingSpecFiles}}
+{{^hasExistingSpecFiles}}
+#if __has_include("codegen/Native{{ pascalName }}Spec.g.h")
+  #include "codegen/Native{{ pascalName }}Spec.g.h"
+#endif
+{{/hasExistingSpecFiles}}
 
 #include "NativeModules.h"
 
@@ -18,7 +28,16 @@ namespace winrt::{{ namespaceCpp }}
 REACT_MODULE({{ pascalName }})
 struct {{ pascalName }}
 {
+  // Note: Mustache template syntax below will be processed during project generation
+  // to produce standard C++ code based on detected codegen files.
+{{#hasExistingSpecFiles}}
+  using ModuleSpec = {{ namespaceCpp }}Codegen::{{ firstSpecName }};
+{{/hasExistingSpecFiles}}
+{{^hasExistingSpecFiles}}
+#if __has_include("codegen/Native{{ pascalName }}Spec.g.h")
   using ModuleSpec = {{ namespaceCpp }}Codegen::{{ pascalName }}Spec;
+#endif
+{{/hasExistingSpecFiles}}
 
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;

package/templates/cpp-lib/windows/MyLib/MyLib.vcxproj

@@ -79,7 +79,6 @@
       <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
       <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
-      <LanguageStandard>stdcpp20</LanguageStandard>
       <AdditionalIncludeDirectories>
         $(MSBuildThisFileDirectory);
         %(AdditionalIncludeDirectories)

package/types/modules/Devtools.d.ts

@@ -9,24 +9,38 @@
 
 declare module 'react-native/Libraries/Core/Devtools/parseErrorStack' {
   export type StackFrame = {
-    file: string;
+    column: number | null | undefined;
+    file: string | null | undefined;
+    lineNumber: number | null | undefined;
     methodName: string;
-    lineNumber: number;
-    column: number | null;
   };
 
-  export interface ExtendedError extends Error {
-    framesToPop?: number | undefined;
-  }
-
-  export default function parseErrorStack(error: ExtendedError): StackFrame[];
+  export default function parseErrorStack(errorStack?: string): StackFrame[];
 }
 
 declare module 'react-native/Libraries/Core/Devtools/symbolicateStackTrace' {
   import {StackFrame} from 'react-native/Libraries/Core/Devtools/parseErrorStack';
 
+  export type CodeFrame = Readonly<{
+    content: string;
+    location:
+      | {
+          row: number;
+          column: number;
+          [key: string]: any;
+        }
+      | null
+      | undefined;
+    fileName: string;
+  }>;
+
+  export type SymbolicatedStackTrace = Readonly<{
+    stack: ReadonlyArray<StackFrame>;
+    codeFrame: CodeFrame | null | undefined;
+  }>;
+
   export default function symbolicateStackTrace(
     stack: ReadonlyArray<StackFrame>,
     extraData?: any,
-  ): Promise<StackFrame[]>;
+  ): Promise<SymbolicatedStackTrace>;
 }

package/Libraries/BugReporting/BugReporting.js

@@ -1,140 +0,0 @@
-/**
- * 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
- * @flow strict-local
- */
-
-import RCTDeviceEventEmitter from '../EventEmitter/RCTDeviceEventEmitter';
-import NativeRedBox from '../NativeModules/specs/NativeRedBox';
-import {type EventSubscription} from '../vendor/emitter/EventEmitter';
-import NativeBugReporting from './NativeBugReporting';
-
-type ExtraData = {[key: string]: string, ...};
-type SourceCallback = () => string;
-type DebugData = {
-  extras: ExtraData,
-  files: ExtraData,
-  ...
-};
-
-function defaultExtras() {
-  BugReporting.addFileSource('react_hierarchy.txt', () =>
-    require('./dumpReactTree').default(),
-  );
-}
-
-/**
- * A simple class for collecting bug report data. Components can add sources that will be queried when a bug report
- * is created via `collectExtraData`. For example, a list component might add a source that provides the list of rows
- * that are currently visible on screen. Components should also remember to call `remove()` on the object that is
- * returned by `addSource` when they are unmounted.
- */
-class BugReporting {
-  static _extraSources: Map<string, SourceCallback> = new Map();
-  static _fileSources: Map<string, SourceCallback> = new Map();
-  static _subscription: ?EventSubscription = null;
-  static _redboxSubscription: ?EventSubscription = null;
-
-  static _maybeInit() {
-    if (!BugReporting._subscription) {
-      BugReporting._subscription = RCTDeviceEventEmitter.addListener(
-        'collectBugExtraData',
-        // $FlowFixMe[method-unbinding]
-        BugReporting.collectExtraData,
-        null,
-      );
-      defaultExtras();
-    }
-
-    if (!BugReporting._redboxSubscription) {
-      BugReporting._redboxSubscription = RCTDeviceEventEmitter.addListener(
-        'collectRedBoxExtraData',
-        // $FlowFixMe[method-unbinding]
-        BugReporting.collectExtraData,
-        null,
-      );
-    }
-  }
-
-  /**
-   * Maps a string key to a simple callback that should return a string payload to be attached
-   * to a bug report. Source callbacks are called when `collectExtraData` is called.
-   *
-   * Returns an object to remove the source when the component unmounts.
-   *
-   * Conflicts trample with a warning.
-   */
-  static addSource(
-    key: string,
-    callback: SourceCallback,
-  ): {remove: () => void, ...} {
-    return this._addSource(key, callback, BugReporting._extraSources);
-  }
-
-  /**
-   * Maps a string key to a simple callback that should return a string payload to be attached
-   * to a bug report. Source callbacks are called when `collectExtraData` is called.
-   *
-   * Returns an object to remove the source when the component unmounts.
-   *
-   * Conflicts trample with a warning.
-   */
-  static addFileSource(
-    key: string,
-    callback: SourceCallback,
-  ): {remove: () => void, ...} {
-    return this._addSource(key, callback, BugReporting._fileSources);
-  }
-
-  static _addSource(
-    key: string,
-    callback: SourceCallback,
-    source: Map<string, SourceCallback>,
-  ): {remove: () => void, ...} {
-    BugReporting._maybeInit();
-    if (source.has(key)) {
-      console.warn(
-        `BugReporting.add* called multiple times for same key '${key}'`,
-      );
-    }
-    source.set(key, callback);
-    return {
-      remove: () => {
-        source.delete(key);
-      },
-    };
-  }
-
-  /**
-   * This can be called from a native bug reporting flow, or from JS code.
-   *
-   * If available, this will call `NativeModules.BugReporting.setExtraData(extraData)`
-   * after collecting `extraData`.
-   */
-  static collectExtraData(): DebugData {
-    const extraData: ExtraData = {};
-    for (const [key, callback] of BugReporting._extraSources) {
-      extraData[key] = callback();
-    }
-    const fileData: ExtraData = {};
-    for (const [key, callback] of BugReporting._fileSources) {
-      fileData[key] = callback();
-    }
-
-    if (NativeBugReporting != null && NativeBugReporting.setExtraData != null) {
-      NativeBugReporting.setExtraData(extraData, fileData);
-    }
-
-    if (NativeRedBox != null && NativeRedBox.setExtraData != null) {
-      NativeRedBox.setExtraData(extraData, 'From BugReporting.js');
-    }
-
-    return {extras: extraData, files: fileData};
-  }
-}
-
-export default BugReporting;

package/Libraries/BugReporting/NativeBugReporting.js

@@ -1,13 +0,0 @@
-/**
- * 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
- */
-
-export * from '../../src/private/specs_DEPRECATED/modules/NativeBugReporting';
-import NativeBugReporting from '../../src/private/specs_DEPRECATED/modules/NativeBugReporting';
-export default NativeBugReporting;