@egen-civitas/esm-platform 0.0.0-stage → 1.2.0

package/dist/adapters/web/web-adapter.test.js

@@ -0,0 +1,1233 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getPlatform } from '../../platform';
+import { isPlatformError } from '../../errors';
+import { createWebCapabilities } from './index';
+import { getWebFile, releaseWebFile } from './file-registry';
+import { assertExternalUrl } from './open-external';
+var w = window;
+/** Simule le sélecteur de fichiers : à `click()`, l'input reçoit `files` (ou un événement `cancel`). */ function stubFilePicker(behaviour) {
+    var inputs = [];
+    vi.spyOn(HTMLInputElement.prototype, 'click').mockImplementation(function() {
+        var _this = this;
+        inputs.push(this);
+        // Le navigateur émet l'événement après le retour de `click()`.
+        queueMicrotask(function() {
+            var _behaviour_files;
+            if (behaviour.cancel) {
+                _this.dispatchEvent(new Event('cancel'));
+                return;
+            }
+            Object.defineProperty(_this, 'files', {
+                value: (_behaviour_files = behaviour.files) !== null && _behaviour_files !== void 0 ? _behaviour_files : [],
+                configurable: true
+            });
+            _this.dispatchEvent(new Event('change'));
+        });
+    });
+    return inputs;
+}
+/** happy-dom fournit une API Permissions : l'absence doit être simulée explicitement. */ var removePermissionsApi = function removePermissionsApi() {
+    return Object.defineProperty(navigator, 'permissions', {
+        value: undefined,
+        configurable: true
+    });
+};
+var pdf = function pdf() {
+    return new File([
+        'contenu'
+    ], 'bilan.pdf', {
+        type: 'application/pdf'
+    });
+};
+var rejection = function rejection(promise) {
+    return promise.then(function() {
+        throw new Error('devait rejeter');
+    }, function(error) {
+        return error;
+    });
+};
+beforeEach(function() {
+    delete w.egenTarget;
+});
+afterEach(function() {
+    vi.restoreAllMocks();
+    delete navigator.permissions;
+    delete w.Notification;
+    document.body.innerHTML = '';
+});
+describe('session (fournisseur vide : le cookie reste le mécanisme)', function() {
+    var session = getPlatform().session;
+    it('getAuthorization → null, refresh → false, clear → no-op', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            expect(session.getAuthorization()).resolves.toBeNull()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            expect(session.refresh()).resolves.toBe(false)
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            4,
+                            expect(session.clear()).resolves.toBeUndefined()
+                        ];
+                    case 3:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('setTokens → UNAVAILABLE : aucun jeton n’est stocké dans le navigateur', function() {
+        return _async_to_generator(function() {
+            var error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            rejection(session.setTokens({
+                                access: 'SECRET-ACCESS'
+                            }))
+                        ];
+                    case 1:
+                        error = _state.sent();
+                        expect(error).toMatchObject({
+                            code: 'UNAVAILABLE',
+                            capability: 'session',
+                            method: 'setTokens'
+                        });
+                        expect(String(error.message)).not.toContain('SECRET-ACCESS');
+                        expect(JSON.stringify(localStorage)).not.toContain('SECRET-ACCESS');
+                        expect(JSON.stringify(sessionStorage)).not.toContain('SECRET-ACCESS');
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+describe('secureStorage, push, biometric : jamais simulés', function() {
+    it.each([
+        [
+            'secureStorage',
+            'get'
+        ],
+        [
+            'secureStorage',
+            'set'
+        ],
+        [
+            'secureStorage',
+            'remove'
+        ],
+        [
+            'push',
+            'register'
+        ],
+        [
+            'biometric',
+            'isAvailable'
+        ],
+        [
+            'biometric',
+            'authenticate'
+        ]
+    ])('%s.%s → UNAVAILABLE en Web', function(capability, method) {
+        return _async_to_generator(function() {
+            var platform, target;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        platform = getPlatform();
+                        expect(platform.has(capability)).toBe(false);
+                        target = platform[capability];
+                        return [
+                            4,
+                            expect(target[method]('k', 'v')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE',
+                                capability: capability,
+                                method: method
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('secureStorage.set n’écrit rien dans localStorage (pas de faux coffre)', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            getPlatform().secureStorage.set('clé', 'valeur-secrète').catch(function() {})
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(localStorage.getItem('clé')).toBeNull();
+                        expect(JSON.stringify(localStorage)).not.toContain('valeur-secrète');
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+describe('openExternal', function() {
+    it.each([
+        'https://exemple.ga/page?x=1',
+        'mailto:contact@exemple.ga',
+        'tel:+24101020304'
+    ])('ouvre %s avec window.open(_blank, noopener,noreferrer)', function(url) {
+        return _async_to_generator(function() {
+            var open;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        open = vi.spyOn(window, 'open').mockReturnValue(null);
+                        return [
+                            4,
+                            getPlatform().openExternal.open(url)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(open).toHaveBeenCalledTimes(1);
+                        expect(open).toHaveBeenCalledWith(new URL(url).href, '_blank', 'noopener,noreferrer');
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it.each([
+        'http://exemple.ga',
+        'javascript:alert(1)',
+        'data:text/html,<script>alert(1)</script>',
+        'file:///etc/passwd',
+        'ftp://exemple.ga',
+        '//exemple.ga',
+        '/chemin/relatif',
+        'pas une url',
+        ''
+    ])('refuse %j (INVALID_ARGS) sans rien ouvrir', function(url) {
+        return _async_to_generator(function() {
+            var open, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        open = vi.spyOn(window, 'open').mockReturnValue(null);
+                        return [
+                            4,
+                            rejection(getPlatform().openExternal.open(url))
+                        ];
+                    case 1:
+                        error = _state.sent();
+                        expect(error).toMatchObject({
+                            code: 'INVALID_ARGS',
+                            capability: 'openExternal',
+                            method: 'open'
+                        });
+                        expect(open).not.toHaveBeenCalled();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('refuse une valeur qui n’est pas une chaîne', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            expect(getPlatform().openExternal.open(undefined)).rejects.toMatchObject({
+                                code: 'INVALID_ARGS'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('le message d’erreur ne reprend jamais l’URL (elle peut contenir un secret)', function() {
+        try {
+            assertExternalUrl('javascript:steal("TOKEN-SECRET")');
+        } catch (error) {
+            expect(error.message).not.toContain('TOKEN-SECRET');
+        }
+    });
+});
+describe('lifecycle (visibilitychange)', function() {
+    var setVisibility = function setVisibility(state) {
+        Object.defineProperty(document, 'visibilityState', {
+            configurable: true,
+            get: function get() {
+                return state;
+            }
+        });
+        document.dispatchEvent(new Event('visibilitychange'));
+    };
+    afterEach(function() {
+        delete document.visibilityState;
+    });
+    it('onResume ne se déclenche que quand la page redevient visible ; onPause quand elle est masquée', function() {
+        var lifecycle = getPlatform().lifecycle;
+        var resume = vi.fn();
+        var pause = vi.fn();
+        var offResume = lifecycle.onResume(resume);
+        var offPause = lifecycle.onPause(pause);
+        setVisibility('hidden');
+        expect(pause).toHaveBeenCalledTimes(1);
+        expect(resume).not.toHaveBeenCalled();
+        setVisibility('visible');
+        expect(resume).toHaveBeenCalledTimes(1);
+        expect(pause).toHaveBeenCalledTimes(1);
+        offResume();
+        offPause();
+    });
+    it('la fonction retournée désabonne', function() {
+        var resume = vi.fn();
+        var off = getPlatform().lifecycle.onResume(resume);
+        off();
+        setVisibility('visible');
+        expect(resume).not.toHaveBeenCalled();
+    });
+    it('plusieurs abonnés sont indépendants', function() {
+        var lifecycle = getPlatform().lifecycle;
+        var a = vi.fn();
+        var b = vi.fn();
+        var offA = lifecycle.onResume(a);
+        var offB = lifecycle.onResume(b);
+        offA();
+        setVisibility('visible');
+        expect(a).not.toHaveBeenCalled();
+        expect(b).toHaveBeenCalledTimes(1);
+        offB();
+    });
+    it('un callback qui n’est pas une fonction lève INVALID_ARGS', function() {
+        expect(function() {
+            return getPlatform().lifecycle.onResume('x');
+        }).toThrowError(expect.objectContaining({
+            code: 'INVALID_ARGS',
+            method: 'onResume'
+        }));
+    });
+});
+describe('files', function() {
+    it('select : <input type="file"> éphémère, handles sans binaire, input retiré du document', function() {
+        return _async_to_generator(function() {
+            var inputs, handles;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        inputs = stubFilePicker({
+                            files: [
+                                pdf()
+                            ]
+                        });
+                        return [
+                            4,
+                            getPlatform().files.select({
+                                accept: [
+                                    'application/pdf',
+                                    '.csv'
+                                ]
+                            })
+                        ];
+                    case 1:
+                        handles = _state.sent();
+                        expect(inputs).toHaveLength(1);
+                        expect(inputs[0].type).toBe('file');
+                        expect(inputs[0].accept).toBe('application/pdf,.csv');
+                        expect(inputs[0].multiple).toBe(false);
+                        expect(document.body.contains(inputs[0])).toBe(false);
+                        expect(handles).toEqual([
+                            {
+                                id: expect.any(String),
+                                name: 'bilan.pdf',
+                                size: 7,
+                                mime: 'application/pdf'
+                            }
+                        ]);
+                        expect(Object.keys(handles[0]).sort()).toEqual([
+                            'id',
+                            'mime',
+                            'name',
+                            'size'
+                        ]);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('select multiple : un handle par fichier, identifiants distincts, fichiers retrouvables puis libérables', function() {
+        return _async_to_generator(function() {
+            var _getWebFile, inputs, handles;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        inputs = stubFilePicker({
+                            files: [
+                                pdf(),
+                                new File([
+                                    'x'
+                                ], 'a.png', {
+                                    type: ''
+                                })
+                            ]
+                        });
+                        return [
+                            4,
+                            getPlatform().files.select({
+                                multiple: true
+                            })
+                        ];
+                    case 1:
+                        handles = _state.sent();
+                        expect(inputs[0].multiple).toBe(true);
+                        expect(new Set(handles.map(function(h) {
+                            return h.id;
+                        })).size).toBe(2);
+                        expect(handles[1].mime).toBe('application/octet-stream');
+                        expect((_getWebFile = getWebFile(handles[0].id)) === null || _getWebFile === void 0 ? void 0 : _getWebFile.name).toBe('bilan.pdf');
+                        expect(releaseWebFile(handles[0].id)).toBe(true);
+                        expect(getWebFile(handles[0].id)).toBeUndefined();
+                        expect(releaseWebFile(handles[0].id)).toBe(false);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('annulation (événement cancel) → CANCELLED, input retiré', function() {
+        return _async_to_generator(function() {
+            var inputs, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        inputs = stubFilePicker({
+                            cancel: true
+                        });
+                        return [
+                            4,
+                            rejection(getPlatform().files.select())
+                        ];
+                    case 1:
+                        error = _state.sent();
+                        expect(error).toMatchObject({
+                            code: 'CANCELLED',
+                            capability: 'files',
+                            method: 'select'
+                        });
+                        expect(document.body.contains(inputs[0])).toBe(false);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('aucun fichier choisi → CANCELLED', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        stubFilePicker({
+                            files: []
+                        });
+                        return [
+                            4,
+                            expect(getPlatform().files.select()).rejects.toMatchObject({
+                                code: 'CANCELLED'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it.each([
+        [
+            '<script>'
+        ],
+        [
+            'image/*;x'
+        ],
+        [
+            ''
+        ],
+        [
+            'a b'
+        ]
+    ])('accept invalide %j → INVALID_ARGS, sélecteur jamais ouvert', function(entry) {
+        return _async_to_generator(function() {
+            var inputs;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        inputs = stubFilePicker({
+                            files: [
+                                pdf()
+                            ]
+                        });
+                        return [
+                            4,
+                            expect(getPlatform().files.select({
+                                accept: [
+                                    entry
+                                ]
+                            })).rejects.toMatchObject({
+                                code: 'INVALID_ARGS'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(inputs).toHaveLength(0);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('download n’est pas fourni en Web (UNAVAILABLE), select l’est', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        platform = getPlatform();
+                        expect(platform.has('files')).toBe(true);
+                        return [
+                            4,
+                            expect(platform.files.download('https://exemple.ga/f.pdf', 'f.pdf')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE',
+                                method: 'download'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+describe('camera (input capture — choix documenté dans camera.ts)', function() {
+    it('capture arrière par défaut : accept image/*, attribut capture=environment', function() {
+        return _async_to_generator(function() {
+            var inputs, handle, capture;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        inputs = stubFilePicker({
+                            files: [
+                                new File([
+                                    'p'
+                                ], 'photo.jpg', {
+                                    type: 'image/jpeg'
+                                })
+                            ]
+                        });
+                        return [
+                            4,
+                            getPlatform().camera.capture()
+                        ];
+                    case 1:
+                        handle = _state.sent();
+                        expect(inputs[0].accept).toBe('image/*');
+                        capture = inputs[0].getAttribute('capture');
+                        expect(capture).toBe('environment');
+                        expect(handle).toMatchObject({
+                            name: 'photo.jpg',
+                            mime: 'image/jpeg',
+                            size: 1
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('facing "front" → capture=user ; "back" → environment', function() {
+        return _async_to_generator(function() {
+            var file, front, frontCapture, back, backCapture;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        file = new File([
+                            'p'
+                        ], 'photo.jpg', {
+                            type: 'image/jpeg'
+                        });
+                        front = stubFilePicker({
+                            files: [
+                                file
+                            ]
+                        });
+                        return [
+                            4,
+                            getPlatform().camera.capture({
+                                facing: 'front'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        frontCapture = front[0].getAttribute('capture');
+                        expect(frontCapture).toBe('user');
+                        vi.restoreAllMocks();
+                        back = stubFilePicker({
+                            files: [
+                                file
+                            ]
+                        });
+                        return [
+                            4,
+                            getPlatform().camera.capture({
+                                facing: 'back'
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        backCapture = back[0].getAttribute('capture');
+                        expect(backCapture).toBe('environment');
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('facing invalide → INVALID_ARGS ; annulation → CANCELLED', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            expect(getPlatform().camera.capture({
+                                facing: 'left'
+                            })).rejects.toMatchObject({
+                                code: 'INVALID_ARGS'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        stubFilePicker({
+                            cancel: true
+                        });
+                        return [
+                            4,
+                            expect(getPlatform().camera.capture()).rejects.toMatchObject({
+                                code: 'CANCELLED',
+                                capability: 'camera'
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+describe('permissions (API Permissions du navigateur)', function() {
+    var stubPermissions = function stubPermissions(query) {
+        return Object.defineProperty(navigator, 'permissions', {
+            value: {
+                query: query
+            },
+            configurable: true
+        });
+    };
+    it('sans API Permissions : capacité non fournie (has faux), méthodes UNAVAILABLE', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        removePermissionsApi();
+                        platform = getPlatform();
+                        expect(platform.has('permissions')).toBe(false);
+                        return [
+                            4,
+                            expect(platform.permissions.check('camera')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it.each([
+        'granted',
+        'denied',
+        'prompt'
+    ])('check retourne l’état du navigateur (%s)', function(state) {
+        return _async_to_generator(function() {
+            var query, platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        query = vi.fn(function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    return [
+                                        2,
+                                        {
+                                            state: state
+                                        }
+                                    ];
+                                });
+                            })();
+                        });
+                        stubPermissions(query);
+                        platform = getPlatform();
+                        expect(platform.has('permissions')).toBe(true);
+                        return [
+                            4,
+                            expect(platform.permissions.check('microphone')).resolves.toBe(state)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(query).toHaveBeenCalledWith({
+                            name: 'microphone'
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('un nom que le navigateur ne connaît pas → UNAVAILABLE (jamais une valeur inventée)', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        stubPermissions(function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    throw new TypeError('inconnu');
+                                });
+                            })();
+                        });
+                        return [
+                            4,
+                            expect(getPlatform().permissions.check('camera')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE',
+                                method: 'check'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('files n’a pas d’équivalent Web → UNAVAILABLE, sans interroger le navigateur', function() {
+        return _async_to_generator(function() {
+            var query;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        query = vi.fn(function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    return [
+                                        2,
+                                        {
+                                            state: 'granted'
+                                        }
+                                    ];
+                                });
+                            })();
+                        });
+                        stubPermissions(query);
+                        return [
+                            4,
+                            expect(getPlatform().permissions.check('files')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(query).not.toHaveBeenCalled();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('nom inconnu → INVALID_ARGS', function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        stubPermissions(function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    return [
+                                        2,
+                                        {
+                                            state: 'granted'
+                                        }
+                                    ];
+                                });
+                            })();
+                        });
+                        return [
+                            4,
+                            expect(getPlatform().permissions.check('gps')).rejects.toMatchObject({
+                                code: 'INVALID_ARGS'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            expect(getPlatform().permissions.request('gps')).rejects.toMatchObject({
+                                code: 'INVALID_ARGS'
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it.each([
+        [
+            'granted',
+            'granted'
+        ],
+        [
+            'denied',
+            'denied'
+        ],
+        [
+            'default',
+            'denied'
+        ]
+    ])('request(notifications) : Notification.requestPermission = %s → %s', function(browser, expected) {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        stubPermissions(function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    return [
+                                        2,
+                                        {
+                                            state: 'prompt'
+                                        }
+                                    ];
+                                });
+                            })();
+                        });
+                        w.Notification = {
+                            requestPermission: vi.fn(function() {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        return [
+                                            2,
+                                            browser
+                                        ];
+                                    });
+                                })();
+                            })
+                        };
+                        return [
+                            4,
+                            expect(getPlatform().permissions.request('notifications')).resolves.toBe(expected)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it.each([
+        'camera',
+        'microphone',
+        'files'
+    ])('request(%s) → UNAVAILABLE (le navigateur demande à l’usage)', function(name) {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        stubPermissions(function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    return [
+                                        2,
+                                        {
+                                            state: 'prompt'
+                                        }
+                                    ];
+                                });
+                            })();
+                        });
+                        return [
+                            4,
+                            expect(getPlatform().permissions.request(name)).rejects.toMatchObject({
+                                code: 'UNAVAILABLE',
+                                method: 'request'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+describe('assemblage Web', function() {
+    it('createWebCapabilities : exactement les capacités fournies par un navigateur sans API Permissions', function() {
+        removePermissionsApi();
+        expect(Object.keys(createWebCapabilities()).sort()).toEqual([
+            'camera',
+            'files',
+            'lifecycle',
+            'openExternal',
+            'session'
+        ]);
+    });
+    it('getPlatform() en Web : has() reflète les capacités réellement fournies', function() {
+        return _async_to_generator(function() {
+            var platform, provided, absent, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, name, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, name1;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        Object.defineProperty(navigator, 'permissions', {
+                            value: {
+                                query: function query() {
+                                    return _async_to_generator(function() {
+                                        return _ts_generator(this, function(_state) {
+                                            return [
+                                                2,
+                                                {
+                                                    state: 'prompt'
+                                                }
+                                            ];
+                                        });
+                                    })();
+                                }
+                            },
+                            configurable: true
+                        });
+                        platform = getPlatform();
+                        expect(platform.environment).toBe('web');
+                        return [
+                            4,
+                            expect(platform.ready).resolves.toBeUndefined()
+                        ];
+                    case 1:
+                        _state.sent();
+                        provided = [
+                            'session',
+                            'openExternal',
+                            'lifecycle',
+                            'files',
+                            'camera',
+                            'permissions'
+                        ];
+                        absent = [
+                            'secureStorage',
+                            'push',
+                            'biometric'
+                        ];
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = provided[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                name = _step.value;
+                                expect(platform.has(name)).toBe(true);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        try {
+                            for(_iterator1 = absent[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                name1 = _step1.value;
+                                expect(platform.has(name1)).toBe(false);
+                            }
+                        } catch (err) {
+                            _didIteratorError1 = true;
+                            _iteratorError1 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                    _iterator1.return();
+                                }
+                            } finally{
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
+                            }
+                        }
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('en natif, l’adaptateur Web n’est JAMAIS utilisé (aucune capacité du navigateur ne fuit vers un Host absent)', function() {
+        w.egenTarget = 'android';
+        var platform = getPlatform();
+        for(var _i = 0, _iter = [
+            'session',
+            'openExternal',
+            'lifecycle',
+            'files',
+            'camera',
+            'permissions',
+            'secureStorage',
+            'push',
+            'biometric'
+        ]; _i < _iter.length; _i++){
+            var name = _iter[_i];
+            expect(platform.has(name)).toBe(false);
+        }
+    });
+    it('toute erreur d’une capacité Web est une PlatformError (jamais une Error générique)', function() {
+        return _async_to_generator(function() {
+            var errors, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            Promise.all([
+                                rejection(getPlatform().openExternal.open('http://x')),
+                                rejection(getPlatform().files.download('https://x', 'f')),
+                                rejection(getPlatform().session.setTokens({
+                                    access: 'a'
+                                }))
+                            ])
+                        ];
+                    case 1:
+                        errors = _state.sent();
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = errors[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                error = _step.value;
+                                expect(isPlatformError(error)).toBe(true);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});