@oxyhq/services 5.13.40 → 5.15.0

package/src/types/elliptic.d.ts

@@ -0,0 +1,60 @@
+declare module 'elliptic' {
+  export interface KeyPair {
+    getPrivate(enc?: 'hex' | 'array' | 'bn'): string | number[] | any;
+    getPublic(enc?: 'hex'): string;
+    getPublic(enc?: 'array'): number[];
+    getPublic(compressed: boolean, enc?: 'hex'): string;
+    getPublic(compressed: boolean, enc?: 'array'): number[];
+    sign(msg: string | number[]): Signature;
+    verify(msg: string | number[], signature: Signature | string | { r: string | number[]; s: string | number[] }): boolean;
+  }
+
+  export interface Signature {
+    r: any;
+    s: any;
+    recoveryParam: number | null;
+    toDER(enc?: 'hex'): string;
+    toCompact(enc?: 'hex', param?: number): string;
+  }
+
+  export interface Curve {
+    n: any;
+    red: any;
+    g: Point;
+    decodePoint(bytes: string | number[], enc?: string): Point;
+  }
+
+  export interface Point {
+    x: any;
+    y: any;
+    inf: boolean;
+    getX(): any;
+    getY(): any;
+    encode(enc?: string, compressed?: boolean): string | number[];
+    add(p: Point): Point;
+    mul(k: any): Point;
+    eq(p: Point): boolean;
+  }
+
+  export class EC {
+    constructor(curve: string | Curve);
+    keyFromPrivate(priv: string | number[], enc?: string): KeyPair;
+    keyFromPublic(pub: string | number[] | Point, enc?: string): KeyPair;
+    genKeyPair(opts?: { entropy?: string | number[]; pers?: string | number[] }): KeyPair;
+    keyPair(opts?: { priv?: string | number[]; pub?: string | number[] | Point; privEnc?: string; pubEnc?: string }): KeyPair;
+    curve: Curve;
+    n: any;
+    nh: any;
+    g: Point;
+  }
+
+  export type ECKeyPair = KeyPair;
+
+  // ec can be called as a function or used as a constructor
+  export interface ECConstructor {
+    new (curve: string | Curve): EC;
+    (curve: string | Curve): EC;
+  }
+  
+  export const ec: ECConstructor;
+}

package/src/types/expo-crypto.d.ts

@@ -0,0 +1,28 @@
+declare module 'expo-crypto' {
+  export enum CryptoDigestAlgorithm {
+    SHA1 = 'SHA1',
+    SHA256 = 'SHA256',
+    SHA384 = 'SHA384',
+    SHA512 = 'SHA512',
+    MD5 = 'MD5',
+    MD2 = 'MD2',
+    MD4 = 'MD4',
+  }
+
+  export async function digestStringAsync(
+    algorithm: CryptoDigestAlgorithm | 'MD5' | 'SHA1' | 'SHA256' | 'SHA384' | 'SHA512',
+    data: string,
+    options?: { encoding?: 'base64' | 'hex' }
+  ): Promise<string>;
+
+  export function digestString(
+    algorithm: CryptoDigestAlgorithm | 'MD5' | 'SHA1' | 'SHA256' | 'SHA384' | 'SHA512',
+    data: string,
+    options?: { encoding?: 'base64' | 'hex' }
+  ): string;
+
+  export function getRandomBytes(byteCount: number): Uint8Array;
+  export function getRandomBytesAsync(byteCount: number): Promise<Uint8Array>;
+  export function getRandomUUID(): string;
+  export function getRandomUUIDAsync(): Promise<string>;
+}

package/src/types/expo-random.d.ts

@@ -0,0 +1,8 @@
+declare module 'expo-random' {
+  export interface RandomOptions {
+    byteCount?: number;
+  }
+
+  export function getRandomBytes(byteCount: number): Uint8Array;
+  export function getRandomBytesAsync(byteCount: number): Promise<Uint8Array>;
+}

package/src/types/expo-secure-store.d.ts

@@ -0,0 +1,20 @@
+declare module 'expo-secure-store' {
+  export interface SecureStoreOptions {
+    keychainAccessible?: 'WHEN_UNLOCKED' | 'AFTER_FIRST_UNLOCK' | 'WHEN_UNLOCKED_THIS_DEVICE_ONLY' | 'AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY' | 'WHEN_PASSCODE_SET_THIS_DEVICE_ONLY';
+    requireAuthentication?: boolean;
+    authenticationPrompt?: string;
+    showModal?: boolean;
+    keychainService?: string;
+  }
+
+  export const WHEN_UNLOCKED: 'WHEN_UNLOCKED';
+  export const AFTER_FIRST_UNLOCK: 'AFTER_FIRST_UNLOCK';
+  export const WHEN_UNLOCKED_THIS_DEVICE_ONLY: 'WHEN_UNLOCKED_THIS_DEVICE_ONLY';
+  export const AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY: 'AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY';
+  export const WHEN_PASSCODE_SET_THIS_DEVICE_ONLY: 'WHEN_PASSCODE_SET_THIS_DEVICE_ONLY';
+
+  export async function setItemAsync(key: string, value: string, options?: SecureStoreOptions): Promise<void>;
+  export async function getItemAsync(key: string, options?: SecureStoreOptions): Promise<string | null>;
+  export async function deleteItemAsync(key: string, options?: SecureStoreOptions): Promise<void>;
+  export async function isAvailableAsync(): Promise<boolean>;
+}

package/src/types/expo-vector-icons.d.ts

@@ -6,5 +6,14 @@ declare module '@expo/vector-icons' {
     size?: number;
     color?: string;
     style?: Record<string, unknown>;
+    testID?: string;
+  }>;
+  
+  export const MaterialCommunityIcons: React.ComponentType<{
+    name: string;
+    size?: number;
+    color?: string;
+    style?: Record<string, unknown>;
+    testID?: string;
   }>;
 }

package/src/ui/components/ActivityIndicator.tsx

@@ -0,0 +1,254 @@
+import * as React from 'react';
+import {
+  Animated,
+  Easing,
+  Platform,
+  StyleProp,
+  StyleSheet,
+  View,
+  ViewStyle,
+} from 'react-native';
+
+import { useInternalTheme } from './theming';
+import type { ThemeProp } from './types';
+
+export type Props = React.ComponentPropsWithRef<typeof View> & {
+  /**
+   * Whether to show the indicator or hide it.
+   */
+  animating?: boolean;
+  /**
+   * The color of the spinner.
+   */
+  color?: string;
+  /**
+   * Size of the indicator.
+   */
+  size?: 'small' | 'large' | number;
+  /**
+   * Whether the indicator should hide when not animating.
+   */
+  hidesWhenStopped?: boolean;
+  style?: StyleProp<ViewStyle>;
+  /**
+   * @optional
+   */
+  theme?: ThemeProp;
+};
+
+const DURATION = 2400;
+
+/**
+ * Activity indicator is used to present progress of some activity in the app.
+ * It can be used as a drop-in replacement for the ActivityIndicator shipped with React Native.
+ *
+ * ## Usage
+ * ```js
+ * import * as React from 'react';
+ * import { ActivityIndicator, MD2Colors } from 'react-native-paper';
+ *
+ * const MyComponent = () => (
+ *   <ActivityIndicator animating={true} color={MD2Colors.red800} />
+ * );
+ *
+ * export default MyComponent;
+ * ```
+ */
+const ActivityIndicator = ({
+  animating = true,
+  color: indicatorColor,
+  hidesWhenStopped = true,
+  size: indicatorSize = 'small',
+  style,
+  theme: themeOverrides,
+  ...rest
+}: Props) => {
+  const theme = useInternalTheme(themeOverrides);
+  const { current: timer } = React.useRef<Animated.Value>(
+    new Animated.Value(0)
+  );
+  const { current: fade } = React.useRef<Animated.Value>(
+    new Animated.Value(!animating && hidesWhenStopped ? 0 : 1)
+  );
+
+  const rotation = React.useRef<Animated.CompositeAnimation | undefined>(
+    undefined
+  );
+
+  const {
+    animation: { scale },
+  } = theme;
+
+  const startRotation = React.useCallback(() => {
+    // Show indicator
+    Animated.timing(fade, {
+      duration: 200 * scale,
+      toValue: 1,
+      isInteraction: false,
+      useNativeDriver: true,
+    }).start();
+
+    // Circular animation in loop
+    if (rotation.current) {
+      timer.setValue(0);
+      // $FlowFixMe
+      Animated.loop(rotation.current).start();
+    }
+  }, [scale, fade, timer]);
+
+  const stopRotation = () => {
+    if (rotation.current) {
+      rotation.current.stop();
+    }
+  };
+
+  React.useEffect(() => {
+    if (rotation.current === undefined) {
+      // Circular animation in loop
+      rotation.current = Animated.timing(timer, {
+        duration: DURATION,
+        easing: Easing.linear,
+        // Animated.loop does not work if useNativeDriver is true on web
+        useNativeDriver: Platform.OS !== 'web',
+        toValue: 1,
+        isInteraction: false,
+      });
+    }
+
+    if (animating) {
+      startRotation();
+    } else if (hidesWhenStopped) {
+      // Hide indicator first and then stop rotation
+      Animated.timing(fade, {
+        duration: 200 * scale,
+        toValue: 0,
+        useNativeDriver: true,
+        isInteraction: false,
+      }).start(stopRotation);
+    } else {
+      stopRotation();
+    }
+  }, [animating, fade, hidesWhenStopped, startRotation, scale, timer]);
+
+  const color = indicatorColor || theme.colors?.primary;
+  const size =
+    typeof indicatorSize === 'string'
+      ? indicatorSize === 'small'
+        ? 24
+        : 48
+      : indicatorSize
+        ? indicatorSize
+        : 24;
+
+  const frames = (60 * DURATION) / 1000;
+  const easing = Easing.bezier(0.4, 0.0, 0.7, 1.0);
+  const containerStyle = {
+    width: size,
+    height: size / 2,
+    overflow: 'hidden' as const,
+  };
+
+  return (
+    <View
+      style={[styles.container, style]}
+      {...rest}
+      accessible
+      accessibilityRole="progressbar"
+      accessibilityState={{ busy: animating }}
+    >
+      <Animated.View
+        style={[{ width: size, height: size, opacity: fade }]}
+        collapsable={false}
+      >
+        {[0, 1].map((index) => {
+          // Thanks to https://github.com/n4kz/react-native-indicators for the great work
+          const inputRange = Array.from(
+            new Array(frames),
+            (_, frameIndex) => frameIndex / (frames - 1)
+          );
+          const outputRange = Array.from(new Array(frames), (_, frameIndex) => {
+            let progress = (2 * frameIndex) / (frames - 1);
+            const rotation = index ? +(360 - 15) : -(180 - 15);
+
+            if (progress > 1.0) {
+              progress = 2.0 - progress;
+            }
+
+            const direction = index ? -1 : +1;
+
+            return `${direction * (180 - 30) * easing(progress) + rotation}deg`;
+          });
+
+          const layerStyle = {
+            width: size,
+            height: size,
+            transform: [
+              {
+                rotate: timer.interpolate({
+                  inputRange: [0, 1],
+                  outputRange: [`${0 + 30 + 15}deg`, `${2 * 360 + 30 + 15}deg`],
+                }),
+              },
+            ],
+          };
+
+          const viewportStyle = {
+            width: size,
+            height: size,
+            transform: [
+              {
+                translateY: index ? -size / 2 : 0,
+              },
+              {
+                rotate: timer.interpolate({ inputRange, outputRange }),
+              },
+            ],
+          };
+
+          const offsetStyle = index ? { top: size / 2 } : null;
+
+          const lineStyle = {
+            width: size,
+            height: size,
+            borderColor: color,
+            borderWidth: size / 10,
+            borderRadius: size / 2,
+          };
+
+          return (
+            <Animated.View key={index} style={[styles.layer]}>
+              <Animated.View style={layerStyle}>
+                <Animated.View
+                  style={[containerStyle, offsetStyle]}
+                  collapsable={false}
+                >
+                  <Animated.View style={viewportStyle}>
+                    <Animated.View style={containerStyle} collapsable={false}>
+                      <Animated.View style={lineStyle} />
+                    </Animated.View>
+                  </Animated.View>
+                </Animated.View>
+              </Animated.View>
+            </Animated.View>
+          );
+        })}
+      </Animated.View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+
+  layer: {
+    ...StyleSheet.absoluteFillObject,
+
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});
+
+export default ActivityIndicator;

package/src/ui/components/AutoHeightScrollView.tsx

@@ -0,0 +1,50 @@
+import React, { useState, forwardRef } from 'react';
+import { ScrollView, type ScrollViewProps, StyleSheet, type ViewStyle } from 'react-native';
+
+export type AutoHeightScrollViewProps = ScrollViewProps & {
+    /**
+     * Optional style override.
+     * Note: height and flexShrink are managed internally but can be overridden if absolutely necessary.
+     */
+    style?: ViewStyle;
+};
+
+/**
+ * A ScrollView that automatically adjusts its height to match its content,
+ * but shrinks if constrained by a parent (e.g., a Max Height Bottom Sheet).
+ * 
+ * This solves the "collapsed to 0 height" issue when using ScrollView inside an auto-height container.
+ */
+export const AutoHeightScrollView = forwardRef<ScrollView, AutoHeightScrollViewProps>((props, ref) => {
+    const [contentHeight, setContentHeight] = useState(0);
+
+    const { style, onContentSizeChange, ...rest } = props;
+
+    const handleContentSizeChange = (w: number, h: number) => {
+        setContentHeight(h);
+        onContentSizeChange?.(w, h);
+    };
+
+    return (
+        <ScrollView
+            ref={ref}
+            style={[
+                styles.defaultStyle,
+                style,
+                { height: contentHeight > 0 ? contentHeight : undefined }
+            ]}
+            onContentSizeChange={handleContentSizeChange}
+            {...rest}
+        />
+    );
+});
+
+const styles = StyleSheet.create({
+    defaultStyle: {
+        flexShrink: 1,
+        flexGrow: 0, // Ensure we don't force expansion beyond content unless needed
+        minHeight: 0,
+    }
+});
+
+AutoHeightScrollView.displayName = 'AutoHeightScrollView';