nexa-device 0.7.0

package/dist/device.d.ts

@@ -0,0 +1,23 @@
+export declare function useVibration(): {
+    supported: boolean;
+    vibrate(pattern?: number | number[]): void;
+    stop(): void;
+};
+export declare function useNetwork(): {
+    type: import("nexa-reactivity").Signal<string>;
+    isOnline: import("nexa-reactivity").Signal<boolean>;
+    destroy(): void;
+};
+export declare function useOrientation(): {
+    isLandscape: import("nexa-reactivity").Signal<boolean>;
+    destroy(): void;
+};
+export declare function useClipboard(): {
+    copied: import("nexa-reactivity").Signal<boolean>;
+    copy(text: string): Promise<void>;
+    read(): Promise<string>;
+};
+export declare function useShare(): {
+    supported: boolean;
+    share(data: ShareData): Promise<boolean>;
+};

package/dist/device.js

@@ -0,0 +1,84 @@
+import { signal } from 'nexa-reactivity';
+export function useVibration() {
+    const supported = 'vibrate' in navigator;
+    return {
+        supported,
+        vibrate(pattern = 200) {
+            if (supported)
+                navigator.vibrate(pattern);
+        },
+        stop() {
+            if (supported)
+                navigator.vibrate(0);
+        }
+    };
+}
+export function useNetwork() {
+    const connection = navigator.connection ?? navigator.mozConnection ?? navigator.webkitConnection;
+    const type = signal(connection?.effectiveType ?? 'unknown');
+    const isOnline = signal(navigator.onLine);
+    const updateType = () => { type.value = connection?.effectiveType ?? 'unknown'; };
+    const updateOnline = () => { isOnline.value = true; };
+    const updateOffline = () => { isOnline.value = false; };
+    connection?.addEventListener('change', updateType);
+    window.addEventListener('online', updateOnline);
+    window.addEventListener('offline', updateOffline);
+    return {
+        type,
+        isOnline,
+        destroy() {
+            connection?.removeEventListener('change', updateType);
+            window.removeEventListener('online', updateOnline);
+            window.removeEventListener('offline', updateOffline);
+        }
+    };
+}
+export function useOrientation() {
+    const isLandscape = signal(window.innerWidth > window.innerHeight);
+    const update = () => {
+        isLandscape.value = window.innerWidth > window.innerHeight;
+    };
+    window.addEventListener('resize', update);
+    window.addEventListener('orientationchange', update);
+    return {
+        isLandscape,
+        destroy() {
+            window.removeEventListener('resize', update);
+            window.removeEventListener('orientationchange', update);
+        }
+    };
+}
+export function useClipboard() {
+    const copied = signal(false);
+    let timer = null;
+    return {
+        copied,
+        async copy(text) {
+            await navigator.clipboard.writeText(text);
+            copied.value = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => { copied.value = false; }, 2000);
+        },
+        async read() {
+            return navigator.clipboard.readText();
+        }
+    };
+}
+export function useShare() {
+    const supported = 'share' in navigator;
+    return {
+        supported,
+        async share(data) {
+            if (!supported)
+                return false;
+            try {
+                await navigator.share(data);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { useGeolocation } from './useGeolocation.js';
+export { useVibration, useNetwork, useOrientation, useClipboard, useShare } from './device.js';
+export type { GeolocationState } from './useGeolocation.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { useGeolocation } from './useGeolocation.js';
+export { useVibration, useNetwork, useOrientation, useClipboard, useShare } from './device.js';

package/dist/useGeolocation.d.ts

@@ -0,0 +1,10 @@
+import { signal } from 'nexa-reactivity';
+export interface GeolocationState {
+    latitude: ReturnType<typeof signal<number | null>>;
+    longitude: ReturnType<typeof signal<number | null>>;
+    accuracy: ReturnType<typeof signal<number | null>>;
+    error: ReturnType<typeof signal<string | null>>;
+    loading: ReturnType<typeof signal<boolean>>;
+    stop: () => void;
+}
+export declare function useGeolocation(options?: PositionOptions): GeolocationState;

package/dist/useGeolocation.js

@@ -0,0 +1,36 @@
+import { signal } from 'nexa-reactivity';
+export function useGeolocation(options) {
+    const latitude = signal(null);
+    const longitude = signal(null);
+    const accuracy = signal(null);
+    const error = signal(null);
+    const loading = signal(true);
+    let watchId = null;
+    if ('geolocation' in navigator) {
+        watchId = navigator.geolocation.watchPosition((pos) => {
+            latitude.value = pos.coords.latitude;
+            longitude.value = pos.coords.longitude;
+            accuracy.value = pos.coords.accuracy;
+            error.value = null;
+            loading.value = false;
+        }, (err) => {
+            error.value = err.message;
+            loading.value = false;
+        }, options);
+    }
+    else {
+        error.value = 'Geolocation not supported';
+        loading.value = false;
+    }
+    return {
+        latitude,
+        longitude,
+        accuracy,
+        error,
+        loading,
+        stop() {
+            if (watchId !== null)
+                navigator.geolocation.clearWatch(watchId);
+        }
+    };
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "nexa-device",
+  "version": "0.7.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "nexa-reactivity": "0.7.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  }
+}