@oxyhq/services 5.7.5 → 5.8.1

package/lib/typescript/ui/styles/authStyles.d.ts

@@ -0,0 +1,326 @@
+export interface AuthThemeColors {
+    text: string;
+    background: string;
+    inputBackground: string;
+    placeholder: string;
+    primary: string;
+    border: string;
+    error: string;
+    success: string;
+    warning: string;
+    secondaryText: string;
+}
+export declare const createAuthStyles: (colors: AuthThemeColors, theme: string) => {
+    container: {
+        flex: number;
+    };
+    scrollContent: {
+        flexGrow: number;
+        paddingHorizontal: number;
+        paddingTop: number;
+        paddingBottom: number;
+    };
+    stepContainer: {
+        flex: number;
+        justifyContent: "flex-start";
+        alignItems: "flex-start";
+    };
+    modernHeader: {
+        alignItems: "flex-start";
+        width: "100%";
+        marginBottom: number;
+    };
+    modernTitle: {
+        fontFamily: string;
+        fontWeight: "bold" | undefined;
+        fontSize: number;
+        lineHeight: number;
+        marginBottom: number;
+        textAlign: "left";
+        letterSpacing: number;
+    };
+    modernSubtitle: {
+        fontSize: number;
+        lineHeight: number;
+        textAlign: "left";
+        opacity: number;
+    };
+    welcomeTitle: {
+        fontFamily: string;
+        fontWeight: "bold" | undefined;
+        fontSize: number;
+        lineHeight: number;
+        marginBottom: number;
+        textAlign: "left";
+        letterSpacing: number;
+    };
+    stepTitle: {
+        fontFamily: string;
+        fontWeight: "bold" | undefined;
+        fontSize: number;
+        lineHeight: number;
+        marginBottom: number;
+        textAlign: "left";
+        letterSpacing: number;
+    };
+    modernInfoCard: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginBottom: number;
+        gap: number;
+        width: "100%";
+    };
+    modernInfoText: {
+        fontSize: number;
+        flex: number;
+    };
+    modernErrorCard: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginBottom: number;
+        gap: number;
+        width: "100%";
+    };
+    errorText: {
+        fontSize: number;
+        fontWeight: "500";
+        flex: number;
+    };
+    modernInputContainer: {
+        width: "100%";
+        marginBottom: number;
+    };
+    inputWrapper: {
+        flexDirection: "row";
+        alignItems: "center";
+        height: number;
+        borderRadius: number;
+        paddingHorizontal: number;
+        borderWidth: number;
+        backgroundColor: string;
+    };
+    premiumInputWrapper: {
+        flexDirection: "row";
+        alignItems: "center";
+        height: number;
+        borderRadius: number;
+        paddingHorizontal: number;
+        borderWidth: number;
+        backgroundColor: string;
+    };
+    inputIcon: {
+        marginRight: number;
+    };
+    inputContent: {
+        flex: number;
+    };
+    modernInput: {
+        flex: number;
+        fontSize: number;
+        height: "100%";
+    };
+    passwordToggle: {
+        padding: number;
+    };
+    validationIndicator: {
+        marginLeft: number;
+    };
+    validationSuccessCard: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginTop: number;
+        gap: number;
+    };
+    validationErrorCard: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginTop: number;
+        gap: number;
+    };
+    validationCard: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginTop: number;
+        gap: number;
+    };
+    validationText: {
+        fontSize: number;
+        fontWeight: "500";
+    };
+    belowInputMessage: {
+        flexDirection: "row";
+        alignItems: "center";
+        marginTop: number;
+        marginBottom: number;
+        gap: number;
+    };
+    belowInputText: {
+        fontSize: number;
+        fontWeight: "500";
+    };
+    modernButton: {
+        flexDirection: "row";
+        alignItems: "center";
+        justifyContent: "center";
+        paddingVertical: number;
+        paddingHorizontal: number;
+        borderRadius: number;
+        marginVertical: number;
+        shadowOffset: {
+            width: number;
+            height: number;
+        };
+        shadowOpacity: number;
+        shadowRadius: number;
+        elevation: number;
+        gap: number;
+        width: "100%";
+    };
+    modernButtonText: {
+        color: string;
+        fontSize: number;
+        fontWeight: "600";
+        letterSpacing: number;
+    };
+    buttonIcon: {
+        marginLeft: number;
+    };
+    modernLabel: {
+        fontSize: number;
+        fontWeight: "500";
+        marginBottom: number;
+    };
+    modernLinkText: {
+        fontSize: number;
+        lineHeight: number;
+        fontWeight: "600";
+        textDecorationLine: "underline";
+    };
+    footerTextContainer: {
+        flexDirection: "row";
+        justifyContent: "center";
+        marginTop: number;
+    };
+    footerText: {
+        fontSize: number;
+    };
+    modernUserProfileContainer: {
+        alignItems: "flex-start";
+        paddingVertical: number;
+    };
+    avatarContainer: {
+        position: "relative";
+        marginBottom: number;
+    };
+    modernUserAvatar: {
+        borderWidth: number;
+        borderColor: string;
+    };
+    statusIndicator: {
+        position: "absolute";
+        bottom: number;
+        right: number;
+        width: number;
+        height: number;
+        borderRadius: number;
+        borderWidth: number;
+        borderColor: string;
+    };
+    modernUserDisplayName: {
+        fontFamily: string;
+        fontWeight: "bold" | undefined;
+        fontSize: number;
+        marginBottom: number;
+        textAlign: "center";
+        letterSpacing: number;
+    };
+    modernUsernameSubtext: {
+        fontSize: number;
+        textAlign: "left";
+        marginBottom: number;
+        opacity: number;
+    };
+    welcomeBackBadge: {
+        flexDirection: "row";
+        alignItems: "center";
+        paddingHorizontal: number;
+        paddingVertical: number;
+        borderRadius: number;
+        gap: number;
+    };
+    welcomeBackText: {
+        fontSize: number;
+        fontWeight: "600";
+        textTransform: "uppercase";
+        letterSpacing: number;
+    };
+    modernNavigationButtons: {
+        flexDirection: "row";
+        justifyContent: "center";
+        marginTop: number;
+        marginBottom: number;
+        width: "100%";
+        gap: number;
+    };
+    modernBackButton: {
+        flexDirection: "row";
+        alignItems: "center";
+        paddingVertical: number;
+        paddingHorizontal: number;
+        borderRadius: number;
+        borderWidth: number;
+        gap: number;
+    };
+    modernBackButtonText: {
+        fontSize: number;
+        fontWeight: "500";
+    };
+    securityNotice: {
+        flexDirection: "row";
+        alignItems: "center";
+        justifyContent: "center";
+        marginTop: number;
+        gap: number;
+    };
+    securityText: {
+        fontSize: number;
+        fontWeight: "500";
+    };
+    welcomeImageContainer: {
+        alignItems: "center";
+        justifyContent: "center";
+        marginVertical: number;
+    };
+    welcomeText: {
+        fontSize: number;
+        lineHeight: number;
+        textAlign: "left";
+        opacity: number;
+        marginBottom: number;
+    };
+    successCard: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginBottom: number;
+        gap: number;
+        width: "100%";
+    };
+    successText: {
+        fontSize: number;
+        fontWeight: "500";
+        flex: number;
+    };
+};
+//# sourceMappingURL=authStyles.d.ts.map

package/lib/typescript/ui/styles/authStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authStyles.d.ts","sourceRoot":"","sources":["../../../../src/ui/styles/authStyles.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,EAAE,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+UrE,CAAC"}

package/lib/typescript/ui/styles/index.d.ts

@@ -1,3 +1,4 @@
 export * from './fonts';
 export * from './theme';
+export * from './authStyles';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/ui/styles/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/styles/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/styles/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@oxyhq/services",
-    "version": "5.7.5",
+    "version": "5.8.1",
     "description": "Reusable OxyHQ module to handle authentication, user management, karma system, device-based session management and more 🚀",
     "main": "lib/commonjs/index.js",
     "module": "lib/module/index.js",
@@ -59,9 +59,6 @@
         "typescript": "tsc --skipLibCheck --noEmit",
         "lint": "biome lint --error-on-warnings ./src",
         "build": "bob build && yarn copy-assets && yarn copy-dts && yarn delete-dts.js && yarn delete-debug-view",
-        "test": "jest",
-        "test:watch": "jest --watch",
-        "test:coverage": "jest --coverage",
         "copy-assets": "copyfiles -u 1 \"src/assets/**/*\" lib/commonjs/assets && copyfiles -u 1 \"src/assets/**/*\" lib/module/assets",
         "copy-dts": "copyfiles -u 1 \"src/**/*.d.ts\" lib/typescript",
         "delete-debug-view": "rm -rf ./lib/commonjs/components/bottomSheetDebugView ./lib/module/components/bottomSheetDebugView ./lib/typescript/components/bottomSheetDebugView || true",

package/src/core/index.ts

@@ -1,10 +1,6 @@
 import axios, { AxiosInstance, AxiosError, AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios';
 import { jwtDecode } from 'jwt-decode';
 
-// Zero-Config Authentication Exports
-export { AuthenticationManager, initializeAuth, getAuthManager } from './auth-manager';
-export { AuthProvider, useAuth, useOxyClient, useAuthStatus, useCurrentUser, withAuth } from './use-auth';
-
 // Remove all FormData, form-data, and polyfill logic. Delete uploadFile and uploadFiles methods. Add a comment to use the new raw upload approach instead.
 
 import {
@@ -44,7 +40,6 @@ import {
 
 // Import secure session types
 import { SecureLoginResponse, SecureClientSession } from '../models/secureSession';
-import { AuthenticationManager, initializeAuth } from './auth-manager';
 
 /**
  * Default cloud URL for Oxy services, cloud is where the user files are. (e.g. images, videos, etc.). Not the API.
@@ -64,23 +59,7 @@ interface JwtPayload {
 /**
  * OxyServices - Client library for interacting with the Oxy API
  * 
- * ZERO-CONFIG MODE:
- * Use the new AuthProvider and useAuth hooks for automatic authentication management:
- * 
- * import { AuthProvider, useAuth } from '@oxyhq/services';
- * 
- * <AuthProvider baseURL="https://api.oxy.so">
- *   <App />
- * </AuthProvider>
- * 
- * Then in components:
- * const { login, user, isAuthenticated } = useAuth();
- * 
- * LEGACY MODE:
- * The OxyServices class below is maintained for backward compatibility
- * but we recommend migrating to the new zero-config approach.
- * 
- * Note: For authentication status in UI components, use `isAuthenticated` from useAuth() context
+ * Note: For authentication status in UI components, use `isAuthenticated` from useOxy() context
  * instead of checking token status directly on this service.
  */
 export class OxyServices {
@@ -88,31 +67,17 @@ export class OxyServices {
   private accessToken: string | null = null;
   private refreshToken: string | null = null;
   private refreshPromise: Promise<{ accessToken: string; refreshToken: string }> | null = null;
-  private authManager: AuthenticationManager | null = null;
 
   /**
    * Creates a new instance of the OxyServices client
    * @param config - Configuration for the client
    */
   constructor(config: OxyConfig) {
-    // Try to use the new auth manager if available, otherwise fall back to legacy mode
-    try {
-      this.authManager = initializeAuth(config.baseURL);
-      this.client = this.authManager.getClient();
-    } catch {
-      // Fall back to legacy implementation
-      this.client = axios.create({ 
-        baseURL: config.baseURL,
-        timeout: 10000 // 10 second timeout
-      });
-      this.setupLegacyInterceptors();
-    }
-  }
-
-  /**
-   * Setup legacy interceptors (only used if auth manager is not available)
-   */
-  private setupLegacyInterceptors(): void {
+    this.client = axios.create({ 
+      baseURL: config.baseURL,
+      timeout: 10000 // 10 second timeout
+    });
+    
     // Interceptor for adding auth header and handling token refresh
     this.client.interceptors.request.use(async (req: InternalAxiosRequestConfig) => {
       if (!this.accessToken) {
@@ -529,9 +494,17 @@ export class OxyServices {
    */
   async getCurrentUser(): Promise<User> {
     try {
+      console.log('OxyServices: Fetching current user...');
       const res = await this.client.get('/users/me');
+      console.log('OxyServices: Current user response:', {
+        hasUser: !!res.data,
+        userLinksMetadata: res.data?.linksMetadata,
+        userLinks: res.data?.links,
+        userWebsite: res.data?.website
+      });
       return res.data;
     } catch (error) {
+      console.error('OxyServices: Error fetching current user:', error);
       throw this.handleError(error);
     }
   }
@@ -543,9 +516,12 @@ export class OxyServices {
    */
   async updateProfile(updates: Record<string, any>): Promise<User> {
     try {
+      console.log('OxyServices: Updating profile with:', updates);
       const res = await this.client.put('/users/me', updates);
+      console.log('OxyServices: Profile update response:', res.data);
       return res.data;
     } catch (error) {
+      console.error('OxyServices: Error updating profile:', error);
       throw this.handleError(error);
     }
   }
@@ -1263,10 +1239,13 @@ export class OxyServices {
    * @returns Array of user sessions
    */
   async getSessionsBySessionId(sessionId: string): Promise<any[]> {
+    console.log('getSessionsBySessionId called with sessionId:', sessionId);
     try {
       const res = await this.client.get(`/secure-session/sessions/${sessionId}`);
+      console.log('getSessionsBySessionId response:', res.data);
       return res.data.sessions;
     } catch (error) {
+      console.error('getSessionsBySessionId error:', error);
       throw this.handleError(error);
     }
   }
@@ -1746,6 +1725,181 @@ export class OxyServices {
       throw this.handleError(error);
     }
   }
+
+  /**
+   * Fetch metadata for a URL (title, description, image)
+   * @param url - The URL to fetch metadata for
+   * @returns Promise with metadata object
+   */
+  async fetchLinkMetadata(url: string): Promise<{
+    url: string;
+    title: string;
+    description: string;
+    image?: string;
+  }> {
+    try {
+      const response = await this.client.post('/link-metadata/fetch-metadata', { url });
+      return response.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Search for locations using the enhanced location search API
+   * @param query - Search query string
+   * @param limit - Maximum number of results (default: 5)
+   * @param countrycodes - Optional country codes filter (e.g., "us,ca")
+   * @returns Promise with array of location results
+   */
+  async searchLocations(query: string, limit: number = 5, countrycodes?: string): Promise<any[]> {
+    try {
+      const params = new URLSearchParams({
+        query,
+        limit: limit.toString()
+      });
+      if (countrycodes) {
+        params.append('countrycodes', countrycodes);
+      }
+      const res = await this.client.get(`/location-search/search?${params.toString()}`);
+      return res.data.results;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get detailed information about a specific location by coordinates
+   * @param lat - Latitude
+   * @param lon - Longitude
+   * @returns Promise with detailed location information
+   */
+  async getLocationDetails(lat: number, lon: number): Promise<any> {
+    try {
+      const res = await this.client.get(`/location-search/details?lat=${lat}&lon=${lon}`);
+      return res.data.result;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Find locations near a point using geospatial queries
+   * @param lat - Latitude
+   * @param lon - Longitude
+   * @param maxDistance - Maximum distance in meters (default: 10000)
+   * @param limit - Maximum number of results (default: 10)
+   * @param skip - Number of results to skip (default: 0)
+   * @returns Promise with nearby locations
+   */
+  async findLocationsNear(
+    lat: number, 
+    lon: number, 
+    maxDistance: number = 10000,
+    limit: number = 10,
+    skip: number = 0
+  ): Promise<any> {
+    try {
+      const params = new URLSearchParams({
+        lat: lat.toString(),
+        lon: lon.toString(),
+        maxDistance: maxDistance.toString(),
+        limit: limit.toString(),
+        skip: skip.toString()
+      });
+      const res = await this.client.get(`/location-search/near?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Search locations in database by text
+   * @param query - Search query
+   * @param limit - Maximum number of results (default: 10)
+   * @param skip - Number of results to skip (default: 0)
+   * @param type - Filter by location type
+   * @param country - Filter by country
+   * @param city - Filter by city
+   * @returns Promise with search results
+   */
+  async searchLocationsInDB(
+    query: string,
+    limit: number = 10,
+    skip: number = 0,
+    type?: string,
+    country?: string,
+    city?: string
+  ): Promise<any> {
+    try {
+      const params = new URLSearchParams({
+        query,
+        limit: limit.toString(),
+        skip: skip.toString()
+      });
+      if (type) params.append('type', type);
+      if (country) params.append('country', country);
+      if (city) params.append('city', city);
+      
+      const res = await this.client.get(`/location-search/db-search?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get location statistics
+   * @returns Promise with location statistics
+   */
+  async getLocationStats(): Promise<any> {
+    try {
+      const res = await this.client.get('/location-search/stats');
+      return res.data.stats;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get cache statistics
+   * @returns Promise with cache statistics
+   */
+  async getLocationCacheStats(): Promise<any> {
+    try {
+      const res = await this.client.get('/location-search/cache/stats');
+      return res.data.stats;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Clear location cache
+   * @returns Promise with success status
+   */
+  async clearLocationCache(): Promise<any> {
+    try {
+      const res = await this.client.delete('/location-search/cache');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get performance statistics
+   * @returns Promise with performance statistics
+   */
+  async getLocationPerformanceStats(): Promise<any> {
+    try {
+      const res = await this.client.get('/location-search/performance');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
 }
 
 // Default export for backward compatibility