@amabeth/repeating-wheel-picker 1.0.0 → 1.2.0

package/example/node_modules/expo/src/winter/fetch/FetchResponse.ts

@@ -0,0 +1,146 @@
+import { ExpoFetchModule } from './ExpoFetchModule';
+import type { NativeResponse } from './NativeRequest';
+
+const ConcreteNativeResponse = ExpoFetchModule.NativeResponse as typeof NativeResponse;
+export type AbortSubscriptionCleanupFunction = () => void;
+
+// FormData from react-native is not compatible with the web standard.
+// We need to extend it with the react-native FormData.
+type RNFormData = Awaited<ReturnType<globalThis.Response['formData']>>;
+type UniversalFormData = globalThis.FormData & RNFormData;
+
+/**
+ * A response implementation for the `fetch.Response` API.
+ */
+export class FetchResponse extends ConcreteNativeResponse implements Response {
+  private streamingState: 'none' | 'started' | 'completed' = 'none';
+  private bodyStream: ReadableStream<Uint8Array> | null = null;
+
+  constructor(private readonly abortCleanupFunction: AbortSubscriptionCleanupFunction) {
+    super();
+    this.addListener('readyForJSFinalization', this.finalize);
+  }
+
+  get body(): ReadableStream<Uint8Array> | null {
+    if (this.bodyStream == null) {
+      const response = this;
+
+      // This flag prevents enqueuing data after the stream is closed or canceled.
+      // Because it might be too late for the multithreaded native code to stop enqueuing data,
+      // we cannot simply rely on the native code to stop sending `didReceiveResponseData`.
+      let isControllerClosed = false;
+
+      this.bodyStream = new ReadableStream({
+        start(controller) {
+          if (response.streamingState === 'completed') {
+            return;
+          }
+          response.addListener('didReceiveResponseData', (data: Uint8Array) => {
+            if (!isControllerClosed) {
+              controller.enqueue(data);
+            }
+          });
+
+          response.addListener('didComplete', () => {
+            controller.close();
+            isControllerClosed = true;
+          });
+
+          response.addListener('didFailWithError', (error: string) => {
+            controller.error(new Error(error));
+            isControllerClosed = true;
+          });
+        },
+        async pull(controller) {
+          if (response.streamingState === 'none') {
+            const completedData = await response.startStreaming();
+            if (completedData != null) {
+              if (!isControllerClosed) {
+                controller.enqueue(completedData);
+                controller.close();
+                isControllerClosed = true;
+              }
+              response.streamingState = 'completed';
+            } else {
+              response.streamingState = 'started';
+            }
+          } else if (response.streamingState === 'completed') {
+            controller.close();
+            isControllerClosed = true;
+          }
+        },
+        cancel(reason) {
+          response.cancelStreaming(String(reason));
+          isControllerClosed = true;
+        },
+      });
+    }
+    return this.bodyStream;
+  }
+
+  get headers(): Headers {
+    return new Headers(this._rawHeaders);
+  }
+
+  get ok(): boolean {
+    return this.status >= 200 && this.status < 300;
+  }
+
+  public readonly type = 'default';
+
+  /**
+   * This method is not currently supported by react-native's Blob constructor.
+   */
+  async blob(): Promise<Blob> {
+    const buffer = await this.arrayBuffer();
+    return new Blob([buffer]);
+  }
+
+  async formData(): Promise<UniversalFormData> {
+    // Reference implementation:
+    // https://chromium.googlesource.com/chromium/src/+/ed9f0b5933cf5ffb413be1ca844de5be140514bf/third_party/blink/renderer/core/fetch/body.cc#120
+    const text = await this.text();
+    const searchParams = new URLSearchParams(text);
+    const formData = new FormData() as UniversalFormData;
+    searchParams.forEach((value, key) => {
+      formData.append(key, value);
+    });
+    return formData;
+  }
+
+  async json(): Promise<any> {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+
+  async bytes(): Promise<Uint8Array> {
+    return new Uint8Array(await this.arrayBuffer());
+  }
+
+  toString(): string {
+    return `FetchResponse: { status: ${this.status}, statusText: ${this.statusText}, url: ${this.url} }`;
+  }
+
+  toJSON(): object {
+    return {
+      status: this.status,
+      statusText: this.statusText,
+      redirected: this.redirected,
+      url: this.url,
+    };
+  }
+
+  clone(): Response {
+    throw new Error('Not implemented');
+  }
+
+  private finalize = (): void => {
+    this.removeListener('readyForJSFinalization', this.finalize);
+
+    this.abortCleanupFunction();
+
+    this.removeAllListeners('didReceiveResponseData');
+    this.removeAllListeners('didComplete');
+    this.removeAllListeners('didFailWithError');
+  };
+}

package/example/node_modules/expo/src/winter/fetch/NativeRequest.ts

@@ -0,0 +1,38 @@
+import type { SharedObject } from 'expo-modules-core';
+
+export type NativeHeadersType = [string, string][];
+
+export declare class NativeRequest extends SharedObject {
+  public start(
+    url: string,
+    requestInit: NativeRequestInit,
+    requestBody: Uint8Array | null
+  ): Promise<NativeResponse>;
+  public cancel(): void;
+}
+
+export interface NativeRequestInit {
+  credentials?: RequestCredentials; // same-origin is not supported
+  headers?: NativeHeadersType;
+  method?: string;
+}
+
+export type NativeResponseEvents = {
+  didReceiveResponseData(data: Uint8Array): void;
+  didComplete(): void;
+  didFailWithError(error: string): void;
+  readyForJSFinalization(): void;
+};
+
+export declare class NativeResponse extends SharedObject<NativeResponseEvents> {
+  readonly bodyUsed: boolean;
+  readonly _rawHeaders: NativeHeadersType;
+  readonly status: number;
+  readonly statusText: string;
+  readonly url: string;
+  readonly redirected: boolean;
+  startStreaming(): Promise<Uint8Array | null>;
+  cancelStreaming(reason: string): void;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+}

package/example/node_modules/expo/src/winter/fetch/RequestUtils.ts

@@ -0,0 +1,124 @@
+import { type NativeHeadersType } from './NativeRequest';
+import { convertFormDataAsync } from './convertFormData';
+import { blobToArrayBufferAsync } from '../../utils/blobUtils';
+
+/**
+ * convert a ReadableStream to a Uint8Array
+ */
+export async function convertReadableStreamToUint8ArrayAsync(
+  stream: ReadableStream<Uint8Array>
+): Promise<Uint8Array> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let totalLength = 0;
+
+  // Read all chunks from the stream
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    totalLength += value.length;
+  }
+
+  // Concatenate all chunks into a single Uint8Array
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+
+  return result;
+}
+
+/**
+ * Normalize a BodyInit object to a Uint8Array for NativeRequest
+ */
+export async function normalizeBodyInitAsync(
+  body: BodyInit | null | undefined
+): Promise<{ body: Uint8Array | null; overriddenHeaders?: NativeHeadersType }> {
+  if (body == null) {
+    return { body: null };
+  }
+
+  if (typeof body === 'string') {
+    const encoder = new TextEncoder();
+    return { body: encoder.encode(body) };
+  }
+
+  if (body instanceof ArrayBuffer) {
+    return { body: new Uint8Array(body) };
+  }
+
+  if (ArrayBuffer.isView(body)) {
+    return { body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength) };
+  }
+
+  if (body instanceof Blob) {
+    return {
+      body: new Uint8Array(await blobToArrayBufferAsync(body)),
+      overriddenHeaders: [['Content-Type', body.type]],
+    };
+  }
+
+  if (body instanceof URLSearchParams) {
+    const encoder = new TextEncoder();
+    return { body: encoder.encode(body.toString()) };
+  }
+
+  if (body instanceof ReadableStream) {
+    const result = await convertReadableStreamToUint8ArrayAsync(body);
+    return { body: result };
+  }
+
+  if (body instanceof FormData) {
+    const { body: result, boundary } = await convertFormDataAsync(body);
+
+    return {
+      body: result,
+      overriddenHeaders: [['Content-Type', `multipart/form-data; boundary=${boundary}`]],
+    };
+  }
+
+  throw new TypeError('Unsupported BodyInit type');
+}
+
+/**
+ * Normalize a HeadersInit object to an array of key-value tuple for NativeRequest.
+ */
+export function normalizeHeadersInit(headers: HeadersInit | null | undefined): NativeHeadersType {
+  if (headers == null) {
+    return [];
+  }
+  if (Array.isArray(headers)) {
+    return headers;
+  }
+  if (headers instanceof Headers) {
+    const results: [string, string][] = [];
+    headers.forEach((value: any, key: any) => {
+      results.push([key, value]);
+    });
+    return results;
+  }
+  return Object.entries(headers);
+}
+
+/**
+ * Create a new header array by overriding the existing headers with new headers (by header key).
+ */
+export function overrideHeaders(
+  headers: NativeHeadersType,
+  newHeaders: NativeHeadersType
+): NativeHeadersType {
+  const newKeySet = new Set(newHeaders.map(([key]) => key.toLocaleLowerCase()));
+  const result: NativeHeadersType = [];
+  for (const [key, value] of headers) {
+    if (!newKeySet.has(key.toLocaleLowerCase())) {
+      result.push([key, value]);
+    }
+  }
+  for (const [key, value] of newHeaders) {
+    result.push([key, value]);
+  }
+  return result;
+}

package/example/node_modules/expo/src/winter/fetch/convertFormData.ts

@@ -0,0 +1,92 @@
+import { blobToArrayBufferAsync } from '../../utils/blobUtils';
+
+/**
+ * Convert FormData to Uint8Array with a boundary
+ *
+ * `uri` is not supported for React Native's FormData.
+ * `blob` is not supported for standard FormData.
+ */
+export async function convertFormDataAsync(
+  formData: FormData,
+  boundary: string = createBoundary()
+): Promise<{ body: Uint8Array; boundary: string }> {
+  // @ts-expect-error: React Native's FormData is not compatible with the web's FormData
+  if (typeof formData.getParts !== 'function') {
+    throw new Error('Unsupported FormData implementation');
+  }
+  // @ts-expect-error: React Native's FormData is not 100% compatible with ours
+  const parts: ExpoFormDataPart[] = formData.getParts();
+
+  const results: (Uint8Array | string)[] = [];
+  for (const entry of parts) {
+    results.push(`--${boundary}\r\n`);
+    for (const [headerKey, headerValue] of Object.entries(entry.headers)) {
+      results.push(`${headerKey}: ${headerValue}\r\n`);
+    }
+    results.push(`\r\n`);
+    if ('string' in entry) {
+      results.push(entry.string);
+    } else if ('file' in entry) {
+      results.push(entry.file.bytes());
+    } else if ('blob' in entry) {
+      results.push(new Uint8Array(await blobToArrayBufferAsync(entry.blob)));
+    } else if (entry._data?.blobId != null) {
+      // When `FormData.getParts()` is called, React Native will use the spread syntax to copy the object and lose the Blob type info.
+      // We should find the original Blob instance from the `FormData._parts` internal properties.
+      // @ts-expect-error: react-native's proprietary Blob type
+      const formDatum = formData._parts?.find(
+        ([_name, value]: [name: string, value: any]) => value.data?.blobId === entry._data.blobId
+      );
+      if (formDatum == null) {
+        throw new Error('Cannot find the original Blob instance from FormData');
+      }
+      if (!(formDatum[1] instanceof Blob)) {
+        throw new Error('Unexpected value type for Blob entry in FormData');
+      }
+      results.push(new Uint8Array(await blobToArrayBufferAsync(formDatum[1])));
+    } else {
+      throw new Error('Unsupported FormDataPart implementation');
+    }
+    results.push(`\r\n`);
+  }
+
+  results.push(`--${boundary}--\r\n`);
+  const arrays = results.map((result) => {
+    if (typeof result === 'string') {
+      // @ts-ignore: TextEncoder is not available in all environments
+      return new TextEncoder().encode(result);
+    } else {
+      return result;
+    }
+  }) as Uint8Array[];
+
+  return { body: joinUint8Arrays(arrays), boundary };
+}
+
+/**
+ * Create mutipart boundary
+ */
+export function createBoundary(): string {
+  const boundaryChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let boundary = '----ExpoFetchFormBoundary';
+  for (let i = 0; i < 16; i++) {
+    boundary += boundaryChars.charAt(Math.floor(Math.random() * boundaryChars.length));
+  }
+  return boundary;
+}
+
+/**
+ * Merge Uint8Arrays into a single Uint8Array
+ */
+export function joinUint8Arrays(arrays: Uint8Array[]): Uint8Array {
+  const totalLength: number = arrays.reduce((acc: number, arr: Uint8Array) => acc + arr.length, 0);
+  const result: Uint8Array = new Uint8Array(totalLength);
+
+  let offset: number = 0;
+  arrays.forEach((array: Uint8Array) => {
+    result.set(array, offset);
+    offset += array.length;
+  });
+
+  return result;
+}

package/example/node_modules/expo/src/winter/fetch/fetch.ts

@@ -0,0 +1,59 @@
+import { ExpoFetchModule } from './ExpoFetchModule';
+import { FetchError } from './FetchErrors';
+import { FetchResponse, type AbortSubscriptionCleanupFunction } from './FetchResponse';
+import { NativeRequest, NativeRequestInit } from './NativeRequest';
+import { normalizeBodyInitAsync, normalizeHeadersInit, overrideHeaders } from './RequestUtils';
+import type { FetchRequestInit } from './fetch.types';
+
+// TODO(@kitten): Do we really want to use our own types for web standards?
+export async function fetch(url: string, init?: FetchRequestInit): Promise<FetchResponse> {
+  let abortSubscription: AbortSubscriptionCleanupFunction | null = null;
+
+  const response = new FetchResponse(() => {
+    abortSubscription?.();
+  });
+  const request = new ExpoFetchModule.NativeRequest(response) as NativeRequest;
+
+  let headers = normalizeHeadersInit(init?.headers);
+
+  const { body: requestBody, overriddenHeaders } = await normalizeBodyInitAsync(init?.body);
+  if (overriddenHeaders) {
+    headers = overrideHeaders(headers, overriddenHeaders);
+  }
+
+  const nativeRequestInit: NativeRequestInit = {
+    credentials: init?.credentials ?? 'include',
+    headers,
+    method: init?.method ?? 'GET',
+  };
+
+  if (init?.signal && init.signal.aborted) {
+    throw new FetchError('The operation was aborted.');
+  }
+  abortSubscription = addAbortSignalListener(init?.signal, () => {
+    request.cancel();
+  });
+  try {
+    await request.start(url, nativeRequestInit, requestBody);
+  } catch (e: unknown) {
+    if (e instanceof Error) {
+      throw FetchError.createFromError(e);
+    } else {
+      throw new FetchError(String(e));
+    }
+  }
+  return response;
+}
+
+/**
+ * A wrapper of `AbortSignal.addEventListener` that returns a cleanup function.
+ */
+function addAbortSignalListener(
+  signal: AbortSignal | undefined,
+  listener: Parameters<AbortSignal['addEventListener']>[1]
+): AbortSubscriptionCleanupFunction {
+  signal?.addEventListener('abort', listener);
+  return () => {
+    signal?.removeEventListener('abort', listener);
+  };
+}

package/example/node_modules/expo/src/winter/fetch/fetch.types.ts

@@ -0,0 +1,17 @@
+/**
+ * A fetch RequestInit compatible structure.
+ */
+export interface FetchRequestInit {
+  body?: BodyInit;
+  credentials?: RequestCredentials; // same-origin is not supported
+  headers?: HeadersInit;
+  method?: string;
+  signal?: AbortSignal;
+
+  // Not supported fields
+  integrity?: string;
+  keepalive?: boolean;
+  mode?: RequestMode;
+  referrer?: string;
+  window?: any;
+}

package/example/node_modules/expo/src/winter/fetch/fetch.web.ts

@@ -0,0 +1 @@
+export const fetch = globalThis.fetch;

package/example/node_modules/expo/src/winter/fetch/index.ts

@@ -0,0 +1,2 @@
+export * from './fetch';
+export * from './fetch.types';

package/example/node_modules/expo/src/winter/index.ts

@@ -0,0 +1 @@
+import './runtime';

package/example/node_modules/expo/src/winter/runtime.native.ts

@@ -0,0 +1,41 @@
+// This file configures the runtime environment to increase compatibility with WinterCG.
+// https://wintercg.org/
+
+// @ts-ignore: PolyfillFunctions does not have types exported
+import { polyfillGlobal as installGlobal } from 'react-native/Libraries/Utilities/PolyfillFunctions';
+
+import { installFormDataPatch } from './FormData';
+// Add a well-known shared symbol that doesn't show up in iteration or inspection
+// this can be used to detect if the global object abides by the Expo team's documented
+// built-in requirements.
+const BUILTIN_SYMBOL = Symbol.for('expo.builtin');
+
+function addBuiltinSymbol(obj: object) {
+  Object.defineProperty(obj, BUILTIN_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+  });
+  return obj;
+}
+
+function install(name: string, getValue: () => any) {
+  installGlobal(name, () => addBuiltinSymbol(getValue()));
+}
+
+// https://encoding.spec.whatwg.org/#textdecoder
+install('TextDecoder', () => require('./TextDecoder').TextDecoder);
+// https://url.spec.whatwg.org/#url
+install('URL', () => require('./url').URL);
+// https://url.spec.whatwg.org/#urlsearchparams
+install('URLSearchParams', () => require('./url').URLSearchParams);
+// https://streams.spec.whatwg.org/#rs
+// ReadableStream is injected by Metro as a global
+
+install('__ExpoImportMetaRegistry', () => require('./ImportMetaRegistry').ImportMetaRegistry);
+
+installFormDataPatch(FormData);
+
+// Polyfill async iterator symbol for Hermes.
+// @ts-expect-error: readonly property only applies when the engine supports it
+Symbol.asyncIterator ??= Symbol.for('Symbol.asyncIterator');

package/example/node_modules/expo/src/winter/runtime.ts

@@ -0,0 +1,5 @@
+Object.defineProperty(globalThis, '__ExpoImportMetaRegistry', {
+  value: require('./ImportMetaRegistry').ImportMetaRegistry,
+  enumerable: false,
+  writable: true,
+});

package/example/node_modules/expo/src/winter/url.ts

@@ -0,0 +1,116 @@
+/**
+ * Copyright © 2023-present 650 Industries, Inc. (aka Expo)
+ * Copyright © 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.
+ */
+
+// This file should not import `react-native` in order to remain self-contained.
+
+/// <reference path="../ts-declarations/whatwg-url-without-unicode.d.ts" />
+import { URL, URLSearchParams } from 'whatwg-url-without-unicode';
+
+declare namespace globalThis {
+  const RN$Bridgeless: undefined | boolean;
+  const nativeModuleProxy: Record<string, unknown>;
+  function __turboModuleProxy(name: string): unknown;
+}
+
+// TODO(@kitten): Provide BlobModule types matching native module
+interface NativeBlobModule {
+  BLOB_URI_SCHEME: string;
+  BLOB_URI_HOST: string;
+}
+interface TurboBlobModule {
+  getConstants(): {
+    BLOB_URI_SCHEME: string;
+    BLOB_URI_HOST: string;
+  };
+}
+
+let isSetup = false;
+let BLOB_URL_PREFIX: string | null = null;
+
+function getBlobUrlPrefix() {
+  if (isSetup) return BLOB_URL_PREFIX;
+  isSetup = true;
+  // if iOS: let BLOB_URL_PREFIX = 'blob:'
+
+  // Pull the blob module without importing React Native.
+  const BlobModule =
+    globalThis.RN$Bridgeless !== true
+      ? // Legacy RN implementation
+        (globalThis.nativeModuleProxy['BlobModule'] as NativeBlobModule)
+      : // Newer RN implementation
+        (globalThis.__turboModuleProxy('BlobModule') as TurboBlobModule);
+
+  const constants = 'BLOB_URI_SCHEME' in BlobModule ? BlobModule : BlobModule.getConstants();
+
+  if (constants && typeof constants.BLOB_URI_SCHEME === 'string') {
+    BLOB_URL_PREFIX = encodeURIComponent(constants.BLOB_URI_SCHEME) + ':';
+    if (typeof constants.BLOB_URI_HOST === 'string') {
+      BLOB_URL_PREFIX += `//${encodeURIComponent(constants.BLOB_URI_HOST)}/`;
+    }
+  }
+  return BLOB_URL_PREFIX;
+}
+
+declare module 'whatwg-url-without-unicode' {
+  // TODO(@kitten): Clarify where this came from
+  type BlobLike = Blob & { data?: { blobId: string; offset: number } };
+
+  interface URLConstructor {
+    createObjectURL(blob: BlobLike): string;
+    revokeObjectURL(url: URL): void;
+    canParse(url: string, base?: string): boolean;
+  }
+}
+
+/**
+ * To allow Blobs be accessed via `content://` URIs,
+ * you need to register `BlobProvider` as a ContentProvider in your app's `AndroidManifest.xml`:
+ *
+ * ```xml
+ * <manifest>
+ *   <application>
+ *     <provider
+ *       android:name="com.facebook.react.modules.blob.BlobProvider"
+ *       android:authorities="@string/blob_provider_authority"
+ *       android:exported="false"
+ *     />
+ *   </application>
+ * </manifest>
+ * ```
+ * And then define the `blob_provider_authority` string in `res/values/strings.xml`.
+ * Use a dotted name that's entirely unique to your app:
+ *
+ * ```xml
+ * <resources>
+ *   <string name="blob_provider_authority">your.app.package.blobs</string>
+ * </resources>
+ * ```
+ */
+URL.createObjectURL = function createObjectURL(blob) {
+  if (getBlobUrlPrefix() == null) {
+    throw new Error('Cannot create URL for blob');
+  }
+  return `${getBlobUrlPrefix()}${encodeURIComponent(blob.data!.blobId)}?offset=${encodeURIComponent(
+    blob.data!.offset
+  )}&size=${encodeURIComponent(blob.size)}`;
+};
+
+URL.revokeObjectURL = function revokeObjectURL(_url) {
+  // Do nothing.
+};
+
+URL.canParse = function canParse(url: string, base?: string): boolean {
+  try {
+    URL(url, base);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export { URL, URLSearchParams };

package/example/node_modules/expo/types/global.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+
+// Extend the NodeJS namespace
+declare namespace NodeJS {
+  interface ProcessEnv {
+    readonly NODE_ENV: 'development' | 'production' | 'test';
+  }
+}
+
+// Create types for CSS modules
+declare module '*.module.css' {
+  /** **Experimental:** Import styles that can be used with `react-native-web` components, using the `style` prop. */
+  export const unstable_styles: { readonly [key: string]: object };
+
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.sass' {
+  /** **Experimental:** Import styles that can be used with `react-native-web` components, using the `style` prop. */
+  export const unstable_styles: { readonly [key: string]: object };
+
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.scss' {
+  /** **Experimental:** Import styles that can be used with `react-native-web` components, using the `style` prop. */
+  export const unstable_styles: { readonly [key: string]: object };
+
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+// Allow for css imports, but don't export anything
+declare module '*.css';
+declare module '*.sass';
+declare module '*.scss';