@digipair/skill-client-sse 0.37.5 → 0.38.0

package/index.cjs.js

@@ -15,21 +15,557 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
-let WebSSEService = class WebSSEService {
-    async connect(params, _pinsSettingsList, context) {
-        const { url = '', connection = 'default', message = [] } = params;
-        const session = new EventSource(url);
-        this.sessions.set(connection, session);
-        session.addEventListener('message', ({ data })=>{
-            engine.executePinsList(message, _extends({}, context, {
-                message: JSON.parse(data),
-                connection
-            }));
+function asyncGeneratorStep$1(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$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
         });
-        return session;
+    };
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = 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(_)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
+        };
     }
-    constructor(){
-        this.sessions = new Map();
+}
+function getBytes(stream, onChunk) {
+    return _getBytes.apply(this, arguments);
+}
+function _getBytes() {
+    _getBytes = _async_to_generator$1(function(stream, onChunk) {
+        var reader, result;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    reader = stream.getReader();
+                    _state.label = 1;
+                case 1:
+                    return [
+                        4,
+                        reader.read()
+                    ];
+                case 2:
+                    if (!!(result = _state.sent()).done) return [
+                        3,
+                        3
+                    ];
+                    onChunk(result.value);
+                    return [
+                        3,
+                        1
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _getBytes.apply(this, arguments);
+}
+function getLines(onLine) {
+    var buffer;
+    var position;
+    var fieldLength;
+    var discardTrailingNewline = false;
+    return function onChunk(arr) {
+        if (buffer === undefined) {
+            buffer = arr;
+            position = 0;
+            fieldLength = -1;
+        } else {
+            buffer = concat(buffer, arr);
+        }
+        var bufLength = buffer.length;
+        var lineStart = 0;
+        while(position < bufLength){
+            if (discardTrailingNewline) {
+                if (buffer[position] === 10) {
+                    lineStart = ++position;
+                }
+                discardTrailingNewline = false;
+            }
+            var lineEnd = -1;
+            for(; position < bufLength && lineEnd === -1; ++position){
+                switch(buffer[position]){
+                    case 58:
+                        if (fieldLength === -1) {
+                            fieldLength = position - lineStart;
+                        }
+                        break;
+                    case 13:
+                        discardTrailingNewline = true;
+                    case 10:
+                        lineEnd = position;
+                        break;
+                }
+            }
+            if (lineEnd === -1) {
+                break;
+            }
+            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+            lineStart = position;
+            fieldLength = -1;
+        }
+        if (lineStart === bufLength) {
+            buffer = undefined;
+        } else if (lineStart !== 0) {
+            buffer = buffer.subarray(lineStart);
+            position -= lineStart;
+        }
+    };
+}
+function getMessages(onId, onRetry, onMessage) {
+    var message = newMessage();
+    var decoder = new TextDecoder();
+    return function onLine(line, fieldLength) {
+        if (line.length === 0) {
+            onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+            message = newMessage();
+        } else if (fieldLength > 0) {
+            var field = decoder.decode(line.subarray(0, fieldLength));
+            var valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+            var value = decoder.decode(line.subarray(valueOffset));
+            switch(field){
+                case "data":
+                    message.data = message.data ? message.data + "\n" + value : value;
+                    break;
+                case "event":
+                    message.event = value;
+                    break;
+                case "id":
+                    onId(message.id = value);
+                    break;
+                case "retry":
+                    var retry = parseInt(value, 10);
+                    if (!isNaN(retry)) {
+                        onRetry(message.retry = retry);
+                    }
+                    break;
+            }
+        }
+    };
+}
+function concat(a, b) {
+    var res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}
+function newMessage() {
+    return {
+        data: "",
+        event: "",
+        id: "",
+        retry: undefined
+    };
+}
+
+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, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = 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(_)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
+        };
+    }
+}
+var __rest = undefined && undefined.__rest || function(s, e) {
+    var t = {};
+    for(var p in s)if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function") for(var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++){
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+    }
+    return t;
+};
+var EventStreamContentType = "text/event-stream";
+var DefaultRetryInterval = 1000;
+var LastEventId = "last-event-id";
+function fetchEventSource(input, _a) {
+    var inputSignal = _a.signal, inputHeaders = _a.headers, inputOnOpen = _a.onopen, onmessage = _a.onmessage, onclose = _a.onclose, onerror = _a.onerror, openWhenHidden = _a.openWhenHidden, inputFetch = _a.fetch, rest = __rest(_a, [
+        "signal",
+        "headers",
+        "onopen",
+        "onmessage",
+        "onclose",
+        "onerror",
+        "openWhenHidden",
+        "fetch"
+    ]);
+    return new Promise(function(resolve, reject) {
+        var onVisibilityChange = function onVisibilityChange() {
+            curRequestController.abort();
+            if (!document.hidden) {
+                create();
+            }
+        };
+        var dispose = function dispose() {
+            document.removeEventListener("visibilitychange", onVisibilityChange);
+            window.clearTimeout(retryTimer);
+            curRequestController.abort();
+        };
+        var create = function create() {
+            return _create.apply(this, arguments);
+        };
+        var headers = Object.assign({}, inputHeaders);
+        if (!headers.accept) {
+            headers.accept = EventStreamContentType;
+        }
+        var curRequestController;
+        if (!openWhenHidden) {
+            document.addEventListener("visibilitychange", onVisibilityChange);
+        }
+        var retryInterval = DefaultRetryInterval;
+        var retryTimer = 0;
+        inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", function() {
+            dispose();
+            resolve();
+        });
+        var fetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+        var onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+        function _create() {
+            _create = _async_to_generator(function() {
+                var _$_a, response, err, interval;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            curRequestController = new AbortController();
+                            _state.label = 1;
+                        case 1:
+                            _state.trys.push([
+                                1,
+                                5,
+                                ,
+                                6
+                            ]);
+                            return [
+                                4,
+                                fetch(input, Object.assign(Object.assign({}, rest), {
+                                    headers: headers,
+                                    signal: curRequestController.signal
+                                }))
+                            ];
+                        case 2:
+                            response = _state.sent();
+                            return [
+                                4,
+                                onopen(response)
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                4,
+                                getBytes(response.body, getLines(getMessages(function(id) {
+                                    if (id) {
+                                        headers[LastEventId] = id;
+                                    } else {
+                                        delete headers[LastEventId];
+                                    }
+                                }, function(retry) {
+                                    retryInterval = retry;
+                                }, onmessage)))
+                            ];
+                        case 4:
+                            _state.sent();
+                            onclose === null || onclose === void 0 ? void 0 : onclose();
+                            dispose();
+                            resolve();
+                            return [
+                                3,
+                                6
+                            ];
+                        case 5:
+                            err = _state.sent();
+                            if (!curRequestController.signal.aborted) {
+                                try {
+                                    interval = (_$_a = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _$_a !== void 0 ? _$_a : retryInterval;
+                                    window.clearTimeout(retryTimer);
+                                    retryTimer = window.setTimeout(create, interval);
+                                } catch (innerErr) {
+                                    dispose();
+                                    reject(innerErr);
+                                }
+                            }
+                            return [
+                                3,
+                                6
+                            ];
+                        case 6:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return _create.apply(this, arguments);
+        }
+        create();
+    });
+}
+function defaultOnOpen(response) {
+    var contentType = response.headers.get("content-type");
+    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+        throw new Error("Expected content-type to be ".concat(EventStreamContentType, ", Actual: ").concat(contentType));
+    }
+}
+
+let WebSSEService = class WebSSEService {
+    async connect(params, _pinsSettingsList, context) {
+        const { url = '', event = 'message', message = [], open = [], close = [], error = [], options = {} } = params;
+        await fetchEventSource(url, _extends({
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            onmessage: (notification)=>{
+                if (notification.event !== event) {
+                    return;
+                }
+                engine.executePinsList(message, _extends({}, context, {
+                    message: JSON.parse(notification.data)
+                }));
+            },
+            onopen: async ()=>{
+                await engine.executePinsList(open, _extends({}, context));
+            },
+            onclose: ()=>{
+                engine.executePinsList(close, _extends({}, context));
+            },
+            onerror (err) {
+                if (error.length === 0) {
+                    console.error(err);
+                }
+                engine.executePinsList(error, _extends({}, context, {
+                    error: err
+                }));
+            }
+        }, options));
     }
 };
 const service = new WebSSEService();

package/index.esm.js

@@ -23489,14 +23489,14 @@ function indent(str, spaces) {
         var match = parseIdentifier(input, i1, namePart) || namePart && parseAdditionalSymbol(input, i1) || maybeSpace && parseSpaces(input, i1);
         // match is required
         if (!match) {
-            return i = i1, tokens = tokens1, nextMatch = nextMatch1, {
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, {
                 v: nextMatch1
             };
         }
         var token = match.token, offset = match.offset;
         i1 += offset;
         if (token === " ") {
-            return i = i1, tokens = tokens1, nextMatch = nextMatch1, "continue";
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
         }
         tokens1 = _to_consumable_array$1(tokens1).concat([
             token
@@ -23515,7 +23515,7 @@ function indent(str, spaces) {
         if (contextKeys.some(function(el) {
             return el.startsWith(name);
         })) {
-            return i = i1, tokens = tokens1, nextMatch = nextMatch1, "continue";
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
         }
         if (dateTimeIdentifiers.some(function(el) {
             return el === name;
@@ -23534,9 +23534,9 @@ function indent(str, spaces) {
         if (dateTimeIdentifiers.some(function(el) {
             return el.startsWith(name);
         })) {
-            return i = i1, tokens = tokens1, nextMatch = nextMatch1, "continue";
+            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
         }
-        return i = i1, tokens = tokens1, nextMatch = nextMatch1, {
+        return nextMatch = nextMatch1, tokens = tokens1, i = i1, {
             v: nextMatch1
         };
     };
@@ -27462,21 +27462,557 @@ const preparePinsSettings = async (settings, context)=>{
     });
 };
 
-let WebSSEService = class WebSSEService {
-    async connect(params, _pinsSettingsList, context) {
-        const { url = '', connection = 'default', message = [] } = params;
-        const session = new EventSource(url);
-        this.sessions.set(connection, session);
-        session.addEventListener('message', ({ data })=>{
-            executePinsList(message, _extends({}, context, {
-                message: JSON.parse(data),
-                connection
-            }));
+function asyncGeneratorStep$1(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$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = 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(_)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
+        };
+    }
+}
+function getBytes(stream, onChunk) {
+    return _getBytes.apply(this, arguments);
+}
+function _getBytes() {
+    _getBytes = _async_to_generator$1(function(stream, onChunk) {
+        var reader, result;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    reader = stream.getReader();
+                    _state.label = 1;
+                case 1:
+                    return [
+                        4,
+                        reader.read()
+                    ];
+                case 2:
+                    if (!!(result = _state.sent()).done) return [
+                        3,
+                        3
+                    ];
+                    onChunk(result.value);
+                    return [
+                        3,
+                        1
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _getBytes.apply(this, arguments);
+}
+function getLines(onLine) {
+    var buffer;
+    var position;
+    var fieldLength;
+    var discardTrailingNewline = false;
+    return function onChunk(arr) {
+        if (buffer === undefined) {
+            buffer = arr;
+            position = 0;
+            fieldLength = -1;
+        } else {
+            buffer = concat(buffer, arr);
+        }
+        var bufLength = buffer.length;
+        var lineStart = 0;
+        while(position < bufLength){
+            if (discardTrailingNewline) {
+                if (buffer[position] === 10) {
+                    lineStart = ++position;
+                }
+                discardTrailingNewline = false;
+            }
+            var lineEnd = -1;
+            for(; position < bufLength && lineEnd === -1; ++position){
+                switch(buffer[position]){
+                    case 58:
+                        if (fieldLength === -1) {
+                            fieldLength = position - lineStart;
+                        }
+                        break;
+                    case 13:
+                        discardTrailingNewline = true;
+                    case 10:
+                        lineEnd = position;
+                        break;
+                }
+            }
+            if (lineEnd === -1) {
+                break;
+            }
+            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+            lineStart = position;
+            fieldLength = -1;
+        }
+        if (lineStart === bufLength) {
+            buffer = undefined;
+        } else if (lineStart !== 0) {
+            buffer = buffer.subarray(lineStart);
+            position -= lineStart;
+        }
+    };
+}
+function getMessages(onId, onRetry, onMessage) {
+    var message = newMessage();
+    var decoder = new TextDecoder();
+    return function onLine(line, fieldLength) {
+        if (line.length === 0) {
+            onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+            message = newMessage();
+        } else if (fieldLength > 0) {
+            var field = decoder.decode(line.subarray(0, fieldLength));
+            var valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+            var value = decoder.decode(line.subarray(valueOffset));
+            switch(field){
+                case "data":
+                    message.data = message.data ? message.data + "\n" + value : value;
+                    break;
+                case "event":
+                    message.event = value;
+                    break;
+                case "id":
+                    onId(message.id = value);
+                    break;
+                case "retry":
+                    var retry = parseInt(value, 10);
+                    if (!isNaN(retry)) {
+                        onRetry(message.retry = retry);
+                    }
+                    break;
+            }
+        }
+    };
+}
+function concat(a, b) {
+    var res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}
+function newMessage() {
+    return {
+        data: "",
+        event: "",
+        id: "",
+        retry: undefined
+    };
+}
+
+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, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = 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(_)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
+        };
+    }
+}
+var __rest = undefined && undefined.__rest || function(s, e) {
+    var t = {};
+    for(var p in s)if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function") for(var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++){
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+    }
+    return t;
+};
+var EventStreamContentType = "text/event-stream";
+var DefaultRetryInterval = 1000;
+var LastEventId = "last-event-id";
+function fetchEventSource(input, _a) {
+    var inputSignal = _a.signal, inputHeaders = _a.headers, inputOnOpen = _a.onopen, onmessage = _a.onmessage, onclose = _a.onclose, onerror = _a.onerror, openWhenHidden = _a.openWhenHidden, inputFetch = _a.fetch, rest = __rest(_a, [
+        "signal",
+        "headers",
+        "onopen",
+        "onmessage",
+        "onclose",
+        "onerror",
+        "openWhenHidden",
+        "fetch"
+    ]);
+    return new Promise(function(resolve, reject) {
+        var onVisibilityChange = function onVisibilityChange() {
+            curRequestController.abort();
+            if (!document.hidden) {
+                create();
+            }
+        };
+        var dispose = function dispose() {
+            document.removeEventListener("visibilitychange", onVisibilityChange);
+            window.clearTimeout(retryTimer);
+            curRequestController.abort();
+        };
+        var create = function create() {
+            return _create.apply(this, arguments);
+        };
+        var headers = Object.assign({}, inputHeaders);
+        if (!headers.accept) {
+            headers.accept = EventStreamContentType;
+        }
+        var curRequestController;
+        if (!openWhenHidden) {
+            document.addEventListener("visibilitychange", onVisibilityChange);
+        }
+        var retryInterval = DefaultRetryInterval;
+        var retryTimer = 0;
+        inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", function() {
+            dispose();
+            resolve();
         });
-        return session;
+        var fetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+        var onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+        function _create() {
+            _create = _async_to_generator(function() {
+                var _$_a, response, err, interval;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            curRequestController = new AbortController();
+                            _state.label = 1;
+                        case 1:
+                            _state.trys.push([
+                                1,
+                                5,
+                                ,
+                                6
+                            ]);
+                            return [
+                                4,
+                                fetch(input, Object.assign(Object.assign({}, rest), {
+                                    headers: headers,
+                                    signal: curRequestController.signal
+                                }))
+                            ];
+                        case 2:
+                            response = _state.sent();
+                            return [
+                                4,
+                                onopen(response)
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                4,
+                                getBytes(response.body, getLines(getMessages(function(id) {
+                                    if (id) {
+                                        headers[LastEventId] = id;
+                                    } else {
+                                        delete headers[LastEventId];
+                                    }
+                                }, function(retry) {
+                                    retryInterval = retry;
+                                }, onmessage)))
+                            ];
+                        case 4:
+                            _state.sent();
+                            onclose === null || onclose === void 0 ? void 0 : onclose();
+                            dispose();
+                            resolve();
+                            return [
+                                3,
+                                6
+                            ];
+                        case 5:
+                            err = _state.sent();
+                            if (!curRequestController.signal.aborted) {
+                                try {
+                                    interval = (_$_a = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _$_a !== void 0 ? _$_a : retryInterval;
+                                    window.clearTimeout(retryTimer);
+                                    retryTimer = window.setTimeout(create, interval);
+                                } catch (innerErr) {
+                                    dispose();
+                                    reject(innerErr);
+                                }
+                            }
+                            return [
+                                3,
+                                6
+                            ];
+                        case 6:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return _create.apply(this, arguments);
+        }
+        create();
+    });
+}
+function defaultOnOpen(response) {
+    var contentType = response.headers.get("content-type");
+    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+        throw new Error("Expected content-type to be ".concat(EventStreamContentType, ", Actual: ").concat(contentType));
     }
-    constructor(){
-        this.sessions = new Map();
+}
+
+let WebSSEService = class WebSSEService {
+    async connect(params, _pinsSettingsList, context) {
+        const { url = '', event = 'message', message = [], open = [], close = [], error = [], options = {} } = params;
+        await fetchEventSource(url, _extends({
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            onmessage: (notification)=>{
+                if (notification.event !== event) {
+                    return;
+                }
+                executePinsList(message, _extends({}, context, {
+                    message: JSON.parse(notification.data)
+                }));
+            },
+            onopen: async ()=>{
+                await executePinsList(open, _extends({}, context));
+            },
+            onclose: ()=>{
+                executePinsList(close, _extends({}, context));
+            },
+            onerror (err) {
+                if (error.length === 0) {
+                    console.error(err);
+                }
+                executePinsList(error, _extends({}, context, {
+                    error: err
+                }));
+            }
+        }, options));
     }
 };
 const service = new WebSSEService();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digipair/skill-client-sse",
-  "version": "0.37.5",
+  "version": "0.38.0",
   "dependencies": {},
   "main": "./index.cjs.js",
   "module": "./index.esm.js"

package/schema.fr.json

@@ -23,19 +23,28 @@
             }
           },
           {
-            "name": "connection",
-            "summary": "Nom",
+            "name": "event",
+            "summary": "Événement",
             "required": false,
-            "description": "Nom de la connexion",
+            "description": "Nom de l'événement",
             "schema": {
               "type": "string"
             }
+          },
+          {
+            "name": "options",
+            "summary": "Options",
+            "required": false,
+            "description": "Options de récupération SSE",
+            "schema": {
+              "type": "object"
+            }
           }
         ],
         "x-events": [
           {
             "name": "message",
-            "summary": "Lors de la réception d'un message",
+            "summary": "Lors d'un message",
             "required": false,
             "description": "Action déclenchée lors de la réception d'un message",
             "schema": {
@@ -44,6 +53,42 @@
                 "$ref": "https://schemas.digipair.ai/pinsSettings"
               }
             }
+          },
+          {
+            "name": "open",
+            "summary": "Lors de l'ouverture",
+            "required": false,
+            "description": "Action déclenchée lors de l'ouverture d'une connexion",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
+          },
+          {
+            "name": "close",
+            "summary": "Lors de la fermeture",
+            "required": false,
+            "description": "Action déclenchée lors de la fermeture d'une connexion",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
+          },
+          {
+            "name": "error",
+            "summary": "Lors d'une erreur",
+            "required": false,
+            "description": "Action déclenchée lors d'une erreur",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
           }
         ]
       }

package/schema.json

@@ -23,19 +23,28 @@
             }
           },
           {
-            "name": "connection",
-            "summary": "Name",
+            "name": "event",
+            "summary": "Event",
             "required": false,
-            "description": "Name of the connection",
+            "description": "Event name",
             "schema": {
               "type": "string"
             }
+          },
+          {
+            "name": "options",
+            "summary": "Options",
+            "required": false,
+            "description": "SSE fetch options",
+            "schema": {
+              "type": "object"
+            }
           }
         ],
         "x-events": [
           {
             "name": "message",
-            "summary": "Upon receiving a message",
+            "summary": "Upon a message",
             "required": false,
             "description": "Action triggered upon receiving a message",
             "schema": {
@@ -44,6 +53,42 @@
                 "$ref": "https://schemas.digipair.ai/pinsSettings"
               }
             }
+          },
+          {
+            "name": "open",
+            "summary": "Upon opening",
+            "required": false,
+            "description": "Action triggered upon opening a connection",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
+          },
+          {
+            "name": "close",
+            "summary": "Upon closing",
+            "required": false,
+            "description": "Action triggered upon closing a connection",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
+          },
+          {
+            "name": "error",
+            "summary": "Upon an error",
+            "required": false,
+            "description": "Action triggered upon an error",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
           }
         ]
       }