@planningcenter/chat-react-native 3.15.0-rc.7 → 3.15.0-rc.9

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
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Internal implementation details for the `EventTarget` module.
+ */
+
+import type Event from '../Event'
+import type EventTarget from '../EventTarget'
+import { setIsTrusted } from './EventInternals'
+
+export const EVENT_TARGET_GET_THE_PARENT_KEY: unique symbol = Symbol('EventTarget[get the parent]')
+
+export const INTERNAL_DISPATCH_METHOD_KEY: unique symbol = Symbol('EventTarget[dispatch]')
+
+export function dispatchTrustedEvent(eventTarget: EventTarget, event: Event): void {
+  setIsTrusted(event, true)
+  return eventTarget[INTERNAL_DISPATCH_METHOD_KEY](event)
+}

package/src/polyfills/webidl/PlatformObjects.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+const IS_PLATFORM_OBJECT_KEY = Symbol('isPlatformObject')
+const CLONE_PLATFORM_OBJECT_KEY = Symbol('clonePlatformObject')
+
+type CloneFn<T extends object> = (value: T) => T
+
+/**
+ * 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 function setPlatformObject<T extends object>(
+  obj: { prototype: unknown },
+  options?: { clone: CloneFn<T> }
+): void
+export function setPlatformObject<T extends object>(obj: T, options?: { clone: CloneFn<T> }): void
+export function setPlatformObject(obj: any, options?: { clone: (value: any) => any }): void {
+  if (typeof obj === 'function') {
+    ;(obj.prototype as any)[IS_PLATFORM_OBJECT_KEY] = true
+    if (options) {
+      ;(obj.prototype as any)[CLONE_PLATFORM_OBJECT_KEY] = options.clone
+    }
+  } else {
+    ;(obj as any)[IS_PLATFORM_OBJECT_KEY] = true
+    if (options) {
+      ;(obj as any)[CLONE_PLATFORM_OBJECT_KEY] = options.clone
+    }
+  }
+}
+
+/**
+ * Indicates if the given object is a platform object.
+ */
+export function isPlatformObject<T extends object>(obj: T): boolean {
+  return IS_PLATFORM_OBJECT_KEY in (obj as any)
+}
+
+/**
+ * Returns the clone function for the given platform object, if it was set.
+ */
+export function getPlatformObjectClone<T extends object>(obj: T): ((value: T) => T) | undefined {
+  return (obj as any)[CLONE_PLATFORM_OBJECT_KEY]
+}

package/src/screens/design_system_screen.tsx

@@ -863,7 +863,7 @@ function ImageIconsSection({ isLast }: SectionProps) {
         description="Displays any icon from @planningcenter/icons. Missing icons will fallback to a grey circle. Styling with `fontSize` will allow it to scale with the device's text a11y size."
       >
         <Row>
-          {/* @ts-expect-error - Icon name is not a string */}
+          {/* @ts-expect-error - Testing missing icon fallback */}
           <Icon name="missingIcon" size={20} />
           <Icon name="general.textMessage" size={20} />
           <Icon name="general.bell" size={20} color={colors.needsDesignPass} />