@egen-civitas/esm-platform 1.1.0 → 1.2.0

package/dist/registry.test.js

@@ -0,0 +1,681 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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, registerPlatformCapabilities } from './index';
+import { getCapabilityDefinition, isHostVersionSufficient, isKnownCapability, listCapabilityNames, registerCapability, unregisterCapability } from './registry';
+import { createMockHost, createMockPlatform } from './testing';
+var w = window;
+var V1 = [
+    'session',
+    'secureStorage',
+    'openExternal',
+    'lifecycle',
+    'permissions',
+    'files',
+    'camera',
+    'push',
+    'biometric'
+];
+function registerFictional() {
+    var overrides = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var _overrides_web = overrides.web, web = _overrides_web === void 0 ? true : _overrides_web, _overrides_native = overrides.native, native = _overrides_native === void 0 ? true : _overrides_native, _overrides_version = overrides.version, version = _overrides_version === void 0 ? 1 : _overrides_version;
+    registerCapability('fictional', {
+        version: version,
+        methods: {
+            ping: 'async',
+            onTick: 'subscribe'
+        },
+        web: web ? function() {
+            return {
+                ping: function ping(message) {
+                    return _async_to_generator(function() {
+                        return _ts_generator(this, function(_state) {
+                            return [
+                                2,
+                                "web:".concat(message)
+                            ];
+                        });
+                    })();
+                }
+            };
+        } : undefined,
+        native: native ? function(client) {
+            return {
+                ping: function ping(message) {
+                    return client.call('fictional', 'ping', {
+                        message: message
+                    });
+                },
+                onTick: function onTick(callback) {
+                    return client.onEvent('fictional.tick', function() {
+                        return callback();
+                    });
+                }
+            };
+        } : undefined
+    });
+}
+beforeEach(function() {
+    delete w.egenTarget;
+});
+afterEach(function() {
+    unregisterCapability('fictional');
+    delete w.egenTarget;
+    delete w.egenHostBridge;
+});
+describe('registre : les 9 capacités v1', function() {
+    it('sont toutes enregistrées, avec leur version et leurs méthodes (contrat de l’annexe 2)', function() {
+        var _getCapabilityDefinition;
+        expect(listCapabilityNames().sort()).toEqual(_to_consumable_array(V1).sort());
+        var methods = function methods(name) {
+            var _getCapabilityDefinition;
+            return (_getCapabilityDefinition = getCapabilityDefinition(name)) === null || _getCapabilityDefinition === void 0 ? void 0 : _getCapabilityDefinition.methods;
+        };
+        expect(methods('session')).toEqual({
+            getAuthorization: 'async',
+            setTokens: 'async',
+            refresh: 'async',
+            clear: 'async'
+        });
+        expect(methods('secureStorage')).toEqual({
+            get: 'async',
+            set: 'async',
+            remove: 'async'
+        });
+        expect(methods('lifecycle')).toEqual({
+            onResume: 'subscribe',
+            onPause: 'subscribe'
+        });
+        expect(methods('push')).toEqual({
+            register: 'async',
+            onMessage: 'subscribe'
+        });
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = V1[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var name = _step.value;
+                expect((_getCapabilityDefinition = getCapabilityDefinition(name)) === null || _getCapabilityDefinition === void 0 ? void 0 : _getCapabilityDefinition.version).toBe(1);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    });
+    it('seules les capacités que le navigateur sait fournir ont un adaptateur Web ; aucune n’a d’adaptateur natif (C7)', function() {
+        var _getCapabilityDefinition;
+        var withWeb = V1.filter(function(name) {
+            var _getCapabilityDefinition;
+            return (_getCapabilityDefinition = getCapabilityDefinition(name)) === null || _getCapabilityDefinition === void 0 ? void 0 : _getCapabilityDefinition.web;
+        });
+        expect(withWeb.sort()).toEqual([
+            'camera',
+            'files',
+            'lifecycle',
+            'openExternal',
+            'permissions',
+            'session'
+        ]);
+        expect(V1.filter(function(name) {
+            var _getCapabilityDefinition;
+            return (_getCapabilityDefinition = getCapabilityDefinition(name)) === null || _getCapabilityDefinition === void 0 ? void 0 : _getCapabilityDefinition.native;
+        })).toEqual([]);
+        // Jamais de faux coffre, de push ni de biométrie simulés en Web.
+        for(var _i = 0, _iter = [
+            'secureStorage',
+            'push',
+            'biometric'
+        ]; _i < _iter.length; _i++){
+            var name = _iter[_i];
+            expect((_getCapabilityDefinition = getCapabilityDefinition(name)) === null || _getCapabilityDefinition === void 0 ? void 0 : _getCapabilityDefinition.web).toBeUndefined();
+        }
+    });
+});
+describe('ajouter une capacité fictive : aucun fichier de production modifié', function() {
+    it('une capacité absente du registre est inconnue partout', function() {
+        expect(isKnownCapability('fictional')).toBe(false);
+        expect(Object.keys(getPlatform())).not.toContain('fictional');
+    });
+    it('gabarit « indisponible » : la capacité existe comme objet, méthodes en UNAVAILABLE (async rejette, abonnement lève)', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional({
+                            web: false,
+                            native: false
+                        });
+                        expect(isKnownCapability('fictional')).toBe(true);
+                        w.egenTarget = 'android'; // natif sans Host : aucun adaptateur ne s'applique
+                        platform = getPlatform();
+                        expect(platform.has('fictional')).toBe(false);
+                        return [
+                            4,
+                            expect(platform.fictional.ping('x')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE',
+                                capability: 'fictional',
+                                method: 'ping'
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(function() {
+                            return platform.fictional.onTick(function() {});
+                        }).toThrowError(expect.objectContaining({
+                            code: 'UNAVAILABLE',
+                            capability: 'fictional',
+                            method: 'onTick'
+                        }));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('Web : l’adaptateur du registre est branché par getPlatform(), has() devient vrai', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional();
+                        platform = getPlatform();
+                        expect(platform.has('fictional')).toBe(true);
+                        return [
+                            4,
+                            expect(platform.fictional.ping('salut')).resolves.toBe('web:salut')
+                        ];
+                    case 1:
+                        _state.sent();
+                        // Une méthode que l'adaptateur ne fournit pas reste UNAVAILABLE (pas de faux succès).
+                        expect(function() {
+                            return platform.fictional.onTick(function() {});
+                        }).toThrowError(expect.objectContaining({
+                            code: 'UNAVAILABLE'
+                        }));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('Web : une fabrique qui retourne undefined (navigateur incapable) laisse la capacité absente', function() {
+        registerCapability('fictional', {
+            version: 1,
+            methods: {
+                ping: 'async',
+                onTick: 'subscribe'
+            },
+            web: function web() {
+                return undefined;
+            }
+        });
+        expect(getPlatform().has('fictional')).toBe(false);
+    });
+    it('natif : le Host l’annonce et l’adaptateur appelle le pont ; événements relayés', function() {
+        return _async_to_generator(function() {
+            var host, platform, tick, off;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional();
+                        w.egenTarget = 'android';
+                        host = createMockHost({
+                            capabilities: {
+                                fictional: {
+                                    v: 1
+                                }
+                            },
+                            handlers: {
+                                'fictional.ping': function(args) {
+                                    return "host:".concat(args.message);
+                                }
+                            }
+                        });
+                        host.install();
+                        platform = getPlatform();
+                        return [
+                            4,
+                            platform.ready
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(platform.has('fictional')).toBe(true);
+                        return [
+                            4,
+                            expect(platform.fictional.ping('salut')).resolves.toBe('host:salut')
+                        ];
+                    case 2:
+                        _state.sent();
+                        tick = vi.fn();
+                        off = platform.fictional.onTick(tick);
+                        host.emit('fictional.tick');
+                        return [
+                            4,
+                            Promise.resolve()
+                        ];
+                    case 3:
+                        _state.sent();
+                        expect(tick).toHaveBeenCalledTimes(1);
+                        off();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('natif : une capacité que le Host n’annonce pas reste indisponible, même avec un adaptateur', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional();
+                        w.egenTarget = 'android';
+                        createMockHost({
+                            capabilities: {}
+                        }).install();
+                        platform = getPlatform();
+                        return [
+                            4,
+                            platform.ready
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(platform.has('fictional')).toBe(false);
+                        return [
+                            4,
+                            expect(platform.fictional.ping('x')).rejects.toMatchObject({
+                                code: 'UNAVAILABLE'
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('natif : une version de Host INFÉRIEURE à celle du framework rend la capacité indisponible', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional({
+                            version: 2
+                        });
+                        w.egenTarget = 'android';
+                        createMockHost({
+                            capabilities: {
+                                fictional: {
+                                    v: 1
+                                }
+                            }
+                        }).install();
+                        platform = getPlatform();
+                        return [
+                            4,
+                            platform.ready
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(platform.has('fictional')).toBe(false);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('natif : une version de Host égale ou supérieure convient', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional({
+                            version: 2
+                        });
+                        w.egenTarget = 'android';
+                        createMockHost({
+                            capabilities: {
+                                fictional: {
+                                    v: 3
+                                }
+                            }
+                        }).install();
+                        platform = getPlatform();
+                        return [
+                            4,
+                            platform.ready
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(platform.has('fictional')).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('handshake : une capacité fictive annoncée par le Host est retenue ; avant son enregistrement elle était ignorée', function() {
+        return _async_to_generator(function() {
+            var _ref, _getHostInfo, ignored, getHostInfo;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        w.egenTarget = 'android';
+                        createMockHost({
+                            capabilities: {
+                                fictional: {
+                                    v: 1
+                                },
+                                session: {
+                                    v: 1
+                                }
+                            }
+                        }).install();
+                        ignored = getPlatform();
+                        return [
+                            4,
+                            ignored.ready
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            import('./index')
+                        ];
+                    case 2:
+                        getHostInfo = _state.sent().getHostInfo;
+                        expect(Object.keys((_ref = (_getHostInfo = getHostInfo()) === null || _getHostInfo === void 0 ? void 0 : _getHostInfo.capabilities) !== null && _ref !== void 0 ? _ref : {})).toEqual([
+                            'session'
+                        ]);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('mock : createMockPlatform fournit la capacité fictive et laisse le reste UNAVAILABLE', function() {
+        return _async_to_generator(function() {
+            var platform;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional({
+                            web: false,
+                            native: false
+                        });
+                        platform = createMockPlatform({
+                            capabilities: {
+                                fictional: {
+                                    ping: function ping(m) {
+                                        return _async_to_generator(function() {
+                                            return _ts_generator(this, function(_state) {
+                                                return [
+                                                    2,
+                                                    "mock:".concat(m)
+                                                ];
+                                            });
+                                        })();
+                                    }
+                                }
+                            }
+                        });
+                        expect(platform.has('fictional')).toBe(true);
+                        return [
+                            4,
+                            expect(platform.fictional.ping('x')).resolves.toBe('mock:x')
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(function() {
+                            return platform.fictional.onTick(function() {});
+                        }).toThrowError(expect.objectContaining({
+                            code: 'UNAVAILABLE'
+                        }));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('filtrage des apps (F2) : requiredCapabilities accepte le nom fictif une fois déclaré', function() {
+        return _async_to_generator(function() {
+            var name, platform, hasCapability;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        registerFictional();
+                        name = 'fictional'; // compile grâce à EgenCapabilityExtensions
+                        platform = getPlatform();
+                        return [
+                            4,
+                            registerPlatformCapabilities(platform)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            import('@egen-civitas/esm-globals')
+                        ];
+                    case 2:
+                        hasCapability = _state.sent().hasCapability;
+                        expect(hasCapability(name)).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('retirer la capacité du registre la fait disparaître partout (aucun état résiduel)', function() {
+        registerFictional();
+        expect(unregisterCapability('fictional')).toBe(true);
+        expect(unregisterCapability('fictional')).toBe(false);
+        expect(isKnownCapability('fictional')).toBe(false);
+        expect(Object.keys(getPlatform())).not.toContain('fictional');
+    });
+});
+describe('isHostVersionSufficient', function() {
+    it.each([
+        [
+            'session',
+            1,
+            true
+        ],
+        [
+            'session',
+            2,
+            true
+        ],
+        [
+            'session',
+            0,
+            false
+        ],
+        [
+            'session',
+            undefined,
+            false
+        ],
+        [
+            'inconnue',
+            1,
+            false
+        ]
+    ])('%s annoncée en version %s → %s', function(name, hostVersion, expected) {
+        expect(isHostVersionSufficient(name, hostVersion)).toBe(expected);
+    });
+});

package/dist/testing/index.d.ts

@@ -20,3 +20,4 @@ export interface MockPlatformOptions {
  * @category Platform
  */
 export declare function createMockPlatform(options?: MockPlatformOptions): Platform;
+export { createMockHost, type MockHost, type MockHostOptions } from './mock-host.js';

package/dist/testing/index.js

@@ -11,3 +11,4 @@ export function createMockPlatform(options = {}) {
     const { environment = 'web', capabilities, ready = Promise.resolve() } = options;
     return assemblePlatform({ environment, capabilities, ready: () => ready });
 }
+export { createMockHost } from './mock-host.js';