@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

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

@@ -0,0 +1,69 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict'
+
+/*
+ * @returns {bool} true if different, false if equal
+ */
+const deepDiffer = function (one, two, 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
+    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 { deepDiffer }
+export default deepDiffer

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

@@ -0,0 +1,14 @@
+/**
+ * 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'
+
+import { EventEmitter } from './_EventEmitter'
+export { EventEmitter }
+export default EventEmitter

package/src/vendor/react-native/emitter/EventSubscription.js

@@ -0,0 +1,12 @@
+/**
+ * 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' // This exists as a separate file only to avoid circular dependencies from
+// using this in `_EmitterSubscription`. Combine this back into `EventEmitter`
+// after migration and cleanup is done.

package/src/vendor/react-native/emitter/_EmitterSubscription.js

@@ -0,0 +1,47 @@
+/**
+ * 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'
+
+import { _EventSubscription } from './_EventSubscription'
+
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+class EmitterSubscription extends _EventSubscription {
+  /**
+   * @param {EventEmitter} emitter - The event emitter that registered this
+   *   subscription
+   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+   *   this subscription
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  constructor(emitter, subscriber, listener, context) {
+    super(subscriber)
+    this.emitter = emitter
+    this.listener = listener
+    this.context = context
+  }
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * Note: we're overriding the `remove()` method of _EventSubscription here
+   * but deliberately not calling `super.remove()` as the responsibility
+   * for removing the subscription lies with the EventEmitter.
+   */
+
+  remove() {
+    this.emitter.removeSubscription(this)
+  }
+}
+
+export { EmitterSubscription }
+export default EmitterSubscription

package/src/vendor/react-native/emitter/_EventEmitter.js

@@ -0,0 +1,175 @@
+/**
+ * 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
+ *
+ * @typecheck
+ */
+import { invariant } from '@hanzogui/react-native-web-internals'
+
+import { EmitterSubscription } from './_EmitterSubscription'
+import { EventSubscriptionVendor } from './_EventSubscriptionVendor'
+
+var sparseFilterPredicate = () => true
+
+/**
+ * @class EventEmitter
+ * @description
+ * An EventEmitter is responsible for managing a set of listeners and publishing
+ * events to them when it is told that such events happened. In addition to the
+ * data for the given event it also sends a event control object which allows
+ * the listeners/handlers to prevent the default behavior of the given event.
+ *
+ * The emitter is designed to be generic enough to support all the different
+ * contexts in which one might want to emit events. It is a simple multicast
+ * mechanism on top of which extra functionality can be composed. For example, a
+ * more advanced emitter may use an EventHolder and EventFactory.
+ */
+class EventEmitter {
+  /**
+   * @constructor
+   *
+   * @param {EventSubscriptionVendor} subscriber - Optional subscriber instance
+   *   to use. If omitted, a new subscriber will be created for the emitter.
+   */
+  constructor(subscriber = new EventSubscriptionVendor()) {
+    this._subscriber = subscriber
+  }
+  /**
+   * Adds a listener to be invoked when events of the specified type are
+   * emitted. An optional calling context may be provided. The data arguments
+   * emitted will be passed to the listener function.
+   *
+   * TODO: Annotate the listener arg's type. This is tricky because listeners
+   *       can be invoked with varargs.
+   *
+   * @param {string} eventType - Name of the event to listen to
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+
+  addListener(
+    eventType, // FIXME: listeners should return void instead of mixed to prevent issues
+    listener,
+    context
+  ) {
+    return this._subscriber.addSubscription(
+      eventType,
+      new EmitterSubscription(this, this._subscriber, listener, context)
+    )
+  }
+  /**
+   * Removes all of the registered listeners, including those registered as
+   * listener maps.
+   *
+   * @param {?string} eventType - Optional name of the event whose registered
+   *   listeners to remove
+   */
+
+  removeAllListeners(eventType) {
+    this._subscriber.removeAllSubscriptions(eventType)
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+
+  removeSubscription(subscription) {
+    invariant(
+      subscription.emitter === this,
+      'Subscription does not belong to this emitter.'
+    )
+
+    this._subscriber.removeSubscription(subscription)
+  }
+  /**
+   * Returns the number of listeners that are currently registered for the given
+   * event.
+   *
+   * @param {string} eventType - Name of the event to query
+   * @returns {number}
+   */
+
+  listenerCount(eventType) {
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType)
+
+    return subscriptions // We filter out missing entries because the array is sparse.
+      ? // "callbackfn is called only for elements of the array which actually
+        // exist; it is not called for missing elements of the array."
+        // https://www.ecma-international.org/ecma-262/9.0/index.html#sec-array.prototype.filter
+        subscriptions.filter(sparseFilterPredicate).length
+      : 0
+  }
+  /**
+   * Emits an event of the given type with the given data. All handlers of that
+   * particular type will be notified.
+   *
+   * @param {string} eventType - Name of the event to emit
+   * @param {...*} Arbitrary arguments to be passed to each registered listener
+   *
+   * @example
+   *   emitter.addListener('someEvent', function(message) {
+   *     console.log(message);
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   */
+
+  emit(eventType) {
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType)
+
+    if (subscriptions) {
+      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, l = subscriptions.length; i < l; i++) {
+        var subscription = subscriptions[i] // The subscription may have been removed during this event loop.
+
+        if (subscription && subscription.listener) {
+          subscription.listener.apply(subscription.context, args)
+        }
+      }
+    }
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+
+  removeListener(
+    eventType, // FIXME: listeners should return void instead of mixed to prevent issues
+    listener
+  ) {
+    console.error(
+      "EventEmitter.removeListener('" +
+        eventType +
+        "', ...): Method has been " +
+        'deprecated. Please instead use `remove()` on the subscription ' +
+        'returned by `EventEmitter.addListener`.'
+    )
+
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType)
+
+    if (subscriptions) {
+      for (var i = 0, l = subscriptions.length; i < l; i++) {
+        var subscription = subscriptions[i] // The subscription may have been removed during this event loop.
+        // its listener matches the listener in method parameters
+
+        if (subscription && subscription.listener === listener) {
+          subscription.remove()
+        }
+      }
+    }
+  }
+}
+
+export { EventEmitter }
+export default EventEmitter

package/src/vendor/react-native/emitter/_EventSubscription.js

@@ -0,0 +1,34 @@
+/**
+ * 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'
+
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+class _EventSubscription {
+  /**
+   * @param {EventSubscriptionVendor} subscriber the subscriber that controls
+   *   this subscription.
+   */
+  constructor(subscriber) {
+    this.subscriber = subscriber
+  }
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+
+  remove() {
+    this.subscriber.removeSubscription(this)
+  }
+}
+
+export { _EventSubscription }
+export default _EventSubscription

package/src/vendor/react-native/emitter/_EventSubscriptionVendor.js

@@ -0,0 +1,96 @@
+/**
+ * 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'
+
+import { invariant } from '@hanzogui/react-native-web-internals'
+
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+class EventSubscriptionVendor {
+  constructor() {
+    this._subscriptionsForType = {}
+  }
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   * @param {string} eventType
+   * @param {EventSubscription} subscription
+   */
+
+  addSubscription(eventType, subscription) {
+    invariant(
+      subscription.subscriber === this,
+      'The subscriber of the subscription is incorrectly set.'
+    )
+
+    if (!this._subscriptionsForType[eventType]) {
+      this._subscriptionsForType[eventType] = []
+    }
+
+    var key = this._subscriptionsForType[eventType].length
+
+    this._subscriptionsForType[eventType].push(subscription)
+
+    subscription.eventType = eventType
+    subscription.key = key
+    return subscription
+  }
+  /**
+   * Removes a bulk set of the subscriptions.
+   *
+   * @param {?string} eventType - Optional name of the event type whose
+   *   registered supscriptions to remove, if null remove all subscriptions.
+   */
+
+  removeAllSubscriptions(eventType) {
+    if (eventType == null) {
+      this._subscriptionsForType = {}
+    } else {
+      delete this._subscriptionsForType[eventType]
+    }
+  }
+  /**
+   * Removes a specific subscription. Instead of calling this function, call
+   * `subscription.remove()` directly.
+   *
+   * @param {object} subscription
+   */
+
+  removeSubscription(subscription) {
+    var eventType = subscription.eventType
+    var key = subscription.key
+    var subscriptionsForType = this._subscriptionsForType[eventType]
+
+    if (subscriptionsForType) {
+      delete subscriptionsForType[key]
+    }
+  }
+  /**
+   * Returns the array of subscriptions that are currently registered for the
+   * given event type.
+   *
+   * Note: This array can be potentially sparse as subscriptions are deleted
+   * from it when they are removed.
+   *
+   * TODO: This returns a nullable array. wat?
+   *
+   * @param {string} eventType
+   * @returns {?array}
+   */
+
+  getSubscriptionsForType(eventType) {
+    return this._subscriptionsForType[eventType]
+  }
+}
+
+export { EventSubscriptionVendor }
+export default EventSubscriptionVendor

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

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

package/src/vendor/react-native/useRefEffect.js

@@ -0,0 +1,44 @@
+/**
+ * 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
+ * @format
+ */
+
+import { useCallback, useRef } from 'react'
+
+/**
+ * Constructs a callback ref that provides similar semantics as `useEffect`. The
+ * supplied `effect` callback will be called with non-null component instances.
+ * The `effect` callback can also optionally return a cleanup function.
+ *
+ * When a component is updated or unmounted, the cleanup function is called. The
+ * `effect` callback will then be called again, if applicable.
+ *
+ * When a new `effect` callback is supplied, the previously returned cleanup
+ * function will be called before the new `effect` callback is called with the
+ * same instance.
+ *
+ * WARNING: The `effect` callback should be stable (e.g. using `useCallback`).
+ */
+function useRefEffect(effect) {
+  const cleanupRef = useRef(undefined)
+  return useCallback(
+    (instance) => {
+      if (cleanupRef.current) {
+        cleanupRef.current()
+        cleanupRef.current = undefined
+      }
+      if (instance != null) {
+        cleanupRef.current = effect(instance)
+      }
+    },
+    [effect]
+  )
+}
+
+export { useRefEffect }
+export default useRefEffect

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

@@ -0,0 +1,121 @@
+/**
+ * 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
+ * @format
+ */
+
+export class EventSubscription {
+  remove() {}
+}
+
+export class IEventEmitter {
+  addListener(eventType, listener, context) {
+    return new EventSubscription()
+  }
+
+  emit(eventType, ...args) {}
+
+  removeAllListeners(eventType) {}
+
+  listenerCount(eventType) {
+    return 0
+  }
+}
+
+class Registration {
+  context = null
+  listener = () => {}
+  remove = () => {}
+}
+
+/**
+ * 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'));
+ *
+ */
+class EventEmitter {
+  _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) {
+    const registrations = allocate(this._registry, eventType)
+    const 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, ...args) {
+    const registrations = this._registry[eventType]
+    if (registrations != null) {
+      for (const registration of [...registrations]) {
+        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) {
+    const registrations = this._registry[eventType]
+    return registrations == null ? 0 : registrations.size
+  }
+}
+
+function allocate(registry, eventType) {
+  let registrations = registry[eventType]
+  if (registrations == null) {
+    registrations = new Set()
+    registry[eventType] = registrations
+  }
+  return registrations
+}
+
+export { EventEmitter }
+export default EventEmitter