@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/vendor/react-native/VirtualizedSectionList/index.js.flow

@@ -0,0 +1,191 @@
+/**
+ * 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 { ViewToken } from '../ViewabilityHelper';
+import View from '../../../exports/View';
+import VirtualizedList from '../VirtualizedList';
+import { keyExtractor as defaultKeyExtractor } from '../VirtualizeUtils';
+import invariant from 'fbjs/lib/invariant';
+import * as React from 'react';
+type Item = any;
+export type SectionBase<SectionItemT> = {
+  /**
+   * The data for rendering items in this section.
+   */
+  data: $ReadOnlyArray<SectionItemT>,
+  /**
+   * Optional key to keep track of section re-ordering. If you don't plan on re-ordering sections,
+   * the array index will be used by default.
+   */
+  key?: string,
+  // Optional props will override list-wide props just for this section.
+  renderItem?: ?(info: {
+    item: SectionItemT,
+    index: number,
+    section: SectionBase<SectionItemT>,
+    separators: {
+      highlight: () => void,
+      unhighlight: () => void,
+      updateProps: (select: 'leading' | 'trailing', newProps: Object) => void,
+      ...
+    },
+    ...
+  }) => null | React.Element<any>,
+  ItemSeparatorComponent?: ?React.ComponentType<any>,
+  keyExtractor?: (item: SectionItemT, index?: ?number) => string,
+  ...
+};
+type RequiredProps<SectionT: SectionBase<any>> = {|
+  sections: $ReadOnlyArray<SectionT>
+|};
+type OptionalProps<SectionT: SectionBase<any>> = {|
+  /**
+   * Default renderer for every item in every section.
+   */
+  renderItem?: (info: {
+    item: Item,
+    index: number,
+    section: SectionT,
+    separators: {
+      highlight: () => void,
+      unhighlight: () => void,
+      updateProps: (select: 'leading' | 'trailing', newProps: Object) => void,
+      ...
+    },
+    ...
+  }) => null | React.Element<any>,
+  /**
+   * Rendered at the top of each section. These stick to the top of the `ScrollView` by default on
+   * iOS. See `stickySectionHeadersEnabled`.
+   */
+  renderSectionHeader?: ?(info: {
+    section: SectionT,
+    ...
+  }) => null | React.Element<any>,
+  /**
+   * Rendered at the bottom of each section.
+   */
+  renderSectionFooter?: ?(info: {
+    section: SectionT,
+    ...
+  }) => null | React.Element<any>,
+  /**
+   * Rendered at the top and bottom of each section (note this is different from
+   * `ItemSeparatorComponent` which is only rendered between items). These are intended to separate
+   * sections from the headers above and below and typically have the same highlight response as
+   * `ItemSeparatorComponent`. Also receives `highlighted`, `[leading/trailing][Item/Separator]`,
+   * and any custom props from `separators.updateProps`.
+   */
+  SectionSeparatorComponent?: ?React.ComponentType<any>,
+  /**
+   * Makes section headers stick to the top of the screen until the next one pushes it off. Only
+   * enabled by default on iOS because that is the platform standard there.
+   */
+  stickySectionHeadersEnabled?: boolean,
+  onEndReached?: ?({
+    distanceFromEnd: number,
+    ...
+  }) => void,
+|};
+type VirtualizedListProps = React.ElementConfig<typeof VirtualizedList>;
+export type Props<SectionT> = {|
+  ...RequiredProps<SectionT>,
+  ...OptionalProps<SectionT>,
+  ...$Diff<VirtualizedListProps, {
+    renderItem: $PropertyType<VirtualizedListProps, 'renderItem'>,
+    data: $PropertyType<VirtualizedListProps, 'data'>,
+    ...
+  }>,
+|};
+export type ScrollToLocationParamsType = {|
+  animated?: ?boolean,
+  itemIndex: number,
+  sectionIndex: number,
+  viewOffset?: number,
+  viewPosition?: number,
+|};
+type State = {
+  childProps: VirtualizedListProps,
+  ...
+};
+
+/**
+ * Right now this just flattens everything into one list and uses VirtualizedList under the
+ * hood. The only operation that might not scale well is concatting the data arrays of all the
+ * sections when new props are received, which should be plenty fast for up to ~10,000 items.
+ */
+declare class VirtualizedSectionList<SectionT: SectionBase<any>> extends React.PureComponent<Props<SectionT>, State> {
+  scrollToLocation(params: ScrollToLocationParamsType): any,
+  getListRef(): ?React.ElementRef<typeof VirtualizedList>,
+  render(): React.Node,
+  _getItem(props: Props<SectionT>, sections: ?$ReadOnlyArray<Item>, index: number): ?Item,
+  _keyExtractor: any,
+  _subExtractor(index: number): ?{
+    section: SectionT,
+    // Key of the section or combined key for section + item
+    key: string,
+    // Relative index within the section
+    index: ?number,
+    // True if this is the section header
+    header?: ?boolean,
+    leadingItem?: ?Item,
+    leadingSection?: ?SectionT,
+    trailingItem?: ?Item,
+    trailingSection?: ?SectionT,
+    ...
+  },
+  _convertViewable: any,
+  _onViewableItemsChanged: any,
+  _renderItem: any,
+  _updatePropsFor: any,
+  _updateHighlightFor: any,
+  _setUpdateHighlightFor: any,
+  _setUpdatePropsFor: any,
+  _getSeparatorComponent(index: number, info?: ?Object, listItemCount: number): ?React.ComponentType<any>,
+  _updateHighlightMap: {
+    [string]: (boolean) => void
+  },
+  _updatePropsMap: {
+    [string]: void | ((boolean) => void)
+  },
+  _listRef: ?React.ElementRef<typeof VirtualizedList>,
+  _captureRef: any,
+}
+type ItemWithSeparatorCommonProps = $ReadOnly<{|
+  leadingItem: ?Item,
+  leadingSection: ?Object,
+  section: Object,
+  trailingItem: ?Item,
+  trailingSection: ?Object,
+|}>;
+type ItemWithSeparatorProps = $ReadOnly<{|
+  ...ItemWithSeparatorCommonProps,
+  LeadingSeparatorComponent: ?React.ComponentType<any>,
+  SeparatorComponent: ?React.ComponentType<any>,
+  cellKey: string,
+  index: number,
+  item: Item,
+  setSelfHighlightCallback: (cellKey: string, updateFn: ?(boolean) => void) => void,
+  setSelfUpdatePropsCallback: (cellKey: string, updateFn: ?(boolean) => void) => void,
+  prevCellKey?: ?string,
+  updateHighlightFor: (prevCellKey: string, value: boolean) => void,
+  updatePropsFor: (prevCellKey: string, value: Object) => void,
+  renderItem: Function,
+  inverted: boolean,
+|}>;
+declare function ItemWithSeparator(props: ItemWithSeparatorProps): React.Node;
+/* $FlowFixMe[class-object-subtyping] added when improving typing for this
+ * parameters */
+// $FlowFixMe[method-unbinding]
+export default (VirtualizedSectionList: React.AbstractComponent<React.ElementConfig<typeof VirtualizedSectionList>, $ReadOnly<{
+  getListRef: () => ?React.ElementRef<typeof VirtualizedList>,
+  scrollToLocation: (params: ScrollToLocationParamsType) => void,
+  ...
+}>>);

package/dist/vendor/react-native/deepDiffer/index.js

@@ -0,0 +1,70 @@
+/**
+ * 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
+ * 
+ */
+
+'use strict';
+
+/*
+ * @returns {bool} true if different, false if equal
+ */
+var _deepDiffer = function deepDiffer(one, two, maxDepth) {
+  if (maxDepth === void 0) {
+    maxDepth = -1;
+  }
+  if (maxDepth === 0) {
+    return true;
+  }
+  if (one === two) {
+    // Short circuit on identical object references instead of traversing them.
+    return false;
+  }
+  if (typeof one === 'function' && typeof two === 'function') {
+    // We consider all functions equal
+    return false;
+  }
+  if (typeof one !== 'object' || one === null) {
+    // Primitives can be directly compared
+    return one !== two;
+  }
+  if (typeof two !== 'object' || two === null) {
+    // We know they are different because the previous case would have triggered
+    // otherwise.
+    return true;
+  }
+  if (one.constructor !== two.constructor) {
+    return true;
+  }
+  if (Array.isArray(one)) {
+    // We know two is also an array because the constructors are equal
+    var len = one.length;
+    if (two.length !== len) {
+      return true;
+    }
+    for (var ii = 0; ii < len; ii++) {
+      if (_deepDiffer(one[ii], two[ii], maxDepth - 1)) {
+        return true;
+      }
+    }
+  } else {
+    for (var key in one) {
+      if (_deepDiffer(one[key], two[key], maxDepth - 1)) {
+        return true;
+      }
+    }
+    for (var twoKey in two) {
+      // The only case we haven't checked yet is keys that are in two but aren't
+      // in one, which means they are different.
+      if (one[twoKey] === undefined && two[twoKey] !== undefined) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+export default _deepDiffer;

package/dist/vendor/react-native/deepDiffer/index.js.flow

@@ -0,0 +1,67 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/*
+ * @returns {bool} true if different, false if equal
+ */
+const deepDiffer = function (one: any, two: any, maxDepth: number = -1): boolean {
+  if (maxDepth === 0) {
+    return true;
+  }
+  if (one === two) {
+    // Short circuit on identical object references instead of traversing them.
+    return false;
+  }
+  if (typeof one === 'function' && typeof two === 'function') {
+    // We consider all functions equal
+    return false;
+  }
+  if (typeof one !== 'object' || one === null) {
+    // Primitives can be directly compared
+    return one !== two;
+  }
+  if (typeof two !== 'object' || two === null) {
+    // We know they are different because the previous case would have triggered
+    // otherwise.
+    return true;
+  }
+  if (one.constructor !== two.constructor) {
+    return true;
+  }
+  if (Array.isArray(one)) {
+    // We know two is also an array because the constructors are equal
+    const len = one.length;
+    if (two.length !== len) {
+      return true;
+    }
+    for (let ii = 0; ii < len; ii++) {
+      if (deepDiffer(one[ii], two[ii], maxDepth - 1)) {
+        return true;
+      }
+    }
+  } else {
+    for (const key in one) {
+      if (deepDiffer(one[key], two[key], maxDepth - 1)) {
+        return true;
+      }
+    }
+    for (const twoKey in two) {
+      // The only case we haven't checked yet is keys that are in two but aren't
+      // in one, which means they are different.
+      if (one[twoKey] === undefined && two[twoKey] !== undefined) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+export default deepDiffer;

package/dist/vendor/react-native/infoLog/index.js

@@ -0,0 +1,19 @@
+/**
+ * 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
+ * 
+ */
+
+'use strict';
+
+/**
+ * Intentional info-level logging for clear separation from ad-hoc console debug logging.
+ */
+function infoLog() {
+  return console.log(...arguments);
+}
+export default infoLog;

package/dist/vendor/react-native/infoLog/index.js.flow

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Intentional info-level logging for clear separation from ad-hoc console debug logging.
+ */
+declare function infoLog(...args: Array<mixed>): void;
+export default infoLog;

package/dist/vendor/react-native/vendor/emitter/EventEmitter.js

@@ -0,0 +1,98 @@
+/**
+ * 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
+ */
+
+/**
+ * EventEmitter manages listeners and publishes events to them.
+ *
+ * EventEmitter accepts a single type parameter that defines the valid events
+ * and associated listener argument(s).
+ *
+ * @example
+ *
+ *   const emitter = new EventEmitter<{
+ *     success: [number, string],
+ *     error: [Error],
+ *   }>();
+ *
+ *   emitter.on('success', (statusCode, responseText) => {...});
+ *   emitter.emit('success', 200, '...');
+ *
+ *   emitter.on('error', error => {...});
+ *   emitter.emit('error', new Error('Resource not found'));
+ *
+ */
+export default class EventEmitter {
+  constructor() {
+    this._registry = {};
+  }
+  /**
+   * Registers a listener that is called when the supplied event is emitted.
+   * Returns a subscription that has a `remove` method to undo registration.
+   */
+  addListener(eventType, listener, context) {
+    var registrations = allocate(this._registry, eventType);
+    var registration = {
+      context,
+      listener,
+      remove() {
+        registrations.delete(registration);
+      }
+    };
+    registrations.add(registration);
+    return registration;
+  }
+
+  /**
+   * Emits the supplied event. Additional arguments supplied to `emit` will be
+   * passed through to each of the registered listeners.
+   *
+   * If a listener modifies the listeners registered for the same event, those
+   * changes will not be reflected in the current invocation of `emit`.
+   */
+  emit(eventType) {
+    var registrations = this._registry[eventType];
+    if (registrations != null) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      for (var _i = 0, _arr = [...registrations]; _i < _arr.length; _i++) {
+        var registration = _arr[_i];
+        registration.listener.apply(registration.context, args);
+      }
+    }
+  }
+
+  /**
+   * Removes all registered listeners.
+   */
+  removeAllListeners(eventType) {
+    if (eventType == null) {
+      this._registry = {};
+    } else {
+      delete this._registry[eventType];
+    }
+  }
+
+  /**
+   * Returns the number of registered listeners for the supplied event.
+   */
+  listenerCount(eventType) {
+    var registrations = this._registry[eventType];
+    return registrations == null ? 0 : registrations.size;
+  }
+}
+function allocate(registry, eventType) {
+  var registrations = registry[eventType];
+  if (registrations == null) {
+    registrations = new Set();
+    registry[eventType] = registrations;
+  }
+  return registrations;
+}

package/dist/vendor/react-native/vendor/emitter/EventEmitter.js.flow

@@ -0,0 +1,54 @@
+/**
+ * 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
+ */
+
+export interface EventSubscription {
+  remove(): void
+}
+export interface IEventEmitter<TEventToArgsMap: {...}> {
+  addListener<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed, context?: mixed): EventSubscription,
+  emit<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, ...args: $ElementType<TEventToArgsMap, TEvent>): void,
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void,
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number,
+}
+interface Registration<TArgs> {
+  +context: mixed,
+  +listener: (...args: TArgs) => mixed,
+  +remove: () => void,
+}
+type Registry<TEventToArgsMap: {...}> = $ObjMap<TEventToArgsMap, <TArgs>(TArgs) => Set<Registration<TArgs>>>;
+
+/**
+ * EventEmitter manages listeners and publishes events to them.
+ *
+ * EventEmitter accepts a single type parameter that defines the valid events
+ * and associated listener argument(s).
+ *
+ * @example
+ *
+ *   const emitter = new EventEmitter<{
+ *     success: [number, string],
+ *     error: [Error],
+ *   }>();
+ *
+ *   emitter.on('success', (statusCode, responseText) => {...});
+ *   emitter.emit('success', 200, '...');
+ *
+ *   emitter.on('error', error => {...});
+ *   emitter.emit('error', new Error('Resource not found'));
+ *
+ */
+declare export default class EventEmitter<TEventToArgsMap: {...}> implements IEventEmitter<TEventToArgsMap> {
+  _registry: Registry<TEventToArgsMap>,
+  addListener<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, listener: (...args: $ElementType<TEventToArgsMap, TEvent>) => mixed, context: mixed): EventSubscription,
+  emit<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent, ...args: $ElementType<TEventToArgsMap, TEvent>): void,
+  removeAllListeners<TEvent: $Keys<TEventToArgsMap>>(eventType?: ?TEvent): void,
+  listenerCount<TEvent: $Keys<TEventToArgsMap>>(eventType: TEvent): number,
+}
+declare function allocate<TEventToArgsMap: {...}, TEvent: $Keys<TEventToArgsMap>, TEventArgs: $ElementType<TEventToArgsMap, TEvent>>(registry: Registry<TEventToArgsMap>, eventType: TEvent): Set<Registration<TEventArgs>>;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "name": "@hps1978/react-native-web-tv",
+  "version": "0.21.2-tv.0",
+  "description": "React Native for Web with TV support",
+  "module": "dist/index.js",
+  "main": "dist/cjs/index.js",
+  "sideEffects": false,
+  "files": [
+    "APACHE-2.0.txt",
+    "LICENSE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "dist",
+    "src",
+    "!**/__tests__"
+  ],
+  "scripts": {
+    "clean": "del-cli ./dist",
+    "build": "npm-run-all clean -p \"build:* {@}\" --",
+    "build:commonjs": "cross-env BABEL_ENV=commonjs babel src --config-file ../../configs/babel.config.js --out-dir dist/cjs --ignore \"**/__tests__\"",
+    "build:es": "babel src --config-file ../../configs/babel.config.js --out-dir dist --ignore \"**/__tests__\"",
+    "build:flow": "gen-flow-files ./src --out-dir ./dist",
+    "dev": "npm-run-all clean -p \"build:* {@} -- --watch\""
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.18.6",
+    "@bbc/tv-lrud-spatial": "github:hps1978/lrud-spatial-rnw",
+    "@react-native/normalize-colors": "^0.74.1",
+    "fbjs": "^3.0.4",
+    "inline-style-prefixer": "^7.0.1",
+    "memoize-one": "^6.0.0",
+    "nullthrows": "^1.1.1",
+    "postcss-value-parser": "^4.2.0",
+    "styleq": "^0.1.3"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "author": "Nicolas Gallagher",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/hps1978/react-native-web-tv.git"
+  },
+  "tags": [
+    "react"
+  ],
+  "keywords": [
+    "react",
+    "react-component",
+    "react-native",
+    "web",
+    "tv"
+  ]
+}

package/src/exports/AccessibilityInfo/index.js

@@ -0,0 +1,118 @@
+/**
+ * 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
+ */
+
+'use client';
+
+import canUseDOM from '../../modules/canUseDom';
+
+function isScreenReaderEnabled(): Promise<*> {
+  return new Promise((resolve, reject) => {
+    resolve(true);
+  });
+}
+
+const prefersReducedMotionMedia =
+  canUseDOM && typeof window.matchMedia === 'function'
+    ? window.matchMedia('(prefers-reduced-motion: reduce)')
+    : null;
+
+function isReduceMotionEnabled(): Promise<*> {
+  return new Promise((resolve, reject) => {
+    resolve(
+      prefersReducedMotionMedia ? prefersReducedMotionMedia.matches : true
+    );
+  });
+}
+
+function addChangeListener(fn) {
+  if (prefersReducedMotionMedia != null) {
+    prefersReducedMotionMedia.addEventListener != null
+      ? prefersReducedMotionMedia.addEventListener('change', fn)
+      : prefersReducedMotionMedia.addListener(fn);
+  }
+}
+
+function removeChangeListener(fn) {
+  if (prefersReducedMotionMedia != null) {
+    prefersReducedMotionMedia.removeEventListener != null
+      ? prefersReducedMotionMedia.removeEventListener('change', fn)
+      : prefersReducedMotionMedia.removeListener(fn);
+  }
+}
+
+const handlers = {};
+
+const AccessibilityInfo = {
+  /**
+   * Query whether a screen reader is currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when a screen reader is enabled and `false` otherwise.
+   */
+  isScreenReaderEnabled,
+
+  /**
+   * Query whether the user prefers reduced motion.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when a screen reader is enabled and `false` otherwise.
+   */
+  isReduceMotionEnabled,
+
+  /**
+   * Deprecated
+   */
+  fetch: isScreenReaderEnabled,
+
+  /**
+   * Add an event handler. Supported events: reduceMotionChanged
+   */
+  addEventListener: function (eventName: string, handler: Function): Object {
+    if (eventName === 'reduceMotionChanged') {
+      if (!prefersReducedMotionMedia) {
+        return;
+      }
+      const listener = (event) => {
+        handler(event.matches);
+      };
+      addChangeListener(listener);
+      handlers[handler] = listener;
+    }
+
+    return {
+      remove: () => AccessibilityInfo.removeEventListener(eventName, handler)
+    };
+  },
+
+  /**
+   * Set accessibility focus to a react component.
+   */
+  setAccessibilityFocus: function (reactTag: number): void {},
+
+  /**
+   * Post a string to be announced by the screen reader.
+   */
+  announceForAccessibility: function (announcement: string): void {},
+
+  /**
+   * Remove an event handler.
+   */
+  removeEventListener: function (eventName: string, handler: Function): void {
+    if (eventName === 'reduceMotionChanged') {
+      const listener = handlers[handler];
+      if (!listener || !prefersReducedMotionMedia) {
+        return;
+      }
+      removeChangeListener(listener);
+    }
+    return;
+  }
+};
+
+export default AccessibilityInfo;