@amabeth/repeating-wheel-picker 1.0.0 → 1.2.0

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

@@ -0,0 +1,235 @@
+/**
+ * A message frame packer that serializes a messageKey and a payload into either a JSON string
+ * (fast path) or a binary format (for complex payloads).
+ *
+ * Fast Path (JSON.stringify/JSON.parse):
+ * - For simple payloads (e.g., strings, numbers, null, undefined, or plain objects), the packer
+ *   uses `JSON.stringify` for serialization and `JSON.parse` for deserialization, ensuring
+ *   optimal performance.
+ *
+ * Binary Format:
+ * - For more complex payloads (e.g., Uint8Array, ArrayBuffer, Blob), the packer uses a binary
+ *   format with the following structure:
+ *
+ *   +------------------+-------------------+----------------------------+--------------------------+
+ *   | 4 bytes (Uint32) | Variable length   | 1 byte (Uint8)             | Variable length          |
+ *   | MessageKeyLength | MessageKey (JSON) | PayloadTypeIndicator (enum)| Payload (binary data)    |
+ *   +------------------+-------------------+----------------------------+--------------------------+
+ *
+ *   1. MessageKeyLength (4 bytes):
+ *      - A 4-byte unsigned integer indicating the length of the MessageKey JSON string.
+ *
+ *   2. MessageKey (Variable length):
+ *      - The JSON string representing the message key, encoded as UTF-8.
+ *
+ *   3. PayloadTypeIndicator (1 byte):
+ *      - A single byte enum value representing the type of the payload (e.g., Uint8Array, String,
+ *        Object, ArrayBuffer, Blob).
+ *
+ *   4. Payload (Variable length):
+ *      - The actual payload data, which can vary in type and length depending on the PayloadType.
+ */
+
+import { blobToArrayBufferAsync } from '../utils/blobUtils';
+
+type MessageKeyTypeBase = string | object;
+type PayloadType = Uint8Array | string | number | null | undefined | object | ArrayBuffer | Blob;
+
+enum PayloadTypeIndicator {
+  Uint8Array = 1,
+  String = 2,
+  Number = 3,
+  Null = 4,
+  Undefined = 5,
+  Object = 6,
+  ArrayBuffer = 7,
+  Blob = 8,
+}
+
+interface MessageFrame<T extends MessageKeyTypeBase> {
+  messageKey: T;
+  payload?: PayloadType;
+}
+
+export class MessageFramePacker<T extends MessageKeyTypeBase> {
+  private textEncoder = new TextEncoder();
+  private textDecoder = new TextDecoder();
+
+  public pack({ messageKey, payload }: MessageFrame<T>): string | Uint8Array | Promise<Uint8Array> {
+    // Fast path to pack as string given `JSON.stringify` is fast.
+    if (this.isFastPathPayload(payload)) {
+      return JSON.stringify({ messageKey, payload });
+    }
+
+    // Slowest path for Blob returns a promise.
+    if (payload instanceof Blob) {
+      return new Promise(async (resolve, reject) => {
+        try {
+          const arrayBuffer = await blobToArrayBufferAsync(payload);
+          resolve(
+            this.packImpl(
+              { messageKey, payload: new Uint8Array(arrayBuffer) },
+              PayloadTypeIndicator.Blob
+            )
+          );
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }
+
+    // Slow path for other types returns a Uint8Array.
+    return this.packImpl({ messageKey, payload }, undefined);
+  }
+
+  public unpack(packedData: string | ArrayBuffer): MessageFrame<T> {
+    // Fast path to unpack as string given `JSON.parse` is fast.
+    if (typeof packedData === 'string') {
+      return JSON.parse(packedData);
+    }
+
+    // [0] messageKeyLength (4 bytes)
+    const messageKeyLengthView = new DataView(packedData, 0, 4);
+    const messageKeyLength = messageKeyLengthView.getUint32(0, false);
+
+    // [1] messageKey (variable length)
+    const messageKeyBytes = packedData.slice(4, 4 + messageKeyLength);
+    const messageKeyString = this.textDecoder.decode(messageKeyBytes);
+    const messageKey = JSON.parse(messageKeyString);
+
+    // [2] payloadTypeIndicator (1 byte)
+    const payloadTypeView = new DataView(packedData, 4 + messageKeyLength, 1);
+    const payloadType = payloadTypeView.getUint8(0);
+
+    // [3] payload (variable length)
+    const payloadBinary = packedData.slice(4 + messageKeyLength + 1);
+    const payload = this.deserializePayload(payloadBinary, payloadType);
+
+    return { messageKey, payload };
+  }
+
+  private isFastPathPayload(payload: PayloadType): boolean {
+    if (payload == null) {
+      return true;
+    }
+    const payloadType = typeof payload;
+    if (payloadType === 'string' || payloadType === 'number') {
+      return true;
+    }
+    if (payloadType === 'object' && payload.constructor === Object) {
+      return true;
+    }
+    return false;
+  }
+
+  private payloadToUint8Array(payload: PayloadType): Uint8Array {
+    if (payload instanceof Uint8Array) {
+      return payload;
+    } else if (typeof payload === 'string') {
+      return this.textEncoder.encode(payload);
+    } else if (typeof payload === 'number') {
+      const buffer = new ArrayBuffer(8);
+      const view = new DataView(buffer);
+      view.setFloat64(0, payload, false);
+      return new Uint8Array(buffer);
+    } else if (payload === null) {
+      return new Uint8Array(0);
+    } else if (payload === undefined) {
+      return new Uint8Array(0);
+    } else if (payload instanceof ArrayBuffer) {
+      return new Uint8Array(payload);
+    } else if (payload instanceof Blob) {
+      throw new Error('Blob is not supported in this callsite.');
+    } else {
+      return this.textEncoder.encode(JSON.stringify(payload));
+    }
+  }
+
+  private packImpl(
+    { messageKey, payload }: MessageFrame<T>,
+    payloadType: PayloadTypeIndicator | undefined
+  ): Promise<Uint8Array> | Uint8Array {
+    const messageKeyString = JSON.stringify(messageKey);
+    const messageKeyBytes = this.textEncoder.encode(messageKeyString);
+    const messageKeyLength = messageKeyBytes.length;
+    const payloadBinary = this.payloadToUint8Array(payload);
+
+    const totalLength = 4 + messageKeyLength + 1 + payloadBinary.byteLength;
+    const buffer = new ArrayBuffer(totalLength);
+    const packedArray = new Uint8Array(buffer);
+
+    // [0] messageKeyLength (4 bytes)
+    const messageKeyLengthView = new DataView(buffer, 0, 4);
+    messageKeyLengthView.setUint32(0, messageKeyLength, false);
+
+    // [1] messageKey (variable length)
+    packedArray.set(messageKeyBytes, 4);
+
+    // [2] payloadTypeIndicator (1 byte)
+    const payloadTypeView = new DataView(buffer, 4 + messageKeyLength, 1);
+    payloadTypeView.setUint8(0, payloadType ?? MessageFramePacker.getPayloadTypeIndicator(payload));
+
+    // [3] payload (variable length)
+    packedArray.set(payloadBinary, 4 + messageKeyLength + 1);
+
+    return packedArray;
+  }
+
+  private deserializePayload(
+    payloadBinary: ArrayBuffer,
+    payloadTypeIndicator: PayloadTypeIndicator
+  ): PayloadType {
+    switch (payloadTypeIndicator) {
+      case PayloadTypeIndicator.Uint8Array: {
+        return new Uint8Array(payloadBinary);
+      }
+      case PayloadTypeIndicator.String: {
+        return this.textDecoder.decode(payloadBinary);
+      }
+      case PayloadTypeIndicator.Number: {
+        const view = new DataView(payloadBinary);
+        return view.getFloat64(0, false);
+      }
+      case PayloadTypeIndicator.Null: {
+        return null;
+      }
+      case PayloadTypeIndicator.Undefined: {
+        return undefined;
+      }
+      case PayloadTypeIndicator.Object: {
+        const jsonString = this.textDecoder.decode(payloadBinary);
+        return JSON.parse(jsonString);
+      }
+      case PayloadTypeIndicator.ArrayBuffer: {
+        return payloadBinary;
+      }
+      case PayloadTypeIndicator.Blob: {
+        return new Blob([payloadBinary]);
+      }
+      default:
+        throw new Error('Unsupported payload type');
+    }
+  }
+
+  private static getPayloadTypeIndicator(payload: PayloadType): PayloadTypeIndicator {
+    if (payload instanceof Uint8Array) {
+      return PayloadTypeIndicator.Uint8Array;
+    } else if (typeof payload === 'string') {
+      return PayloadTypeIndicator.String;
+    } else if (typeof payload === 'number') {
+      return PayloadTypeIndicator.Number;
+    } else if (payload === null) {
+      return PayloadTypeIndicator.Null;
+    } else if (payload === undefined) {
+      return PayloadTypeIndicator.Undefined;
+    } else if (payload instanceof ArrayBuffer) {
+      return PayloadTypeIndicator.ArrayBuffer;
+    } else if (payload instanceof Blob) {
+      return PayloadTypeIndicator.Blob;
+    } else if (typeof payload === 'object') {
+      return PayloadTypeIndicator.Object;
+    } else {
+      throw new Error('Unsupported payload type');
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * A transport protocol version between the app and the webui.
+ * It shows a warning in handshaking stage if the version is different between the app and the webui.
+ * The value should be increased when the protocol is changed.
+ */
+export const PROTOCOL_VERSION = 1;

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

@@ -0,0 +1,10 @@
+/**
+ * The backing store for the WebSocket connection and reference count.
+ * This is used for connection multiplexing.
+ */
+export class WebSocketBackingStore {
+  constructor(
+    public ws: WebSocket | null = null,
+    public refCount: number = 0
+  ) {}
+}

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

@@ -0,0 +1,318 @@
+import type { DevToolsPluginClientOptions } from './devtools.types';
+
+export interface Options {
+  /**
+   * Reconnect interval in milliseconds.
+   * @default 1500
+   */
+  retriesInterval?: number;
+
+  /**
+   * The maximum number of retries.
+   * @default 200
+   */
+  maxRetries?: number;
+
+  /**
+   * The timeout in milliseconds for the WebSocket connecting.
+   */
+  connectTimeout?: number;
+
+  /**
+   * The error handler.
+   * @default throwing an error
+   */
+  onError?: (error: Error) => void;
+
+  /**
+   * The callback to be called when the WebSocket is reconnected.
+   * @default no-op
+   */
+  onReconnect?: (reason: string) => void;
+
+  /**
+   * The [`binaryType`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/binaryType).
+   */
+  binaryType?: DevToolsPluginClientOptions['websocketBinaryType'];
+}
+
+interface InternalEventListeners {
+  message?: Set<(event: WebSocketMessageEvent) => void>;
+  open?: Set<() => void>;
+  error?: Set<(event: WebSocketErrorEvent) => void>;
+  close?: Set<(event: WebSocketCloseEvent) => void>;
+  [eventName: string]: undefined | Set<(event: any) => void>;
+}
+
+export class WebSocketWithReconnect implements WebSocket {
+  private readonly retriesInterval: number;
+  private readonly maxRetries: number;
+  private readonly connectTimeout: number;
+  private readonly onError: (error: Error) => void;
+  private readonly onReconnect: (reason: string) => void;
+
+  private ws: WebSocket | null = null;
+  private retries = 0;
+  private connectTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
+  private isClosed = false;
+  private sendQueue: (string | ArrayBufferView | Blob | ArrayBufferLike)[] = [];
+  private lastCloseEvent: { code?: number; reason?: string; message?: string } | null = null;
+  private eventListeners: InternalEventListeners;
+
+  private readonly wsBinaryType?: Options['binaryType'];
+
+  constructor(
+    public readonly url: string,
+    options?: Options
+  ) {
+    this.retriesInterval = options?.retriesInterval ?? 1500;
+    this.maxRetries = options?.maxRetries ?? 200;
+    this.connectTimeout = options?.connectTimeout ?? 5000;
+    this.onError =
+      options?.onError ??
+      ((error) => {
+        throw error;
+      });
+    this.onReconnect = options?.onReconnect ?? (() => {});
+    this.wsBinaryType = options?.binaryType;
+    this.eventListeners = Object.create(null);
+
+    this.connect();
+  }
+
+  public close(code?: number, reason?: string) {
+    this.clearConnectTimeoutIfNeeded();
+    this.emitEvent(
+      'close',
+      (this.lastCloseEvent ?? {
+        code: code ?? 1000,
+        reason: reason ?? 'Explicit closing',
+        message: 'Explicit closing',
+      }) as WebSocketCloseEvent
+    );
+    this.lastCloseEvent = null;
+    this.isClosed = true;
+    this.eventListeners = Object.create(null);
+    this.sendQueue = [];
+    if (this.ws != null) {
+      const ws = this.ws;
+      this.ws = null;
+      this.wsClose(ws);
+    }
+  }
+
+  public addEventListener(event: 'message', listener: (event: WebSocketMessageEvent) => void): void;
+  public addEventListener(event: 'open', listener: () => void): void;
+  public addEventListener(event: 'error', listener: (event: WebSocketErrorEvent) => void): void;
+  public addEventListener(event: 'close', listener: (event: WebSocketCloseEvent) => void): void;
+  public addEventListener(event: string, listener: (event: any) => void) {
+    const listeners = this.eventListeners[event] || (this.eventListeners[event] = new Set());
+    listeners.add(listener);
+  }
+
+  public removeEventListener(event: string, listener: (event: any) => void) {
+    this.eventListeners[event]?.delete(listener);
+  }
+
+  //#region Internals
+
+  private connect() {
+    if (this.ws != null) {
+      return;
+    }
+    this.connectTimeoutHandle = setTimeout(this.handleConnectTimeout, this.connectTimeout);
+
+    this.ws = new WebSocket(this.url.toString());
+    if (this.wsBinaryType != null) {
+      this.ws.binaryType = this.wsBinaryType;
+    }
+    this.ws.addEventListener('message', this.handleMessage);
+    this.ws.addEventListener('open', this.handleOpen);
+    // @ts-ignore TypeScript expects (e: Event) => any, but we want (e: WebSocketErrorEvent) => any
+    this.ws.addEventListener('error', this.handleError);
+    this.ws.addEventListener('close', this.handleClose);
+  }
+
+  public send(data: string | ArrayBufferView | Blob | ArrayBufferLike): void {
+    if (this.isClosed) {
+      this.onError(new Error('Unable to send data: WebSocket is closed'));
+      return;
+    }
+
+    if (this.retries >= this.maxRetries) {
+      this.onError(
+        new Error(`Unable to send data: Exceeded max retries - retries[${this.retries}]`)
+      );
+      return;
+    }
+
+    const ws = this.ws;
+    if (ws != null && ws.readyState === WebSocket.OPEN) {
+      ws.send(data);
+    } else {
+      this.sendQueue.push(data);
+    }
+  }
+
+  private emitEvent(event: 'message', payload: WebSocketMessageEvent): void;
+  private emitEvent(event: 'open', payload?: void): void;
+  private emitEvent(event: 'error', payload: WebSocketErrorEvent): void;
+  private emitEvent(event: 'close', payload: WebSocketCloseEvent): void;
+  private emitEvent(event: string, payload: any) {
+    const listeners = this.eventListeners[event];
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(payload);
+      }
+    }
+  }
+
+  private handleOpen = () => {
+    this.clearConnectTimeoutIfNeeded();
+    this.lastCloseEvent = null;
+    this.emitEvent('open');
+
+    const sendQueue = this.sendQueue;
+    this.sendQueue = [];
+    for (const data of sendQueue) {
+      this.send(data);
+    }
+  };
+
+  private handleMessage = (event: WebSocketMessageEvent) => {
+    this.emitEvent('message', event);
+  };
+
+  private handleError = (event: WebSocketErrorEvent) => {
+    this.clearConnectTimeoutIfNeeded();
+    this.emitEvent('error', event);
+    this.reconnectIfNeeded(`WebSocket error - ${event.message}`);
+  };
+
+  private handleClose = (event: WebSocketCloseEvent) => {
+    this.clearConnectTimeoutIfNeeded();
+    this.lastCloseEvent = {
+      code: event.code,
+      reason: event.reason,
+      message: event.message,
+    };
+    this.reconnectIfNeeded(`WebSocket closed - code[${event.code}] reason[${event.reason}]`);
+  };
+
+  private handleConnectTimeout = () => {
+    this.reconnectIfNeeded('Timeout from connecting to the WebSocket');
+  };
+
+  private clearConnectTimeoutIfNeeded() {
+    if (this.connectTimeoutHandle != null) {
+      clearTimeout(this.connectTimeoutHandle);
+      this.connectTimeoutHandle = null;
+    }
+  }
+
+  private reconnectIfNeeded(reason: string) {
+    if (this.ws != null) {
+      this.wsClose(this.ws);
+      this.ws = null;
+    }
+    if (this.isClosed) {
+      return;
+    }
+
+    if (this.retries >= this.maxRetries) {
+      this.onError(new Error('Exceeded max retries'));
+      this.close();
+      return;
+    }
+
+    setTimeout(() => {
+      this.retries += 1;
+      this.connect();
+      this.onReconnect(reason);
+    }, this.retriesInterval);
+  }
+
+  private wsClose(ws: WebSocket) {
+    try {
+      ws.removeEventListener('message', this.handleMessage);
+      ws.removeEventListener('open', this.handleOpen);
+      ws.removeEventListener('close', this.handleClose);
+
+      // WebSocket throws errors if we don't handle the error event.
+      // Specifically when closing a ws in CONNECTING readyState,
+      // WebSocket will have `WebSocket was closed before the connection was established` error.
+      // We won't like to have the exception, so set a noop error handler.
+      ws.onerror = () => {};
+
+      ws.close();
+    } catch {}
+  }
+
+  public get readyState() {
+    // Only return closed if the WebSocket is explicitly closed or exceeds max retries.
+    if (this.isClosed) {
+      return WebSocket.CLOSED;
+    }
+
+    const readyState = this.ws?.readyState;
+    if (readyState === WebSocket.CLOSED) {
+      return WebSocket.CONNECTING;
+    }
+    return readyState ?? WebSocket.CONNECTING;
+  }
+
+  //#endregion
+
+  //#region WebSocket API proxy
+
+  public readonly CONNECTING = 0;
+  public readonly OPEN = 1;
+  public readonly CLOSING = 2;
+  public readonly CLOSED = 3;
+
+  public get binaryType() {
+    return this.ws?.binaryType ?? 'blob';
+  }
+
+  public get bufferedAmount() {
+    return this.ws?.bufferedAmount ?? 0;
+  }
+
+  public get extensions() {
+    return this.ws?.extensions ?? '';
+  }
+
+  public get protocol() {
+    return this.ws?.protocol ?? '';
+  }
+
+  public ping(): void {
+    return this.ws?.ping();
+  }
+
+  public dispatchEvent(event: Event) {
+    return this.ws?.dispatchEvent(event) ?? false;
+  }
+
+  //#endregion
+
+  //#regions Unsupported legacy properties
+
+  public set onclose(_value: ((e: WebSocketCloseEvent) => any) | null) {
+    throw new Error('Unsupported legacy property, use addEventListener instead');
+  }
+
+  public set onerror(_value: ((e: Event) => any) | null) {
+    throw new Error('Unsupported legacy property, use addEventListener instead');
+  }
+
+  public set onmessage(_value: ((e: WebSocketMessageEvent) => any) | null) {
+    throw new Error('Unsupported legacy property, use addEventListener instead');
+  }
+
+  public set onopen(_value: (() => any) | null) {
+    throw new Error('Unsupported legacy property, use addEventListener instead');
+  }
+
+  //#endregion
+}

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

@@ -0,0 +1,50 @@
+import type { WebSocketBackingStore } from './WebSocketBackingStore';
+
+/**
+ * The connection info for devtools plugins client.
+ */
+export interface ConnectionInfo {
+  /** Indicates the sender towards the devtools plugin. */
+  sender:
+    | 'app' // client running in the app environment.
+    | 'browser'; // client running in the browser environment.
+
+  /** Dev server address. */
+  devServer: string;
+
+  /** The plugin name. */
+  pluginName: string;
+
+  /**
+   * The backing store for the WebSocket connection. Exposed for testing.
+   * If not provided, the default singleton instance will be used.
+   * @hidden
+   */
+  wsStore?: WebSocketBackingStore;
+
+  /**
+   * The transport protocol version between the app and the webui.
+   */
+  protocolVersion: number;
+}
+
+/**
+ * Options for the devtools plugin client.
+ */
+export interface DevToolsPluginClientOptions {
+  /**
+   * The underlying WebSocket [`binaryType`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/binaryType).
+   */
+  websocketBinaryType?: 'arraybuffer' | 'blob';
+}
+
+/**
+ * The handshake messages for the devtools plugin client.
+ * @hidden
+ */
+export interface HandshakeMessageParams {
+  protocolVersion: number;
+  pluginName: string;
+  method: 'handshake' | 'terminateBrowserClient';
+  browserClientId: string;
+}

package/example/node_modules/expo/src/devtools/getConnectionInfo.native.ts

@@ -0,0 +1,18 @@
+/**
+ * Get the dev server address.
+ */
+
+import { PROTOCOL_VERSION } from './ProtocolVersion';
+import type { ConnectionInfo } from './devtools.types';
+
+export function getConnectionInfo(): Omit<ConnectionInfo, 'pluginName'> {
+  const getDevServer = require('react-native/Libraries/Core/Devtools/getDevServer').default;
+  const devServer = getDevServer()
+    .url.replace(/^https?:\/\//, '')
+    .replace(/\/?$/, '') as string;
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    sender: 'app',
+    devServer,
+  };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Get the dev server address.
+ */
+
+import { PROTOCOL_VERSION } from './ProtocolVersion';
+import type { ConnectionInfo } from './devtools.types';
+
+export function getConnectionInfo(): Omit<ConnectionInfo, 'pluginName'> {
+  const devServerQuery = new URLSearchParams(window.location.search).get('devServer');
+  const host = window.location.origin.replace(/^https?:\/\//, '');
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    sender: 'browser',
+    devServer: devServerQuery || host,
+  };
+}