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

package/dist/cjs/vendor/react-native/emitter/_EventEmitter.cjs

@@ -0,0 +1,136 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var EventEmitter_exports = {};
+__export(EventEmitter_exports, {
+  EventEmitter: () => EventEmitter,
+  default: () => EventEmitter_default
+});
+module.exports = __toCommonJS(EventEmitter_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var import_EmitterSubscription = require("./_EmitterSubscription.cjs");
+var import_EventSubscriptionVendor = require("./_EventSubscriptionVendor.cjs");
+var sparseFilterPredicate = () => true;
+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 import_EventSubscriptionVendor.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, listener, context) {
+    return this._subscriber.addSubscription(eventType, new import_EmitterSubscription.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) {
+    (0, import_react_native_web_internals.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 ?
+    // "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];
+        if (subscription && subscription.listener) {
+          subscription.listener.apply(subscription.context, args);
+        }
+      }
+    }
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+  removeListener(eventType, 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];
+        if (subscription && subscription.listener === listener) {
+          subscription.remove();
+        }
+      }
+    }
+  }
+}
+var EventEmitter_default = EventEmitter;

package/dist/cjs/vendor/react-native/emitter/_EventSubscription.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var EventSubscription_exports = {};
+__export(EventSubscription_exports, {
+  _EventSubscription: () => _EventSubscription,
+  default: () => EventSubscription_default
+});
+module.exports = __toCommonJS(EventSubscription_exports);
+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);
+  }
+}
+var EventSubscription_default = _EventSubscription;

package/dist/cjs/vendor/react-native/emitter/_EventSubscriptionVendor.cjs

@@ -0,0 +1,96 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var EventSubscriptionVendor_exports = {};
+__export(EventSubscriptionVendor_exports, {
+  EventSubscriptionVendor: () => EventSubscriptionVendor,
+  default: () => EventSubscriptionVendor_default
+});
+module.exports = __toCommonJS(EventSubscriptionVendor_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class EventSubscriptionVendor {
+  constructor() {
+    this._subscriptionsForType = {};
+  }
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   * @param {string} eventType
+   * @param {EventSubscription} subscription
+   */
+  addSubscription(eventType, subscription) {
+    (0, import_react_native_web_internals.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];
+  }
+}
+var EventSubscriptionVendor_default = EventSubscriptionVendor;

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var infoLog_exports = {};
+__export(infoLog_exports, {
+  default: () => infoLog_default,
+  infoLog: () => infoLog
+});
+module.exports = __toCommonJS(infoLog_exports);
+function infoLog(...args) {
+  return console.log(...args);
+}
+var infoLog_default = infoLog;

package/dist/cjs/vendor/react-native/useRefEffect.cjs

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useRefEffect_exports = {};
+__export(useRefEffect_exports, {
+  default: () => useRefEffect_default,
+  useRefEffect: () => useRefEffect
+});
+module.exports = __toCommonJS(useRefEffect_exports);
+var import_react = require("react");
+function useRefEffect(effect) {
+  const cleanupRef = (0, import_react.useRef)(void 0);
+  return (0, import_react.useCallback)(instance => {
+    if (cleanupRef.current) {
+      cleanupRef.current();
+      cleanupRef.current = void 0;
+    }
+    if (instance != null) {
+      cleanupRef.current = effect(instance);
+    }
+  }, [effect]);
+}
+var useRefEffect_default = useRefEffect;

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

@@ -0,0 +1,103 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var EventEmitter_exports = {};
+__export(EventEmitter_exports, {
+  EventEmitter: () => EventEmitter,
+  EventSubscription: () => EventSubscription,
+  IEventEmitter: () => IEventEmitter,
+  default: () => EventEmitter_default
+});
+module.exports = __toCommonJS(EventEmitter_exports);
+class EventSubscription {
+  remove() {}
+}
+class IEventEmitter {
+  addListener(eventType, listener, context) {
+    return new EventSubscription();
+  }
+  emit(eventType, ...args) {}
+  removeAllListeners(eventType) {}
+  listenerCount(eventType) {
+    return 0;
+  }
+}
+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 = /* @__PURE__ */new Set();
+    registry[eventType] = registrations;
+  }
+  return registrations;
+}
+var EventEmitter_default = EventEmitter;