@digipair/skill-client-sse 0.91.0-0 → 0.92.0

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,575 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var engine = require('@digipair/engine');
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+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();
+        });
+        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 ClientSSEService = class ClientSSEService {
+    async connect(params, _pinsSettingsList, context) {
+        var _context_protected;
+        const { url = '', event = 'message', message = [], open = [], close = [], error = [], options = {} } = params;
+        await fetchEventSource(url, _extends({
+            signal: (_context_protected = context.protected) == null ? void 0 : _context_protected.signal,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            onmessage: (notification)=>{
+                if (notification.event !== event) {
+                    return;
+                }
+                engine.executePinsList(message, _extends({}, context, {
+                    message: JSON.parse(notification.data)
+                }), `${context.__PATH__}.message`);
+            },
+            onopen: async ()=>{
+                await engine.executePinsList(open, _extends({}, context), `${context.__PATH__}.open`);
+            },
+            onclose: ()=>{
+                engine.executePinsList(close, _extends({}, context), `${context.__PATH__}.close`);
+            },
+            onerror (err) {
+                if (error.length === 0) {
+                    console.error(err);
+                }
+                engine.executePinsList(error, _extends({}, context, {
+                    error: err
+                }), `${context.__PATH__}.error`);
+            }
+        }, options));
+    }
+};
+const connect = (params, pinsSettingsList, context)=>new ClientSSEService().connect(params, pinsSettingsList, context);
+
+exports.connect = connect;