@amabeth/repeating-wheel-picker 1.1.0 → 1.2.0

package/example/node_modules/expo/src/Expo.fx.tsx

@@ -0,0 +1,53 @@
+// load expo-asset immediately to set a custom `source` transformer in React Native
+import './winter';
+import 'expo-asset';
+import 'expo/virtual/rsc';
+
+import Constants from 'expo-constants';
+import { AppRegistry, NativeModules, LogBox, Platform } from 'react-native';
+
+import { isRunningInExpoGo } from './environment/ExpoGo';
+import { AppEntryNotFound } from './errors/AppEntryNotFound';
+import { createErrorHandler } from './errors/ExpoErrorManager';
+
+if (isRunningInExpoGo()) {
+  // set up some improvements to commonly logged error messages stemming from react-native
+  const globalHandler = ErrorUtils.getGlobalHandler();
+  ErrorUtils.setGlobalHandler(createErrorHandler(globalHandler));
+}
+
+// Warn if the New Architecture is not explicitly enabled in the app config and we are running in Expo Go.
+// This could be problematic because you will be developing your app with the New Architecture enabled and
+// but your builds will have the New Architecture disabled.
+if (__DEV__ && isRunningInExpoGo() && process.env.NODE_ENV === 'development') {
+  (['android', 'ios'] as const).forEach((platform) => {
+    const newArchPlatformConfig = Constants.expoConfig?.[platform]?.newArchEnabled;
+    const newArchRootConfig = Constants.expoConfig?.newArchEnabled;
+
+    const isNewArchExplicitlyDisabled =
+      newArchPlatformConfig === false ||
+      (newArchPlatformConfig === undefined && newArchRootConfig === false);
+
+    if (Platform.OS === platform && isNewArchExplicitlyDisabled) {
+      // Wrap it in rAF to show the warning after the React Native DevTools message
+      requestAnimationFrame(() => {
+        console.warn(
+          `🚨 React Native's New Architecture is always enabled in Expo Go, but it is explicitly disabled in your project's app config. This may lead to unexpected behavior when creating a production or development build. Remove "newArchEnabled": false from your app.json.\nLearn more: https://docs.expo.dev/guides/new-architecture/`
+        );
+      });
+    }
+  });
+}
+
+// Disable the "Open debugger to view warnings" React Native DevTools warning in
+// Expo Go and expo-dev-client, because launching the debugger from there will not
+// get the correct JS target.
+const IS_RUNNING_IN_DEV_CLIENT = !!NativeModules.EXDevLauncher;
+if (__DEV__ && LogBox?.ignoreLogs && (isRunningInExpoGo() || IS_RUNNING_IN_DEV_CLIENT)) {
+  LogBox.ignoreLogs([/Open debugger to view warnings/]);
+}
+
+if (process.env.NODE_ENV !== 'production') {
+  // Register a default component and expect `registerRootComponent` to be called later and update it.
+  AppRegistry.registerComponent('main', () => AppEntryNotFound);
+}

package/example/node_modules/expo/src/Expo.fx.web.tsx

@@ -0,0 +1,21 @@
+import './winter';
+import 'expo/virtual/rsc';
+
+// When users dangerously import a file inside of react-native, it breaks the web alias.
+// This is one of the most common, and cryptic web errors that users encounter.
+// This conditional side-effect provides a more helpful error message for debugging.
+// Use a wrapper `__DEV__` to remove this entire block in production.
+if (__DEV__) {
+  if (
+    // Skip mocking if someone is shimming this value out.
+    !('__fbBatchedBridgeConfig' in global)
+  ) {
+    Object.defineProperty(global, '__fbBatchedBridgeConfig', {
+      get() {
+        throw new Error(
+          "Your web project is importing a module from 'react-native' instead of 'react-native-web'. Learn more: https://expo.fyi/fb-batched-bridge-config-web"
+        );
+      },
+    });
+  }
+}

package/example/node_modules/expo/src/Expo.ts

@@ -0,0 +1,30 @@
+import './Expo.fx';
+
+export { disableErrorHandling } from './errors/ExpoErrorManager';
+export { default as registerRootComponent } from './launch/registerRootComponent';
+
+export { isRunningInExpoGo, getExpoGoProjectConfig } from './environment/ExpoGo';
+
+export {
+  // Core classes
+  EventEmitter,
+  SharedObject,
+  SharedRef,
+  NativeModule,
+
+  // Methods
+  requireNativeModule,
+  requireOptionalNativeModule,
+  requireNativeViewManager as requireNativeView,
+  registerWebModule,
+  reloadAppAsync,
+} from 'expo-modules-core';
+
+export type {
+  SharedRef as SharedRefType,
+  EventEmitter as EventEmitterType,
+  NativeModule as NativeModuleType,
+  SharedObject as SharedObjectType,
+} from 'expo-modules-core/types';
+
+export { useEvent, useEventListener } from './hooks/useEvent';

package/example/node_modules/expo/src/devtools/DevToolsPluginClient.ts

@@ -0,0 +1,240 @@
+import { MessageFramePacker } from './MessageFramePacker';
+import { WebSocketBackingStore } from './WebSocketBackingStore';
+import { WebSocketWithReconnect } from './WebSocketWithReconnect';
+import type {
+  ConnectionInfo,
+  DevToolsPluginClientOptions,
+  HandshakeMessageParams,
+} from './devtools.types';
+import * as logger from './logger';
+import { blobToArrayBufferAsync } from '../utils/blobUtils';
+
+interface MessageFramePackerMessageKey {
+  pluginName: string;
+  method: string;
+}
+
+export interface EventSubscription {
+  remove(): void;
+}
+
+/**
+ * This client is for the Expo DevTools Plugins to communicate between the app and the DevTools webpage hosted in a browser.
+ * All the code should be both compatible with browsers and React Native.
+ */
+export abstract class DevToolsPluginClient {
+  private listeners: Record<string, undefined | Set<(params: any) => void>>;
+
+  private static defaultWSStore: WebSocketBackingStore = new WebSocketBackingStore();
+  private readonly wsStore: WebSocketBackingStore = DevToolsPluginClient.defaultWSStore;
+
+  protected isClosed = false;
+  protected retries = 0;
+  private readonly messageFramePacker: MessageFramePacker<MessageFramePackerMessageKey> =
+    new MessageFramePacker();
+
+  public constructor(
+    public readonly connectionInfo: ConnectionInfo,
+    private readonly options?: DevToolsPluginClientOptions
+  ) {
+    this.wsStore = connectionInfo.wsStore || DevToolsPluginClient.defaultWSStore;
+    this.listeners = Object.create(null);
+  }
+
+  /**
+   * Initialize the connection.
+   * @hidden
+   */
+  public async initAsync(): Promise<void> {
+    if (this.wsStore.ws == null) {
+      this.wsStore.ws = await this.connectAsync();
+    }
+    this.wsStore.refCount += 1;
+    this.wsStore.ws.addEventListener('message', this.handleMessage);
+  }
+
+  /**
+   * Close the connection.
+   */
+  public async closeAsync(): Promise<void> {
+    this.isClosed = true;
+    this.wsStore.ws?.removeEventListener('message', this.handleMessage);
+    this.wsStore.refCount -= 1;
+    if (this.wsStore.refCount < 1) {
+      this.wsStore.ws?.close();
+      this.wsStore.ws = null;
+    }
+    this.listeners = Object.create(null);
+  }
+
+  /**
+   * Send a message to the other end of DevTools.
+   * @param method A method name.
+   * @param params any extra payload.
+   */
+  public sendMessage(method: string, params: any) {
+    if (this.wsStore.ws?.readyState === WebSocket.CLOSED) {
+      logger.warn('Unable to send message in a disconnected state.');
+      return;
+    }
+    const messageKey: MessageFramePackerMessageKey = {
+      pluginName: this.connectionInfo.pluginName,
+      method,
+    };
+    const packedData = this.messageFramePacker.pack({ messageKey, payload: params });
+    if (!(packedData instanceof Promise)) {
+      this.wsStore.ws?.send(packedData);
+      return;
+    }
+    packedData.then((data) => {
+      this.wsStore.ws?.send(data);
+    });
+  }
+
+  /**
+   * Subscribe to a message from the other end of DevTools.
+   * @param method Subscribe to a message with a method name.
+   * @param listener Listener to be called when a message is received.
+   */
+  public addMessageListener(method: string, listener: (params: any) => void): EventSubscription {
+    const listenersForMethod = this.listeners[method] || (this.listeners[method] = new Set());
+    listenersForMethod.add(listener);
+    return {
+      remove: () => {
+        this.listeners[method]?.delete(listener);
+      },
+    };
+  }
+
+  /**
+   * Subscribe to a message from the other end of DevTools just once.
+   * @param method Subscribe to a message with a method name.
+   * @param listener Listener to be called when a message is received.
+   */
+  public addMessageListenerOnce(method: string, listener: (params: any) => void): void {
+    const wrappedListenerOnce = (params: any): void => {
+      listener(params);
+      this.listeners[method]?.delete(wrappedListenerOnce);
+    };
+    this.addMessageListener(method, wrappedListenerOnce);
+  }
+
+  /**
+   * Internal handshake message sender.
+   * @hidden
+   */
+  protected sendHandshakeMessage(params: HandshakeMessageParams) {
+    if (this.wsStore.ws?.readyState === WebSocket.CLOSED) {
+      logger.warn('Unable to send message in a disconnected state.');
+      return;
+    }
+    this.wsStore.ws?.send(JSON.stringify({ ...params, __isHandshakeMessages: true }));
+  }
+
+  /**
+   * Internal handshake message listener.
+   * @hidden
+   */
+  protected addHandskakeMessageListener(
+    listener: (params: HandshakeMessageParams) => void
+  ): EventSubscription {
+    const messageListener = (event: MessageEvent) => {
+      if (typeof event.data !== 'string') {
+        // binary data is not coming from the handshake messages.
+        return;
+      }
+
+      const data = JSON.parse(event.data);
+      if (!data.__isHandshakeMessages) {
+        return;
+      }
+      delete data.__isHandshakeMessages;
+      const params = data as HandshakeMessageParams;
+      if (params.pluginName && params.pluginName !== this.connectionInfo.pluginName) {
+        return;
+      }
+      listener(params);
+    };
+
+    this.wsStore.ws?.addEventListener('message', messageListener);
+    return {
+      remove: () => {
+        this.wsStore.ws?.removeEventListener('message', messageListener);
+      },
+    };
+  }
+
+  /**
+   * Returns whether the client is connected to the server.
+   */
+  public isConnected(): boolean {
+    return this.wsStore.ws?.readyState === WebSocket.OPEN;
+  }
+
+  /**
+   * The method to create the WebSocket connection.
+   */
+  protected connectAsync(): Promise<WebSocket> {
+    return new Promise((resolve, reject) => {
+      const endpoint = 'expo-dev-plugins/broadcast';
+      const ws = new WebSocketWithReconnect(`ws://${this.connectionInfo.devServer}/${endpoint}`, {
+        binaryType: this.options?.websocketBinaryType,
+        onError: (e: unknown) => {
+          if (e instanceof Error) {
+            console.warn(`Error happened from the WebSocket connection: ${e.message}\n${e.stack}`);
+          } else {
+            console.warn(`Error happened from the WebSocket connection: ${JSON.stringify(e)}`);
+          }
+        },
+      });
+      ws.addEventListener('open', () => {
+        resolve(ws);
+      });
+      ws.addEventListener('error', (e) => {
+        reject(e);
+      });
+      ws.addEventListener('close', (e: WebSocketCloseEvent) => {
+        logger.info('WebSocket closed', e.code, e.reason);
+      });
+    });
+  }
+
+  protected handleMessage = async (event: WebSocketMessageEvent) => {
+    let data: ArrayBuffer | string;
+    if (typeof event.data === 'string') {
+      data = event.data;
+    } else if (event.data instanceof ArrayBuffer) {
+      data = event.data;
+    } else if (ArrayBuffer.isView(event.data)) {
+      data = event.data.buffer as ArrayBuffer;
+    } else if (event.data instanceof Blob) {
+      data = await blobToArrayBufferAsync(event.data);
+    } else {
+      logger.warn('Unsupported received data type in handleMessageImpl');
+      return;
+    }
+    const { messageKey, payload, ...rest } = this.messageFramePacker.unpack(data);
+    // @ts-expect-error: `__isHandshakeMessages` is a private field that is not part of the MessageFramePacker type.
+    if (rest?.__isHandshakeMessages === true) {
+      return;
+    }
+    if (messageKey.pluginName && messageKey.pluginName !== this.connectionInfo.pluginName) {
+      return;
+    }
+
+    const listenersForMethod = this.listeners[messageKey.method];
+    if (listenersForMethod) {
+      for (const listener of listenersForMethod) {
+        listener(payload);
+      }
+    }
+  };
+
+  /**
+   * Get the WebSocket backing store. Exposed for testing.
+   * @hidden
+   */
+  public getWebSocketBackingStore(): WebSocketBackingStore {
+    return this.wsStore;
+  }
+}

package/example/node_modules/expo/src/devtools/DevToolsPluginClientFactory.ts

@@ -0,0 +1,73 @@
+import type { DevToolsPluginClient } from './DevToolsPluginClient';
+import { DevToolsPluginClientImplApp } from './DevToolsPluginClientImplApp';
+import { DevToolsPluginClientImplBrowser } from './DevToolsPluginClientImplBrowser';
+import type { ConnectionInfo, DevToolsPluginClientOptions } from './devtools.types';
+import { getConnectionInfo } from './getConnectionInfo';
+
+const instanceMap: Record<string, DevToolsPluginClient | Promise<DevToolsPluginClient>> = {};
+
+/**
+ * Factory of DevToolsPluginClient based on sender types.
+ * @hidden
+ */
+export async function createDevToolsPluginClient(
+  connectionInfo: ConnectionInfo,
+  options?: DevToolsPluginClientOptions
+): Promise<DevToolsPluginClient> {
+  let client: DevToolsPluginClient;
+  if (connectionInfo.sender === 'app') {
+    client = new DevToolsPluginClientImplApp(connectionInfo, options);
+  } else {
+    client = new DevToolsPluginClientImplBrowser(connectionInfo, options);
+  }
+  await client.initAsync();
+  return client;
+}
+
+/**
+ * Public API to get the DevToolsPluginClient instance.
+ */
+export async function getDevToolsPluginClientAsync(
+  pluginName: string,
+  options?: DevToolsPluginClientOptions
+): Promise<DevToolsPluginClient> {
+  const connectionInfo = getConnectionInfo();
+
+  let instance: DevToolsPluginClient | Promise<DevToolsPluginClient> | null =
+    instanceMap[pluginName];
+  if (instance != null) {
+    if (instance instanceof Promise) {
+      return instance;
+    }
+    if (
+      instance.isConnected() === false ||
+      instance.connectionInfo.devServer !== connectionInfo.devServer
+    ) {
+      await instance.closeAsync();
+      delete instanceMap[pluginName];
+      instance = null;
+    }
+  }
+  if (instance == null) {
+    const instancePromise = createDevToolsPluginClient({ ...connectionInfo, pluginName }, options);
+    instanceMap[pluginName] = instancePromise;
+    instance = await instancePromise;
+    instanceMap[pluginName] = instance;
+  }
+  return instance;
+}
+
+/**
+ * Internal testing API to cleanup all DevToolsPluginClient instances.
+ */
+export function cleanupDevToolsPluginInstances() {
+  for (const pluginName of Object.keys(instanceMap)) {
+    const instance = instanceMap[pluginName];
+    delete instanceMap[pluginName];
+    if (instance instanceof Promise) {
+      instance.then((instance) => instance.closeAsync());
+    } else {
+      instance.closeAsync();
+    }
+  }
+}

package/example/node_modules/expo/src/devtools/DevToolsPluginClientImplApp.ts

@@ -0,0 +1,56 @@
+import { DevToolsPluginClient } from './DevToolsPluginClient';
+import * as logger from './logger';
+
+/**
+ * The DevToolsPluginClient for the app -> browser communication.
+ */
+export class DevToolsPluginClientImplApp extends DevToolsPluginClient {
+  // Map of pluginName -> browserClientId
+  private browserClientMap: Record<string, string> = {};
+
+  /**
+   * Initialize the connection.
+   * @hidden
+   */
+  override async initAsync(): Promise<void> {
+    await super.initAsync();
+    this.addHandshakeHandler();
+  }
+
+  private addHandshakeHandler() {
+    this.addHandskakeMessageListener((params) => {
+      if (params.method === 'handshake') {
+        const { pluginName, protocolVersion } = params;
+
+        // [0] Check protocol version
+        if (protocolVersion !== this.connectionInfo.protocolVersion) {
+          // Use console.warn than logger because we want to show the warning even logging is disabled.
+          console.warn(
+            `Received an incompatible devtools plugin handshake message - pluginName[${pluginName}]`
+          );
+          this.terminateBrowserClient(pluginName, params.browserClientId);
+          return;
+        }
+
+        // [1] Terminate duplicated browser clients for the same plugin
+        const previousBrowserClientId = this.browserClientMap[pluginName];
+        if (previousBrowserClientId != null && previousBrowserClientId !== params.browserClientId) {
+          logger.info(
+            `Terminate the previous browser client connection - previousBrowserClientId[${previousBrowserClientId}]`
+          );
+          this.terminateBrowserClient(pluginName, previousBrowserClientId);
+        }
+        this.browserClientMap[pluginName] = params.browserClientId;
+      }
+    });
+  }
+
+  private terminateBrowserClient(pluginName: string, browserClientId: string) {
+    this.sendHandshakeMessage({
+      protocolVersion: this.connectionInfo.protocolVersion,
+      method: 'terminateBrowserClient',
+      browserClientId,
+      pluginName,
+    });
+  }
+}

package/example/node_modules/expo/src/devtools/DevToolsPluginClientImplBrowser.ts

@@ -0,0 +1,38 @@
+import { DevToolsPluginClient } from './DevToolsPluginClient';
+import * as logger from './logger';
+
+/**
+ * The DevToolsPluginClient for the browser -> app communication.
+ */
+export class DevToolsPluginClientImplBrowser extends DevToolsPluginClient {
+  private browserClientId: string = Date.now().toString();
+
+  /**
+   * Initialize the connection.
+   * @hidden
+   */
+  override async initAsync(): Promise<void> {
+    await super.initAsync();
+    this.startHandshake();
+  }
+
+  private startHandshake() {
+    this.addHandskakeMessageListener((params) => {
+      if (
+        params.method === 'terminateBrowserClient' &&
+        this.browserClientId === params.browserClientId
+      ) {
+        logger.info(
+          'Received terminateBrowserClient messages and terminate the current connection'
+        );
+        this.closeAsync();
+      }
+    });
+    this.sendHandshakeMessage({
+      protocolVersion: this.connectionInfo.protocolVersion,
+      pluginName: this.connectionInfo.pluginName,
+      method: 'handshake',
+      browserClientId: this.browserClientId,
+    });
+  }
+}