nativine 1.0.2

package/README.md

@@ -0,0 +1,410 @@
+<p align="center">
+  <img src="https://assets.nativine.com/asset-1784820238974-121251783.png" alt="Nativine" width="120" />
+</p>
+
+<h1 align="center">nativine</h1>
+
+<p align="center">
+  The most powerful JavaScript bridge ever made for WebViews.<br>
+  Access 50+ native device APIs from your web app with TypeScript support.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/nativine"><img src="https://img.shields.io/npm/v/nativine.svg" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/nativine"><img src="https://img.shields.io/npm/dm/nativine.svg" alt="npm downloads" /></a>
+  <a href="https://bundlephobia.com/package/nativine"><img src="https://img.shields.io/bundlephobia/minzip/nativine" alt="bundle size" /></a>
+  <a href="https://www.npmjs.com/package/nativine"><img src="https://img.shields.io/npm/l/nativine.svg" alt="license" /></a>
+</p>
+
+---
+
+## Features
+
+- **50+ native APIs** across 12 namespaces
+- **TypeScript-first** with full type declarations
+- **Promise-based** async methods (no string callbacks)
+- **3 output formats**: ESM, CJS, UMD (CDN-ready)
+- **Tree-shakeable** — import only what you need
+- **Graceful web fallback** — every method safely no-ops in browsers
+- **Event system** — subscribe to `appResume`, `appPause`, `keyboardShow` events
+- **Zero dependencies** in production
+
+## Quick Start
+
+### npm / yarn / pnpm
+
+```bash
+npm install nativine
+```
+
+```javascript
+import nativine from 'nativine';
+
+if (nativine.isNativeApp) {
+  const info = await nativine.device.getInfo();
+  console.log(`Running on ${info.model} (${info.platform})`);
+}
+```
+
+### CDN / Script Tag
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/nativine@latest/dist/nativine.umd.js"></script>
+<script>
+  if (Nativine.default.isNativeApp) {
+    Nativine.default.haptics.vibrate(200);
+  }
+</script>
+```
+
+---
+
+## API Reference
+
+### Detection
+
+```javascript
+nativine.isNativeApp  // boolean — true if inside a Nativine app
+nativine.platform     // 'android' | 'ios' | 'web'
+nativine.isAndroid    // boolean
+nativine.isIos        // boolean
+nativine.version      // SDK version string
+```
+
+---
+
+### 📱 Device
+
+```javascript
+const info = await nativine.device.getInfo();
+// { model, manufacturer, osVersion, appVersion, appVersionCode,
+//   packageName, locale, screenWidth, screenHeight, density, platform }
+
+const insets = await nativine.device.getSafeAreaInsets();
+// { top, bottom, left, right }
+
+const version = await nativine.device.getAppVersion();
+// "1.2.0"
+
+const id = await nativine.device.getDeviceId();
+// "a1b2c3d4-..." (anonymous, per-installation)
+```
+
+---
+
+### 🎨 UI
+
+```javascript
+nativine.ui.statusBar({ color: '#1a1a2e', style: 'light' });
+nativine.ui.navigationBar({ color: '#16213e' });
+nativine.ui.hideSplashScreen();
+nativine.ui.setOrientation('landscape'); // 'portrait' | 'landscape' | 'auto'
+nativine.ui.showNativeComponents();
+nativine.ui.hideNativeComponents();
+nativine.ui.setPullToRefresh(false);
+nativine.ui.setPinchToZoom(true);
+```
+
+---
+
+### 🧭 Navigation
+
+```javascript
+nativine.navigation.goBack();
+nativine.navigation.goForward();
+nativine.navigation.navigate('/products');
+nativine.navigation.openInBrowser('https://docs.nativine.com');
+nativine.navigation.closeApp();
+```
+
+---
+
+### 📳 Haptics
+
+```javascript
+nativine.haptics.vibrate(200); // duration in ms
+
+nativine.haptics.feedback('light');   // light tap
+nativine.haptics.feedback('medium');  // standard tap
+nativine.haptics.feedback('heavy');   // strong tap
+nativine.haptics.feedback('success'); // double tap pattern
+nativine.haptics.feedback('error');   // triple tap pattern
+nativine.haptics.feedback('warning');
+nativine.haptics.feedback('selection');
+```
+
+---
+
+### 💾 Storage (Persistent)
+
+Data stored here survives WebView cache clears (uses SharedPreferences / UserDefaults).
+
+```javascript
+nativine.storage.set('auth_token', 'abc123');
+const token = nativine.storage.get('auth_token');        // 'abc123'
+const user = nativine.storage.get('missing_key', '{}');  // '{}'
+nativine.storage.remove('auth_token');
+nativine.storage.clear();
+```
+
+---
+
+### 📤 Share
+
+```javascript
+nativine.share({
+  title: 'Check this out!',
+  text: 'Amazing content',
+  url: 'https://example.com'
+});
+
+nativine.shareFile({
+  filePath: '/storage/emulated/0/Download/report.pdf',
+  mimeType: 'application/pdf'
+});
+```
+
+---
+
+### 🔐 Auth
+
+```javascript
+// Google Sign-In
+const user = await nativine.auth.googleSignIn();
+// { email, displayName, idToken, photoUrl, id }
+
+await nativine.auth.googleSignOut();
+```
+
+---
+
+### 🔒 Biometrics
+
+```javascript
+const { available, biometryType } = await nativine.biometrics.isAvailable();
+// { available: true, biometryType: 'fingerprint' | 'face' | 'iris' }
+
+const result = await nativine.biometrics.authenticate({
+  reason: 'Verify identity',
+  allowFallback: true
+});
+// { success: true }
+```
+
+---
+
+### 👥 Contacts
+
+```javascript
+const contacts = await nativine.contacts.getAll();
+// [{ name, phone, email }, ...]
+```
+
+---
+
+### 📋 Clipboard
+
+```javascript
+await nativine.clipboard.copy('Copied text!');
+const text = await nativine.clipboard.read();
+```
+
+---
+
+### 📥 Downloads
+
+```javascript
+nativine.downloads.downloadFile({
+  url: 'https://example.com/report.pdf',
+  filename: 'monthly-report.pdf',
+  openAfterDownload: true
+});
+```
+
+---
+
+### 📷 Scanner
+
+```javascript
+const result = await nativine.scanner.scan();
+// { value: 'https://example.com', format: 'QR_CODE' }
+```
+
+---
+
+### 📍 Location
+
+```javascript
+const loc = await nativine.location.getCurrent();
+// { latitude, longitude, accuracy, altitude?, speed? }
+```
+
+---
+
+### 🌐 Network
+
+```javascript
+const status = await nativine.network.isOnline();
+// { online: true, type: 'wifi' | 'cellular' | 'none' }
+
+const unsubscribe = nativine.network.onConnectivityChange((status) => {
+  console.log(status.online ? 'Online' : 'Offline');
+});
+
+// Later: stop listening
+unsubscribe();
+```
+
+---
+
+### 🗑️ Cache
+
+```javascript
+nativine.cache.clear();
+nativine.cache.clearCookies();
+```
+
+---
+
+### 🖨️ Print
+
+```javascript
+nativine.print();
+```
+
+---
+
+### 🛡️ Screenshot Protection
+
+```javascript
+nativine.screenshot.setProtection(true);  // Block screenshots
+nativine.screenshot.setProtection(false); // Allow screenshots
+```
+
+---
+
+### ⭐ Reviews
+
+```javascript
+nativine.reviews.request(); // Triggers Google Play / App Store review dialog
+```
+
+---
+
+### 🔄 Updates
+
+```javascript
+nativine.updates.check(); // Triggers in-app update check (Android)
+```
+
+---
+
+### 📺 Ads
+
+```javascript
+nativine.ads.showInterstitial();
+
+const reward = await nativine.ads.showRewarded();
+if (reward.rewarded) {
+  unlockPremiumContent();
+}
+```
+
+---
+
+### 🔔 OneSignal
+
+```javascript
+nativine.onesignal.setExternalUserId('user_123');
+nativine.onesignal.sendTag('plan', 'premium');
+nativine.onesignal.sendTags({ plan: 'premium', language: 'en' });
+const playerId = await nativine.onesignal.getPlayerId();
+nativine.onesignal.removeExternalUserId();
+```
+
+---
+
+### 🏃 Pedometer / Step Counter
+
+```javascript
+// Check availability
+const { available } = await nativine.pedometer.isAvailable();
+
+if (available) {
+  // Start tracking
+  nativine.pedometer.startTracking();
+  
+  // Listen for real-time updates
+  nativine.on('stepUpdate', ({ steps }) => {
+    console.log(`Current steps: ${steps}`);
+  });
+  
+  // Or fetch manually
+  const { steps } = await nativine.pedometer.getStepCount();
+  
+  // Stop tracking when done
+  nativine.pedometer.stopTracking();
+}
+```
+
+---
+
+### 💬 Toast
+
+```javascript
+nativine.toast('Item added to cart!');
+nativine.toast('Processing...', 'long'); // 'short' (~2s) or 'long' (~3.5s)
+```
+
+---
+
+### 📡 Events
+
+```javascript
+// App lifecycle
+nativine.on('appResume', () => fetchLatestData());
+nativine.on('appPause', () => saveState());
+
+// Bridge ready
+nativine.on('pageReady', () => initializeApp());
+
+// Keyboard
+nativine.on('keyboardShow', ({ height }) => adjustLayout(height));
+nativine.on('keyboardHide', () => resetLayout());
+
+// Unsubscribe
+const unsub = nativine.on('appResume', handler);
+unsub(); // Remove this specific listener
+
+// Remove all listeners for an event
+nativine.off('appResume');
+
+// Remove ALL listeners
+nativine.off();
+```
+
+---
+
+## Tree Shaking
+
+Import only the modules you need to minimize bundle size:
+
+```javascript
+import { haptics, device, isNativeApp } from 'nativine';
+
+if (isNativeApp) {
+  haptics.vibrate(100);
+}
+```
+
+---
+
+## Requirements
+
+- Nativine app built with template v2.0+
+- Android 7.0+ (API 24+)
+- iOS 14+ (coming soon)
+
+## License
+
+ISC © [Nativine](https://nativine.com)

package/dist/core/bridge.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Nativine Bridge Dispatcher
+ *
+ * Low-level bridge call mechanism that provides a unified, Promise-based interface
+ * for communicating with the native Android/iOS app shell.
+ *
+ * Architecture:
+ * - Android: Calls `window.nativine.<method>(args, callbackId)` via @JavascriptInterface
+ * - iOS: Calls `window.webkit.messageHandlers.nativine.postMessage({ method, args, callbackId })`
+ * - Web: Returns rejected promises or no-ops gracefully
+ *
+ * The native side resolves the Promise by calling: `window[callbackId](jsonResult)`
+ */
+/**
+ * Error thrown when a bridge method is called outside a native app context.
+ */
+export declare class NativineNotAvailableError extends Error {
+    constructor(method: string);
+}
+/**
+ * Error thrown when a bridge call times out waiting for native response.
+ */
+export declare class NativineTimeoutError extends Error {
+    constructor(method: string, timeoutMs: number);
+}
+/**
+ * Makes an async call to the native bridge and returns a Promise that resolves
+ * when the native side responds via the callback.
+ *
+ * @param method - The native method name to call (e.g., 'getDeviceInfo')
+ * @param args - Optional arguments to pass to the native method (serialized as JSON string)
+ * @param timeoutMs - Timeout in milliseconds (default: 10s)
+ * @returns Promise that resolves with the parsed native response
+ */
+export declare function callNativeAsync<T = any>(method: string, args?: Record<string, any>, timeoutMs?: number): Promise<T>;
+/**
+ * Makes a synchronous (fire-and-forget) call to the native bridge.
+ * Used for methods that don't need a return value (e.g., vibrate, statusBar).
+ *
+ * @param method - The native method name to call
+ * @param args - Optional arguments
+ */
+export declare function callNativeSync(method: string, args?: Record<string, any>): void;
+/**
+ * Calls a native method that returns a synchronous value via @JavascriptInterface.
+ * Only works on Android where @JavascriptInterface methods can return values directly.
+ *
+ * @param method - The native method name
+ * @param args - Arguments to pass
+ * @returns The return value from the native method, or undefined
+ */
+export declare function callNativeDirect<T = any>(method: string, ...args: any[]): T | undefined;

package/dist/core/platform.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Nativine Platform Detection
+ *
+ * Detects whether the web page is running inside a Nativine-powered native app
+ * and identifies the platform (Android, iOS, or Web).
+ */
+export type Platform = 'android' | 'ios' | 'web';
+/** The detected platform: `'android'`, `'ios'`, or `'web'` */
+export declare const platform: Platform;
+/** `true` if the page is running inside a Nativine native app (Android or iOS) */
+export declare const isNativeApp: boolean;
+/** `true` if the page is running inside a Nativine Android app */
+export declare const isAndroid: boolean;
+/** `true` if the page is running inside a Nativine iOS app */
+export declare const isIos: boolean;

package/dist/index.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Nativine JavaScript Bridge
+ *
+ * Enterprise-grade bridge for communicating between web apps and Nativine native shells.
+ * Provides 50+ APIs across 12 namespaces with full TypeScript support, Promise-based
+ * async methods, and graceful web fallbacks.
+ *
+ * @example ESM (recommended)
+ * ```js
+ * import nativine from 'nativine';
+ *
+ * if (nativine.isNativeApp) {
+ *   const info = await nativine.device.getInfo();
+ *   nativine.haptics.vibrate(200);
+ * }
+ * ```
+ *
+ * @example CDN / Script tag
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/nativine@latest/dist/nativine.umd.js"></script>
+ * <script>
+ *   if (Nativine.isNativeApp) {
+ *     Nativine.haptics.vibrate(200);
+ *   }
+ * </script>
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { platform, isNativeApp, isAndroid, isIos } from './core/platform';
+import type { Platform } from './core/platform';
+import * as device from './modules/device';
+import * as ui from './modules/ui';
+import * as navigation from './modules/navigation';
+import * as haptics from './modules/haptics';
+import * as storage from './modules/storage';
+import * as shareModule from './modules/share';
+import * as auth from './modules/auth';
+import * as biometrics from './modules/biometrics';
+import * as contacts from './modules/contacts';
+import * as clipboard from './modules/clipboard';
+import * as downloads from './modules/downloads';
+import * as scanner from './modules/camera';
+import * as location from './modules/location';
+import * as network from './modules/network';
+import * as cache from './modules/cache';
+import * as printModule from './modules/print';
+import * as screenshot from './modules/screenshot';
+import * as reviews from './modules/reviews';
+import * as updates from './modules/updates';
+import * as ads from './modules/ads';
+import * as onesignal from './modules/onesignal';
+import * as toastModule from './modules/toast';
+import * as pedometer from './modules/pedometer';
+import { on, off } from './modules/events';
+declare const nativine: {
+    /** The detected platform: `'android'`, `'ios'`, or `'web'` */
+    platform: Platform;
+    /** `true` if running inside a Nativine native app */
+    isNativeApp: boolean;
+    /** `true` if running inside a Nativine Android app */
+    isAndroid: boolean;
+    /** `true` if running inside a Nativine iOS app */
+    isIos: boolean;
+    /** The version of this SDK */
+    version: string;
+    device: {
+        getInfo: typeof device.getInfo;
+        getSafeAreaInsets: typeof device.getSafeAreaInsets;
+        getAppVersion: typeof device.getAppVersion;
+        getDeviceId: typeof device.getDeviceId;
+    };
+    ui: {
+        statusBar: typeof ui.statusBar;
+        navigationBar: typeof ui.navigationBar;
+        hideSplashScreen: typeof ui.hideSplashScreen;
+        setOrientation: typeof ui.setOrientation;
+        showNativeComponents: typeof ui.showNativeComponents;
+        hideNativeComponents: typeof ui.hideNativeComponents;
+        setPullToRefresh: typeof ui.setPullToRefresh;
+        setPinchToZoom: typeof ui.setPinchToZoom;
+    };
+    navigation: {
+        goBack: typeof navigation.goBack;
+        goForward: typeof navigation.goForward;
+        navigate: typeof navigation.navigate;
+        openInBrowser: typeof navigation.openInBrowser;
+        closeApp: typeof navigation.closeApp;
+    };
+    haptics: {
+        vibrate: typeof haptics.vibrate;
+        feedback: typeof haptics.feedback;
+    };
+    storage: {
+        set: typeof storage.set;
+        get: typeof storage.get;
+        remove: typeof storage.remove;
+        clear: typeof storage.clear;
+    };
+    share: typeof shareModule.share;
+    shareFile: typeof shareModule.shareFile;
+    auth: {
+        googleSignIn: typeof auth.googleSignIn;
+        googleSignOut: typeof auth.googleSignOut;
+    };
+    biometrics: {
+        isAvailable: typeof biometrics.isAvailable;
+        authenticate: typeof biometrics.authenticate;
+    };
+    contacts: {
+        getAll: typeof contacts.getAll;
+    };
+    clipboard: {
+        copy: typeof clipboard.copy;
+        read: typeof clipboard.read;
+    };
+    downloads: {
+        downloadFile: typeof downloads.downloadFile;
+    };
+    scanner: {
+        scan: typeof scanner.scan;
+    };
+    location: {
+        getCurrent: typeof location.getCurrent;
+    };
+    network: {
+        isOnline: typeof network.isOnline;
+        onConnectivityChange: typeof network.onConnectivityChange;
+    };
+    cache: {
+        clear: typeof cache.clear;
+        clearCookies: typeof cache.clearCookies;
+    };
+    print: typeof printModule.printPage;
+    screenshot: {
+        setProtection: typeof screenshot.setProtection;
+    };
+    reviews: {
+        request: typeof reviews.request;
+    };
+    updates: {
+        check: typeof updates.check;
+    };
+    ads: {
+        showInterstitial: typeof ads.showInterstitial;
+        showRewarded: typeof ads.showRewarded;
+    };
+    onesignal: {
+        setExternalUserId: typeof onesignal.setExternalUserId;
+        removeExternalUserId: typeof onesignal.removeExternalUserId;
+        sendTag: typeof onesignal.sendTag;
+        sendTags: typeof onesignal.sendTags;
+        getPlayerId: typeof onesignal.getPlayerId;
+    };
+    toast: typeof toastModule.showToast;
+    pedometer: {
+        isAvailable: typeof pedometer.isAvailable;
+        getStepCount: typeof pedometer.getStepCount;
+        startTracking: typeof pedometer.startTracking;
+        stopTracking: typeof pedometer.stopTracking;
+    };
+    on: typeof on;
+    off: typeof off;
+};
+export default nativine;
+export { platform, isNativeApp, isAndroid, isIos, device, ui, navigation, haptics, storage, auth, biometrics, contacts, clipboard, downloads, scanner, location, network, cache, screenshot, reviews, updates, ads, onesignal, pedometer, on, off, };
+export type { Platform } from './core/platform';
+export type { NativineEvent } from './modules/events';
+export type { DeviceInfo, SafeAreaInsets } from './modules/device';
+export type { StatusBarOptions, NavigationBarOptions } from './modules/ui';
+export type { HapticFeedbackType } from './modules/haptics';
+export type { ShareOptions, ShareFileOptions } from './modules/share';
+export type { GoogleSignInResult } from './modules/auth';
+export type { BiometricAvailability, BiometricAuthOptions, BiometricAuthResult, BiometryType } from './modules/biometrics';
+export type { Contact } from './modules/contacts';
+export type { DownloadFileOptions } from './modules/downloads';
+export type { ScanResult, ScanOptions } from './modules/camera';
+export type { LocationResult } from './modules/location';
+export type { ConnectivityStatus } from './modules/network';
+export type { ToastDuration } from './modules/toast';
+export type { RewardedAdResult } from './modules/ads';
+export type { StepCountResult, PedometerAvailability } from './modules/pedometer';

package/dist/modules/ads.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ads Module
+ *
+ * Control AdMob interstitial and rewarded ad display from your web app.
+ */
+export interface RewardedAdResult {
+    /** Whether the user watched the full ad and earned the reward */
+    rewarded: boolean;
+    /** Reward amount (if configured in AdMob) */
+    amount?: number;
+    /** Reward type (if configured in AdMob) */
+    type?: string;
+}
+/**
+ * Show a fullscreen interstitial ad.
+ * The ad must be pre-loaded by the native app.
+ *
+ * @example
+ * ```js
+ * // Show an ad between content transitions
+ * nativine.ads.showInterstitial();
+ * ```
+ */
+export declare function showInterstitial(): void;
+/**
+ * Show a rewarded video ad.
+ * Returns a Promise that resolves when the user finishes watching.
+ *
+ * @returns Promise resolving with the reward result
+ *
+ * @example
+ * ```js
+ * const result = await nativine.ads.showRewarded();
+ * if (result.rewarded) {
+ *   // Grant premium access for 24 hours
+ *   unlockPremiumContent();
+ * }
+ * ```
+ */
+export declare function showRewarded(): Promise<RewardedAdResult>;