@planningcenter/chat-react-native 3.15.0-rc.6 → 3.15.0-rc.8

package/src/polyfills/events/Event.ts

@@ -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.
+ */
+
+/**
+ * This module implements the `Event` interface from the DOM.
+ * See https://dom.spec.whatwg.org/#interface-event.
+ */
+
+import type RNEventTarget from './EventTarget'
+import {
+  getComposedPath,
+  getCurrentTarget,
+  getEventPhase,
+  getInPassiveListenerFlag,
+  getIsTrusted,
+  getTarget,
+  setStopImmediatePropagationFlag,
+  setStopPropagationFlag,
+  setIsTrusted,
+  setEventPhase,
+} from './internals/EventInternals'
+import { setPlatformObject } from '../webidl/PlatformObjects'
+
+export interface EventInit {
+  bubbles?: boolean
+  cancelable?: boolean
+  composed?: boolean
+}
+
+export type EventPhase = 0 | 1 | 2 | 3
+
+export default class Event {
+  static NONE: 0
+  static CAPTURING_PHASE: 1
+  static AT_TARGET: 2
+  static BUBBLING_PHASE: 3
+
+  readonly NONE!: 0
+  readonly CAPTURING_PHASE!: 1
+  readonly AT_TARGET!: 2
+  readonly BUBBLING_PHASE!: 3
+
+  private _bubbles: boolean
+  private _cancelable: boolean
+  private _composed: boolean
+  private _type: string
+
+  private _defaultPrevented: boolean = false
+  private _timeStamp: number = performance.now()
+
+  // Symbol-keyed fields are internal and managed via helpers; not declared here.
+
+  constructor(type: string, options?: EventInit | null) {
+    if (arguments.length < 1) {
+      throw new TypeError("Failed to construct 'Event': 1 argument required, but only 0 present.")
+    }
+
+    const typeOfOptions = typeof options
+    if (options != null && typeOfOptions !== 'object' && typeOfOptions !== 'function') {
+      throw new TypeError(
+        "Failed to construct 'Event': The provided value is not of type 'EventInit'."
+      )
+    }
+
+    this._type = String(type)
+    this._bubbles = Boolean((options as EventInit | undefined)?.bubbles)
+    this._cancelable = Boolean((options as EventInit | undefined)?.cancelable)
+    this._composed = Boolean((options as EventInit | undefined)?.composed)
+
+    // Initialize internal flags
+    setIsTrusted(this, false)
+    setEventPhase(this, 0 as 0)
+  }
+
+  get bubbles(): boolean {
+    return this._bubbles
+  }
+
+  get cancelable(): boolean {
+    return this._cancelable
+  }
+
+  get composed(): boolean {
+    return this._composed
+  }
+
+  get currentTarget(): RNEventTarget | null {
+    return getCurrentTarget(this)
+  }
+
+  get defaultPrevented(): boolean {
+    return this._defaultPrevented
+  }
+
+  get eventPhase(): EventPhase {
+    return getEventPhase(this)
+  }
+
+  get isTrusted(): boolean {
+    return getIsTrusted(this)
+  }
+
+  get target(): RNEventTarget | null {
+    return getTarget(this)
+  }
+
+  get timeStamp(): number {
+    return this._timeStamp
+  }
+
+  get type(): string {
+    return this._type
+  }
+
+  composedPath(): ReadonlyArray<RNEventTarget> {
+    return getComposedPath(this).slice()
+  }
+
+  preventDefault(): void {
+    if (!this._cancelable) {
+      return
+    }
+
+    if (getInPassiveListenerFlag(this)) {
+      console.error(new Error('Unable to preventDefault inside passive event listener invocation.'))
+      return
+    }
+
+    this._defaultPrevented = true
+  }
+
+  stopImmediatePropagation(): void {
+    setStopPropagationFlag(this, true)
+    setStopImmediatePropagationFlag(this, true)
+  }
+
+  stopPropagation(): void {
+    setStopPropagationFlag(this, true)
+  }
+}
+
+Object.defineProperty(Event, 'NONE', {
+  enumerable: true,
+  value: 0,
+})
+
+Object.defineProperty(Event.prototype, 'NONE', {
+  enumerable: true,
+  value: 0,
+})
+
+Object.defineProperty(Event, 'CAPTURING_PHASE', {
+  enumerable: true,
+  value: 1,
+})
+
+Object.defineProperty(Event.prototype, 'CAPTURING_PHASE', {
+  enumerable: true,
+  value: 1,
+})
+
+Object.defineProperty(Event, 'AT_TARGET', {
+  enumerable: true,
+  value: 2,
+})
+
+Object.defineProperty(Event.prototype, 'AT_TARGET', {
+  enumerable: true,
+  value: 2,
+})
+
+Object.defineProperty(Event, 'BUBBLING_PHASE', {
+  enumerable: true,
+  value: 3,
+})
+
+Object.defineProperty(Event.prototype, 'BUBBLING_PHASE', {
+  enumerable: true,
+  value: 3,
+})
+
+setPlatformObject(Event)

package/src/polyfills/events/EventHandlerAttributes.ts

@@ -0,0 +1,67 @@
+/**
+ * Helpers to implement event handler IDL attributes.
+ */
+
+import type EventTarget from './EventTarget'
+import type { EventCallback } from './EventTarget'
+
+type EventHandler = Readonly<{
+  handleEvent: EventCallback
+}>
+type EventHandlerAttributeMap = Map<string, EventHandler | null>
+
+const EVENT_HANDLER_CONTENT_ATTRIBUTE_MAP_KEY = Symbol('eventHandlerAttributeMap')
+
+function getEventHandlerAttributeMap(
+  target: EventTarget
+): EventHandlerAttributeMap | null | undefined {
+  return (target as any)[EVENT_HANDLER_CONTENT_ATTRIBUTE_MAP_KEY]
+}
+
+function setEventHandlerAttributeMap(target: EventTarget, map: EventHandlerAttributeMap | null) {
+  ;(target as any)[EVENT_HANDLER_CONTENT_ATTRIBUTE_MAP_KEY] = map
+}
+
+export function getEventHandlerAttribute(target: EventTarget, type: string): EventCallback | null {
+  const listener = getEventHandlerAttributeMap(target)?.get(type)
+  return listener != null ? listener.handleEvent : null
+}
+
+export function setEventHandlerAttribute(
+  target: EventTarget,
+  type: string,
+  callback: EventCallback | null | undefined
+): void {
+  let map = getEventHandlerAttributeMap(target)
+  if (map != null) {
+    const currentListener = map.get(type)
+    if (currentListener) {
+      target.removeEventListener(type, currentListener)
+      map.delete(type)
+    }
+  }
+
+  if (
+    callback != null &&
+    (typeof callback === 'function' || typeof (callback as any) === 'object')
+  ) {
+    const listener: EventHandler = {
+      handleEvent: callback as EventCallback,
+    }
+
+    try {
+      target.addEventListener(type, listener)
+      if (map == null) {
+        map = new Map()
+        setEventHandlerAttributeMap(target, map)
+      }
+      map.set(type, listener)
+    } catch (_e) {
+      // Assigning incorrect listener does not throw in setters.
+    }
+  }
+
+  if (map != null && map.size === 0) {
+    setEventHandlerAttributeMap(target, null)
+  }
+}

package/src/polyfills/events/EventTarget.ts

@@ -0,0 +1,360 @@
+/**
+ * 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.
+ */
+
+/**
+ * Implements the `EventTarget` interface from the DOM.
+ */
+
+import Event from './Event'
+import {
+  getStopImmediatePropagationFlag,
+  getStopPropagationFlag,
+  setComposedPath,
+  setCurrentTarget,
+  setEventPhase,
+  setInPassiveListenerFlag,
+  setIsTrusted,
+  setStopImmediatePropagationFlag,
+  setStopPropagationFlag,
+  setTarget,
+} from './internals/EventInternals'
+import {
+  EVENT_TARGET_GET_THE_PARENT_KEY,
+  INTERNAL_DISPATCH_METHOD_KEY,
+} from './internals/EventTargetInternals'
+import { setPlatformObject } from '../webidl/PlatformObjects'
+
+export type EventCallback = (event: Event) => void
+export type EventHandler = { handleEvent(event: Event): void }
+export type EventListener = EventCallback | EventHandler
+
+export type EventListenerOptions = Readonly<{
+  capture?: boolean
+}>
+
+export type AddEventListenerOptions = Readonly<{
+  capture?: boolean
+  passive?: boolean
+  once?: boolean
+  signal?: AbortSignal
+}>
+
+type EventListenerRegistration = {
+  readonly callback: EventListener
+  readonly passive: boolean
+  readonly once: boolean
+  removed: boolean
+}
+
+type ListenersMap = Map<string, Map<EventListener, EventListenerRegistration>>
+
+export default class EventTarget {
+  addEventListener(
+    type: string,
+    callback: EventListener | null,
+    optionsOrUseCapture: AddEventListenerOptions | boolean = {}
+  ): void {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to execute 'addEventListener' on 'EventTarget': 2 arguments required, but only ${arguments.length} present.`
+      )
+    }
+
+    if (callback == null) {
+      return
+    }
+
+    validateCallback(callback, 'addEventListener')
+
+    const processedType = String(type)
+
+    let capture: boolean
+    let passive: boolean
+    let once: boolean
+    let signal: AbortSignal | null | undefined
+
+    if (
+      optionsOrUseCapture != null &&
+      (typeof optionsOrUseCapture === 'object' || typeof optionsOrUseCapture === 'function')
+    ) {
+      const opts = optionsOrUseCapture as AddEventListenerOptions
+      capture = Boolean(opts.capture)
+      passive =
+        opts.passive == null ? getDefaultPassiveValue(processedType, this) : Boolean(opts.passive)
+      once = Boolean(opts.once)
+      signal = opts.signal
+      if (signal !== undefined && !(signal instanceof AbortSignal)) {
+        throw new TypeError(
+          "Failed to execute 'addEventListener' on 'EventTarget': Failed to read the 'signal' property from 'AddEventListenerOptions': Failed to convert value to 'AbortSignal'."
+        )
+      }
+    } else {
+      capture = Boolean(optionsOrUseCapture)
+      passive = false
+      once = false
+      signal = null
+    }
+
+    if (signal?.aborted) {
+      return
+    }
+
+    let listenersByType = getListenersForPhase(this, capture)
+    let listeners = listenersByType?.get(processedType)
+    if (listeners == null) {
+      if (listenersByType == null) {
+        listenersByType = new Map()
+        setListenersMap(this, capture, listenersByType)
+      }
+      listeners = new Map()
+      listenersByType.set(processedType, listeners)
+    } else if (listeners.has(callback)) {
+      return
+    }
+
+    const listener: EventListenerRegistration = {
+      callback,
+      passive,
+      once,
+      removed: false,
+    }
+    listeners.set(callback, listener)
+
+    const nonNullListeners = listeners
+
+    if (signal != null) {
+      signal.addEventListener(
+        'abort',
+        () => {
+          listener.removed = true
+          if (nonNullListeners.get(callback) === listener) {
+            nonNullListeners.delete(callback)
+          }
+        },
+        { once: true }
+      )
+    }
+  }
+
+  removeEventListener(
+    type: string,
+    callback: EventListener,
+    optionsOrUseCapture: EventListenerOptions | boolean = {}
+  ): void {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to execute 'removeEventListener' on 'EventTarget': 2 arguments required, but only ${arguments.length} present.`
+      )
+    }
+
+    if (callback == null) {
+      return
+    }
+
+    validateCallback(callback, 'removeEventListener')
+
+    const processedType = String(type)
+
+    const capture =
+      typeof optionsOrUseCapture === 'boolean'
+        ? optionsOrUseCapture
+        : Boolean((optionsOrUseCapture as EventListenerOptions).capture)
+
+    const listenersByType = getListenersForPhase(this, capture)
+    const listeners = listenersByType?.get(processedType)
+    if (listeners == null) {
+      return
+    }
+
+    const listener = listeners.get(callback)
+    if (listener != null) {
+      listener.removed = true
+      listeners.delete(callback)
+    }
+  }
+
+  dispatchEvent(event: Event): boolean {
+    if (!(event instanceof Event)) {
+      throw new TypeError(
+        "Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'."
+      )
+    }
+
+    if (getEventDispatchFlag(event)) {
+      throw new Error(
+        "Failed to execute 'dispatchEvent' on 'EventTarget': The event is already being dispatched."
+      )
+    }
+
+    setIsTrusted(event, false)
+    dispatch(this, event)
+    return !event.defaultPrevented
+  }
+
+  // "protected" for subclasses: get the parent (see spec)
+  [EVENT_TARGET_GET_THE_PARENT_KEY](): EventTarget | null {
+    return null
+  }
+
+  // "protected" to dispatch trusted events
+  [INTERNAL_DISPATCH_METHOD_KEY](event: Event): void {
+    dispatch(this, event)
+  }
+}
+
+setPlatformObject(EventTarget)
+
+function validateCallback(callback: EventListener, methodName: string): void {
+  if (typeof callback !== 'function' && typeof callback !== 'object') {
+    throw new TypeError(
+      `Failed to execute '${methodName}' on 'EventTarget': parameter 2 is not of type 'Object'.`
+    )
+  }
+}
+
+function getDefaultPassiveValue(_type: string, _eventTarget: EventTarget): boolean {
+  return false
+}
+
+function dispatch(eventTarget: EventTarget, event: Event): void {
+  setEventDispatchFlag(event, true)
+
+  const eventPath = getEventPath(eventTarget, event)
+  setComposedPath(event, eventPath)
+  setTarget(event, eventTarget)
+
+  for (let i = eventPath.length - 1; i >= 0; i--) {
+    if (getStopPropagationFlag(event)) {
+      break
+    }
+    const target = eventPath[i]
+    setEventPhase(event, target === eventTarget ? Event.AT_TARGET : Event.CAPTURING_PHASE)
+    invoke(target, event, Event.CAPTURING_PHASE)
+  }
+
+  for (const target of eventPath) {
+    if (getStopPropagationFlag(event)) {
+      break
+    }
+    if (!event.bubbles && target !== eventTarget) {
+      break
+    }
+    setEventPhase(event, target === eventTarget ? Event.AT_TARGET : Event.BUBBLING_PHASE)
+    invoke(target, event, Event.BUBBLING_PHASE)
+  }
+
+  setEventPhase(event, Event.NONE)
+  setCurrentTarget(event, null)
+  setComposedPath(event, [])
+
+  setEventDispatchFlag(event, false)
+  setStopImmediatePropagationFlag(event, false)
+  setStopPropagationFlag(event, false)
+}
+
+function getEventPath(eventTarget: EventTarget, _event: Event): ReadonlyArray<EventTarget> {
+  const path: EventTarget[] = []
+  let target: EventTarget | null = eventTarget
+
+  while (target != null) {
+    path.push(target)
+    target = target[EVENT_TARGET_GET_THE_PARENT_KEY]()
+  }
+
+  return path
+}
+
+function invoke(eventTarget: EventTarget, event: Event, eventPhase: import('./Event').EventPhase) {
+  const listenersByType = getListenersForPhase(eventTarget, eventPhase === Event.CAPTURING_PHASE)
+
+  setCurrentTarget(event, eventTarget)
+
+  const maybeListeners = listenersByType?.get(event.type)
+  if (maybeListeners == null) {
+    return
+  }
+
+  const listeners = Array.from(maybeListeners.values())
+  setCurrentTarget(event, eventTarget)
+
+  for (const listener of listeners) {
+    if (listener.removed) {
+      continue
+    }
+
+    if (listener.once) {
+      eventTarget.removeEventListener(
+        event.type,
+        listener.callback,
+        eventPhase === Event.CAPTURING_PHASE
+      )
+    }
+
+    if (listener.passive) {
+      setInPassiveListenerFlag(event, true)
+    }
+
+    const currentEvent = (global as any).event
+    ;(global as any).event = event
+
+    const callback = listener.callback as any
+    try {
+      if (typeof callback === 'function') {
+        callback.call(eventTarget, event)
+      } else if (typeof callback.handleEvent === 'function') {
+        callback.handleEvent(event)
+      }
+    } catch (error) {
+      // TODO: replace with `reportError` when it's available.
+
+      console.error(error)
+    }
+
+    if (listener.passive) {
+      setInPassiveListenerFlag(event, false)
+    }
+
+    ;(global as any).event = currentEvent
+
+    if (getStopImmediatePropagationFlag(event)) {
+      break
+    }
+  }
+}
+
+const CAPTURING_LISTENERS_KEY = Symbol('capturingListeners')
+const BUBBLING_LISTENERS_KEY = Symbol('bubblingListeners')
+
+function getListenersForPhase(
+  eventTarget: EventTarget,
+  isCapture: boolean
+): ListenersMap | null | undefined {
+  // @ts-expect-error index on symbol
+  return isCapture ? eventTarget[CAPTURING_LISTENERS_KEY] : eventTarget[BUBBLING_LISTENERS_KEY]
+}
+
+function setListenersMap(
+  eventTarget: EventTarget,
+  isCapture: boolean,
+  listenersMap: ListenersMap
+): void {
+  if (isCapture) {
+    ;(eventTarget as any)[CAPTURING_LISTENERS_KEY] = listenersMap
+  } else {
+    ;(eventTarget as any)[BUBBLING_LISTENERS_KEY] = listenersMap
+  }
+}
+
+const EVENT_DISPATCH_FLAG = Symbol('Event.dispatch')
+
+function getEventDispatchFlag(event: Event): boolean {
+  return (event as any)[EVENT_DISPATCH_FLAG]
+}
+
+function setEventDispatchFlag(event: Event, value: boolean): void {
+  ;(event as any)[EVENT_DISPATCH_FLAG] = value
+}

package/src/polyfills/events/README.md

@@ -0,0 +1 @@
+This code is taken from react-native core. 

package/src/polyfills/events/internals/EventInternals.ts

@@ -0,0 +1,95 @@
+/**
+ * Internal implementation details for the `Event` module.
+ */
+
+import type Event from '../Event'
+import type EventTarget from '../EventTarget'
+
+export const COMPOSED_PATH_KEY: unique symbol = Symbol('composedPath')
+export const CURRENT_TARGET_KEY: unique symbol = Symbol('currentTarget')
+export const EVENT_PHASE_KEY: unique symbol = Symbol('eventPhase')
+export const IN_PASSIVE_LISTENER_FLAG_KEY: unique symbol = Symbol('inPassiveListenerFlag')
+export const IS_TRUSTED_KEY: unique symbol = Symbol('isTrusted')
+export const STOP_IMMEDIATE_PROPAGATION_FLAG_KEY: unique symbol = Symbol('stopPropagationFlag')
+export const STOP_PROPAGATION_FLAG_KEY: unique symbol = Symbol('stopPropagationFlag')
+export const TARGET_KEY: unique symbol = Symbol('target')
+
+export function getCurrentTarget(event: Event): EventTarget | null {
+  // @ts-expect-error index on symbol
+  return event[CURRENT_TARGET_KEY]
+}
+
+export function setCurrentTarget(event: Event, currentTarget: EventTarget | null): void {
+  // @ts-expect-error index on symbol
+  event[CURRENT_TARGET_KEY] = currentTarget
+}
+
+export function getComposedPath(event: Event): ReadonlyArray<EventTarget> {
+  // @ts-expect-error index on symbol
+  return event[COMPOSED_PATH_KEY]
+}
+
+export function setComposedPath(event: Event, composedPath: ReadonlyArray<EventTarget>): void {
+  // @ts-expect-error index on symbol
+  event[COMPOSED_PATH_KEY] = composedPath
+}
+
+export function getEventPhase(event: Event): import('../Event').EventPhase {
+  // @ts-expect-error index on symbol
+  return event[EVENT_PHASE_KEY]
+}
+
+export function setEventPhase(event: Event, eventPhase: import('../Event').EventPhase): void {
+  // @ts-expect-error index on symbol
+  event[EVENT_PHASE_KEY] = eventPhase
+}
+
+export function getInPassiveListenerFlag(event: Event): boolean {
+  // @ts-expect-error index on symbol
+  return event[IN_PASSIVE_LISTENER_FLAG_KEY]
+}
+
+export function setInPassiveListenerFlag(event: Event, value: boolean): void {
+  // @ts-expect-error index on symbol
+  event[IN_PASSIVE_LISTENER_FLAG_KEY] = value
+}
+
+export function getIsTrusted(event: Event): boolean {
+  // @ts-expect-error index on symbol
+  return event[IS_TRUSTED_KEY]
+}
+
+export function setIsTrusted(event: Event, isTrusted: boolean): void {
+  // @ts-expect-error index on symbol
+  event[IS_TRUSTED_KEY] = isTrusted
+}
+
+export function getStopImmediatePropagationFlag(event: Event): boolean {
+  // @ts-expect-error index on symbol
+  return event[STOP_IMMEDIATE_PROPAGATION_FLAG_KEY]
+}
+
+export function setStopImmediatePropagationFlag(event: Event, value: boolean): void {
+  // @ts-expect-error index on symbol
+  event[STOP_IMMEDIATE_PROPAGATION_FLAG_KEY] = value
+}
+
+export function getStopPropagationFlag(event: Event): boolean {
+  // @ts-expect-error index on symbol
+  return event[STOP_PROPAGATION_FLAG_KEY]
+}
+
+export function setStopPropagationFlag(event: Event, value: boolean): void {
+  // @ts-expect-error index on symbol
+  event[STOP_PROPAGATION_FLAG_KEY] = value
+}
+
+export function getTarget(event: Event): EventTarget | null {
+  // @ts-expect-error index on symbol
+  return event[TARGET_KEY]
+}
+
+export function setTarget(event: Event, target: EventTarget | null): void {
+  // @ts-expect-error index on symbol
+  event[TARGET_KEY] = target
+}