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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/browser-web-apis",
-  "version": "21.5.0",
+  "version": "21.7.0",
   "description": "Sistema de servicios Angular para acceso formalizado a Browser Web APIs (cámara, permisos, geolocalización, etc.)",
   "homepage": "https://gaspar1992.github.io/angular-helpers/docs/browser-web-apis",
   "repository": {
@@ -43,6 +43,10 @@
     ".": {
       "types": "./types/angular-helpers-browser-web-apis.d.ts",
       "default": "./fesm2022/angular-helpers-browser-web-apis.mjs"
+    },
+    "./experimental": {
+      "types": "./types/angular-helpers-browser-web-apis-experimental.d.ts",
+      "default": "./fesm2022/angular-helpers-browser-web-apis-experimental.mjs"
     }
   },
   "dependencies": {

package/types/angular-helpers-browser-web-apis-experimental.d.ts

@@ -0,0 +1,325 @@
+import { Observable } from 'rxjs';
+import { BrowserApiBaseService } from '@angular-helpers/browser-web-apis';
+import * as i0 from '@angular/core';
+import { Signal, EnvironmentProviders } from '@angular/core';
+
+type UserIdleState = 'active' | 'idle';
+type ScreenIdleState = 'locked' | 'unlocked';
+interface IdleState {
+    user: UserIdleState;
+    screen: ScreenIdleState;
+}
+interface IdleDetectorOptions {
+    threshold?: number;
+}
+declare class IdleDetectorService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    requestPermission(): Promise<PermissionState>;
+    watch(options?: IdleDetectorOptions): Observable<IdleState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdleDetectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdleDetectorService>;
+}
+
+interface ColorSelectionResult {
+    sRGBHex: string;
+}
+declare class EyeDropperService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    open(): Promise<ColorSelectionResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EyeDropperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EyeDropperService>;
+}
+
+type BarcodeFormat = 'aztec' | 'code_128' | 'code_39' | 'code_93' | 'codabar' | 'data_matrix' | 'ean_13' | 'ean_8' | 'itf' | 'pdf417' | 'qr_code' | 'upc_a' | 'upc_e' | 'unknown';
+interface DetectedBarcode {
+    boundingBox: DOMRectReadOnly;
+    cornerPoints: Array<{
+        x: number;
+        y: number;
+    }>;
+    format: BarcodeFormat;
+    rawValue: string;
+}
+declare class BarcodeDetectorService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    getSupportedFormats(): Promise<BarcodeFormat[]>;
+    detect(source: ImageBitmapSource, formats?: BarcodeFormat[]): Promise<DetectedBarcode[]>;
+    detectStream(video: HTMLVideoElement, options?: {
+        formats?: BarcodeFormat[];
+        interval?: number;
+    }): Observable<DetectedBarcode[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BarcodeDetectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BarcodeDetectorService>;
+}
+
+interface BluetoothRequestDeviceOptions {
+    filters?: Array<{
+        services?: string[];
+        name?: string;
+        namePrefix?: string;
+    }>;
+    optionalServices?: string[];
+    acceptAllDevices?: boolean;
+}
+interface BluetoothRemoteGATTServer {
+    readonly connected: boolean;
+    readonly device: BluetoothDeviceRef;
+    connect(): Promise<BluetoothRemoteGATTServer>;
+    disconnect(): void;
+    getPrimaryService(service: string): Promise<BluetoothRemoteGATTService>;
+}
+interface BluetoothRemoteGATTService {
+    getCharacteristic(characteristic: string): Promise<BluetoothRemoteGATTCharacteristic>;
+}
+interface BluetoothRemoteGATTCharacteristic extends EventTarget {
+    readonly value: DataView | null;
+    readValue(): Promise<DataView>;
+    writeValue(value: BufferSource): Promise<void>;
+    startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+    stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+}
+interface BluetoothDeviceRef extends EventTarget {
+    readonly id: string;
+    readonly name: string | undefined;
+    readonly gatt: BluetoothRemoteGATTServer | undefined;
+}
+interface BluetoothApi {
+    requestDevice(options: BluetoothRequestDeviceOptions): Promise<BluetoothDeviceRef>;
+}
+interface UsbDeviceRef {
+    readonly vendorId: number;
+    readonly productId: number;
+    readonly productName: string | undefined;
+    readonly manufacturerName: string | undefined;
+    readonly serialNumber: string | undefined;
+    readonly opened: boolean;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    selectConfiguration(configurationValue: number): Promise<void>;
+    claimInterface(interfaceNumber: number): Promise<void>;
+    releaseInterface(interfaceNumber: number): Promise<void>;
+    transferIn(endpointNumber: number, length: number): Promise<UsbTransferResult>;
+    transferOut(endpointNumber: number, data: BufferSource): Promise<UsbTransferResult>;
+}
+interface UsbTransferResult {
+    readonly data: DataView | undefined;
+    readonly status: 'ok' | 'stall' | 'babble';
+}
+interface UsbApi {
+    requestDevice(options: {
+        filters: UsbDeviceFilterDef[];
+    }): Promise<UsbDeviceRef>;
+    getDevices(): Promise<UsbDeviceRef[]>;
+    addEventListener(type: string, listener: (event: {
+        device: UsbDeviceRef;
+    }) => void): void;
+    removeEventListener(type: string, listener: (event: {
+        device: UsbDeviceRef;
+    }) => void): void;
+}
+interface UsbDeviceFilterDef {
+    vendorId?: number;
+    productId?: number;
+    classCode?: number;
+    subclassCode?: number;
+    protocolCode?: number;
+    serialNumber?: string;
+}
+interface NdefMessage {
+    records: NdefRecord[];
+}
+interface NdefRecord {
+    recordType: string;
+    mediaType?: string;
+    id?: string;
+    data?: DataView;
+    encoding?: string;
+    lang?: string;
+}
+interface NdefReadingEvent {
+    serialNumber: string;
+    message: NdefMessage;
+}
+interface NdefWriteOptions {
+    overwrite?: boolean;
+    signal?: AbortSignal;
+}
+interface NdefScanOptions {
+    signal?: AbortSignal;
+}
+interface NdefReaderInstance extends EventTarget {
+    scan(options?: NdefScanOptions): Promise<void>;
+    write(message: NdefMessage | string, options?: NdefWriteOptions): Promise<void>;
+}
+interface NdefReaderConstructor {
+    new (): NdefReaderInstance;
+}
+interface NavigatorWithExperimentalApis extends Navigator {
+    bluetooth?: BluetoothApi;
+    usb?: UsbApi;
+}
+
+declare class WebBluetoothService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    requestDevice(options?: BluetoothRequestDeviceOptions): Promise<BluetoothDeviceRef>;
+    getConnectedDevices(): Promise<BluetoothDeviceRef[]>;
+    watchConnectionChanges(): Observable<{
+        device: BluetoothDeviceRef;
+        connected: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebBluetoothService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebBluetoothService>;
+}
+
+declare class WebUsbService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    requestDevice(filters: UsbDeviceFilterDef[]): Promise<UsbDeviceRef>;
+    getDevices(): Promise<UsbDeviceRef[]>;
+    watchDeviceChanges(): Observable<{
+        device: UsbDeviceRef;
+        type: 'connect' | 'disconnect';
+    }>;
+    getDeviceInfo(device: UsbDeviceRef): {
+        vendorId: number;
+        productId: number;
+        productName: string | undefined;
+        manufacturerName: string | undefined;
+        serialNumber: string | undefined;
+        opened: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebUsbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebUsbService>;
+}
+
+declare class WebNfcService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    scan(): Observable<NdefReadingEvent>;
+    write(message: NdefMessage | string, options?: NdefWriteOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebNfcService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebNfcService>;
+}
+
+interface PaymentMethodConfig {
+    supportedMethods: string;
+    data?: Record<string, unknown>;
+}
+interface PaymentDetailsInit {
+    total: {
+        label: string;
+        amount: {
+            currency: string;
+            value: string;
+        };
+    };
+    displayItems?: Array<{
+        label: string;
+        amount: {
+            currency: string;
+            value: string;
+        };
+    }>;
+}
+interface PaymentOptionsConfig {
+    requestPayerName?: boolean;
+    requestPayerEmail?: boolean;
+    requestPayerPhone?: boolean;
+    requestShipping?: boolean;
+}
+interface PaymentResult {
+    methodName: string;
+    details: Record<string, unknown>;
+    payerName: string | null;
+    payerEmail: string | null;
+    payerPhone: string | null;
+}
+declare class PaymentRequestService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    canMakePayment(methods: PaymentMethodConfig[], details: PaymentDetailsInit): Promise<boolean>;
+    show(methods: PaymentMethodConfig[], details: PaymentDetailsInit, options?: PaymentOptionsConfig): Promise<PaymentResult>;
+    abort(methods: PaymentMethodConfig[], details: PaymentDetailsInit): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaymentRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaymentRequestService>;
+}
+
+interface PasswordCredentialData {
+    id: string;
+    password: string;
+    name?: string;
+    iconURL?: string;
+}
+interface PublicKeyCredentialOptions {
+    challenge: BufferSource;
+    rp: {
+        name: string;
+        id?: string;
+    };
+    user: {
+        id: BufferSource;
+        name: string;
+        displayName: string;
+    };
+    pubKeyCredParams: Array<{
+        type: 'public-key';
+        alg: number;
+    }>;
+    timeout?: number;
+    attestation?: AttestationConveyancePreference;
+    authenticatorSelection?: AuthenticatorSelectionCriteria;
+}
+interface CredentialResult {
+    id: string;
+    type: string;
+}
+declare class CredentialManagementService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    isSupported(): boolean;
+    isPublicKeySupported(): boolean;
+    get(options?: CredentialRequestOptions): Promise<Credential | null>;
+    store(credential: Credential): Promise<void>;
+    createPasswordCredential(data: PasswordCredentialData): Promise<Credential>;
+    createPublicKeyCredential(options: PublicKeyCredentialOptions): Promise<Credential | null>;
+    preventSilentAccess(): Promise<void>;
+    isConditionalMediationAvailable(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CredentialManagementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CredentialManagementService>;
+}
+
+interface IdleDetectorRef {
+    readonly state: Signal<IdleState>;
+    readonly userState: Signal<UserIdleState>;
+    readonly screenState: Signal<ScreenIdleState>;
+    readonly isUserIdle: Signal<boolean>;
+    readonly isScreenLocked: Signal<boolean>;
+}
+declare function injectIdleDetector(options?: IdleDetectorOptions): IdleDetectorRef;
+
+declare function provideIdleDetector(): EnvironmentProviders;
+declare function provideEyeDropper(): EnvironmentProviders;
+declare function provideBarcodeDetector(): EnvironmentProviders;
+declare function provideWebBluetooth(): EnvironmentProviders;
+declare function provideWebUsb(): EnvironmentProviders;
+declare function provideWebNfc(): EnvironmentProviders;
+declare function providePaymentRequest(): EnvironmentProviders;
+declare function provideCredentialManagement(): EnvironmentProviders;
+interface ExperimentalWebApisConfig {
+    enableIdleDetector?: boolean;
+    enableEyeDropper?: boolean;
+    enableBarcodeDetector?: boolean;
+    enableWebBluetooth?: boolean;
+    enableWebUsb?: boolean;
+    enableWebNfc?: boolean;
+    enablePaymentRequest?: boolean;
+    enableCredentialManagement?: boolean;
+}
+declare const defaultExperimentalWebApisConfig: ExperimentalWebApisConfig;
+declare function provideExperimentalWebApis(config?: ExperimentalWebApisConfig): EnvironmentProviders;
+
+export { BarcodeDetectorService, CredentialManagementService, EyeDropperService, IdleDetectorService, PaymentRequestService, WebBluetoothService, WebNfcService, WebUsbService, defaultExperimentalWebApisConfig, injectIdleDetector, provideBarcodeDetector, provideCredentialManagement, provideExperimentalWebApis, provideEyeDropper, provideIdleDetector, providePaymentRequest, provideWebBluetooth, provideWebNfc, provideWebUsb };
+export type { BarcodeFormat, BluetoothApi, BluetoothDeviceRef, BluetoothRemoteGATTCharacteristic, BluetoothRemoteGATTServer, BluetoothRemoteGATTService, BluetoothRequestDeviceOptions, ColorSelectionResult, CredentialResult, DetectedBarcode, ExperimentalWebApisConfig, IdleDetectorOptions, IdleDetectorRef, IdleState, NavigatorWithExperimentalApis, NdefMessage, NdefReaderConstructor, NdefReaderInstance, NdefReadingEvent, NdefRecord, NdefScanOptions, NdefWriteOptions, PasswordCredentialData, PaymentDetailsInit, PaymentMethodConfig, PaymentOptionsConfig, PaymentResult, PublicKeyCredentialOptions, ScreenIdleState, UsbApi, UsbDeviceFilterDef, UsbDeviceRef, UsbTransferResult, UserIdleState };