react-native-tvos 0.78.0-0rc4 → 0.79.0-0rc2

package/Libraries/Blob/FileReader.js

@@ -8,179 +8,13 @@
  * @format
  */
 
-import type Blob from './Blob';
+import typeof FileReader from './FileReader_old';
 
-import NativeFileReaderModule from './NativeFileReaderModule';
-import {toByteArray} from 'base64-js';
-import EventTarget from 'event-target-shim';
+// Use a global instead of a flag from ReactNativeFeatureFlags because this will
+// be read before apps have a chance to set overrides.
+const useBuiltInEventTarget = global.RN$useBuiltInEventTarget?.();
 
-type ReadyState =
-  | 0 // EMPTY
-  | 1 // LOADING
-  | 2; // DONE
-
-type ReaderResult = string | ArrayBuffer;
-
-const READER_EVENTS = [
-  'abort',
-  'error',
-  'load',
-  'loadstart',
-  'loadend',
-  'progress',
-];
-
-const EMPTY = 0;
-const LOADING = 1;
-const DONE = 2;
-
-class FileReader extends (EventTarget(...READER_EVENTS): typeof EventTarget) {
-  static EMPTY: number = EMPTY;
-  static LOADING: number = LOADING;
-  static DONE: number = DONE;
-
-  EMPTY: number = EMPTY;
-  LOADING: number = LOADING;
-  DONE: number = DONE;
-
-  _readyState: ReadyState;
-  _error: ?Error;
-  _result: ?ReaderResult;
-  _aborted: boolean = false;
-
-  constructor() {
-    super();
-    this._reset();
-  }
-
-  _reset(): void {
-    this._readyState = EMPTY;
-    this._error = null;
-    this._result = null;
-  }
-
-  _setReadyState(newState: ReadyState) {
-    this._readyState = newState;
-    this.dispatchEvent({type: 'readystatechange'});
-    if (newState === DONE) {
-      if (this._aborted) {
-        this.dispatchEvent({type: 'abort'});
-      } else if (this._error) {
-        this.dispatchEvent({type: 'error'});
-      } else {
-        this.dispatchEvent({type: 'load'});
-      }
-      this.dispatchEvent({type: 'loadend'});
-    }
-  }
-
-  readAsArrayBuffer(blob: ?Blob): void {
-    this._aborted = false;
-
-    if (blob == null) {
-      throw new TypeError(
-        "Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'",
-      );
-    }
-
-    NativeFileReaderModule.readAsDataURL(blob.data).then(
-      (text: string) => {
-        if (this._aborted) {
-          return;
-        }
-
-        const base64 = text.split(',')[1];
-        const typedArray = toByteArray(base64);
-
-        this._result = typedArray.buffer;
-        this._setReadyState(DONE);
-      },
-      error => {
-        if (this._aborted) {
-          return;
-        }
-        this._error = error;
-        this._setReadyState(DONE);
-      },
-    );
-  }
-
-  readAsDataURL(blob: ?Blob): void {
-    this._aborted = false;
-
-    if (blob == null) {
-      throw new TypeError(
-        "Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'",
-      );
-    }
-
-    NativeFileReaderModule.readAsDataURL(blob.data).then(
-      (text: string) => {
-        if (this._aborted) {
-          return;
-        }
-        this._result = text;
-        this._setReadyState(DONE);
-      },
-      error => {
-        if (this._aborted) {
-          return;
-        }
-        this._error = error;
-        this._setReadyState(DONE);
-      },
-    );
-  }
-
-  readAsText(blob: ?Blob, encoding: string = 'UTF-8'): void {
-    this._aborted = false;
-
-    if (blob == null) {
-      throw new TypeError(
-        "Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'",
-      );
-    }
-
-    NativeFileReaderModule.readAsText(blob.data, encoding).then(
-      (text: string) => {
-        if (this._aborted) {
-          return;
-        }
-        this._result = text;
-        this._setReadyState(DONE);
-      },
-      error => {
-        if (this._aborted) {
-          return;
-        }
-        this._error = error;
-        this._setReadyState(DONE);
-      },
-    );
-  }
-
-  abort() {
-    this._aborted = true;
-    // only call onreadystatechange if there is something to abort, as per spec
-    if (this._readyState !== EMPTY && this._readyState !== DONE) {
-      this._reset();
-      this._setReadyState(DONE);
-    }
-    // Reset again after, in case modified in handler
-    this._reset();
-  }
-
-  get readyState(): ReadyState {
-    return this._readyState;
-  }
-
-  get error(): ?Error {
-    return this._error;
-  }
-
-  get result(): ?ReaderResult {
-    return this._result;
-  }
-}
-
-module.exports = FileReader;
+export default (useBuiltInEventTarget
+  ? // $FlowExpectedError[incompatible-cast]
+    require('./FileReader_new').default
+  : require('./FileReader_old').default) as FileReader;

package/Libraries/Blob/FileReader_new.js

@@ -0,0 +1,231 @@
+/**
+ * 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
+ * @format
+ */
+
+import type {EventCallback} from '../../src/private/webapis/dom/events/EventTarget';
+import type Blob from './Blob';
+
+import Event from '../../src/private/webapis/dom/events/Event';
+import {
+  getEventHandlerAttribute,
+  setEventHandlerAttribute,
+} from '../../src/private/webapis/dom/events/EventHandlerAttributes';
+import EventTarget from '../../src/private/webapis/dom/events/EventTarget';
+import NativeFileReaderModule from './NativeFileReaderModule';
+import {toByteArray} from 'base64-js';
+
+type ReadyState =
+  | 0 // EMPTY
+  | 1 // LOADING
+  | 2; // DONE
+
+type ReaderResult = string | ArrayBuffer;
+
+const EMPTY = 0;
+const LOADING = 1;
+const DONE = 2;
+
+class FileReader extends EventTarget {
+  static EMPTY: number = EMPTY;
+  static LOADING: number = LOADING;
+  static DONE: number = DONE;
+
+  EMPTY: number = EMPTY;
+  LOADING: number = LOADING;
+  DONE: number = DONE;
+
+  _readyState: ReadyState;
+  _error: ?Error;
+  _result: ?ReaderResult;
+  _aborted: boolean = false;
+
+  constructor() {
+    super();
+    this._reset();
+  }
+
+  _reset(): void {
+    this._readyState = EMPTY;
+    this._error = null;
+    this._result = null;
+  }
+
+  _setReadyState(newState: ReadyState) {
+    this._readyState = newState;
+    this.dispatchEvent(new Event('readystatechange'));
+    if (newState === DONE) {
+      if (this._aborted) {
+        this.dispatchEvent(new Event('abort'));
+      } else if (this._error) {
+        this.dispatchEvent(new Event('error'));
+      } else {
+        this.dispatchEvent(new Event('load'));
+      }
+      this.dispatchEvent(new Event('loadend'));
+    }
+  }
+
+  readAsArrayBuffer(blob: ?Blob): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsDataURL(blob.data).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+
+        const base64 = text.split(',')[1];
+        const typedArray = toByteArray(base64);
+
+        this._result = typedArray.buffer;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  readAsDataURL(blob: ?Blob): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsDataURL(blob.data).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+        this._result = text;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  readAsText(blob: ?Blob, encoding: string = 'UTF-8'): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsText(blob.data, encoding).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+        this._result = text;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  abort() {
+    this._aborted = true;
+    // only call onreadystatechange if there is something to abort, as per spec
+    if (this._readyState !== EMPTY && this._readyState !== DONE) {
+      this._reset();
+      this._setReadyState(DONE);
+    }
+    // Reset again after, in case modified in handler
+    this._reset();
+  }
+
+  get readyState(): ReadyState {
+    return this._readyState;
+  }
+
+  get error(): ?Error {
+    return this._error;
+  }
+
+  get result(): ?ReaderResult {
+    return this._result;
+  }
+
+  get onabort(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'abort');
+  }
+
+  set onabort(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'abort', listener);
+  }
+
+  get onerror(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'error');
+  }
+
+  set onerror(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'error', listener);
+  }
+
+  get onload(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'load');
+  }
+
+  set onload(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'load', listener);
+  }
+
+  get onloadstart(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadstart');
+  }
+
+  set onloadstart(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadstart', listener);
+  }
+
+  get onloadend(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadend');
+  }
+
+  set onloadend(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadend', listener);
+  }
+
+  get onprogress(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'progress');
+  }
+
+  set onprogress(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'progress', listener);
+  }
+}
+
+export default FileReader;

package/Libraries/Blob/FileReader_old.js

@@ -0,0 +1,186 @@
+/**
+ * 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
+ * @format
+ */
+
+import type Blob from './Blob';
+
+import NativeFileReaderModule from './NativeFileReaderModule';
+import {toByteArray} from 'base64-js';
+import EventTarget from 'event-target-shim';
+
+type ReadyState =
+  | 0 // EMPTY
+  | 1 // LOADING
+  | 2; // DONE
+
+type ReaderResult = string | ArrayBuffer;
+
+const READER_EVENTS = [
+  'abort',
+  'error',
+  'load',
+  'loadstart',
+  'loadend',
+  'progress',
+];
+
+const EMPTY = 0 as const;
+const LOADING = 1 as const;
+const DONE = 2 as const;
+
+class FileReader extends (EventTarget(...READER_EVENTS): typeof EventTarget) {
+  static EMPTY: 0 = EMPTY;
+  static LOADING: 1 = LOADING;
+  static DONE: 2 = DONE;
+
+  EMPTY: 0 = EMPTY;
+  LOADING: 1 = LOADING;
+  DONE: 2 = DONE;
+
+  _readyState: ReadyState;
+  _error: ?Error;
+  _result: ?ReaderResult;
+  _aborted: boolean = false;
+
+  constructor() {
+    super();
+    this._reset();
+  }
+
+  _reset(): void {
+    this._readyState = EMPTY;
+    this._error = null;
+    this._result = null;
+  }
+
+  _setReadyState(newState: ReadyState) {
+    this._readyState = newState;
+    this.dispatchEvent({type: 'readystatechange'});
+    if (newState === DONE) {
+      if (this._aborted) {
+        this.dispatchEvent({type: 'abort'});
+      } else if (this._error) {
+        this.dispatchEvent({type: 'error'});
+      } else {
+        this.dispatchEvent({type: 'load'});
+      }
+      this.dispatchEvent({type: 'loadend'});
+    }
+  }
+
+  readAsArrayBuffer(blob: ?Blob): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsDataURL(blob.data).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+
+        const base64 = text.split(',')[1];
+        const typedArray = toByteArray(base64);
+
+        this._result = typedArray.buffer;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  readAsDataURL(blob: ?Blob): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsDataURL(blob.data).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+        this._result = text;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  readAsText(blob: ?Blob, encoding: string = 'UTF-8'): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsText(blob.data, encoding).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+        this._result = text;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  abort() {
+    this._aborted = true;
+    // only call onreadystatechange if there is something to abort, as per spec
+    if (this._readyState !== EMPTY && this._readyState !== DONE) {
+      this._reset();
+      this._setReadyState(DONE);
+    }
+    // Reset again after, in case modified in handler
+    this._reset();
+  }
+
+  get readyState(): ReadyState {
+    return this._readyState;
+  }
+
+  get error(): ?Error {
+    return this._error;
+  }
+
+  get result(): ?ReaderResult {
+    return this._result;
+  }
+}
+
+export default FileReader;

package/Libraries/Blob/NativeBlobModule.js

@@ -8,6 +8,6 @@
  * @format
  */
 
-export * from '../../src/private/specs/modules/NativeBlobModule';
-import NativeBlobModule from '../../src/private/specs/modules/NativeBlobModule';
+export * from '../../src/private/specs_DEPRECATED/modules/NativeBlobModule';
+import NativeBlobModule from '../../src/private/specs_DEPRECATED/modules/NativeBlobModule';
 export default NativeBlobModule;

package/Libraries/Blob/NativeFileReaderModule.js

@@ -8,6 +8,6 @@
  * @format
  */
 
-export * from '../../src/private/specs/modules/NativeFileReaderModule';
-import NativeFileReaderModule from '../../src/private/specs/modules/NativeFileReaderModule';
+export * from '../../src/private/specs_DEPRECATED/modules/NativeFileReaderModule';
+import NativeFileReaderModule from '../../src/private/specs_DEPRECATED/modules/NativeFileReaderModule';
 export default NativeFileReaderModule;

package/Libraries/Blob/React-RCTBlob.podspec

@@ -50,7 +50,7 @@ Pod::Spec.new do |s|
 
   s.dependency "DoubleConversion"
   s.dependency "fast_float", "6.1.4"
-  s.dependency "fmt", "9.1.0"
+  s.dependency "fmt", "11.0.2"
   s.dependency "RCT-Folly", folly_version
   s.dependency "React-jsi"
   s.dependency "React-Core/RCTBlobHeaders"

package/Libraries/Blob/URL.js

@@ -77,7 +77,7 @@ export class URL {
   }
 
   // $FlowFixMe[missing-local-annot]
-  constructor(url: string, base: string | URL) {
+  constructor(url: string, base?: string | URL) {
     let baseUrl = null;
     if (!base || validateBaseUrl(url)) {
       this._url = url;

package/Libraries/Blob/URLSearchParams.js

@@ -11,9 +11,9 @@
 // Small subset from whatwg-url: https://github.com/jsdom/whatwg-url/tree/master/src
 // The reference code bloat comes from Unicode issues with URLs, so those won't work here.
 export class URLSearchParams {
-  _searchParams: Array<Array<string>> = [];
+  _searchParams: Array<[string, string]> = [];
 
-  constructor(params: any) {
+  constructor(params?: Record<string, string>) {
     if (typeof params === 'object') {
       Object.keys(params).forEach(key => this.append(key, params[key]));
     }
@@ -23,33 +23,32 @@ export class URLSearchParams {
     this._searchParams.push([key, value]);
   }
 
-  delete(name: string): void {
+  delete(name: string): empty {
     throw new Error('URLSearchParams.delete is not implemented');
   }
 
-  get(name: string): void {
+  get(name: string): empty {
     throw new Error('URLSearchParams.get is not implemented');
   }
 
-  getAll(name: string): void {
+  getAll(name: string): empty {
     throw new Error('URLSearchParams.getAll is not implemented');
   }
 
-  has(name: string): void {
+  has(name: string): empty {
     throw new Error('URLSearchParams.has is not implemented');
   }
 
-  set(name: string, value: string): void {
+  set(name: string, value: string): empty {
     throw new Error('URLSearchParams.set is not implemented');
   }
 
-  sort(): void {
+  sort(): empty {
     throw new Error('URLSearchParams.sort is not implemented');
   }
 
   // $FlowFixMe[unsupported-syntax]
-  // $FlowFixMe[missing-local-annot]
-  [Symbol.iterator]() {
+  [Symbol.iterator](): Iterator<[string, string]> {
     return this._searchParams[Symbol.iterator]();
   }