@chatie/angular/fesm5/chatie-angular.js

import { __awaiter, __generator, __decorate } from 'tslib';
import { EventEmitter, NgZone, Output, Input, Component, NgModule } from '@angular/core';
import { BehaviorSubject, Observable, Subject, interval } from 'rxjs';
import { filter, share, tap, takeUntil } from 'rxjs/operators';
import { Brolog } from 'brolog';
import { StateSwitch } from 'state-switch';

/**
 * This file will be overwrite when we publish NPM module
 * by scripts/generate_version.ts
 */
var VERSION = '0.0.0';

var ReadyState;
(function (ReadyState) {
    ReadyState[ReadyState["CLOSED"] = WebSocket.CLOSED] = "CLOSED";
    ReadyState[ReadyState["CLOSING"] = WebSocket.CLOSING] = "CLOSING";
    ReadyState[ReadyState["CONNECTING"] = WebSocket.CONNECTING] = "CONNECTING";
    ReadyState[ReadyState["OPEN"] = WebSocket.OPEN] = "OPEN";
})(ReadyState || (ReadyState = {}));
var IoService = /** @class */ (function () {
    function IoService() {
        this.autoReconnect = true;
        this.log = Brolog.instance();
        this.CONNECT_TIMEOUT = 10 * 1000; // 10 seconds
        this.ENDPOINT = 'wss://api.chatie.io/v0/websocket/token/';
        this.PROTOCOL = 'web|0.0.1';
        this.sendBuffer = [];
        this.log.verbose('IoService', 'constructor()');
    }
    Object.defineProperty(IoService.prototype, "readyState", {
        get: function () {
            return this._readyState.asObservable();
        },
        enumerable: true,
        configurable: true
    });
    IoService.prototype.init = function () {
        return __awaiter(this, void 0, void 0, function () {
            var e_1;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.log.verbose('IoService', 'init()');
                        if (this.state) {
                            throw new Error('re-init');
                        }
                        this.snapshot = {
                            readyState: ReadyState.CLOSED,
                            event: null,
                        };
                        this._readyState = new BehaviorSubject(ReadyState.CLOSED);
                        this.state = new StateSwitch('IoService', this.log);
                        this.state.setLog(this.log);
                        _a.label = 1;
                    case 1:
                        _a.trys.push([1, 4, , 5]);
                        return [4 /*yield*/, this.initStateDealer()];
                    case 2:
                        _a.sent();
                        return [4 /*yield*/, this.initRxSocket()];
                    case 3:
                        _a.sent();
                        return [3 /*break*/, 5];
                    case 4:
                        e_1 = _a.sent();
                        this.log.silly('IoService', 'init() exception: %s', e_1.message);
                        throw e_1;
                    case 5:
                        this.readyState.subscribe(function (s) {
                            _this.log.silly('IoService', 'init() readyState.subscribe(%s)', ReadyState[s]);
                            _this.snapshot.readyState = s;
                        });
                        // IMPORTANT: subscribe to event and make it HOT!
                        this.event.subscribe(function (s) {
                            _this.log.silly('IoService', 'init() event.subscribe({name:%s})', s.name);
                            _this.snapshot.event = s;
                        });
                        return [2 /*return*/];
                }
            });
        });
    };
    IoService.prototype.token = function (newToken) {
        this.log.silly('IoService', 'token(%s)', newToken);
        if (newToken) {
            this._token = newToken;
            return;
        }
        return this._token;
    };
    IoService.prototype.start = function () {
        return __awaiter(this, void 0, void 0, function () {
            var e_2;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.log.verbose('IoService', 'start() with token:%s', this._token);
                        if (!this._token) {
                            throw new Error('start() without token');
                        }
                        if (this.state.on()) {
                            throw new Error('state is already ON');
                        }
                        if (this.state.pending()) {
                            throw new Error('state is pending');
                        }
                        this.state.on('pending');
                        this.autoReconnect = true;
                        _a.label = 1;
                    case 1:
                        _a.trys.push([1, 3, , 4]);
                        return [4 /*yield*/, this.connectRxSocket()];
                    case 2:
                        _a.sent();
                        this.state.on(true);
                        return [3 /*break*/, 4];
                    case 3:
                        e_2 = _a.sent();
                        this.log.warn('IoService', 'start() failed:%s', e_2.message);
                        this.state.off(true);
                        return [3 /*break*/, 4];
                    case 4: return [2 /*return*/];
                }
            });
        });
    };
    IoService.prototype.stop = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.log.verbose('IoService', 'stop()');
                        if (this.state.off()) {
                            this.log.warn('IoService', 'stop() state is already off');
                            if (this.state.pending()) {
                                throw new Error('state pending() is true');
                            }
                            return [2 /*return*/];
                        }
                        this.state.off('pending');
                        this.autoReconnect = false;
                        if (!this._websocket) {
                            throw new Error('no websocket');
                        }
                        return [4 /*yield*/, this.socketClose(1000, 'IoService.stop()')];
                    case 1:
                        _a.sent();
                        this.state.off(true);
                        return [2 /*return*/];
                }
            });
        });
    };
    IoService.prototype.restart = function () {
        return __awaiter(this, void 0, void 0, function () {
            var e_3;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.log.verbose('IoService', 'restart()');
                        _a.label = 1;
                    case 1:
                        _a.trys.push([1, 4, , 5]);
                        return [4 /*yield*/, this.stop()];
                    case 2:
                        _a.sent();
                        return [4 /*yield*/, this.start()];
                    case 3:
                        _a.sent();
                        return [3 /*break*/, 5];
                    case 4:
                        e_3 = _a.sent();
                        this.log.error('IoService', 'restart() error:%s', e_3.message);
                        throw e_3;
                    case 5: return [2 /*return*/];
                }
            });
        });
    };
    IoService.prototype.initStateDealer = function () {
        var _this = this;
        this.log.verbose('IoService', 'initStateDealer()');
        this.readyState.pipe(filter(function (s) { return s === ReadyState.OPEN; }))
            .subscribe(function (open) { return _this.stateOnOpen(); });
    };
    /**
     * Creates a subject from the specified observer and observable.
     *  - https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/subjects/subject.md
     * Create an Rx.Subject using Subject.create that allows onNext without subscription
     *   A socket implementation (example, don't use)
     *  - http://stackoverflow.com/a/34862286/1123955
     */
    IoService.prototype.initRxSocket = function () {
        return __awaiter(this, void 0, void 0, function () {
            var observable;
            var _this = this;
            return __generator(this, function (_a) {
                this.log.verbose('IoService', 'initRxSocket()');
                if (this.event) {
                    throw new Error('re-init is not permitted');
                }
                // 1. Mobile Originated. moObserver.next() means mobile is sending
                this.moObserver = {
                    next: this.socketSend.bind(this),
                    error: this.socketClose.bind(this),
                    complete: this.socketClose.bind(this),
                };
                observable = Observable.create(function (observer) {
                    _this.log.verbose('IoService', 'initRxSocket() Observable.create()');
                    _this.mtObserver = observer;
                    return _this.socketClose.bind(_this);
                });
                // 3. Subject for MO & MT Observers
                this.event = Subject.create(this.moObserver, observable.pipe(share()));
                return [2 /*return*/];
            });
        });
    };
    IoService.prototype.connectRxSocket = function () {
        return __awaiter(this, void 0, void 0, function () {
            var onOpenPromise;
            var _this = this;
            return __generator(this, function (_a) {
                this.log.verbose('IoService', 'connectRxSocket()');
                // FIXME: check & close the old one
                if (this._websocket) {
                    throw new Error('already has a websocket');
                }
                // if (this.state.target() !== 'open'
                //   || this.state.current() !== 'open'
                //   || this.state.stable()
                if (this.state.off()) {
                    throw new Error('switch state is off');
                }
                else if (!this.state.pending()) {
                    throw new Error('switch state is already ON');
                }
                this._websocket = new WebSocket(this.endPoint(), this.PROTOCOL);
                this.socketUpdateState();
                onOpenPromise = new Promise(function (resolve, reject) {
                    _this.log.verbose('IoService', 'connectRxSocket() Promise()');
                    var id = setTimeout(function () {
                        _this._websocket = null;
                        var e = new Error('rxSocket connect timeout after '
                            + Math.round(_this.CONNECT_TIMEOUT / 1000));
                        reject(e);
                    }, _this.CONNECT_TIMEOUT); // timeout for connect websocket
                    _this._websocket.onopen = function (e) {
                        _this.log.verbose('IoService', 'connectRxSocket() Promise() WebSocket.onOpen() resolve()');
                        _this.socketUpdateState();
                        clearTimeout(id);
                        resolve();
                    };
                });
                // Handle the payload
                this._websocket.onmessage = this.socketOnMessage.bind(this);
                // Deal the event
                this._websocket.onerror = this.socketOnError.bind(this);
                this._websocket.onclose = this.socketOnClose.bind(this);
                return [2 /*return*/, onOpenPromise];
            });
        });
    };
    IoService.prototype.endPoint = function () {
        var url = this.ENDPOINT + this._token;
        this.log.verbose('IoService', 'endPoint() => %s', url);
        return url;
    };
    /******************************************************************
     *
     * State Event Listeners
     *
     */
    IoService.prototype.stateOnOpen = function () {
        this.log.verbose('IoService', 'stateOnOpen()');
        this.socketSendBuffer();
        this.rpcUpdate('from stateOnOpen()');
    };
    /******************************************************************
     *
     * Io RPC Methods
     *
     */
    IoService.prototype.rpcDing = function (payload) {
        return __awaiter(this, void 0, void 0, function () {
            var e;
            return __generator(this, function (_a) {
                this.log.verbose('IoService', 'ding(%s)', payload);
                e = {
                    name: 'ding',
                    payload: payload,
                };
                this.event.next(e);
                return [2 /*return*/];
            });
        });
    };
    IoService.prototype.rpcUpdate = function (payload) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                this.event.next({
                    name: 'update',
                    payload: payload,
                });
                return [2 /*return*/];
            });
        });
    };
    /******************************************************************
     *
     * Socket Actions
     *
     */
    IoService.prototype.socketClose = function (code, reason) {
        return __awaiter(this, void 0, void 0, function () {
            var future;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.log.verbose('IoService', 'socketClose()');
                        if (!this._websocket) {
                            throw new Error('no websocket');
                        }
                        this._websocket.close(code, reason);
                        this.socketUpdateState();
                        future = new Promise(function (resolve) {
                            _this.readyState.pipe(filter(function (s) { return s === ReadyState.CLOSED; }))
                                .subscribe(resolve);
                        });
                        return [4 /*yield*/, future];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    IoService.prototype.socketSend = function (ioEvent) {
        this.log.silly('IoService', 'socketSend({name:%s, payload:%s})', ioEvent.name, ioEvent.payload);
        if (!this._websocket) {
            this.log.silly('IoService', 'socketSend() no _websocket');
        }
        var strEvt = JSON.stringify(ioEvent);
        this.sendBuffer.push(strEvt);
        // XXX can move this to onOpen?
        this.socketSendBuffer();
    };
    IoService.prototype.socketSendBuffer = function () {
        this.log.silly('IoService', 'socketSendBuffer() length:%s', this.sendBuffer.length);
        if (!this._websocket) {
            throw new Error('socketSendBuffer(): no _websocket');
        }
        if (this._websocket.readyState !== WebSocket.OPEN) {
            this.log.warn('IoService', 'socketSendBuffer() readyState is not OPEN, send job delayed.');
            return;
        }
        while (this.sendBuffer.length) {
            var buf = this.sendBuffer.shift();
            this.log.silly('IoService', 'socketSendBuffer() sending(%s)', buf);
            this._websocket.send(buf);
        }
    };
    IoService.prototype.socketUpdateState = function () {
        this.log.verbose('IoService', 'socketUpdateState() is %s', ReadyState[this._websocket.readyState]);
        if (!this._websocket) {
            this.log.error('IoService', 'socketUpdateState() no _websocket');
            return;
        }
        this._readyState.next(this._websocket.readyState);
    };
    /******************************************************************
     *
     * Socket Events Listener
     *
     */
    IoService.prototype.socketOnMessage = function (message) {
        this.log.verbose('IoService', 'onMessage({data: %s})', message.data);
        var data = message.data; // WebSocket data
        var ioEvent = {
            name: 'raw',
            payload: data,
        }; // this is default io event for unknown format message
        try {
            var obj = JSON.parse(data);
            ioEvent.name = obj.name;
            ioEvent.payload = obj.payload;
        }
        catch (e) {
            this.log.warn('IoService', 'onMessage parse message fail. save as RAW');
        }
        this.mtObserver.next(ioEvent);
    };
    IoService.prototype.socketOnError = function (event) {
        this.log.silly('IoService', 'socketOnError(%s)', event);
        // this._websocket = null
    };
    /**
     * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
     * code: 1006	CLOSE_ABNORMAL
     *  - Reserved. Used to indicate that a connection was closed abnormally
     *    (that is, with no close frame being sent) when a status code is expected.
     */
    IoService.prototype.socketOnClose = function (closeEvent) {
        var _this = this;
        this.log.verbose('IoService', 'socketOnClose({code:%s, reason:%s, returnValue:%s})', closeEvent.code, closeEvent.reason, closeEvent.returnValue);
        this.socketUpdateState();
        /**
         * reconnect inside onClose
         */
        if (this.autoReconnect) {
            this.state.on('pending');
            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
                var e_4;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            _a.trys.push([0, 2, , 3]);
                            return [4 /*yield*/, this.connectRxSocket()];
                        case 1:
                            _a.sent();
                            this.state.on(true);
                            return [3 /*break*/, 3];
                        case 2:
                            e_4 = _a.sent();
                            this.log.warn('IoService', 'socketOnClose() autoReconnect() exception: %s', e_4);
                            this.state.off(true);
                            return [3 /*break*/, 3];
                        case 3: return [2 /*return*/];
                    }
                });
            }); }, 1000);
        }
        else {
            this.state.off(true);
        }
        this._websocket = null;
        if (!closeEvent.wasClean) {
            this.log.warn('IoService', 'socketOnClose() event.wasClean FALSE');
            // TODO emit error
        }
    };
    return IoService;
}());

var WechatyComponent = /** @class */ (function () {
    function WechatyComponent(log, ngZone) {
        this.log = log;
        this.ngZone = ngZone;
        this.message = new EventEmitter();
        this.scan = new EventEmitter();
        this.login = new EventEmitter();
        this.logout = new EventEmitter();
        this.error = new EventEmitter();
        this.heartbeat = new EventEmitter();
        this.timerSub = null;
        this.counter = 0;
        this.timestamp = new Date();
        this.log.verbose('WechatyComponent', 'constructor() v%s', VERSION);
    }
    Object.defineProperty(WechatyComponent.prototype, "token", {
        get: function () { return this._token; },
        set: function (_newToken) {
            this.log.verbose('WechatyComponent', 'set token(%s)', _newToken);
            var newToken = (_newToken || '').trim();
            if (this._token === newToken) {
                this.log.silly('WechatyComponent', 'set token(%s) not new', newToken);
                return;
            }
            this._token = newToken;
            if (!this.ioService) {
                this.log.silly('WechatyComponent', 'set token() skip token init value');
                this.log.silly('WechatyComponent', 'set token() because ioService will do it inside ngOnInit()');
                return;
            }
            this.log.silly('WechatyComponent', 'set token(%s) reloading ioService now...', newToken);
            this.ioService.token(this.token);
            this.ioService.restart(); // async
        },
        enumerable: true,
        configurable: true
    });
    WechatyComponent.prototype.ngOnInit = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.log.verbose('WechatyComponent', 'ngOninit() with token: ' + this.token);
                        this.ioService = new IoService();
                        return [4 /*yield*/, this.ioService.init()];
                    case 1:
                        _a.sent();
                        this.ioService.event.subscribe(this.onIo.bind(this));
                        this.log.silly('WechatyComponent', 'ngOninit() ioService.event.subscribe()-ed');
                        if (!this.token) return [3 /*break*/, 3];
                        this.ioService.token(this.token);
                        return [4 /*yield*/, this.ioService.start()];
                    case 2:
                        _a.sent();
                        _a.label = 3;
                    case 3: return [2 /*return*/];
                }
            });
        });
    };
    WechatyComponent.prototype.ngOnDestroy = function () {
        this.log.verbose('WechatyComponent', 'ngOnDestroy()');
        this.endTimer();
        if (this.ioService) {
            this.ioService.stop();
            // this.ioService = null
        }
    };
    WechatyComponent.prototype.onIo = function (e) {
        this.log.silly('WechatyComponent', 'onIo#%d(%s)', this.counter++, e.name);
        this.timestamp = new Date();
        switch (e.name) {
            case 'scan':
                this.scan.emit(e.payload);
                break;
            case 'login':
                this.login.emit(e.payload);
                break;
            case 'logout':
                this.logout.emit(e.payload);
                break;
            case 'message':
                this.message.emit(e.payload);
                break;
            case 'error':
                this.error.emit(e.payload);
                break;
            case 'ding':
            case 'dong':
            case 'raw':
                this.heartbeat.emit(e.name + '[' + e.payload + ']');
                break;
            case 'heartbeat':
                this.heartbeat.emit(e.payload);
                break;
            case 'sys':
                this.log.silly('WechatyComponent', 'onIo(%s): %s', e.name, e.payload);
                break;
            default:
                this.log.warn('WechatyComponent', 'onIo() unknown event name: %s[%s]', e.name, e.payload);
                break;
        }
    };
    WechatyComponent.prototype.reset = function (reason) {
        this.log.verbose('WechatyComponent', 'reset(%s)', reason);
        var resetEvent = {
            name: 'reset',
            payload: reason,
        };
        if (!this.ioService) {
            throw new Error('no ioService');
        }
        this.ioService.event.next(resetEvent);
    };
    WechatyComponent.prototype.shutdown = function (reason) {
        this.log.verbose('WechatyComponent', 'shutdown(%s)', reason);
        var shutdownEvent = {
            name: 'shutdown',
            payload: reason,
        };
        if (!this.ioService) {
            throw new Error('no ioService');
        }
        this.ioService.event.next(shutdownEvent);
    };
    WechatyComponent.prototype.startTimer = function () {
        var _this = this;
        this.log.verbose('WechatyComponent', 'startTimer()');
        this.ender = new Subject();
        // https://github.com/angular/protractor/issues/3349#issuecomment-232253059
        // https://github.com/juliemr/ngconf-2016-zones/blob/master/src/app/main.ts#L38
        this.ngZone.runOutsideAngular(function () {
            _this.timer = interval(3000).pipe(tap(function (i) { _this.log.verbose('do', ' %d', i); }), takeUntil(_this.ender), share());
            // .publish()
        });
        this.timerSub = this.timer.subscribe(function (t) {
            _this.counter = t;
            if (!_this.ioService) {
                throw new Error('no ioService');
            }
            _this.ioService.rpcDing(_this.counter);
            // this.message.emit('#' + this.token + ':' + dong)
        });
    };
    WechatyComponent.prototype.endTimer = function () {
        this.log.verbose('WechatyComponent', 'endTimer()');
        if (this.timerSub) {
            this.timerSub.unsubscribe();
            this.timerSub = null;
        }
        // this.timer = null
        if (this.ender) {
            this.ender.next(null);
            // this.ender = null
        }
    };
    WechatyComponent.prototype.logoff = function (reason) {
        this.log.silly('WechatyComponent', 'logoff(%s)', reason);
        var quitEvent = {
            name: 'logout',
            payload: reason,
        };
        this.ioService.event.next(quitEvent);
    };
    Object.defineProperty(WechatyComponent.prototype, "readyState", {
        get: function () {
            return this.ioService.readyState;
        },
        enumerable: true,
        configurable: true
    });
    WechatyComponent.ctorParameters = function () { return [
        { type: Brolog },
        { type: NgZone }
    ]; };
    __decorate([
        Output()
    ], WechatyComponent.prototype, "message", void 0);
    __decorate([
        Output()
    ], WechatyComponent.prototype, "scan", void 0);
    __decorate([
        Output()
    ], WechatyComponent.prototype, "login", void 0);
    __decorate([
        Output()
    ], WechatyComponent.prototype, "logout", void 0);
    __decorate([
        Output()
    ], WechatyComponent.prototype, "error", void 0);
    __decorate([
        Output()
    ], WechatyComponent.prototype, "heartbeat", void 0);
    __decorate([
        Input()
    ], WechatyComponent.prototype, "token", null);
    WechatyComponent = __decorate([
        Component({
            // tslint:disable-next-line:component-selector
            selector: 'wechaty',
            /**
             * http://localhost:4200/app.component.html 404 (Not Found)
             * zone.js:344 Unhandled Promise rejection: Failed to load app.component.html
             * https://github.com/angular/angular-cli/issues/2592#issuecomment-266635266
             * https://github.com/angular/angular-cli/issues/2293
             *
             * console.log from angular:
             *   If you're using Webpack you should inline the template and the styles,
             *   see https://goo.gl/X2J8zc.
             */
            template: '<ng-content></ng-content>'
        })
    ], WechatyComponent);
    return WechatyComponent;
}());

var WechatyModule = /** @class */ (function () {
    function WechatyModule() {
    }
    WechatyModule = __decorate([
        NgModule({
            id: 'wechaty',
            declarations: [
                WechatyComponent,
            ],
            exports: [
                WechatyComponent,
            ],
        })
    ], WechatyModule);
    return WechatyModule;
}());

/**
 * Generated bundle index. Do not edit.
 */

export { VERSION, WechatyComponent, WechatyModule, WechatyComponent as ɵa };
//# sourceMappingURL=chatie-angular.js.map