@angular-helpers/browser-web-apis 21.5.0 → 21.7.0

package/fesm2022/angular-helpers-browser-web-apis-experimental.mjs

@@ -0,0 +1,478 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, DestroyRef, PLATFORM_ID, signal, computed, makeEnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BrowserApiBaseService, PermissionsService } from '@angular-helpers/browser-web-apis';
+import { isPlatformBrowser } from '@angular/common';
+
+function getIdleDetectorClass$1() {
+    return window.IdleDetector;
+}
+class IdleDetectorService extends BrowserApiBaseService {
+    getApiName() {
+        return 'idle-detector';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'IdleDetector' in window;
+    }
+    async requestPermission() {
+        if (!this.isSupported()) {
+            throw new Error('IdleDetector API not supported');
+        }
+        return getIdleDetectorClass$1().requestPermission();
+    }
+    watch(options = {}) {
+        if (!this.isSupported()) {
+            return new Observable((o) => o.error(new Error('IdleDetector API not supported')));
+        }
+        return new Observable((subscriber) => {
+            const abortController = new AbortController();
+            const detector = new (getIdleDetectorClass$1())();
+            detector.addEventListener('change', () => {
+                subscriber.next({
+                    user: detector.userState,
+                    screen: detector.screenState,
+                });
+            });
+            detector
+                .start({
+                threshold: options.threshold ?? 60_000,
+                signal: abortController.signal,
+            })
+                .catch((err) => subscriber.error(err));
+            return () => abortController.abort();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, decorators: [{
+            type: Injectable
+        }] });
+
+function getEyeDropperClass() {
+    return window.EyeDropper;
+}
+class EyeDropperService extends BrowserApiBaseService {
+    getApiName() {
+        return 'eye-dropper';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'EyeDropper' in window;
+    }
+    async open() {
+        if (!this.isSupported()) {
+            throw new Error('EyeDropper API not supported');
+        }
+        const eyeDropper = new (getEyeDropperClass())();
+        return eyeDropper.open();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, decorators: [{
+            type: Injectable
+        }] });
+
+function getBarcodeDetectorClass() {
+    return window.BarcodeDetector;
+}
+class BarcodeDetectorService extends BrowserApiBaseService {
+    getApiName() {
+        return 'barcode-detector';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'BarcodeDetector' in window;
+    }
+    async getSupportedFormats() {
+        if (!this.isSupported()) {
+            return [];
+        }
+        return getBarcodeDetectorClass().getSupportedFormats();
+    }
+    async detect(source, formats) {
+        if (!this.isSupported()) {
+            throw new Error('BarcodeDetector API not supported');
+        }
+        const detector = new (getBarcodeDetectorClass())(formats ? { formats } : undefined);
+        return detector.detect(source);
+    }
+    detectStream(video, options = {}) {
+        return new Observable((subscriber) => {
+            if (!this.isSupported()) {
+                subscriber.error(new Error('BarcodeDetector API not supported'));
+                return () => { };
+            }
+            const detector = new (getBarcodeDetectorClass())(options.formats ? { formats: options.formats } : undefined);
+            let rafId = null;
+            let isActive = true;
+            const detect = async () => {
+                if (!isActive)
+                    return;
+                try {
+                    const barcodes = await detector.detect(video);
+                    if (barcodes.length > 0) {
+                        subscriber.next(barcodes);
+                    }
+                    rafId = requestAnimationFrame(detect);
+                }
+                catch (error) {
+                    subscriber.error(error);
+                }
+            };
+            rafId = requestAnimationFrame(detect);
+            return () => {
+                isActive = false;
+                if (rafId !== null) {
+                    cancelAnimationFrame(rafId);
+                }
+            };
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, decorators: [{
+            type: Injectable
+        }] });
+
+function getBluetoothApi() {
+    return navigator.bluetooth;
+}
+class WebBluetoothService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-bluetooth';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'bluetooth' in navigator;
+    }
+    async requestDevice(options) {
+        if (!this.isSupported()) {
+            throw new Error('Web Bluetooth API not supported');
+        }
+        const device = await getBluetoothApi().requestDevice(options ?? {});
+        return device;
+    }
+    async getConnectedDevices() {
+        // Note: Web Bluetooth does not expose an API to list all connected devices
+        // Devices must be paired/connected per session
+        return [];
+    }
+    watchConnectionChanges() {
+        return new Observable((subscriber) => {
+            // Web Bluetooth doesn't have a global connection event
+            // This would need to be implemented per-device via gattserverdisconnected
+            subscriber.complete();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, decorators: [{
+            type: Injectable
+        }] });
+
+function getUsb() {
+    return navigator.usb;
+}
+class WebUsbService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-usb';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'usb' in navigator;
+    }
+    async requestDevice(filters) {
+        if (!this.isSupported()) {
+            throw new Error('WebUSB API not supported');
+        }
+        const device = await getUsb().requestDevice({ filters });
+        return device;
+    }
+    async getDevices() {
+        if (!this.isSupported()) {
+            return [];
+        }
+        return getUsb().getDevices();
+    }
+    watchDeviceChanges() {
+        if (!this.isSupported()) {
+            return new Observable((o) => o.error(new Error('WebUSB API not supported')));
+        }
+        return new Observable((subscriber) => {
+            const usb = getUsb();
+            const onConnect = (e) => subscriber.next({ device: e.device, type: 'connect' });
+            const onDisconnect = (e) => subscriber.next({ device: e.device, type: 'disconnect' });
+            usb.addEventListener('connect', onConnect);
+            usb.addEventListener('disconnect', onDisconnect);
+            return () => {
+                usb.removeEventListener('connect', onConnect);
+                usb.removeEventListener('disconnect', onDisconnect);
+            };
+        });
+    }
+    getDeviceInfo(device) {
+        return {
+            vendorId: device.vendorId,
+            productId: device.productId,
+            productName: device.productName,
+            manufacturerName: device.manufacturerName,
+            serialNumber: device.serialNumber,
+            opened: device.opened,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, decorators: [{
+            type: Injectable
+        }] });
+
+function getNdefReaderClass() {
+    return window.NDEFReader;
+}
+class WebNfcService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-nfc';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'NDEFReader' in window;
+    }
+    scan() {
+        if (!this.isSupported()) {
+            return new Observable((o) => o.error(new Error('Web NFC API not supported')));
+        }
+        return new Observable((subscriber) => {
+            const abortController = new AbortController();
+            const reader = new (getNdefReaderClass())();
+            const onReading = (event) => {
+                const e = event;
+                subscriber.next({
+                    serialNumber: e.serialNumber,
+                    message: e.message,
+                });
+            };
+            const onError = (event) => {
+                subscriber.error(event.error ?? new Error('NFC read error'));
+            };
+            reader.addEventListener('reading', onReading);
+            reader.addEventListener('readingerror', onError);
+            reader
+                .scan({ signal: abortController.signal })
+                .catch((err) => subscriber.error(err));
+            return () => abortController.abort();
+        });
+    }
+    async write(message, options) {
+        if (!this.isSupported()) {
+            throw new Error('Web NFC API not supported');
+        }
+        const reader = new (getNdefReaderClass())();
+        await reader.write(message, options);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, decorators: [{
+            type: Injectable
+        }] });
+
+class PaymentRequestService extends BrowserApiBaseService {
+    getApiName() {
+        return 'payment-request';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'PaymentRequest' in window;
+    }
+    async canMakePayment(methods, details) {
+        if (!this.isSupported())
+            return false;
+        const request = new PaymentRequest(methods, details);
+        return request.canMakePayment();
+    }
+    async show(methods, details, options) {
+        if (!this.isSupported()) {
+            throw new Error('Payment Request API not supported');
+        }
+        const request = new PaymentRequest(methods, details, options);
+        const response = await request.show();
+        const result = {
+            methodName: response.methodName,
+            details: response.details,
+            payerName: response.payerName ?? null,
+            payerEmail: response.payerEmail ?? null,
+            payerPhone: response.payerPhone ?? null,
+        };
+        await response.complete('success');
+        return result;
+    }
+    async abort(methods, details) {
+        if (!this.isSupported())
+            return;
+        const request = new PaymentRequest(methods, details);
+        await request.abort();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, decorators: [{
+            type: Injectable
+        }] });
+
+class CredentialManagementService extends BrowserApiBaseService {
+    getApiName() {
+        return 'credential-management';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'credentials' in navigator;
+    }
+    isPublicKeySupported() {
+        return this.isSupported() && 'PublicKeyCredential' in window;
+    }
+    async get(options) {
+        if (!this.isSupported()) {
+            throw new Error('Credential Management API not supported');
+        }
+        return navigator.credentials.get(options);
+    }
+    async store(credential) {
+        if (!this.isSupported()) {
+            throw new Error('Credential Management API not supported');
+        }
+        await navigator.credentials.store(credential);
+    }
+    async createPasswordCredential(data) {
+        if (!this.isSupported()) {
+            throw new Error('Credential Management API not supported');
+        }
+        return navigator.credentials.create({
+            password: data,
+        });
+    }
+    async createPublicKeyCredential(options) {
+        if (!this.isPublicKeySupported()) {
+            throw new Error('PublicKeyCredential API not supported');
+        }
+        return navigator.credentials.create({
+            publicKey: options,
+        });
+    }
+    async preventSilentAccess() {
+        if (!this.isSupported())
+            return;
+        await navigator.credentials.preventSilentAccess();
+    }
+    async isConditionalMediationAvailable() {
+        if (!this.isPublicKeySupported())
+            return false;
+        if ('isConditionalMediationAvailable' in PublicKeyCredential) {
+            return PublicKeyCredential.isConditionalMediationAvailable();
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, decorators: [{
+            type: Injectable
+        }] });
+
+function getIdleDetectorClass() {
+    return window.IdleDetector;
+}
+function injectIdleDetector(options = {}) {
+    const destroyRef = inject(DestroyRef);
+    const platformId = inject(PLATFORM_ID);
+    const defaultState = { user: 'active', screen: 'unlocked' };
+    const state = signal(defaultState, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    if (isPlatformBrowser(platformId) && 'IdleDetector' in window) {
+        const abortController = new AbortController();
+        const detector = new (getIdleDetectorClass())();
+        detector.addEventListener('change', () => {
+            state.set({
+                user: detector.userState,
+                screen: detector.screenState,
+            });
+        });
+        detector
+            .start({
+            threshold: options.threshold ?? 60_000,
+            signal: abortController.signal,
+        })
+            .catch(() => {
+            /* permission denied or unsupported — keep defaults */
+        });
+        destroyRef.onDestroy(() => abortController.abort());
+    }
+    return {
+        state: state.asReadonly(),
+        userState: computed(() => state().user),
+        screenState: computed(() => state().screen),
+        isUserIdle: computed(() => state().user === 'idle'),
+        isScreenLocked: computed(() => state().screen === 'locked'),
+    };
+}
+
+function provideIdleDetector() {
+    return makeEnvironmentProviders([PermissionsService, IdleDetectorService]);
+}
+function provideEyeDropper() {
+    return makeEnvironmentProviders([EyeDropperService]);
+}
+function provideBarcodeDetector() {
+    return makeEnvironmentProviders([BarcodeDetectorService]);
+}
+function provideWebBluetooth() {
+    return makeEnvironmentProviders([WebBluetoothService]);
+}
+function provideWebUsb() {
+    return makeEnvironmentProviders([WebUsbService]);
+}
+function provideWebNfc() {
+    return makeEnvironmentProviders([WebNfcService]);
+}
+function providePaymentRequest() {
+    return makeEnvironmentProviders([PaymentRequestService]);
+}
+function provideCredentialManagement() {
+    return makeEnvironmentProviders([CredentialManagementService]);
+}
+const defaultExperimentalWebApisConfig = {
+    enableIdleDetector: false,
+    enableEyeDropper: false,
+    enableBarcodeDetector: false,
+    enableWebBluetooth: false,
+    enableWebUsb: false,
+    enableWebNfc: false,
+    enablePaymentRequest: false,
+    enableCredentialManagement: false,
+};
+function provideExperimentalWebApis(config = {}) {
+    const mergedConfig = { ...defaultExperimentalWebApisConfig, ...config };
+    const providers = [];
+    const conditionalProviders = [
+        [mergedConfig.enableIdleDetector, IdleDetectorService],
+        [mergedConfig.enableEyeDropper, EyeDropperService],
+        [mergedConfig.enableBarcodeDetector, BarcodeDetectorService],
+        [mergedConfig.enableWebBluetooth, WebBluetoothService],
+        [mergedConfig.enableWebUsb, WebUsbService],
+        [mergedConfig.enableWebNfc, WebNfcService],
+        [mergedConfig.enablePaymentRequest, PaymentRequestService],
+        [mergedConfig.enableCredentialManagement, CredentialManagementService],
+    ];
+    for (const [enabled, provider] of conditionalProviders) {
+        if (enabled) {
+            providers.push(provider);
+        }
+    }
+    return makeEnvironmentProviders(providers);
+}
+
+// Secondary entry point: @angular-helpers/browser-web-apis/experimental
+// Experimental Chromium-only APIs that require specific browser support
+// --- Services ---
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BarcodeDetectorService, CredentialManagementService, EyeDropperService, IdleDetectorService, PaymentRequestService, WebBluetoothService, WebNfcService, WebUsbService, defaultExperimentalWebApisConfig, injectIdleDetector, provideBarcodeDetector, provideCredentialManagement, provideExperimentalWebApis, provideEyeDropper, provideIdleDetector, providePaymentRequest, provideWebBluetooth, provideWebNfc, provideWebUsb };