@mostajs/browser-kit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog — @mostajs/browser-kit
+
+## [0.1.0] — 2026-06-23
+### Ajouté
+- **Lot 1** : wake-lock (extrait du plateau VoxStudio/host), fullscreen, visibility, network, web-share, clipboard (repli execCommand), vibration, screen-orientation.
+- **Lot 2** : geolocation, notifications, permissions, battery, idle-detection, media-devices (getUserMedia/getDisplayMedia/enumerate), sensors (orientation/motion + permission iOS), audio (beep/playSequence Web Audio), badging, file-system-access (repli input/download), contact-picker.
+- `capabilities()` : carte de support 21 clés. Exports par sous-chemin (tree-shaking). 6 tests (dégradé Node + navigateur simulé). README exhaustif + how2use.

package/README.md

@@ -0,0 +1,157 @@
+# @mostajs/browser-kit
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com>
+
+Façade unifiée des **Web APIs du navigateur** : une API cohérente, sûre et testable par-dessus une vingtaine de capacités natives. Membre de `mosta-browser-stack`.
+
+**Principes (chaque capacité respecte le même contrat) :**
+- **Feature-detection** — `isXSupported()` ou `capabilities()` avant tout appel.
+- **Promesses** — pas de callbacks bruts ; les abonnements renvoient une **fonction de désabonnement**.
+- **Dégradation gracieuse** — sur navigateur non compatible (ou sous **Node** : SSR/tests), rien ne jette : `false` / `null` / no-op.
+- **Tree-shaking** — import global *ou* par sous-chemin : `@mostajs/browser-kit/wake-lock`.
+- **Repli** quand pertinent — `clipboard` (execCommand), `file-system-access` (`<input type=file>` / `<a download>`).
+
+```bash
+npm i @mostajs/browser-kit
+```
+
+---
+
+## Démarrage rapide
+
+```js
+import { capabilities, createWakeLock, share, vibrate } from '@mostajs/browser-kit';
+
+// 1) Que sait faire ce navigateur ?
+console.log(capabilities());
+// { wakeLock:true, fullscreen:true, share:true, clipboard:true, geolocation:true, … }
+
+// 2) Empêcher la veille pendant une diffusion / lecture vidéo
+const wl = createWakeLock({ onChange: (on) => console.log('écran maintenu allumé:', on) });
+await wl.acquire();
+wl.bindAutoReacquire();          // ré-acquiert tout seul au retour au premier plan
+// … à la fin : await wl.dispose();
+
+// 3) Partager + vibrer (mobile)
+if (await share({ title: 'VoxStudio', url: location.href })) vibrate(50);
+```
+
+> Sous Node, `capabilities()` renvoie tout à `false` et chaque appel dégrade sans erreur — le module est **SSR-safe** et **testable**.
+
+---
+
+## How to use — recettes par cas d'usage
+
+### Garder l'écran allumé pendant un live (cas VoxStudio)
+```js
+import { createWakeLock } from '@mostajs/browser-kit/wake-lock';
+const wl = createWakeLock();
+startPublishBtn.onclick = async () => { /* … getUserMedia + WHIP … */ await wl.acquire(); wl.bindAutoReacquire(); };
+stopBtn.onclick = async () => { await wl.dispose(); };
+```
+
+### Bouton plein écran (avec icône qui suit l'état)
+```js
+import { toggleFullscreen, onFullscreenChange } from '@mostajs/browser-kit/fullscreen';
+btn.onclick = () => toggleFullscreen(document.getElementById('player'));
+onFullscreenChange((on) => btn.textContent = on ? '⤡ Quitter' : '⤢ Plein écran');
+```
+
+### Mettre l'app en pause quand l'onglet est caché (économie CPU/batterie)
+```js
+import { onHidden, onVisible } from '@mostajs/browser-kit/visibility';
+onHidden(() => player.pause());
+onVisible(() => player.play());
+```
+
+### Bandeau « hors-ligne » + adaptation à la qualité réseau
+```js
+import { onOffline, onOnline, connectionInfo } from '@mostajs/browser-kit/network';
+onOffline(() => banner.show('Hors-ligne — reconnexion…'));
+onOnline(() => banner.hide());
+const net = connectionInfo();                 // { effectiveType:'4g', downlink:10, saveData:false }
+if (net?.saveData || net?.effectiveType === '2g') useLowQuality();
+```
+
+### Copier un lien d'invitation (repli automatique en HTTP)
+```js
+import { writeText } from '@mostajs/browser-kit/clipboard';
+copyBtn.onclick = async () => { if (await writeText(inviteUrl)) toast('Lien copié ✓'); };
+```
+
+### Notifier + pastille d'icône (PWA) à l'arrivée d'une question Q&A
+```js
+import { notify } from '@mostajs/browser-kit/notifications';
+import { setBadge } from '@mostajs/browser-kit/badging';
+await notify('Nouvelle question', { body: q.text, icon: '/logo.png' });
+await setBadge(unread);
+```
+
+### Position de l'utilisateur (carte d'un événement)
+```js
+import { getCurrentPosition } from '@mostajs/browser-kit/geolocation';
+const pos = await getCurrentPosition();        // { lat, lng, accuracy } ou null si refusé
+if (pos) centerMap(pos.lat, pos.lng);
+```
+
+### Choisir caméra/micro + partage d'écran (plateau)
+```js
+import { enumerateDevices, getUserMedia, getDisplayMedia, stopStream } from '@mostajs/browser-kit/media-devices';
+const { cameras, microphones } = await enumerateDevices();
+const cam = await getUserMedia({ video: { deviceId: cameras[0]?.deviceId }, audio: true });
+const screen = await getDisplayMedia();        // partage d'écran
+// … stopStream(cam) à l'arrêt
+```
+
+### Bip de notification synthétisé (sans fichier audio)
+```js
+import { beep, playSequence } from '@mostajs/browser-kit/audio';
+beep({ freq: 880, duration: 120 });            // après un geste utilisateur
+playSequence([{ freq: 660, duration: 100 }, { freq: 990, duration: 140 }]);
+```
+
+---
+
+## Référence des capacités
+
+`capabilities()` → carte booléenne de tout ce qui suit (**21 clés**).
+
+### Lot 1
+| Module / sous-chemin | Exports |
+|---|---|
+| **`wake-lock`** | `isWakeLockSupported()` · `createWakeLock({onChange})` → `{ isSupported, acquire(), release(), isActive(), bindAutoReacquire()→off, dispose() }` |
+| **`fullscreen`** | `isFullscreenSupported()` · `isFullscreen()` · `requestFullscreen(el?)` · `exitFullscreen()` · `toggleFullscreen(el?)` · `onFullscreenChange(cb)→off` |
+| **`visibility`** | `isVisibilitySupported()` · `isVisible()` · `onVisibilityChange(cb)→off` · `onVisible(cb)` · `onHidden(cb)` |
+| **`network`** | `isOnline()` · `isNetworkInfoSupported()` · `connectionInfo()` → `{effectiveType,downlink,rtt,saveData,type}` · `onNetworkChange(cb)` · `onOnline(cb)` · `onOffline(cb)` · `onConnectionChange(cb)` |
+| **`web-share`** | `isShareSupported()` · `canShareFiles()` · `canShare(data)` · `share({title,text,url,files})` → bool |
+| **`clipboard`** | `isClipboardSupported()` · `writeText(s)` → bool *(repli execCommand)* · `readText()` → string\|null |
+| **`vibration`** | `isVibrationSupported()` · `vibrate(pattern)` · `stopVibration()` |
+| **`screen-orientation`** | `isOrientationSupported()` · `currentOrientation()` → `{type,angle}` · `lockOrientation(type)` · `unlockOrientation()` · `onOrientationChange(cb)→off` |
+
+### Lot 2
+| Module / sous-chemin | Exports |
+|---|---|
+| **`geolocation`** | `isGeolocationSupported()` · `getCurrentPosition(opts)` → `{lat,lng,accuracy,altitude,heading,speed,timestamp}`\|null · `watchPosition(cb,opts)`→off |
+| **`notifications`** | `isNotificationSupported()` · `notificationPermission()` · `requestNotificationPermission()` → état · `notify(title,opts)` → Notification\|null |
+| **`permissions`** | `isPermissionsSupported()` · `queryPermission(name)` → `'granted'\|'denied'\|'prompt'`\|null · `onPermissionChange(name,cb)`→off |
+| **`battery`** | `isBatterySupported()` · `getBattery()` → `{level,charging,chargingTime,dischargingTime}`\|null · `onBatteryChange(cb)`→off |
+| **`idle-detection`** | `isIdleDetectionSupported()` · `requestIdlePermission()` · `createIdleDetector({threshold,onChange})` → `{start(),stop()}` |
+| **`media-devices`** | `isMediaDevicesSupported()` · `isDisplayMediaSupported()` · `enumerateDevices()` → `{cameras,microphones,speakers}` · `getUserMedia(c)` · `getDisplayMedia(c)` · `stopStream(s)` · `onDeviceChange(cb)`→off |
+| **`sensors`** | `isOrientationSensorSupported()` · `isMotionSensorSupported()` · `requestSensorPermission()` *(iOS 13+)* · `onDeviceOrientation(cb)`→off · `onDeviceMotion(cb)`→off |
+| **`audio`** | `isAudioSupported()` · `beep({freq,duration,type,volume})` → bool · `playSequence([{freq,duration,gap}])` *(Web Audio, sans fichier)* |
+| **`badging`** | `isBadgingSupported()` · `setBadge(count?)` · `clearBadge()` *(pastille icône PWA)* |
+| **`file-system-access`** | `isFileSystemAccessSupported()` · `openFile(opts)` → File\|null *(repli `<input file>`)* · `saveFile(blob,opts)` → bool *(repli `<a download>`)* |
+| **`contact-picker`** | `isContactPickerSupported()` · `pickContacts(props,opts)` → contacts\|null · `availableContactProperties()` |
+
+---
+
+## Notes & limites
+- **Contexte sécurisé (HTTPS)** requis par la plupart des API (Wake Lock, Clipboard async, getUserMedia, Geolocation…).
+- **Geste utilisateur** requis pour : Fullscreen, Web Share, déblocage du contexte Audio, permission capteurs iOS.
+- **Permissions** : Geolocation, Notifications, Camera/Micro, Idle Detection demandent l'accord de l'utilisateur — vérifier l'état via `permissions`.
+- **Disponibilité variable** : `idle-detection`, `badging`, `contact-picker`, `file-system-access`, Network Information sont surtout sur Chromium. Toujours tester via `capabilities()` et prévoir le repli.
+
+## Tests
+`npm test` — 6 tests (`@mostajs/mjs-unit`) : dégradé sous Node + navigateur simulé (`globalThis.navigator`/`Notification`).
+
+Licence : AGPL-3.0-or-later.

package/llms.txt

@@ -0,0 +1,28 @@
+# @mostajs/browser-kit
+Façade des Web APIs du navigateur. ESM côté navigateur (dégrade sous Node : isSupported=false, SSR-safe). Chaque capacité : feature-detection (isXSupported) + API promise + cleanup (abonnement → fonction off). Exports par sous-chemin (tree-shaking).
+capabilities() → carte booléenne 21 clés : wakeLock fullscreen visibility network share clipboard vibration orientation geolocation notifications permissions battery idleDetection mediaDevices displayMedia orientationSensor motionSensor audio badging fileSystemAccess contactPicker.
+
+## Lot 1
+./wake-lock         isWakeLockSupported() ; createWakeLock({onChange}) → {isSupported,acquire(),release(),isActive(),bindAutoReacquire()→off,dispose()}
+./fullscreen        isFullscreenSupported() isFullscreen() requestFullscreen(el?) exitFullscreen() toggleFullscreen(el?) onFullscreenChange(cb)→off
+./visibility        isVisibilitySupported() isVisible() onVisibilityChange(cb)→off onVisible(cb) onHidden(cb)
+./network           isOnline() isNetworkInfoSupported() connectionInfo()→{effectiveType,downlink,rtt,saveData,type} onNetworkChange/onOnline/onOffline/onConnectionChange(cb)→off
+./web-share         isShareSupported() canShareFiles() canShare(data) share({title,text,url,files})→bool
+./clipboard         isClipboardSupported() writeText(s)→bool (repli execCommand) readText()→string|null
+./vibration         isVibrationSupported() vibrate(pattern) stopVibration()
+./screen-orientation isOrientationSupported() currentOrientation()→{type,angle} lockOrientation(type) unlockOrientation() onOrientationChange(cb)→off
+
+## Lot 2
+./geolocation       isGeolocationSupported() getCurrentPosition(opts)→{lat,lng,accuracy,...}|null watchPosition(cb,opts)→off
+./notifications     isNotificationSupported() notificationPermission() requestNotificationPermission()→état notify(title,opts)→Notification|null
+./permissions       isPermissionsSupported() queryPermission(name)→state|null onPermissionChange(name,cb)→off
+./battery           isBatterySupported() getBattery()→{level,charging,chargingTime,dischargingTime}|null onBatteryChange(cb)→off
+./idle-detection    isIdleDetectionSupported() requestIdlePermission() createIdleDetector({threshold,onChange})→{start(),stop()}
+./media-devices     isMediaDevicesSupported() isDisplayMediaSupported() enumerateDevices()→{cameras,microphones,speakers} getUserMedia(c) getDisplayMedia(c) stopStream(s) onDeviceChange(cb)→off
+./sensors           isOrientationSensorSupported() isMotionSensorSupported() requestSensorPermission() (iOS13+) onDeviceOrientation(cb)→off onDeviceMotion(cb)→off
+./audio             isAudioSupported() beep({freq,duration,type,volume})→bool playSequence([{freq,duration,gap}]) (Web Audio, sans fichier)
+./badging           isBadgingSupported() setBadge(count?) clearBadge() (pastille PWA)
+./file-system-access isFileSystemAccessSupported() openFile(opts)→File|null (repli input) saveFile(blob,opts)→bool (repli a download)
+./contact-picker    isContactPickerSupported() pickContacts(props,opts)→contacts|null availableContactProperties()
+
+Notes : HTTPS requis (Wake Lock, Clipboard async, getUserMedia, Geolocation) ; geste utilisateur (Fullscreen, Share, Audio, capteurs iOS) ; idle/badging/contact/file-system/network-info surtout Chromium → tester via capabilities().

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@mostajs/browser-kit",
+  "version": "0.1.0",
+  "description": "Façade unifiée des Web APIs du navigateur (Wake Lock, Fullscreen, Visibility, Network, Web Share, Clipboard, Vibration, Screen Orientation…). Feature-detection + API promise + cleanup, dégradation gracieuse. ESM côté navigateur (se charge aussi sous Node : isSupported=false).",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": "./src/index.js",
+    "./wake-lock": "./src/wake-lock.js",
+    "./fullscreen": "./src/fullscreen.js",
+    "./visibility": "./src/visibility.js",
+    "./network": "./src/network.js",
+    "./web-share": "./src/web-share.js",
+    "./clipboard": "./src/clipboard.js",
+    "./vibration": "./src/vibration.js",
+    "./screen-orientation": "./src/screen-orientation.js",
+    "./geolocation": "./src/geolocation.js",
+    "./notifications": "./src/notifications.js",
+    "./permissions": "./src/permissions.js",
+    "./battery": "./src/battery.js",
+    "./idle-detection": "./src/idle-detection.js",
+    "./media-devices": "./src/media-devices.js",
+    "./sensors": "./src/sensors.js",
+    "./audio": "./src/audio.js",
+    "./badging": "./src/badging.js",
+    "./file-system-access": "./src/file-system-access.js",
+    "./contact-picker": "./src/contact-picker.js"
+  },
+  "keywords": [
+    "mostajs",
+    "browser",
+    "web-api",
+    "wake-lock",
+    "fullscreen",
+    "web-share",
+    "clipboard",
+    "pwa"
+  ],
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.3.0"
+  },
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh"
+  }
+}

package/src/audio.js

@@ -0,0 +1,36 @@
+// @mostajs/browser-kit — Web Audio : bips/tonalités sans fichier. Author: Dr Hamid MADANI <drmdh@msn.com>
+const AC = () => (typeof window !== 'undefined' ? window.AudioContext || window.webkitAudioContext : null);
+
+export const isAudioSupported = () => !!AC();
+
+let ctx = null;
+function context() {
+  const Ctor = AC();
+  if (!Ctor) return null;
+  if (!ctx) ctx = new Ctor();
+  if (ctx.state === 'suspended') ctx.resume().catch(() => {}); // débloquer après un geste utilisateur
+  return ctx;
+}
+
+/** Joue une tonalité synthétisée. { freq=880, duration=150 (ms), type='sine', volume=0.2 }. → true/false. */
+export function beep({ freq = 880, duration = 150, type = 'sine', volume = 0.2 } = {}) {
+  const c = context();
+  if (!c) return false;
+  try {
+    const osc = c.createOscillator();
+    const gain = c.createGain();
+    osc.type = type; osc.frequency.value = freq; gain.gain.value = volume;
+    osc.connect(gain); gain.connect(c.destination);
+    const now = c.currentTime;
+    osc.start(now);
+    gain.gain.setValueAtTime(volume, now);
+    gain.gain.exponentialRampToValueAtTime(0.0001, now + duration / 1000); // fondu pour éviter le clic
+    osc.stop(now + duration / 1000);
+    return true;
+  } catch { return false; }
+}
+
+/** Joue une séquence de bips : [{freq,duration,gap?}, …]. */
+export async function playSequence(notes = []) {
+  for (const n of notes) { beep(n); await new Promise((r) => setTimeout(r, (n.duration || 150) + (n.gap || 40))); }
+}

package/src/badging.js

@@ -0,0 +1,15 @@
+// @mostajs/browser-kit — App Badging API (pastille sur l'icône PWA). Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasNavigator = () => typeof navigator !== 'undefined';
+
+export const isBadgingSupported = () => hasNavigator() && typeof navigator.setAppBadge === 'function';
+
+/** Pose une pastille (nombre, ou pastille simple si count omis). → true/false. */
+export async function setBadge(count) {
+  if (!isBadgingSupported()) return false;
+  try { await (count === undefined ? navigator.setAppBadge() : navigator.setAppBadge(count)); return true; } catch { return false; }
+}
+
+export async function clearBadge() {
+  if (!hasNavigator() || typeof navigator.clearAppBadge !== 'function') return false;
+  try { await navigator.clearAppBadge(); return true; } catch { return false; }
+}

package/src/battery.js

@@ -0,0 +1,24 @@
+// @mostajs/browser-kit — Battery Status API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasNavigator = () => typeof navigator !== 'undefined';
+
+export const isBatterySupported = () => hasNavigator() && typeof navigator.getBattery === 'function';
+
+const snapshot = (b) => ({ level: b.level, charging: b.charging, chargingTime: b.chargingTime, dischargingTime: b.dischargingTime });
+
+/** État courant de la batterie. → { level, charging, chargingTime, dischargingTime } ou null. */
+export async function getBattery() {
+  if (!isBatterySupported()) return null;
+  try { return snapshot(await navigator.getBattery()); } catch { return null; }
+}
+
+/** Abonne aux changements de batterie (niveau/charge). cb(snapshot). → désabonnement. */
+export async function onBatteryChange(cb) {
+  if (!isBatterySupported()) return () => {};
+  try {
+    const b = await navigator.getBattery();
+    const handler = () => cb(snapshot(b));
+    const events = ['levelchange', 'chargingchange', 'chargingtimechange', 'dischargingtimechange'];
+    events.forEach((e) => b.addEventListener(e, handler));
+    return () => events.forEach((e) => b.removeEventListener(e, handler));
+  } catch { return () => {}; }
+}

package/src/clipboard.js

@@ -0,0 +1,27 @@
+// @mostajs/browser-kit — Clipboard API (avec repli execCommand). Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasNavigator = () => typeof navigator !== 'undefined';
+const hasDocument = () => typeof document !== 'undefined';
+
+export const isClipboardSupported = () => hasNavigator() && !!navigator.clipboard;
+
+/** Copie un texte. Repli sur un <textarea> + execCommand si l'API async indisponible (http, vieux navigateur). → true/false. */
+export async function writeText(text) {
+  if (isClipboardSupported() && navigator.clipboard.writeText) {
+    try { await navigator.clipboard.writeText(text); return true; } catch { /* repli */ }
+  }
+  if (!hasDocument()) return false;
+  try {
+    const ta = document.createElement('textarea');
+    ta.value = text; ta.style.position = 'fixed'; ta.style.opacity = '0';
+    document.body.appendChild(ta); ta.select();
+    const ok = document.execCommand('copy');
+    document.body.removeChild(ta);
+    return ok;
+  } catch { return false; }
+}
+
+/** Lit le presse-papiers (nécessite permission + contexte sécurisé). → texte ou null. */
+export async function readText() {
+  if (!isClipboardSupported() || !navigator.clipboard.readText) return null;
+  try { return await navigator.clipboard.readText(); } catch { return null; }
+}

package/src/contact-picker.js

@@ -0,0 +1,18 @@
+// @mostajs/browser-kit — Contact Picker API (Android Chrome). Author: Dr Hamid MADANI <drmdh@msn.com>
+const cp = () => (typeof navigator !== 'undefined' ? navigator.contacts : null);
+
+export const isContactPickerSupported = () => !!(cp() && cp().select);
+
+/** Ouvre le sélecteur de contacts. props = ['name','email','tel','address','icon']. → tableau de contacts ou null. */
+export async function pickContacts(props = ['name', 'email', 'tel'], opts = { multiple: true }) {
+  const c = cp();
+  if (!c || !c.select) return null;
+  try { return await c.select(props, opts); } catch { return null; }
+}
+
+/** Propriétés sélectionnables par ce navigateur. → tableau ou []. */
+export async function availableContactProperties() {
+  const c = cp();
+  if (!c || !c.getProperties) return [];
+  try { return await c.getProperties(); } catch { return []; }
+}

package/src/file-system-access.js

@@ -0,0 +1,38 @@
+// @mostajs/browser-kit — File System Access API (avec replis). Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasWindow = () => typeof window !== 'undefined';
+const hasDocument = () => typeof document !== 'undefined';
+
+export const isFileSystemAccessSupported = () => hasWindow() && 'showOpenFilePicker' in window;
+
+/** Ouvre un sélecteur de fichier. → File ou null (repli <input type=file>). opts = { types?, multiple? }. */
+export async function openFile(opts = {}) {
+  if (isFileSystemAccessSupported()) {
+    try { const [h] = await window.showOpenFilePicker(opts); return await h.getFile(); } catch { return null; }
+  }
+  if (!hasDocument()) return null;
+  return new Promise((resolve) => {
+    const input = document.createElement('input');
+    input.type = 'file';
+    if (opts.accept) input.accept = opts.accept;
+    input.onchange = () => resolve(input.files?.[0] || null);
+    input.click();
+  });
+}
+
+/** Enregistre un Blob. → true/false (repli téléchargement <a download>). opts = { suggestedName?, types? }. */
+export async function saveFile(blob, opts = {}) {
+  if (hasWindow() && 'showSaveFilePicker' in window) {
+    try {
+      const h = await window.showSaveFilePicker({ suggestedName: opts.suggestedName, types: opts.types });
+      const w = await h.createWritable(); await w.write(blob); await w.close(); return true;
+    } catch { return false; }
+  }
+  if (!hasDocument()) return false;
+  try {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url; a.download = opts.suggestedName || 'download';
+    a.click(); setTimeout(() => URL.revokeObjectURL(url), 1000);
+    return true;
+  } catch { return false; }
+}

package/src/fullscreen.js

@@ -0,0 +1,37 @@
+// @mostajs/browser-kit — Fullscreen API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasDocument = () => typeof document !== 'undefined';
+
+export const isFullscreenSupported = () =>
+  hasDocument() && !!(document.fullscreenEnabled || document.webkitFullscreenEnabled);
+
+export const isFullscreen = () =>
+  hasDocument() && !!(document.fullscreenElement || document.webkitFullscreenElement);
+
+export async function requestFullscreen(el) {
+  if (!hasDocument()) return false;
+  const target = el || document.documentElement;
+  const fn = target.requestFullscreen || target.webkitRequestFullscreen;
+  if (!fn) return false;
+  try { await fn.call(target); return true; } catch { return false; }
+}
+
+export async function exitFullscreen() {
+  if (!hasDocument()) return false;
+  const fn = document.exitFullscreen || document.webkitExitFullscreen;
+  if (!fn) return false;
+  try { await fn.call(document); return true; } catch { return false; }
+}
+
+export const toggleFullscreen = (el) => (isFullscreen() ? exitFullscreen() : requestFullscreen(el));
+
+/** Abonne aux changements de plein écran. → fonction de désabonnement. */
+export function onFullscreenChange(cb) {
+  if (!hasDocument()) return () => {};
+  const handler = () => cb(isFullscreen());
+  document.addEventListener('fullscreenchange', handler);
+  document.addEventListener('webkitfullscreenchange', handler);
+  return () => {
+    document.removeEventListener('fullscreenchange', handler);
+    document.removeEventListener('webkitfullscreenchange', handler);
+  };
+}

package/src/geolocation.js

@@ -0,0 +1,24 @@
+// @mostajs/browser-kit — Geolocation API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const geo = () => (typeof navigator !== 'undefined' ? navigator.geolocation : null);
+
+export const isGeolocationSupported = () => !!geo();
+
+const toPos = (p) => ({
+  lat: p.coords.latitude, lng: p.coords.longitude, accuracy: p.coords.accuracy,
+  altitude: p.coords.altitude, heading: p.coords.heading, speed: p.coords.speed, timestamp: p.timestamp,
+});
+
+/** Position courante. → { lat, lng, accuracy, … } ou null. */
+export function getCurrentPosition(opts = { enableHighAccuracy: true, timeout: 10000 }) {
+  const g = geo();
+  if (!g) return Promise.resolve(null);
+  return new Promise((resolve) => g.getCurrentPosition((p) => resolve(toPos(p)), () => resolve(null), opts));
+}
+
+/** Suit la position. cb({lat,lng,…}). → fonction d'arrêt. */
+export function watchPosition(cb, opts = { enableHighAccuracy: true }) {
+  const g = geo();
+  if (!g) return () => {};
+  const id = g.watchPosition((p) => cb(toPos(p)), () => {}, opts);
+  return () => g.clearWatch(id);
+}

package/src/idle-detection.js

@@ -0,0 +1,31 @@
+// @mostajs/browser-kit — Idle Detection API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasIdle = () => typeof globalThis !== 'undefined' && 'IdleDetector' in globalThis;
+
+export const isIdleDetectionSupported = () => hasIdle();
+
+/** Demande la permission idle-detection. → 'granted' | 'denied'. */
+export async function requestIdlePermission() {
+  if (!hasIdle()) return 'denied';
+  try { return await globalThis.IdleDetector.requestPermission(); } catch { return 'denied'; }
+}
+
+/**
+ * Détecteur d'inactivité utilisateur/écran.
+ *   threshold : ms (≥ 60000).  onChange({ user:'active'|'idle', screen:'locked'|'unlocked' }).
+ * → { start(), stop() }.
+ */
+export function createIdleDetector({ threshold = 60000, onChange } = {}) {
+  let detector = null, ctrl = null;
+  async function start() {
+    if (!hasIdle()) return false;
+    try {
+      ctrl = new AbortController();
+      detector = new globalThis.IdleDetector();
+      detector.addEventListener('change', () => onChange?.({ user: detector.userState, screen: detector.screenState }));
+      await detector.start({ threshold, signal: ctrl.signal });
+      return true;
+    } catch { return false; }
+  }
+  function stop() { try { ctrl?.abort(); } catch {} detector = null; ctrl = null; }
+  return { start, stop };
+}

package/src/index.js

@@ -0,0 +1,70 @@
+// @mostajs/browser-kit — façade des Web APIs du navigateur. Author: Dr Hamid MADANI <drmdh@msn.com>
+// Chaque capacité : feature-detection (isXSupported) + API promise + cleanup. ESM navigateur (dégrade proprement sous Node).
+// — Lot 1 —
+export * from './wake-lock.js';
+export * from './fullscreen.js';
+export * from './visibility.js';
+export * from './network.js';
+export * from './web-share.js';
+export * from './clipboard.js';
+export * from './vibration.js';
+export * from './screen-orientation.js';
+// — Lot 2 —
+export * from './geolocation.js';
+export * from './notifications.js';
+export * from './permissions.js';
+export * from './battery.js';
+export * from './idle-detection.js';
+export * from './media-devices.js';
+export * from './sensors.js';
+export * from './audio.js';
+export * from './badging.js';
+export * from './file-system-access.js';
+export * from './contact-picker.js';
+
+import { isWakeLockSupported } from './wake-lock.js';
+import { isFullscreenSupported } from './fullscreen.js';
+import { isVisibilitySupported } from './visibility.js';
+import { isNetworkInfoSupported } from './network.js';
+import { isShareSupported } from './web-share.js';
+import { isClipboardSupported } from './clipboard.js';
+import { isVibrationSupported } from './vibration.js';
+import { isOrientationSupported } from './screen-orientation.js';
+import { isGeolocationSupported } from './geolocation.js';
+import { isNotificationSupported } from './notifications.js';
+import { isPermissionsSupported } from './permissions.js';
+import { isBatterySupported } from './battery.js';
+import { isIdleDetectionSupported } from './idle-detection.js';
+import { isMediaDevicesSupported, isDisplayMediaSupported } from './media-devices.js';
+import { isOrientationSensorSupported, isMotionSensorSupported } from './sensors.js';
+import { isAudioSupported } from './audio.js';
+import { isBadgingSupported } from './badging.js';
+import { isFileSystemAccessSupported } from './file-system-access.js';
+import { isContactPickerSupported } from './contact-picker.js';
+
+/** Carte de support de toutes les capacités du navigateur courant (booléens). */
+export function capabilities() {
+  return {
+    wakeLock: isWakeLockSupported(),
+    fullscreen: isFullscreenSupported(),
+    visibility: isVisibilitySupported(),
+    network: isNetworkInfoSupported(),
+    share: isShareSupported(),
+    clipboard: isClipboardSupported(),
+    vibration: isVibrationSupported(),
+    orientation: isOrientationSupported(),
+    geolocation: isGeolocationSupported(),
+    notifications: isNotificationSupported(),
+    permissions: isPermissionsSupported(),
+    battery: isBatterySupported(),
+    idleDetection: isIdleDetectionSupported(),
+    mediaDevices: isMediaDevicesSupported(),
+    displayMedia: isDisplayMediaSupported(),
+    orientationSensor: isOrientationSensorSupported(),
+    motionSensor: isMotionSensorSupported(),
+    audio: isAudioSupported(),
+    badging: isBadgingSupported(),
+    fileSystemAccess: isFileSystemAccessSupported(),
+    contactPicker: isContactPickerSupported(),
+  };
+}

package/src/media-devices.js

@@ -0,0 +1,45 @@
+// @mostajs/browser-kit — MediaDevices (caméras/micros, getUserMedia, partage d'écran). Author: Dr Hamid MADANI <drmdh@msn.com>
+const md = () => (typeof navigator !== 'undefined' ? navigator.mediaDevices : null);
+
+export const isMediaDevicesSupported = () => !!(md() && md().getUserMedia);
+export const isDisplayMediaSupported = () => !!(md() && md().getDisplayMedia);
+
+/** Liste les périphériques groupés. → { cameras, microphones, speakers } (tableaux de MediaDeviceInfo). */
+export async function enumerateDevices() {
+  const m = md();
+  if (!m || !m.enumerateDevices) return { cameras: [], microphones: [], speakers: [] };
+  try {
+    const all = await m.enumerateDevices();
+    return {
+      cameras: all.filter((d) => d.kind === 'videoinput'),
+      microphones: all.filter((d) => d.kind === 'audioinput'),
+      speakers: all.filter((d) => d.kind === 'audiooutput'),
+    };
+  } catch { return { cameras: [], microphones: [], speakers: [] }; }
+}
+
+/** getUserMedia (caméra/micro). → MediaStream ou null. */
+export async function getUserMedia(constraints = { video: true, audio: true }) {
+  const m = md();
+  if (!m || !m.getUserMedia) return null;
+  try { return await m.getUserMedia(constraints); } catch { return null; }
+}
+
+/** getDisplayMedia (partage d'écran). → MediaStream ou null. */
+export async function getDisplayMedia(constraints = { video: true }) {
+  const m = md();
+  if (!m || !m.getDisplayMedia) return null;
+  try { return await m.getDisplayMedia(constraints); } catch { return null; }
+}
+
+/** Arrête toutes les pistes d'un flux. */
+export function stopStream(stream) { stream?.getTracks?.().forEach((t) => t.stop()); }
+
+/** Abonne aux changements de périphériques (branchement/débranchement). → désabonnement. */
+export function onDeviceChange(cb) {
+  const m = md();
+  if (!m || !m.addEventListener) return () => {};
+  const handler = () => cb();
+  m.addEventListener('devicechange', handler);
+  return () => m.removeEventListener('devicechange', handler);
+}

package/src/network.js

@@ -0,0 +1,35 @@
+// @mostajs/browser-kit — Online/Offline + Network Information API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasNavigator = () => typeof navigator !== 'undefined';
+const hasWindow = () => typeof window !== 'undefined';
+const conn = () => (hasNavigator() ? navigator.connection || navigator.mozConnection || navigator.webkitConnection : null);
+
+export const isOnline = () => (hasNavigator() && 'onLine' in navigator ? navigator.onLine : true);
+export const isNetworkInfoSupported = () => !!conn();
+
+/** Infos de connexion (Network Information API) : { effectiveType, downlink, rtt, saveData } ou null. */
+export function connectionInfo() {
+  const c = conn();
+  if (!c) return null;
+  return { effectiveType: c.effectiveType, downlink: c.downlink, rtt: c.rtt, saveData: !!c.saveData, type: c.type };
+}
+
+/** Abonne aux passages online/offline. cb(online:boolean). → désabonnement. */
+export function onNetworkChange(cb) {
+  if (!hasWindow()) return () => {};
+  const on = () => cb(true), off = () => cb(false);
+  window.addEventListener('online', on);
+  window.addEventListener('offline', off);
+  return () => { window.removeEventListener('online', on); window.removeEventListener('offline', off); };
+}
+
+export const onOnline = (cb) => onNetworkChange((o) => { if (o) cb(); });
+export const onOffline = (cb) => onNetworkChange((o) => { if (!o) cb(); });
+
+/** Abonne aux changements de qualité de connexion (effectiveType…). → désabonnement. */
+export function onConnectionChange(cb) {
+  const c = conn();
+  if (!c || !c.addEventListener) return () => {};
+  const handler = () => cb(connectionInfo());
+  c.addEventListener('change', handler);
+  return () => c.removeEventListener('change', handler);
+}

package/src/notifications.js

@@ -0,0 +1,20 @@
+// @mostajs/browser-kit — Notifications API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const N = () => (typeof Notification !== 'undefined' ? Notification : null);
+
+export const isNotificationSupported = () => !!N();
+export const notificationPermission = () => (N() ? N().permission : 'denied');
+
+/** Demande la permission. → 'granted' | 'denied' | 'default'. */
+export async function requestNotificationPermission() {
+  const n = N();
+  if (!n) return 'denied';
+  try { return await n.requestPermission(); } catch { return 'denied'; }
+}
+
+/** Affiche une notification (demande la permission si besoin). → Notification | null. */
+export async function notify(title, options = {}) {
+  const n = N();
+  if (!n) return null;
+  if (n.permission !== 'granted') { if ((await requestNotificationPermission()) !== 'granted') return null; }
+  try { return new n(title, options); } catch { return null; }
+}

package/src/permissions.js

@@ -0,0 +1,23 @@
+// @mostajs/browser-kit — Permissions API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const perms = () => (typeof navigator !== 'undefined' ? navigator.permissions : null);
+
+export const isPermissionsSupported = () => !!perms();
+
+/** État d'une permission ('granted'|'denied'|'prompt') ou null. name = 'camera'|'microphone'|'geolocation'|'notifications'|… */
+export async function queryPermission(name) {
+  const p = perms();
+  if (!p) return null;
+  try { const status = await p.query({ name }); return status.state; } catch { return null; }
+}
+
+/** Abonne aux changements d'état d'une permission. cb(state). → désabonnement. */
+export async function onPermissionChange(name, cb) {
+  const p = perms();
+  if (!p) return () => {};
+  try {
+    const status = await p.query({ name });
+    const handler = () => cb(status.state);
+    status.addEventListener('change', handler);
+    return () => status.removeEventListener('change', handler);
+  } catch { return () => {}; }
+}

package/src/screen-orientation.js

@@ -0,0 +1,27 @@
+// @mostajs/browser-kit — Screen Orientation API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const so = () => (typeof screen !== 'undefined' ? screen.orientation : null);
+
+export const isOrientationSupported = () => !!so();
+export const currentOrientation = () => { const o = so(); return o ? { type: o.type, angle: o.angle } : null; };
+
+/** Verrouille l'orientation (ex. 'landscape', 'portrait'). Nécessite souvent le plein écran. → true/false. */
+export async function lockOrientation(type) {
+  const o = so();
+  if (!o || !o.lock) return false;
+  try { await o.lock(type); return true; } catch { return false; }
+}
+
+export function unlockOrientation() {
+  const o = so();
+  if (!o || !o.unlock) return false;
+  try { o.unlock(); return true; } catch { return false; }
+}
+
+/** Abonne aux changements d'orientation. cb({type,angle}). → désabonnement. */
+export function onOrientationChange(cb) {
+  const o = so();
+  if (!o || !o.addEventListener) return () => {};
+  const handler = () => cb(currentOrientation());
+  o.addEventListener('change', handler);
+  return () => o.removeEventListener('change', handler);
+}

package/src/sensors.js

@@ -0,0 +1,33 @@
+// @mostajs/browser-kit — DeviceOrientation / DeviceMotion (capteurs). Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasWindow = () => typeof window !== 'undefined';
+
+export const isOrientationSensorSupported = () => hasWindow() && 'DeviceOrientationEvent' in window;
+export const isMotionSensorSupported = () => hasWindow() && 'DeviceMotionEvent' in window;
+
+/** iOS 13+ exige une permission explicite (sur geste utilisateur). → 'granted' | 'denied'. */
+export async function requestSensorPermission() {
+  const E = hasWindow() ? window.DeviceOrientationEvent : null;
+  if (E && typeof E.requestPermission === 'function') {
+    try { return await E.requestPermission(); } catch { return 'denied'; }
+  }
+  return 'granted'; // pas de gate de permission sur ce navigateur
+}
+
+/** Abonne à l'orientation de l'appareil. cb({ alpha, beta, gamma, absolute }). → désabonnement. */
+export function onDeviceOrientation(cb) {
+  if (!isOrientationSensorSupported()) return () => {};
+  const handler = (e) => cb({ alpha: e.alpha, beta: e.beta, gamma: e.gamma, absolute: e.absolute });
+  window.addEventListener('deviceorientation', handler);
+  return () => window.removeEventListener('deviceorientation', handler);
+}
+
+/** Abonne au mouvement de l'appareil. cb({ acceleration, accelerationIncludingGravity, rotationRate, interval }). → désabonnement. */
+export function onDeviceMotion(cb) {
+  if (!isMotionSensorSupported()) return () => {};
+  const handler = (e) => cb({
+    acceleration: e.acceleration, accelerationIncludingGravity: e.accelerationIncludingGravity,
+    rotationRate: e.rotationRate, interval: e.interval,
+  });
+  window.addEventListener('devicemotion', handler);
+  return () => window.removeEventListener('devicemotion', handler);
+}

package/src/vibration.js

@@ -0,0 +1,12 @@
+// @mostajs/browser-kit — Vibration API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasNavigator = () => typeof navigator !== 'undefined';
+
+export const isVibrationSupported = () => hasNavigator() && typeof navigator.vibrate === 'function';
+
+/** Fait vibrer. pattern = ms ou tableau [vibre, pause, vibre, …]. → true/false. */
+export function vibrate(pattern = 200) {
+  if (!isVibrationSupported()) return false;
+  try { return navigator.vibrate(pattern); } catch { return false; }
+}
+
+export const stopVibration = () => vibrate(0);

package/src/visibility.js

@@ -0,0 +1,16 @@
+// @mostajs/browser-kit — Page Visibility API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasDocument = () => typeof document !== 'undefined';
+
+export const isVisibilitySupported = () => hasDocument() && 'visibilityState' in document;
+export const isVisible = () => (hasDocument() ? document.visibilityState === 'visible' : true);
+
+/** Abonne aux changements de visibilité de l'onglet. cb(visible:boolean). → désabonnement. */
+export function onVisibilityChange(cb) {
+  if (!hasDocument()) return () => {};
+  const handler = () => cb(isVisible());
+  document.addEventListener('visibilitychange', handler);
+  return () => document.removeEventListener('visibilitychange', handler);
+}
+
+export const onVisible = (cb) => onVisibilityChange((v) => { if (v) cb(); });
+export const onHidden = (cb) => onVisibilityChange((v) => { if (!v) cb(); });

package/src/wake-lock.js

@@ -0,0 +1,48 @@
+// @mostajs/browser-kit — Screen Wake Lock (empêche la mise en veille de l'écran). Author: Dr Hamid MADANI <drmdh@msn.com>
+// Extrait du plateau VoxStudio (live.amia.fr/host). API : https://developer.mozilla.org/docs/Web/API/Screen_Wake_Lock_API
+
+const hasNavigator = () => typeof navigator !== 'undefined';
+const hasDocument = () => typeof document !== 'undefined';
+
+export const isWakeLockSupported = () => hasNavigator() && 'wakeLock' in navigator;
+
+/**
+ * Crée un contrôleur de verrou d'écran.
+ *   onChange(active:boolean) : notifié à l'acquisition / libération.
+ * → { isSupported, acquire, release, isActive, bindAutoReacquire, dispose }
+ * Le verrou est auto-libéré par le navigateur quand l'onglet passe en arrière-plan : bindAutoReacquire() le ré-acquiert au retour.
+ */
+export function createWakeLock({ onChange } = {}) {
+  let sentinel = null;
+  let unbind = null;
+
+  async function acquire() {
+    if (!isWakeLockSupported()) return false;
+    if (sentinel) return true;
+    try {
+      sentinel = await navigator.wakeLock.request('screen');
+      sentinel.addEventListener('release', () => { sentinel = null; onChange?.(false); });
+      onChange?.(true);
+      return true;
+    } catch { sentinel = null; return false; }
+  }
+
+  async function release() {
+    try { await sentinel?.release(); } catch { /* déjà libéré */ }
+    sentinel = null;
+  }
+
+  function bindAutoReacquire() {
+    if (!hasDocument() || unbind) return unbind || (() => {});
+    const handler = () => { if (document.visibilityState === 'visible' && !sentinel) acquire(); };
+    document.addEventListener('visibilitychange', handler);
+    unbind = () => { document.removeEventListener('visibilitychange', handler); unbind = null; };
+    return unbind;
+  }
+
+  function dispose() { unbind?.(); return release(); }
+
+  return { isSupported: isWakeLockSupported, acquire, release, isActive: () => !!sentinel, bindAutoReacquire, dispose };
+}
+
+export default createWakeLock;

package/src/web-share.js

@@ -0,0 +1,19 @@
+// @mostajs/browser-kit — Web Share API. Author: Dr Hamid MADANI <drmdh@msn.com>
+const hasNavigator = () => typeof navigator !== 'undefined';
+
+export const isShareSupported = () => hasNavigator() && typeof navigator.share === 'function';
+export const canShareFiles = () => hasNavigator() && typeof navigator.canShare === 'function';
+
+/** Teste si une charge utile est partageable (utile pour les fichiers). */
+export function canShare(data) {
+  if (!isShareSupported()) return false;
+  if (data && navigator.canShare) { try { return navigator.canShare(data); } catch { return false; } }
+  return true;
+}
+
+/** Ouvre la feuille de partage native. data = { title?, text?, url?, files? }. → true si partagé, false si annulé/non supporté. */
+export async function share(data) {
+  if (!isShareSupported()) return false;
+  try { await navigator.share(data); return true; }
+  catch (e) { if (e && e.name === 'AbortError') return false; return false; }
+}