@amabeth/repeating-wheel-picker 1.1.0 → 1.2.0

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

@@ -0,0 +1,53 @@
+import { useState, useEffect } from 'react';
+
+import { DevToolsPluginClient } from './DevToolsPluginClient';
+import { getDevToolsPluginClientAsync } from './DevToolsPluginClientFactory';
+import type { DevToolsPluginClientOptions } from './devtools.types';
+
+export { getDevToolsPluginClientAsync, DevToolsPluginClient };
+export type { DevToolsPluginClientOptions };
+// Export the EventSubscription type if people need to use explicit type from `addMessageListener`
+export type { EventSubscription } from './DevToolsPluginClient';
+export { setEnableLogging } from './logger';
+
+/**
+ * A React hook to get the DevToolsPluginClient instance.
+ */
+export function useDevToolsPluginClient(
+  pluginName: string,
+  options?: DevToolsPluginClientOptions
+): DevToolsPluginClient | null {
+  const [client, setClient] = useState<DevToolsPluginClient | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    async function setup() {
+      try {
+        const client = await getDevToolsPluginClientAsync(pluginName, options);
+        setClient(client);
+      } catch (e: any) {
+        setError(new Error('Failed to setup client from useDevToolsPluginClient: ' + e.toString()));
+      }
+    }
+
+    async function teardown() {
+      try {
+        await client?.closeAsync();
+      } catch (e: any) {
+        setError(
+          new Error('Failed to teardown client from useDevToolsPluginClient: ' + e.toString())
+        );
+      }
+    }
+
+    setup();
+    return () => {
+      teardown();
+    };
+  }, [pluginName]);
+
+  if (error != null) {
+    throw error;
+  }
+  return client;
+}

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

@@ -0,0 +1,29 @@
+let enableLogging = false;
+
+export function log(...params: Parameters<typeof console.log>) {
+  if (enableLogging) {
+    console.log(...params);
+  }
+}
+
+export function debug(...params: Parameters<typeof console.debug>) {
+  if (enableLogging) {
+    console.debug(...params);
+  }
+}
+
+export function info(...params: Parameters<typeof console.info>) {
+  if (enableLogging) {
+    console.info(...params);
+  }
+}
+
+export function warn(...params: Parameters<typeof console.info>) {
+  if (enableLogging) {
+    console.warn(...params);
+  }
+}
+
+export function setEnableLogging(enabled: boolean) {
+  enableLogging = enabled;
+}

package/example/node_modules/expo/src/dom/base.ts

@@ -0,0 +1,62 @@
+let cachedBaseUrl: string | null = null;
+
+/**
+ * Get the base URL for the DOM Components HTML
+ */
+export function getBaseURL(): string {
+  if (cachedBaseUrl != null) {
+    return cachedBaseUrl;
+  }
+
+  // Serving from updates
+  const updatesBaseUrl = getUpdatesBaseURL();
+  if (updatesBaseUrl != null) {
+    cachedBaseUrl = updatesBaseUrl;
+    return cachedBaseUrl;
+  }
+
+  if (process.env.EXPO_OS === 'web') {
+    cachedBaseUrl = process.env.EXPO_BASE_URL ?? '';
+    return cachedBaseUrl;
+  }
+
+  // Serving from local production
+  if (process.env.NODE_ENV === 'production') {
+    if (process.env.EXPO_OS === 'android') {
+      cachedBaseUrl = 'file:///android_asset/www.bundle';
+    } else if (process.env.EXPO_OS === 'ios') {
+      cachedBaseUrl = 'www.bundle';
+    } else {
+      cachedBaseUrl = process.env.EXPO_BASE_URL ?? '';
+    }
+    return cachedBaseUrl;
+  }
+
+  // Serving from local dev server
+  const getDevServer = require('react-native/Libraries/Core/Devtools/getDevServer').default;
+  const devServer = getDevServer();
+  cachedBaseUrl = new URL('/_expo/@dom', devServer.url).toString();
+  return cachedBaseUrl;
+}
+
+/**
+ * Get the base URL for the DOM Components when serving from updates
+ */
+function getUpdatesBaseURL(): string | null {
+  const ExpoUpdates = globalThis.expo?.modules?.['ExpoUpdates'] as
+    | import('expo-updates').ExpoUpdatesModule
+    | undefined;
+  const updatesIsInstalledAndEnabled = ExpoUpdates?.isEnabled ?? false;
+  const updatesIsEmbeddedLaunch = ExpoUpdates?.isEmbeddedLaunch ?? false;
+  const shouldServeDomFromUpdates = updatesIsInstalledAndEnabled && !updatesIsEmbeddedLaunch;
+  // If updates is installed and enabled, and we're not running from an embedded launch, we should serve the DOM Components from the `.expo-internal` directory
+  if (shouldServeDomFromUpdates) {
+    const localAssets = ExpoUpdates?.localAssets ?? {};
+    const anyLocalAsset = Object.values(localAssets)[0];
+    if (anyLocalAsset) {
+      // Try to get the `.expo-internal` directory from the first local asset
+      return anyLocalAsset.slice(0, anyLocalAsset.lastIndexOf('/'));
+    }
+  }
+  return null;
+}

package/example/node_modules/expo/src/dom/dom-entry.tsx

@@ -0,0 +1,128 @@
+// Entry file for a DOM Component.
+import '@expo/metro-runtime';
+
+import { withErrorOverlay } from '@expo/metro-runtime/error-overlay';
+import React from 'react';
+
+import { JSONValue } from './dom.types';
+import { addEventListener, getActionsObject } from './marshal';
+import registerRootComponent from '../launch/registerRootComponent';
+
+interface MarshalledProps {
+  name: string[];
+  props: Record<string, JSONValue>;
+  [key: string]: undefined | JSONValue;
+}
+
+interface WindowType {
+  $$EXPO_INITIAL_PROPS?: MarshalledProps;
+}
+
+declare let window: WindowType;
+
+const ACTIONS = getActionsObject!();
+
+function isBaseObject(obj: any) {
+  if (Object.prototype.toString.call(obj) !== '[object Object]') {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto === null) {
+    return true;
+  }
+  return proto === Object.prototype;
+}
+
+function isErrorShaped(error: any): error is Error {
+  return (
+    error &&
+    typeof error === 'object' &&
+    typeof error.name === 'string' &&
+    typeof error.message === 'string'
+  );
+}
+
+/**
+ * After we throw this error, any number of tools could handle it.
+ * This check ensures the error is always in a reasonable state before surfacing it to the runtime.
+ */
+function convertError(error: any) {
+  if (isErrorShaped(error)) {
+    return error;
+  }
+
+  if (process.env.NODE_ENV === 'development') {
+    if (error == null) {
+      return new Error('A null/undefined error was thrown.');
+    }
+  }
+
+  if (isBaseObject(error)) {
+    return new Error(JSON.stringify(error));
+  }
+
+  return new Error(String(error));
+}
+
+export function registerDOMComponent(AppModule: any) {
+  function DOMComponentRoot(props: Record<string, unknown>) {
+    // Props listeners
+    const [marshalledProps, setProps] = React.useState(() => {
+      if (typeof window.$$EXPO_INITIAL_PROPS === 'undefined') {
+        throw new Error(
+          'Initial props are not defined. This is a bug in the DOM Component runtime.'
+        );
+      }
+      return window.$$EXPO_INITIAL_PROPS;
+    });
+
+    React.useEffect(() => {
+      const remove = addEventListener!((msg) => {
+        if (msg.type === '$$props') {
+          setProps(msg.data as MarshalledProps);
+        }
+      });
+      return () => {
+        remove();
+      };
+    }, [setProps]);
+
+    const proxyActions = React.useMemo(() => {
+      if (!marshalledProps.names) return {};
+      // Create a named map { [name: string]: ProxyFunction }
+      // TODO(@kitten): Unclear how this is typed or shaped
+      return Object.fromEntries(
+        (marshalledProps.names as string[]).map((key: string) => {
+          return [key, ACTIONS[key]];
+        })
+      );
+    }, [marshalledProps.names]);
+
+    return <AppModule {...props} {...(marshalledProps.props || {})} {...proxyActions} />;
+  }
+
+  try {
+    React.startTransition(() => {
+      if (process.env.NODE_ENV !== 'production') {
+        registerRootComponent(withErrorOverlay(DOMComponentRoot));
+      } else {
+        registerRootComponent(DOMComponentRoot);
+      }
+    });
+  } catch (e) {
+    const error = convertError(e);
+    // Prevent the app from throwing confusing:
+    //  ERROR  Invariant Violation: "main" has not been registered. This can happen if:
+    // * Metro (the local dev server) is run from the wrong folder. Check if Metro is running, stop it and restart it in the current project.
+    // * A module failed to load due to an error and `AppRegistry.registerComponent` wasn't called.
+    registerRootComponent(() => React.createElement('div'));
+
+    console.error(error);
+    console.error(`A runtime error has occurred while rendering the root component.`);
+
+    // Give React a tick to render before throwing.
+    setTimeout(() => {
+      throw error;
+    });
+  }
+}

package/example/node_modules/expo/src/dom/dom-hooks.ts

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useImperativeHandle, type DependencyList, type Ref } from 'react';
+
+import type { DOMImperativeFactory } from './dom.types';
+import { REGISTER_DOM_IMPERATIVE_HANDLE_PROPS } from './injection';
+
+declare namespace globalThis {
+  let _domRefProxy: undefined | unknown;
+}
+
+/**
+ * A React `useImperativeHandle` like hook for DOM components.
+ *
+ */
+export function useDOMImperativeHandle<T extends DOMImperativeFactory>(
+  ref: Ref<T>,
+  init: () => T,
+  deps?: DependencyList
+) {
+  // @ts-expect-error: Added via react-native-webview
+  const isTargetWeb = typeof window.ReactNativeWebView === 'undefined';
+
+  const stubHandlerFactory = useCallback(() => ({}) as T, deps ?? []);
+
+  // This standard useImperativeHandle hook is serving for web
+  useImperativeHandle(ref, isTargetWeb ? init : stubHandlerFactory, deps);
+
+  // This `globalThis._domRefProxy` is serving for native
+  useEffect(() => {
+    if (!isTargetWeb) {
+      globalThis._domRefProxy = init();
+      // TODO(@kitten): Type `ReactNativeWebView` and the message data
+      // @ts-expect-error: Added via react-native-webview
+      window.ReactNativeWebView.postMessage(
+        JSON.stringify({
+          type: REGISTER_DOM_IMPERATIVE_HANDLE_PROPS,
+          data: Object.keys(globalThis._domRefProxy as any),
+        })
+      );
+    }
+    return () => {
+      if (!isTargetWeb) {
+        globalThis._domRefProxy = undefined;
+      }
+    };
+  }, deps);
+}

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

@@ -0,0 +1,8 @@
+// Native file
+
+export * from './dom-hooks';
+export type { DOMProps, DOMImperativeFactory } from './dom.types';
+
+// TODO: Maybe this could be a bundler global instead.
+/** @returns `true` when the current JS running in a DOM Component environment. */
+export const IS_DOM = false;

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

@@ -0,0 +1,39 @@
+import type { RNWebView, RNWebViewProps } from './webview/RNWebView';
+
+export type JSONValue = boolean | number | string | null | JSONArray | JSONObject;
+
+export interface JSONArray extends Array<JSONValue> {}
+
+export interface JSONObject {
+  [key: string]: JSONValue | undefined;
+}
+
+export type BridgeMessage<TData extends JSONValue> = {
+  type: string;
+  data: TData;
+};
+
+/**
+ * The return type of the init function for `useDOMImperativeHandle`.
+ */
+export interface DOMImperativeFactory {
+  [key: string]: (...args: JSONValue[]) => void;
+}
+
+type RNWebViewRef = RNWebView;
+export type WebViewRef = RNWebViewRef;
+export type WebViewProps = RNWebViewProps;
+
+export interface DOMProps extends Omit<RNWebViewProps, 'source'> {
+  /**
+   * Whether to resize the native WebView size based on the DOM content size.
+   * @default false
+   */
+  matchContents?: boolean;
+
+  /**
+   * Whether to use the `@expo/dom-webview` as the underlying WebView implementation.
+   * @default false
+   */
+  useExpoDOMWebView?: boolean;
+}

package/example/node_modules/expo/src/dom/dom.web.ts

@@ -0,0 +1,6 @@
+export * from './dom-hooks';
+
+// TODO: Maybe this could be a bundler global instead.
+export const IS_DOM =
+  // @ts-expect-error: Added via react-native-webview
+  typeof ReactNativeWebView !== 'undefined';

package/example/node_modules/expo/src/dom/global-events.ts

@@ -0,0 +1,16 @@
+import { BridgeMessage, JSONValue } from './dom.types';
+
+const globalListeners = new Set<(message: BridgeMessage<any>) => void>();
+
+export function _emitGlobalEvent<TData extends JSONValue>(message: BridgeMessage<TData>) {
+  globalListeners.forEach((listener) => listener(message));
+}
+
+export const addGlobalDomEventListener = <TData extends JSONValue>(
+  onSubscribe: (message: BridgeMessage<TData>) => void
+): (() => void) => {
+  globalListeners.add(onSubscribe);
+  return () => {
+    globalListeners.delete(onSubscribe);
+  };
+};

package/example/node_modules/expo/src/dom/injection.ts

@@ -0,0 +1,42 @@
+import type { BridgeMessage } from './dom.types';
+
+export const NATIVE_ACTION = '$$native_action';
+export const NATIVE_ACTION_RESULT = '$$native_action_result';
+export const DOM_EVENT = '$$dom_event';
+export const MATCH_CONTENTS_EVENT = '$$match_contents_event';
+export const REGISTER_DOM_IMPERATIVE_HANDLE_PROPS = '$$register_dom_imperative_handle_props';
+
+export const getInjectEventScript = <T extends BridgeMessage<any>>(detail: T) => {
+  return `;(function() {
+  try {
+  window.dispatchEvent(new CustomEvent("${DOM_EVENT}",${JSON.stringify({ detail })}));
+  } catch (e) {}
+  })();
+  true;`;
+};
+
+export function getInjectBodySizeObserverScript() {
+  return `;(function observeDocumentBodySize() {
+  window.addEventListener('DOMContentLoaded', () => {
+    new ResizeObserver(entries => {
+      const { width, height } = entries[0].contentRect;
+      window.ReactNativeWebView?.postMessage(JSON.stringify({
+        type: '${MATCH_CONTENTS_EVENT}',
+        data: {
+          width,
+          height,
+        },
+      }));
+    })
+    .observe(document.body);
+    window.ReactNativeWebView?.postMessage(JSON.stringify({
+      type: '${MATCH_CONTENTS_EVENT}',
+      data: {
+        width: document.body.clientWidth,
+        height: document.body.clientHeight,
+      },
+    }));
+  });
+  })();
+  true;`;
+}

package/example/node_modules/expo/src/dom/internal.ts

@@ -0,0 +1,5 @@
+export { default as WebView } from './webview-wrapper';
+
+// Skip all dom-only functions to give 'undefined is not a function' errors.
+export const registerDOMComponent: undefined | typeof import('./dom-entry').registerDOMComponent =
+  undefined;

package/example/node_modules/expo/src/dom/internal.web.ts

@@ -0,0 +1 @@
+export { registerDOMComponent } from './dom-entry';

package/example/node_modules/expo/src/dom/marshal.tsx

@@ -0,0 +1,116 @@
+import { BridgeMessage, JSONValue } from './dom.types';
+import { DOM_EVENT, NATIVE_ACTION, NATIVE_ACTION_RESULT } from './injection';
+
+const IS_DOM =
+  typeof window !== 'undefined' &&
+  // @ts-expect-error: Added via react-native-webview
+  typeof window.ReactNativeWebView !== 'undefined';
+
+const emit = <TData extends JSONValue>(message: BridgeMessage<TData>) => {
+  if (!IS_DOM) {
+    return;
+  }
+  (window as any).ReactNativeWebView.postMessage(JSON.stringify(message));
+};
+
+export const addEventListener = <TData extends JSONValue>(
+  onSubscribe: (message: BridgeMessage<TData>) => void
+): (() => void) => {
+  if (!IS_DOM) {
+    return () => {};
+  }
+  const listener = ({ detail }: any) => {
+    onSubscribe(detail);
+  };
+
+  // TODO: Add component ID to the event name to prevent conflicts with other components.
+  window.addEventListener(DOM_EVENT, listener);
+  return () => {
+    window.removeEventListener(DOM_EVENT, listener);
+  };
+};
+
+function invokeNativeAction(actionId: string, args: any[]): Promise<any> {
+  if (!IS_DOM) {
+    throw new Error('Cannot invoke native actions outside of a webview');
+  }
+  return new Promise((res, rej) => {
+    const uid = Math.random().toString(36).slice(2);
+    const sub = addEventListener<{
+      uid: string;
+      actionId: string;
+      result?: any;
+      error?: any;
+    }>((message) => {
+      if (
+        message.type === NATIVE_ACTION_RESULT &&
+        message.data.uid === uid &&
+        message.data.actionId === actionId
+      ) {
+        // Unsubscribe from the event listener
+        sub();
+        if ('error' in message.data) {
+          rej(errorFromJson(message.data.error));
+        }
+        res(message.data.result);
+      }
+    });
+    emit({
+      type: NATIVE_ACTION,
+      data: {
+        uid,
+        actionId,
+        args,
+      },
+    });
+  });
+}
+
+export function getActionsObject(): Record<string, (...args: any[]) => void | Promise<any>> {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        return async (...args: any[]) => {
+          const resolvedProps = await Promise.all(
+            args.map((arg, index) => {
+              if (arg instanceof Promise) {
+                console.warn(
+                  `The promise passed to native action "${prop.toString()}(${new Array(index).fill(',').join('')}promise)" will be evaluated on the web-side before sending to native. This may not be what you want.`
+                );
+              }
+              return arg;
+            })
+          );
+
+          // Assert that props must be serializable
+          resolvedProps.forEach((arg, index) => {
+            if (!arg) return;
+
+            if (typeof arg === 'function') {
+              console.error('Functions are not supported in arguments');
+              throw new Error('Functions are not supported in arguments');
+            } else if (typeof arg === 'object') {
+              try {
+                JSON.stringify(arg);
+              } catch (cause) {
+                console.error('Functions are not supported in arguments');
+                throw new Error(`Argument at index ${index} is not serializable`, { cause });
+              }
+            }
+          });
+
+          return invokeNativeAction(prop.toString(), resolvedProps);
+        };
+      },
+    }
+  );
+}
+
+function errorFromJson(errorJson: any) {
+  const error = new Error(errorJson.message);
+  for (const key of Object.keys(errorJson)) {
+    (error as any)[key] = errorJson[key];
+  }
+  return error;
+}

package/example/node_modules/expo/src/dom/webview/ExpoDOMWebView.ts

@@ -0,0 +1,10 @@
+/**
+ * A re-export of `@expo/dom-webview` that supports optional dependency.
+ */
+
+let module: undefined | typeof import('@expo/dom-webview').WebView;
+try {
+  module = require('@expo/dom-webview').WebView;
+} catch {}
+
+export default module;

package/example/node_modules/expo/src/dom/webview/RNWebView.ts

@@ -0,0 +1,12 @@
+/**
+ * A re-export of `react-native-webview` that supports optional dependency.
+ */
+
+let module: undefined | typeof import('react-native-webview').WebView;
+try {
+  module = require('react-native-webview').WebView;
+} catch {}
+
+export default module;
+
+export type { WebView as RNWebView, WebViewProps as RNWebViewProps } from 'react-native-webview';

package/example/node_modules/expo/src/dom/webview/useDebugZeroHeight.ts

@@ -0,0 +1,62 @@
+import { useState, useCallback } from 'react';
+import { type ViewProps } from 'react-native';
+
+import { type DOMProps, type WebViewProps } from '../dom.types';
+
+type UseDebugZeroHeightType = (dom?: DOMProps) => {
+  debugZeroHeightStyle: WebViewProps['containerStyle'] | undefined;
+  debugOnLayout: ViewProps['onLayout'];
+};
+
+/**
+ * Debug only hook to help identify zero height issues in the DOM component.
+ */
+export const useDebugZeroHeight: UseDebugZeroHeightType = __DEV__
+  ? (dom) => {
+      const [debugZeroHeightStyle, setDebugZeroHeightStyle] = useState<
+        WebViewProps['containerStyle'] | undefined
+      >(undefined);
+      const [hasLoggedWarning, setHasLoggedWarning] = useState(false);
+
+      const debugOnLayout = useCallback<NonNullable<ViewProps['onLayout']>>(
+        (event) => {
+          dom?.onLayout?.(event);
+          if (dom?.matchContents) {
+            return;
+          }
+          if (debugZeroHeightStyle !== undefined) {
+            return;
+          }
+          if (event.nativeEvent.layout.height === 0) {
+            if (!hasLoggedWarning) {
+              console.warn(`
+The DOM component has a zero height in native hierarchy.
+We are adding a debug style to help you identify the issue.
+You can remove this style by using the \`matchContents\` prop or explicitly add a height from the component callsite.
+\`\`\`
+<YourDomComponent dom={{ matchContents: true }} />
+// or
+<YourDomComponent dom={{ style: { height: 50 } }} />
+\`\`\`
+`);
+              setHasLoggedWarning(true);
+            }
+            setDebugZeroHeightStyle({
+              borderWidth: 1,
+              borderColor: 'red',
+              borderRadius: 2,
+              minHeight: 40,
+            });
+          } else {
+            setDebugZeroHeightStyle({});
+          }
+        },
+        [dom?.matchContents, dom?.onLayout, debugZeroHeightStyle, hasLoggedWarning]
+      );
+
+      return { debugZeroHeightStyle, debugOnLayout };
+    }
+  : (dom) => ({
+      debugZeroHeightStyle: undefined,
+      debugOnLayout: dom?.onLayout,
+    });