@oxyhq/core 1.0.0

package/dist/cjs/mixins/OxyServices.language.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyServicesLanguageMixin = OxyServicesLanguageMixin;
+/**
+ * Language Methods Mixin
+ */
+const languageUtils_1 = require("../utils/languageUtils");
+function OxyServicesLanguageMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        /**
+         * Get appropriate storage for the platform (similar to DeviceManager)
+         */
+        async getStorage() {
+            const isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+            if (isReactNative) {
+                try {
+                    const asyncStorageModule = await Promise.resolve().then(() => __importStar(require('@react-native-async-storage/async-storage')));
+                    const storage = asyncStorageModule.default;
+                    return {
+                        getItem: storage.getItem.bind(storage),
+                        setItem: storage.setItem.bind(storage),
+                        removeItem: storage.removeItem.bind(storage),
+                    };
+                }
+                catch (error) {
+                    console.error('AsyncStorage not available in React Native:', error);
+                    throw new Error('AsyncStorage is required in React Native environment');
+                }
+            }
+            else {
+                // Use localStorage for web
+                return {
+                    getItem: async (key) => {
+                        if (typeof window !== 'undefined' && window.localStorage) {
+                            return localStorage.getItem(key);
+                        }
+                        return null;
+                    },
+                    setItem: async (key, value) => {
+                        if (typeof window !== 'undefined' && window.localStorage) {
+                            localStorage.setItem(key, value);
+                        }
+                    },
+                    removeItem: async (key) => {
+                        if (typeof window !== 'undefined' && window.localStorage) {
+                            localStorage.removeItem(key);
+                        }
+                    }
+                };
+            }
+        }
+        /**
+         * Get the current language from storage or user profile
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns The current language code (e.g., 'en-US') or null if not set
+         */
+        async getCurrentLanguage(storageKeyPrefix = 'oxy_session') {
+            try {
+                // First try to get from user profile if authenticated
+                try {
+                    const user = await this.getCurrentUser();
+                    const userLanguage = user?.language;
+                    if (userLanguage) {
+                        return (0, languageUtils_1.normalizeLanguageCode)(userLanguage) || userLanguage;
+                    }
+                }
+                catch (e) {
+                    // User not authenticated or error, continue to storage
+                }
+                // Fall back to storage
+                const storage = await this.getStorage();
+                const storageKey = `${storageKeyPrefix}_language`;
+                const storedLanguage = await storage.getItem(storageKey);
+                if (storedLanguage) {
+                    return (0, languageUtils_1.normalizeLanguageCode)(storedLanguage) || storedLanguage;
+                }
+                return null;
+            }
+            catch (error) {
+                if (__DEV__) {
+                    console.warn('Failed to get current language:', error);
+                }
+                return null;
+            }
+        }
+        /**
+         * Get the current language with metadata (name, nativeName, etc.)
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns Language metadata object or null if not set
+         */
+        async getCurrentLanguageMetadata(storageKeyPrefix = 'oxy_session') {
+            const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+            return (0, languageUtils_1.getLanguageMetadata)(languageCode);
+        }
+        /**
+         * Get the current language name (e.g., 'English')
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns Language name or null if not set
+         */
+        async getCurrentLanguageName(storageKeyPrefix = 'oxy_session') {
+            const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+            if (!languageCode)
+                return null;
+            return (0, languageUtils_1.getLanguageName)(languageCode);
+        }
+        /**
+         * Get the current native language name (e.g., 'Español')
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns Native language name or null if not set
+         */
+        async getCurrentNativeLanguageName(storageKeyPrefix = 'oxy_session') {
+            const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+            if (!languageCode)
+                return null;
+            return (0, languageUtils_1.getNativeLanguageName)(languageCode);
+        }
+    };
+}

package/dist/cjs/mixins/OxyServices.location.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyServicesLocationMixin = OxyServicesLocationMixin;
+function OxyServicesLocationMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        /**
+         * Update user location
+         * @param latitude - Latitude coordinate
+         * @param longitude - Longitude coordinate
+         * @returns Location update result
+         */
+        async updateLocation(latitude, longitude) {
+            try {
+                return await this.makeRequest('POST', '/api/location', {
+                    latitude,
+                    longitude
+                }, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get nearby users
+         * @param radius - Optional search radius in meters
+         * @returns Array of nearby users
+         */
+        async getNearbyUsers(radius) {
+            try {
+                const params = radius ? { radius } : undefined;
+                return await this.makeRequest('GET', '/api/location/nearby', params, {
+                    cache: false, // Don't cache location data - always get fresh data
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+    };
+}

package/dist/cjs/mixins/OxyServices.payment.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyServicesPaymentMixin = OxyServicesPaymentMixin;
+const mixinHelpers_1 = require("./mixinHelpers");
+function OxyServicesPaymentMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        /**
+         * Create a payment
+         * @param data - Payment data
+         * @returns Created payment object
+         */
+        async createPayment(data) {
+            try {
+                return await this.makeRequest('POST', '/api/payments', data, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get payment by ID
+         * @param paymentId - The payment ID
+         * @returns Payment object
+         */
+        async getPayment(paymentId) {
+            try {
+                return await this.makeRequest('GET', `/api/payments/${paymentId}`, undefined, {
+                    cache: true,
+                    cacheTTL: mixinHelpers_1.CACHE_TIMES.LONG,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get user payments
+         * @returns Array of user payments
+         */
+        async getUserPayments() {
+            try {
+                return await this.makeRequest('GET', '/api/payments/user', undefined, {
+                    cache: false, // Don't cache user payments - always get fresh data
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get user subscription
+         * @param userId - The user ID
+         * @returns Subscription object
+         */
+        async getSubscription(userId) {
+            try {
+                return await this.makeRequest('GET', `/api/subscription/${userId}`, undefined, {
+                    cache: true,
+                    cacheTTL: mixinHelpers_1.CACHE_TIMES.MEDIUM,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get current user's subscription
+         * @returns Subscription object
+         */
+        async getCurrentUserSubscription() {
+            try {
+                const userId = this.getCurrentUserId();
+                if (!userId) {
+                    throw new Error('User not authenticated');
+                }
+                return await this.getSubscription(userId);
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get user wallet
+         * @param userId - The user ID
+         * @returns Wallet object with balance
+         */
+        async getWallet(userId) {
+            try {
+                return await this.makeRequest('GET', `/api/wallet/${userId}`, undefined, {
+                    cache: true,
+                    cacheTTL: mixinHelpers_1.CACHE_TIMES.SHORT, // Cache wallet for short time as balance changes frequently
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get current user's wallet
+         * @returns Wallet object with balance
+         */
+        async getCurrentUserWallet() {
+            try {
+                const userId = this.getCurrentUserId();
+                if (!userId) {
+                    throw new Error('User not authenticated');
+                }
+                return await this.getWallet(userId);
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get wallet transaction history
+         * @param userId - The user ID
+         * @param options - Pagination options
+         * @returns Transaction history
+         */
+        async getWalletTransactions(userId, options) {
+            try {
+                const params = new URLSearchParams();
+                if (options?.limit)
+                    params.append('limit', options.limit.toString());
+                if (options?.offset)
+                    params.append('offset', options.offset.toString());
+                const queryString = params.toString();
+                const url = `/api/wallet/transactions/${userId}${queryString ? `?${queryString}` : ''}`;
+                return await this.makeRequest('GET', url, undefined, {
+                    cache: false, // Don't cache transactions - always get fresh data
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get current user's wallet transaction history
+         * @param options - Pagination options
+         * @returns Transaction history
+         */
+        async getCurrentUserWalletTransactions(options) {
+            try {
+                const userId = this.getCurrentUserId();
+                if (!userId) {
+                    throw new Error('User not authenticated');
+                }
+                return await this.getWalletTransactions(userId, options);
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+    };
+}