@office-iss/react-native-win32 0.0.0-canary.288 → 0.0.0-canary.289

package/src/types/third_party/event-target-shim.d.ts

@@ -0,0 +1,392 @@
+/**
+ * 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
+ */
+
+export as namespace EventTargetShim;
+
+/**
+ * `Event` interface.
+ * @see https://dom.spec.whatwg.org/#event
+ */
+export interface Event {
+  /**
+   * The type of this event.
+   */
+  readonly type: string;
+
+  /**
+   * The target of this event.
+   */
+  readonly target: EventTarget<{}, {}, 'standard'> | null;
+
+  /**
+   * The current target of this event.
+   */
+  readonly currentTarget: EventTarget<{}, {}, 'standard'> | null;
+
+  /**
+   * The target of this event.
+   * @deprecated
+   */
+  readonly srcElement: any | null;
+
+  /**
+   * The composed path of this event.
+   */
+  composedPath(): EventTarget<{}, {}, 'standard'>[];
+
+  /**
+   * Constant of NONE.
+   */
+  readonly NONE: number;
+
+  /**
+   * Constant of CAPTURING_PHASE.
+   */
+  readonly CAPTURING_PHASE: number;
+
+  /**
+   * Constant of BUBBLING_PHASE.
+   */
+  readonly BUBBLING_PHASE: number;
+
+  /**
+   * Constant of AT_TARGET.
+   */
+  readonly AT_TARGET: number;
+
+  /**
+   * Indicates which phase of the event flow is currently being evaluated.
+   */
+  readonly eventPhase: number;
+
+  /**
+   * Stop event bubbling.
+   */
+  stopPropagation(): void;
+
+  /**
+   * Stop event bubbling.
+   */
+  stopImmediatePropagation(): void;
+
+  /**
+   * Initialize event.
+   * @deprecated
+   */
+  initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+
+  /**
+   * The flag indicating bubbling.
+   */
+  readonly bubbles: boolean;
+
+  /**
+   * Stop event bubbling.
+   * @deprecated
+   */
+  cancelBubble: boolean;
+
+  /**
+   * Set or get cancellation flag.
+   * @deprecated
+   */
+  returnValue: boolean;
+
+  /**
+   * The flag indicating whether the event can be canceled.
+   */
+  readonly cancelable: boolean;
+
+  /**
+   * Cancel this event.
+   */
+  preventDefault(): void;
+
+  /**
+   * The flag to indicating whether the event was canceled.
+   */
+  readonly defaultPrevented: boolean;
+
+  /**
+   * The flag to indicating if event is composed.
+   */
+  readonly composed: boolean;
+
+  /**
+   * Indicates whether the event was dispatched by the user agent.
+   */
+  readonly isTrusted: boolean;
+
+  /**
+   * The unix time of this event.
+   */
+  readonly timeStamp: number;
+}
+
+/**
+ * The constructor of `EventTarget` interface.
+ */
+export type EventTargetConstructor<
+  TEvents extends EventTarget.EventDefinition = {},
+  TEventAttributes extends EventTarget.EventDefinition = {},
+  TMode extends EventTarget.Mode = 'loose',
+> = {
+  prototype: EventTarget<TEvents, TEventAttributes, TMode>;
+  new (): EventTarget<TEvents, TEventAttributes, TMode>;
+};
+
+/**
+ * `EventTarget` interface.
+ * @see https://dom.spec.whatwg.org/#interface-eventtarget
+ */
+export type EventTarget<
+  TEvents extends EventTarget.EventDefinition = {},
+  TEventAttributes extends EventTarget.EventDefinition = {},
+  TMode extends EventTarget.Mode = 'loose',
+> = EventTarget.EventAttributes<TEventAttributes> & {
+  /**
+   * Add a given listener to this event target.
+   * @param eventName The event name to add.
+   * @param listener The listener to add.
+   * @param options The options for this listener.
+   */
+  addEventListener<TEventType extends EventTarget.EventType<TEvents, TMode>>(
+    type: TEventType,
+    listener: EventTarget.Listener<
+      EventTarget.PickEvent<TEvents, TEventType>
+    > | null,
+    options?: boolean | EventTarget.AddOptions,
+  ): void;
+
+  /**
+   * Remove a given listener from this event target.
+   * @param eventName The event name to remove.
+   * @param listener The listener to remove.
+   * @param options The options for this listener.
+   */
+  removeEventListener<TEventType extends EventTarget.EventType<TEvents, TMode>>(
+    type: TEventType,
+    listener: EventTarget.Listener<
+      EventTarget.PickEvent<TEvents, TEventType>
+    > | null,
+    options?: boolean | EventTarget.RemoveOptions,
+  ): void;
+
+  /**
+   * Dispatch a given event.
+   * @param event The event to dispatch.
+   * @returns `false` if canceled.
+   */
+  dispatchEvent<TEventType extends EventTarget.EventType<TEvents, TMode>>(
+    event: EventTarget.EventData<TEvents, TEventType, TMode>,
+  ): boolean;
+};
+
+export const EventTarget: EventTargetConstructor & {
+  /**
+   * Create an `EventTarget` instance with detailed event definition.
+   *
+   * The detailed event definition requires to use `defineEventAttribute()`
+   * function later.
+   *
+   * Unfortunately, the second type parameter `TEventAttributes` was needed
+   * because we cannot compute string literal types.
+   *
+   * @example
+   * const signal = new EventTarget<{ abort: Event }, { onabort: Event }>()
+   * defineEventAttribute(signal, "abort")
+   */
+  new <
+    TEvents extends EventTarget.EventDefinition,
+    TEventAttributes extends EventTarget.EventDefinition,
+    TMode extends EventTarget.Mode = 'loose',
+  >(): EventTarget<TEvents, TEventAttributes, TMode>;
+
+  /**
+   * Define an `EventTarget` constructor with attribute events and detailed event definition.
+   *
+   * Unfortunately, the second type parameter `TEventAttributes` was needed
+   * because we cannot compute string literal types.
+   *
+   * @example
+   * class AbortSignal extends EventTarget<{ abort: Event }, { onabort: Event }>("abort") {
+   *      abort(): void {}
+   * }
+   *
+   * @param events Optional event attributes (e.g. passing in `"click"` adds `onclick` to prototype).
+   */
+  <
+    TEvents extends EventTarget.EventDefinition = {},
+    TEventAttributes extends EventTarget.EventDefinition = {},
+    TMode extends EventTarget.Mode = 'loose',
+  >(
+    events: string[],
+  ): EventTargetConstructor<TEvents, TEventAttributes, TMode>;
+
+  /**
+   * Define an `EventTarget` constructor with attribute events and detailed event definition.
+   *
+   * Unfortunately, the second type parameter `TEventAttributes` was needed
+   * because we cannot compute string literal types.
+   *
+   * @example
+   * class AbortSignal extends EventTarget<{ abort: Event }, { onabort: Event }>("abort") {
+   *      abort(): void {}
+   * }
+   *
+   * @param events Optional event attributes (e.g. passing in `"click"` adds `onclick` to prototype).
+   */
+  <
+    TEvents extends EventTarget.EventDefinition = {},
+    TEventAttributes extends EventTarget.EventDefinition = {},
+    TMode extends EventTarget.Mode = 'loose',
+  >(
+    event0: string,
+    ...events: string[]
+  ): EventTargetConstructor<TEvents, TEventAttributes, TMode>;
+};
+
+export namespace EventTarget {
+  /**
+   * Options of `removeEventListener()` method.
+   */
+  export interface RemoveOptions {
+    /**
+     * The flag to indicate that the listener is for the capturing phase.
+     */
+    capture?: boolean | undefined;
+  }
+
+  /**
+   * Options of `addEventListener()` method.
+   */
+  export interface AddOptions extends RemoveOptions {
+    /**
+     * The flag to indicate that the listener doesn't support
+     * `event.preventDefault()` operation.
+     */
+    passive?: boolean | undefined;
+    /**
+     * The flag to indicate that the listener will be removed on the first
+     * event.
+     */
+    once?: boolean | undefined;
+  }
+
+  /**
+   * The type of regular listeners.
+   */
+  export interface FunctionListener<TEvent> {
+    (event: TEvent): void;
+  }
+
+  /**
+   * The type of object listeners.
+   */
+  export interface ObjectListener<TEvent> {
+    handleEvent(event: TEvent): void;
+  }
+
+  /**
+   * The type of listeners.
+   */
+  export type Listener<TEvent> =
+    | FunctionListener<TEvent>
+    | ObjectListener<TEvent>;
+
+  /**
+   * Event definition.
+   */
+  export type EventDefinition = {
+    readonly [key: string]: Event;
+  };
+
+  /**
+   * Mapped type for event attributes.
+   */
+  export type EventAttributes<TEventAttributes extends EventDefinition> = {
+    [P in keyof TEventAttributes]: FunctionListener<TEventAttributes[P]> | null;
+  };
+
+  /**
+   * The type of event data for `dispatchEvent()` method.
+   */
+  export type EventData<
+    TEvents extends EventDefinition,
+    TEventType extends keyof TEvents | string,
+    TMode extends Mode,
+  > = TEventType extends keyof TEvents
+    ? // Require properties which are not generated automatically.
+      Pick<
+        TEvents[TEventType],
+        Exclude<keyof TEvents[TEventType], OmittableEventKeys>
+      > &
+        // Properties which are generated automatically are optional.
+        Partial<Pick<Event, OmittableEventKeys>>
+    : TMode extends 'standard'
+    ? Event
+    : Event | NonStandardEvent;
+
+  /**
+   * The string literal types of the properties which are generated
+   * automatically in `dispatchEvent()` method.
+   */
+  export type OmittableEventKeys = Exclude<keyof Event, 'type'>;
+
+  /**
+   * The type of event data.
+   */
+  export type NonStandardEvent = {
+    [key: string]: any;
+    type: string;
+  };
+
+  /**
+   * The type of listeners.
+   */
+  export type PickEvent<
+    TEvents extends EventDefinition,
+    TEventType extends keyof TEvents | string,
+  > = TEventType extends keyof TEvents ? TEvents[TEventType] : Event;
+
+  /**
+   * Event type candidates.
+   */
+  export type EventType<
+    TEvents extends EventDefinition,
+    TMode extends Mode,
+  > = TMode extends 'strict' ? keyof TEvents : keyof TEvents | string;
+
+  /**
+   * - `"strict"` ..... Methods don't accept unknown events.
+   *                    `dispatchEvent()` accepts partial objects.
+   * - `"loose"` ...... Methods accept unknown events.
+   *                    `dispatchEvent()` accepts partial objects.
+   * - `"standard"` ... Methods accept unknown events.
+   *                    `dispatchEvent()` doesn't accept partial objects.
+   */
+  export type Mode = 'strict' | 'standard' | 'loose';
+}
+
+/**
+ * Specialized `type` property.
+ */
+export type Type<T extends string> = {type: T};
+
+/**
+ * Define an event attribute (e.g. `eventTarget.onclick`).
+ * @param prototype The event target prototype to define an event attribute.
+ * @param eventName The event name to define.
+ */
+export function defineEventAttribute(
+  prototype: EventTarget,
+  eventName: string,
+): void;
+
+export default EventTarget;

package/src-win/Libraries/Components/TextInput/Tests/TextInputTest.tsx

@@ -114,49 +114,49 @@ export const examples = [
     {
       title: 'Autofocus Example',
       description: 'autoFocus in action',
-      render(): JSX.Element {
+      render() {
         return (<AutoFocusingTextInputTest />);
       },
     },
     {
       title: 'Placeholders Example',
       description: 'placeholder in action',
-      render(): JSX.Element {
+      render() {
         return (<PlaceholderTextInputTest />);
       },
     },
     {
       title: 'Controlled Example',
       description: 'Controlling inputs in action',
-      render(): JSX.Element {
+      render() {
         return (<ControllingTextInputTest />);
       },
     },
     {
       title: 'Focus and Blur Example',
       description: 'onFocus/onBlur in action',
-      render(): JSX.Element {
+      render() {
         return (<BlurringAndFocusingTextInputTest />);
       },
     },
     {
       title: 'ContentSizeChange Example',
       description: 'onContentSizeChange in action',
-      render(): JSX.Element {
+      render() {
         return (<LayoutListeningTextInputTest />);
       },
     },
     {
       title: 'Control via onKeyPress Example',
       description: 'onKeyPress in action',
-      render(): JSX.Element {
+      render() {
         return (<KeyPressListeningTextInputTest />);
       },
     },
     {
       title: 'Super Styling Example',
       description: 'Styling in action',
-      render(): JSX.Element {
+      render() {
         return (<StyleTextInputTest />);
       },
     },

package/src-win/Libraries/Components/Touchable/Tests/TouchableWin32Test.tsx

@@ -481,21 +481,21 @@ export const examples = [
   {
     title: 'TouchableWithoutFeedback Example',
     description: 'A simple example implementation of without feedback behavior',
-    render(): JSX.Element {
+    render() {
       return <TouchableWithoutFeedbackExample />;
     },
   },
   {
     title: 'TouchableHighlight Example',
     description: 'A simple example implementation of highlight behavior',
-    render(): JSX.Element {
+    render() {
       return <TouchableHighlightExample />;
     },
   },
   {
     title: 'Imperative Focus on TouchableWin32 Example',
     description: 'A simple example implementation of imperative focus behavior',
-    render(): JSX.Element {
+    render() {
       return <TouchableFocusExample />;
     },
   }

package/src-win/Libraries/Image/Tests/ImageWin32Test.tsx

@@ -10,7 +10,7 @@ export const examples = [
     {
       title: 'Win32 Image control test',
       description: 'Test Image',
-      render(): JSX.Element {
+      render() {
         return (
           <Image
             style={ { width: 100, height: 100 } }

package/types/index.d.ts

@@ -139,6 +139,7 @@ export * from '../Libraries/StyleSheet/processColor';
 export * from '../Libraries/Text/Text';
 export * from '../Libraries/TurboModule/RCTExport';
 export * as TurboModuleRegistry from '../Libraries/TurboModule/TurboModuleRegistry';
+export * as CodegenTypes from '../Libraries/Types/CodegenTypesNamespace';
 export * from '../Libraries/Types/CoreEventTypes';
 export * from '../Libraries/Utilities/Appearance';
 export * from '../Libraries/Utilities/BackHandler';
@@ -159,5 +160,8 @@ export * from './public/Insets';
 export * from './public/ReactNativeRenderer';
 export * from './public/ReactNativeTypes';
 
+export {default as codegenNativeCommands} from '../Libraries/Utilities/codegenNativeCommands';
+export {default as codegenNativeComponent} from '../Libraries/Utilities/codegenNativeComponent';
+
 // Export platform specific types
 export * from '../Libraries/platform-types';