(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["tinode"] = factory();
else
root["tinode"] = factory();
})(this, () => {
return /******/ (() => { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ "./src/access-mode.js":
/*!****************************!*\
!*** ./src/access-mode.js ***!
\****************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (/* binding */ AccessMode)
/* harmony export */ });
class AccessMode {
constructor(acs) {
if (acs) {
this.given = typeof acs.given == 'number' ? acs.given : AccessMode.decode(acs.given);
this.want = typeof acs.want == 'number' ? acs.want : AccessMode.decode(acs.want);
this.mode = acs.mode ? typeof acs.mode == 'number' ? acs.mode : AccessMode.decode(acs.mode) : this.given & this.want;
}
}
static #checkFlag(val, side, flag) {
side = side || 'mode';
if (['given', 'want', 'mode'].includes(side)) {
return (val[side] & flag) != 0;
}
throw new Error(`Invalid AccessMode component '${side}'`);
}
static decode(str) {
if (!str) {
return null;
} else if (typeof str == 'number') {
return str & AccessMode._BITMASK;
} else if (str === 'N' || str === 'n') {
return AccessMode._NONE;
}
const bitmask = {
'J': AccessMode._JOIN,
'R': AccessMode._READ,
'W': AccessMode._WRITE,
'P': AccessMode._PRES,
'A': AccessMode._APPROVE,
'S': AccessMode._SHARE,
'D': AccessMode._DELETE,
'O': AccessMode._OWNER
};
let m0 = AccessMode._NONE;
for (let i = 0; i < str.length; i++) {
const bit = bitmask[str.charAt(i).toUpperCase()];
if (!bit) {
continue;
}
m0 |= bit;
}
return m0;
}
static encode(val) {
if (val === null || val === AccessMode._INVALID) {
return null;
} else if (val === AccessMode._NONE) {
return 'N';
}
const bitmask = ['J', 'R', 'W', 'P', 'A', 'S', 'D', 'O'];
let res = '';
for (let i = 0; i < bitmask.length; i++) {
if ((val & 1 << i) != 0) {
res = res + bitmask[i];
}
}
return res;
}
static update(val, upd) {
if (!upd || typeof upd != 'string') {
return val;
}
let action = upd.charAt(0);
if (action == '+' || action == '-') {
let val0 = val;
const parts = upd.split(/([-+])/);
for (let i = 1; i < parts.length - 1; i += 2) {
action = parts[i];
const m0 = AccessMode.decode(parts[i + 1]);
if (m0 == AccessMode._INVALID) {
return val;
}
if (m0 == null) {
continue;
}
if (action === '+') {
val0 |= m0;
} else if (action === '-') {
val0 &= ~m0;
}
}
val = val0;
} else {
const val0 = AccessMode.decode(upd);
if (val0 != AccessMode._INVALID) {
val = val0;
}
}
return val;
}
static diff(a1, a2) {
a1 = AccessMode.decode(a1);
a2 = AccessMode.decode(a2);
if (a1 == AccessMode._INVALID || a2 == AccessMode._INVALID) {
return AccessMode._INVALID;
}
return a1 & ~a2;
}
toString() {
return '{"mode": "' + AccessMode.encode(this.mode) + '", "given": "' + AccessMode.encode(this.given) + '", "want": "' + AccessMode.encode(this.want) + '"}';
}
jsonHelper() {
return {
mode: AccessMode.encode(this.mode),
given: AccessMode.encode(this.given),
want: AccessMode.encode(this.want)
};
}
setMode(m) {
this.mode = AccessMode.decode(m);
return this;
}
updateMode(u) {
this.mode = AccessMode.update(this.mode, u);
return this;
}
getMode() {
return AccessMode.encode(this.mode);
}
setGiven(g) {
this.given = AccessMode.decode(g);
return this;
}
updateGiven(u) {
this.given = AccessMode.update(this.given, u);
return this;
}
getGiven() {
return AccessMode.encode(this.given);
}
setWant(w) {
this.want = AccessMode.decode(w);
return this;
}
updateWant(u) {
this.want = AccessMode.update(this.want, u);
return this;
}
getWant() {
return AccessMode.encode(this.want);
}
getMissing() {
return AccessMode.encode(this.want & ~this.given);
}
getExcessive() {
return AccessMode.encode(this.given & ~this.want);
}
updateAll(val) {
if (val) {
this.updateGiven(val.given);
this.updateWant(val.want);
this.mode = this.given & this.want;
}
return this;
}
isOwner(side) {
return AccessMode.#checkFlag(this, side, AccessMode._OWNER);
}
isPresencer(side) {
return AccessMode.#checkFlag(this, side, AccessMode._PRES);
}
isMuted(side) {
return !this.isPresencer(side);
}
isJoiner(side) {
return AccessMode.#checkFlag(this, side, AccessMode._JOIN);
}
isReader(side) {
return AccessMode.#checkFlag(this, side, AccessMode._READ);
}
isWriter(side) {
return AccessMode.#checkFlag(this, side, AccessMode._WRITE);
}
isApprover(side) {
return AccessMode.#checkFlag(this, side, AccessMode._APPROVE);
}
isAdmin(side) {
return this.isOwner(side) || this.isApprover(side);
}
isSharer(side) {
return this.isAdmin(side) || AccessMode.#checkFlag(this, side, AccessMode._SHARE);
}
isDeleter(side) {
return AccessMode.#checkFlag(this, side, AccessMode._DELETE);
}
}
AccessMode._NONE = 0x00;
AccessMode._JOIN = 0x01;
AccessMode._READ = 0x02;
AccessMode._WRITE = 0x04;
AccessMode._PRES = 0x08;
AccessMode._APPROVE = 0x10;
AccessMode._SHARE = 0x20;
AccessMode._DELETE = 0x40;
AccessMode._OWNER = 0x80;
AccessMode._BITMASK = AccessMode._JOIN | AccessMode._READ | AccessMode._WRITE | AccessMode._PRES | AccessMode._APPROVE | AccessMode._SHARE | AccessMode._DELETE | AccessMode._OWNER;
AccessMode._INVALID = 0x100000;
/***/ }),
/***/ "./src/cbuffer.js":
/*!************************!*\
!*** ./src/cbuffer.js ***!
\************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (/* binding */ CBuffer)
/* harmony export */ });
class CBuffer {
#comparator = undefined;
#unique = false;
buffer = [];
constructor(compare_, unique_) {
this.#comparator = compare_ || ((a, b) => {
return a === b ? 0 : a < b ? -1 : 1;
});
this.#unique = unique_;
}
#findNearest(elem, arr, exact) {
let start = 0;
let end = arr.length - 1;
let pivot = 0;
let diff = 0;
let found = false;
while (start <= end) {
pivot = (start + end) / 2 | 0;
diff = this.#comparator(arr[pivot], elem);
if (diff < 0) {
start = pivot + 1;
} else if (diff > 0) {
end = pivot - 1;
} else {
found = true;
break;
}
}
if (found) {
return {
idx: pivot,
exact: true
};
}
if (exact) {
return {
idx: -1
};
}
return {
idx: diff < 0 ? pivot + 1 : pivot
};
}
#insertSorted(elem, arr) {
const found = this.#findNearest(elem, arr, false);
const count = found.exact && this.#unique ? 1 : 0;
arr.splice(found.idx, count, elem);
return arr;
}
getAt(at) {
return this.buffer[at];
}
getLast(filter) {
return filter ? this.buffer.findLast(filter) : this.buffer[this.buffer.length - 1];
}
put() {
let insert;
if (arguments.length == 1 && Array.isArray(arguments[0])) {
insert = arguments[0];
} else {
insert = arguments;
}
for (let idx in insert) {
this.#insertSorted(insert[idx], this.buffer);
}
}
delAt(at) {
at |= 0;
let r = this.buffer.splice(at, 1);
if (r && r.length > 0) {
return r[0];
}
return undefined;
}
delRange(since, before) {
return this.buffer.splice(since, before - since);
}
length() {
return this.buffer.length;
}
reset() {
this.buffer = [];
}
forEach(callback, startIdx, beforeIdx, context) {
startIdx = Math.max(0, startIdx | 0);
beforeIdx = Math.min(beforeIdx || this.buffer.length, this.buffer.length);
for (let i = startIdx; i < beforeIdx; i++) {
callback.call(context, this.buffer[i], i > startIdx ? this.buffer[i - 1] : undefined, i < beforeIdx - 1 ? this.buffer[i + 1] : undefined, i);
}
}
find(elem, nearest) {
const {
idx
} = this.#findNearest(elem, this.buffer, !nearest);
return idx;
}
filter(callback, context) {
let count = 0;
for (let i = 0; i < this.buffer.length; i++) {
if (callback.call(context, this.buffer[i], i)) {
this.buffer[count] = this.buffer[i];
count++;
}
}
this.buffer.splice(count);
}
isEmpty() {
return this.buffer.length == 0;
}
}
/***/ }),
/***/ "./src/comm-error.js":
/*!***************************!*\
!*** ./src/comm-error.js ***!
\***************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (/* binding */ CommError)
/* harmony export */ });
class CommError extends Error {
constructor(message, code) {
super(`${message} (${code})`);
this.name = 'CommError';
this.code = code;
}
}
/***/ }),
/***/ "./src/config.js":
/*!***********************!*\
!*** ./src/config.js ***!
\***********************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ DEFAULT_MESSAGES_PAGE: () => (/* binding */ DEFAULT_MESSAGES_PAGE),
/* harmony export */ DEL_CHAR: () => (/* binding */ DEL_CHAR),
/* harmony export */ EXPIRE_PROMISES_PERIOD: () => (/* binding */ EXPIRE_PROMISES_PERIOD),
/* harmony export */ EXPIRE_PROMISES_TIMEOUT: () => (/* binding */ EXPIRE_PROMISES_TIMEOUT),
/* harmony export */ LIBRARY: () => (/* binding */ LIBRARY),
/* harmony export */ LOCAL_SEQID: () => (/* binding */ LOCAL_SEQID),
/* harmony export */ MAX_PINNED_COUNT: () => (/* binding */ MAX_PINNED_COUNT),
/* harmony export */ MESSAGE_STATUS_FAILED: () => (/* binding */ MESSAGE_STATUS_FAILED),
/* harmony export */ MESSAGE_STATUS_FATAL: () => (/* binding */ MESSAGE_STATUS_FATAL),
/* harmony export */ MESSAGE_STATUS_NONE: () => (/* binding */ MESSAGE_STATUS_NONE),
/* harmony export */ MESSAGE_STATUS_QUEUED: () => (/* binding */ MESSAGE_STATUS_QUEUED),
/* harmony export */ MESSAGE_STATUS_READ: () => (/* binding */ MESSAGE_STATUS_READ),
/* harmony export */ MESSAGE_STATUS_RECEIVED: () => (/* binding */ MESSAGE_STATUS_RECEIVED),
/* harmony export */ MESSAGE_STATUS_SENDING: () => (/* binding */ MESSAGE_STATUS_SENDING),
/* harmony export */ MESSAGE_STATUS_SENT: () => (/* binding */ MESSAGE_STATUS_SENT),
/* harmony export */ MESSAGE_STATUS_TO_ME: () => (/* binding */ MESSAGE_STATUS_TO_ME),
/* harmony export */ PROTOCOL_VERSION: () => (/* binding */ PROTOCOL_VERSION),
/* harmony export */ RECV_TIMEOUT: () => (/* binding */ RECV_TIMEOUT),
/* harmony export */ TAG_ALIAS: () => (/* binding */ TAG_ALIAS),
/* harmony export */ TAG_EMAIL: () => (/* binding */ TAG_EMAIL),
/* harmony export */ TAG_PHONE: () => (/* binding */ TAG_PHONE),
/* harmony export */ TOPIC_CHAN: () => (/* binding */ TOPIC_CHAN),
/* harmony export */ TOPIC_FND: () => (/* binding */ TOPIC_FND),
/* harmony export */ TOPIC_GRP: () => (/* binding */ TOPIC_GRP),
/* harmony export */ TOPIC_ME: () => (/* binding */ TOPIC_ME),
/* harmony export */ TOPIC_NEW: () => (/* binding */ TOPIC_NEW),
/* harmony export */ TOPIC_NEW_CHAN: () => (/* binding */ TOPIC_NEW_CHAN),
/* harmony export */ TOPIC_P2P: () => (/* binding */ TOPIC_P2P),
/* harmony export */ TOPIC_SLF: () => (/* binding */ TOPIC_SLF),
/* harmony export */ TOPIC_SYS: () => (/* binding */ TOPIC_SYS),
/* harmony export */ USER_NEW: () => (/* binding */ USER_NEW),
/* harmony export */ VERSION: () => (/* binding */ VERSION)
/* harmony export */ });
/* harmony import */ var _version_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../version.js */ "./version.js");
const PROTOCOL_VERSION = '0';
const VERSION = _version_js__WEBPACK_IMPORTED_MODULE_0__.PACKAGE_VERSION || '0.24';
const LIBRARY = 'tinodejs/' + VERSION;
const TOPIC_NEW = 'new';
const TOPIC_NEW_CHAN = 'nch';
const TOPIC_ME = 'me';
const TOPIC_FND = 'fnd';
const TOPIC_SYS = 'sys';
const TOPIC_SLF = 'slf';
const TOPIC_CHAN = 'chn';
const TOPIC_GRP = 'grp';
const TOPIC_P2P = 'p2p';
const USER_NEW = 'new';
const LOCAL_SEQID = 0xFFFFFFF;
const MESSAGE_STATUS_NONE = 0;
const MESSAGE_STATUS_QUEUED = 10;
const MESSAGE_STATUS_SENDING = 20;
const MESSAGE_STATUS_FAILED = 30;
const MESSAGE_STATUS_FATAL = 40;
const MESSAGE_STATUS_SENT = 50;
const MESSAGE_STATUS_RECEIVED = 60;
const MESSAGE_STATUS_READ = 70;
const MESSAGE_STATUS_TO_ME = 80;
const EXPIRE_PROMISES_TIMEOUT = 5000;
const EXPIRE_PROMISES_PERIOD = 1000;
const RECV_TIMEOUT = 100;
const DEFAULT_MESSAGES_PAGE = 24;
const DEL_CHAR = '\u2421';
const MAX_PINNED_COUNT = 5;
const TAG_ALIAS = 'alias:';
const TAG_EMAIL = 'email:';
const TAG_PHONE = 'tel:';
/***/ }),
/***/ "./src/connection.js":
/*!***************************!*\
!*** ./src/connection.js ***!
\***************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (/* binding */ Connection)
/* harmony export */ });
/* harmony import */ var _comm_error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./comm-error.js */ "./src/comm-error.js");
/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils.js */ "./src/utils.js");
let WebSocketProvider;
let XHRProvider;
const NETWORK_ERROR = 503;
const NETWORK_ERROR_TEXT = "Connection failed";
const NETWORK_USER = 418;
const NETWORK_USER_TEXT = "Disconnected by client";
const _BOFF_BASE = 2000;
const _BOFF_MAX_ITER = 10;
const _BOFF_JITTER = 0.3;
function makeBaseUrl(host, protocol, version, apiKey) {
let url = null;
if (['http', 'https', 'ws', 'wss'].includes(protocol)) {
url = `${protocol}://${host}`;
if (url.charAt(url.length - 1) !== '/') {
url += '/';
}
url += 'v' + version + '/channels';
if (['http', 'https'].includes(protocol)) {
url += '/lp';
}
url += '?apikey=' + apiKey;
}
return url;
}
class Connection {
static #log = _ => {};
#boffTimer = null;
#boffIteration = 0;
#boffClosed = false;
#socket = null;
host;
secure;
apiKey;
version;
autoreconnect;
initialized;
constructor(config, version_, autoreconnect_) {
this.host = config.host;
this.secure = config.secure;
this.apiKey = config.apiKey;
this.version = version_;
this.autoreconnect = autoreconnect_;
if (config.transport === 'lp') {
this.#init_lp();
this.initialized = 'lp';
} else if (config.transport === 'ws') {
this.#init_ws();
this.initialized = 'ws';
}
if (!this.initialized) {
Connection.#log("Unknown or invalid network transport. Running under Node? Call 'Tinode.setNetworkProviders()'.");
throw new Error("Unknown or invalid network transport. Running under Node? Call 'Tinode.setNetworkProviders()'.");
}
}
static setNetworkProviders(wsProvider, xhrProvider) {
WebSocketProvider = wsProvider;
XHRProvider = xhrProvider;
}
static set logger(l) {
Connection.#log = l;
}
connect(host_, force) {
return Promise.reject(null);
}
reconnect(force) {}
disconnect() {}
sendText(msg) {}
isConnected() {
return false;
}
transport() {
return this.initialized;
}
probe() {
this.sendText('1');
}
backoffReset() {
this.#boffReset();
}
#boffReconnect() {
clearTimeout(this.#boffTimer);
const timeout = _BOFF_BASE * (Math.pow(2, this.#boffIteration) * (1.0 + _BOFF_JITTER * Math.random()));
this.#boffIteration = this.#boffIteration >= _BOFF_MAX_ITER ? this.#boffIteration : this.#boffIteration + 1;
if (this.onAutoreconnectIteration) {
this.onAutoreconnectIteration(timeout);
}
this.#boffTimer = setTimeout(_ => {
Connection.#log(`Reconnecting, iter=${this.#boffIteration}, timeout=${timeout}`);
if (!this.#boffClosed) {
const prom = this.connect();
if (this.onAutoreconnectIteration) {
this.onAutoreconnectIteration(0, prom);
} else {
prom.catch(_ => {});
}
} else if (this.onAutoreconnectIteration) {
this.onAutoreconnectIteration(-1);
}
}, timeout);
}
#boffStop() {
clearTimeout(this.#boffTimer);
this.#boffTimer = null;
}
#boffReset() {
this.#boffIteration = 0;
}
#init_lp() {
const XDR_UNSENT = 0;
const XDR_OPENED = 1;
const XDR_HEADERS_RECEIVED = 2;
const XDR_LOADING = 3;
const XDR_DONE = 4;
let _lpURL = null;
let _poller = null;
let _sender = null;
let lp_sender = url_ => {
const sender = new XHRProvider();
sender.onreadystatechange = evt => {
if (sender.readyState == XDR_DONE && sender.status >= 400) {
throw new _comm_error_js__WEBPACK_IMPORTED_MODULE_0__["default"]("LP sender failed", sender.status);
}
};
sender.open('POST', url_, true);
return sender;
};
let lp_poller = (url_, resolve, reject) => {
let poller = new XHRProvider();
let promiseCompleted = false;
poller.onreadystatechange = evt => {
if (poller.readyState == XDR_DONE) {
if (poller.status == 201) {
let pkt = JSON.parse(poller.responseText, _utils_js__WEBPACK_IMPORTED_MODULE_1__.jsonParseHelper);
_lpURL = url_ + '&sid=' + pkt.ctrl.params.sid;
poller = lp_poller(_lpURL);
poller.send(null);
if (this.onOpen) {
this.onOpen();
}
if (resolve) {
promiseCompleted = true;
resolve();
}
if (this.autoreconnect) {
this.#boffStop();
}
} else if (poller.status > 0 && poller.status < 400) {
if (this.onMessage) {
this.onMessage(poller.responseText);
}
poller = lp_poller(_lpURL);
poller.send(null);
} else {
if (reject && !promiseCompleted) {
promiseCompleted = true;
reject(poller.responseText);
}
if (this.onMessage && poller.responseText) {
this.onMessage(poller.responseText);
}
if (this.onDisconnect) {
const code = poller.status || (this.#boffClosed ? NETWORK_USER : NETWORK_ERROR);
const text = poller.responseText || (this.#boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT);
this.onDisconnect(new _comm_error_js__WEBPACK_IMPORTED_MODULE_0__["default"](text, code), code);
}
poller = null;
if (!this.#boffClosed && this.autoreconnect) {
this.#boffReconnect();
}
}
}
};
poller.open('POST', url_, true);
return poller;
};
this.connect = (host_, force) => {
this.#boffClosed = false;
if (_poller) {
if (!force) {
return Promise.resolve();
}
_poller.onreadystatechange = undefined;
_poller.abort();
_poller = null;
}
if (host_) {
this.host = host_;
}
return new Promise((resolve, reject) => {
const url = makeBaseUrl(this.host, this.secure ? 'https' : 'http', this.version, this.apiKey);
Connection.#log("LP connecting to:", url);
_poller = lp_poller(url, resolve, reject);
_poller.send(null);
}).catch(err => {
Connection.#log("LP connection failed:", err);
});
};
this.reconnect = force => {
this.#boffStop();
this.connect(null, force);
};
this.disconnect = _ => {
this.#boffClosed = true;
this.#boffStop();
if (_sender) {
_sender.onreadystatechange = undefined;
_sender.abort();
_sender = null;
}
if (_poller) {
_poller.onreadystatechange = undefined;
_poller.abort();
_poller = null;
}
if (this.onDisconnect) {
this.onDisconnect(new _comm_error_js__WEBPACK_IMPORTED_MODULE_0__["default"](NETWORK_USER_TEXT, NETWORK_USER), NETWORK_USER);
}
_lpURL = null;
};
this.sendText = msg => {
_sender = lp_sender(_lpURL);
if (_sender && _sender.readyState == XDR_OPENED) {
_sender.send(msg);
} else {
throw new Error("Long poller failed to connect");
}
};
this.isConnected = _ => {
return _poller && true;
};
}
#init_ws() {
this.connect = (host_, force) => {
this.#boffClosed = false;
if (this.#socket) {
if (!force && this.#socket.readyState == this.#socket.OPEN) {
this.probe();
return Promise.resolve();
}
this.#socket.close();
this.#socket = null;
}
if (host_) {
this.host = host_;
}
return new Promise((resolve, reject) => {
const url = makeBaseUrl(this.host, this.secure ? 'wss' : 'ws', this.version, this.apiKey);
Connection.#log("WS connecting to: ", url);
const conn = new WebSocketProvider(url);
conn.onerror = err => {
reject(err);
};
conn.onopen = _ => {
if (this.autoreconnect) {
this.#boffStop();
}
if (this.onOpen) {
this.onOpen();
}
resolve();
};
conn.onclose = _ => {
this.#socket = null;
if (this.onDisconnect) {
const code = this.#boffClosed ? NETWORK_USER : NETWORK_ERROR;
this.onDisconnect(new _comm_error_js__WEBPACK_IMPORTED_MODULE_0__["default"](this.#boffClosed ? NETWORK_USER_TEXT : NETWORK_ERROR_TEXT, code), code);
}
if (!this.#boffClosed && this.autoreconnect) {
this.#boffReconnect();
}
};
conn.onmessage = evt => {
if (this.onMessage) {
this.onMessage(evt.data);
}
};
this.#socket = conn;
});
};
this.reconnect = force => {
this.#boffStop();
this.connect(null, force);
};
this.disconnect = _ => {
this.#boffClosed = true;
this.#boffStop();
if (!this.#socket) {
return;
}
this.#socket.close();
this.#socket = null;
};
this.sendText = msg => {
if (this.#socket && this.#socket.readyState == this.#socket.OPEN) {
this.#socket.send(msg);
} else {
throw new Error("Websocket is not connected");
}
};
this.isConnected = _ => {
return this.#socket && this.#socket.readyState == this.#socket.OPEN;
};
}
onMessage = undefined;
onDisconnect = undefined;
onOpen = undefined;
onAutoreconnectIteration = undefined;
}
Connection.NETWORK_ERROR = NETWORK_ERROR;
Connection.NETWORK_ERROR_TEXT = NETWORK_ERROR_TEXT;
Connection.NETWORK_USER = NETWORK_USER;
Connection.NETWORK_USER_TEXT = NETWORK_USER_TEXT;
/***/ }),
/***/ "./src/db.js":
/*!*******************!*\
!*** ./src/db.js ***!
\*******************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (/* binding */ DB)
/* harmony export */ });
const DB_VERSION = 3;
const DB_NAME = 'tinode-web';
let IDBProvider;
class DB {
#onError = _ => {};
#logger = _ => {};
db = null;
disabled = true;
constructor(onError, logger) {
this.#onError = onError || this.#onError;
this.#logger = logger || this.#logger;
}
#mapObjects(source, callback, context) {
if (!this.db) {
return disabled ? Promise.resolve([]) : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction([source]);
trx.onerror = event => {
this.#logger('PCache', 'mapObjects', source, event.target.error);
reject(event.target.error);
};
trx.objectStore(source).getAll().onsuccess = event => {
if (callback) {
event.target.result.forEach(topic => {
callback.call(context, topic);
});
}
resolve(event.target.result);
};
});
}
initDatabase() {
return new Promise((resolve, reject) => {
const req = IDBProvider.open(DB_NAME, DB_VERSION);
req.onsuccess = event => {
this.db = event.target.result;
this.disabled = false;
resolve(this.db);
};
req.onerror = event => {
this.#logger('PCache', "failed to initialize", event);
reject(event.target.error);
this.#onError(event.target.error);
};
req.onupgradeneeded = event => {
this.db = event.target.result;
this.db.onerror = event => {
this.#logger('PCache', "failed to create storage", event);
this.#onError(event.target.error);
};
this.db.createObjectStore('topic', {
keyPath: 'name'
});
this.db.createObjectStore('user', {
keyPath: 'uid'
});
this.db.createObjectStore('subscription', {
keyPath: ['topic', 'uid']
});
this.db.createObjectStore('message', {
keyPath: ['topic', 'seq']
});
const dellog = this.db.createObjectStore('dellog', {
keyPath: ['topic', 'low', 'hi']
});
dellog.createIndex('topic_clear', ['topic', 'clear'], {
unique: false
});
};
});
}
deleteDatabase() {
if (this.db) {
this.db.close();
this.db = null;
}
return new Promise((resolve, reject) => {
const req = IDBProvider.deleteDatabase(DB_NAME);
req.onblocked = _ => {
if (this.db) {
this.db.close();
}
const err = new Error("blocked");
this.#logger('PCache', 'deleteDatabase', err);
reject(err);
};
req.onsuccess = _ => {
this.db = null;
this.disabled = true;
resolve(true);
};
req.onerror = event => {
this.#logger('PCache', 'deleteDatabase', event.target.error);
reject(event.target.error);
};
});
}
isReady() {
return !!this.db;
}
updTopic(topic) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['topic'], 'readwrite');
trx.oncomplete = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'updTopic', event.target.error);
reject(event.target.error);
};
const req = trx.objectStore('topic').get(topic.name);
req.onsuccess = _ => {
trx.objectStore('topic').put(DB.#serializeTopic(req.result, topic));
trx.commit();
};
});
}
markTopicAsDeleted(name, deleted) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['topic'], 'readwrite');
trx.oncomplete = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'markTopicAsDeleted', event.target.error);
reject(event.target.error);
};
const req = trx.objectStore('topic').get(name);
req.onsuccess = event => {
const topic = event.target.result;
if (topic && topic._deleted != deleted) {
topic._deleted = deleted;
trx.objectStore('topic').put(topic);
}
trx.commit();
};
});
}
remTopic(name) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['topic', 'subscription', 'message'], 'readwrite');
trx.oncomplete = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'remTopic', event.target.error);
reject(event.target.error);
};
trx.objectStore('topic').delete(IDBKeyRange.only(name));
trx.objectStore('subscription').delete(IDBKeyRange.bound([name, '-'], [name, '~']));
trx.objectStore('message').delete(IDBKeyRange.bound([name, 0], [name, Number.MAX_SAFE_INTEGER]));
trx.commit();
});
}
mapTopics(callback, context) {
return this.#mapObjects('topic', callback, context);
}
deserializeTopic(topic, src) {
DB.#deserializeTopic(topic, src);
}
updUser(uid, pub) {
if (arguments.length < 2 || pub === undefined) {
return;
}
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['user'], 'readwrite');
trx.oncomplete = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'updUser', event.target.error);
reject(event.target.error);
};
trx.objectStore('user').put({
uid: uid,
public: pub
});
trx.commit();
});
}
remUser(uid) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['user'], 'readwrite');
trx.oncomplete = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'remUser', event.target.error);
reject(event.target.error);
};
trx.objectStore('user').delete(IDBKeyRange.only(uid));
trx.commit();
});
}
mapUsers(callback, context) {
return this.#mapObjects('user', callback, context);
}
getUser(uid) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['user']);
trx.oncomplete = event => {
const user = event.target.result;
resolve({
user: user.uid,
public: user.public
});
};
trx.onerror = event => {
this.#logger('PCache', 'getUser', event.target.error);
reject(event.target.error);
};
trx.objectStore('user').get(uid);
});
}
updSubscription(topicName, uid, sub) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['subscription'], 'readwrite');
trx.oncomplete = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'updSubscription', event.target.error);
reject(event.target.error);
};
trx.objectStore('subscription').get([topicName, uid]).onsuccess = event => {
trx.objectStore('subscription').put(DB.#serializeSubscription(event.target.result, topicName, uid, sub));
trx.commit();
};
});
}
mapSubscriptions(topicName, callback, context) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve([]) : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['subscription']);
trx.onerror = event => {
this.#logger('PCache', 'mapSubscriptions', event.target.error);
reject(event.target.error);
};
trx.objectStore('subscription').getAll(IDBKeyRange.bound([topicName, '-'], [topicName, '~'])).onsuccess = event => {
if (callback) {
event.target.result.forEach(topic => {
callback.call(context, topic);
});
}
resolve(event.target.result);
};
});
}
addMessage(msg) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['message'], 'readwrite');
trx.onsuccess = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'addMessage', event.target.error);
reject(event.target.error);
};
trx.objectStore('message').add(DB.#serializeMessage(null, msg));
trx.commit();
});
}
updMessageStatus(topicName, seq, status) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['message'], 'readwrite');
trx.onsuccess = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'updMessageStatus', event.target.error);
reject(event.target.error);
};
const req = trx.objectStore('message').get(IDBKeyRange.only([topicName, seq]));
req.onsuccess = event => {
const src = req.result || event.target.result;
if (!src || src._status == status) {
trx.commit();
return;
}
trx.objectStore('message').put(DB.#serializeMessage(src, {
topic: topicName,
seq: seq,
_status: status
}));
trx.commit();
};
});
}
remMessages(topicName, from, to) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
if (!from && !to) {
from = 0;
to = Number.MAX_SAFE_INTEGER;
}
const range = to > 0 ? IDBKeyRange.bound([topicName, from], [topicName, to], false, true) : IDBKeyRange.only([topicName, from]);
const trx = this.db.transaction(['message'], 'readwrite');
trx.onsuccess = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'remMessages', event.target.error);
reject(event.target.error);
};
trx.objectStore('message').delete(range);
trx.commit();
});
}
readMessages(topicName, query, callback, context) {
query = query || {};
if (!this.isReady()) {
return this.disabled ? Promise.resolve([]) : Promise.reject(new Error("not initialized"));
}
const trx = this.db.transaction(['message']);
let result = [];
if (Array.isArray(query.ranges)) {
return new Promise((resolve, reject) => {
trx.onerror = event => {
this.#logger('PCache', 'readMessages', event.target.error);
reject(event.target.error);
};
let count = 0;
query.ranges.forEach(range => {
const key = range.hi ? IDBKeyRange.bound([topicName, range.low], [topicName, range.hi], false, true) : IDBKeyRange.only([topicName, range.low]);
trx.objectStore('message').getAll(key).onsuccess = event => {
const msgs = event.target.result;
if (msgs) {
if (callback) {
callback.call(context, msgs);
}
if (Array.isArray(msgs)) {
result = result.concat(msgs);
} else {
result.push(msgs);
}
}
count++;
if (count == query.ranges.length) {
resolve(result);
}
};
});
});
}
return new Promise((resolve, reject) => {
const since = query.since > 0 ? query.since : 0;
const before = query.before > 0 ? query.before : Number.MAX_SAFE_INTEGER;
const limit = query.limit | 0;
trx.onerror = event => {
this.#logger('PCache', 'readMessages', event.target.error);
reject(event.target.error);
};
const range = IDBKeyRange.bound([topicName, since], [topicName, before], false, true);
trx.objectStore('message').openCursor(range, 'prev').onsuccess = event => {
const cursor = event.target.result;
if (cursor) {
if (callback) {
callback.call(context, cursor.value);
}
result.push(cursor.value);
if (limit <= 0 || result.length < limit) {
cursor.continue();
} else {
resolve(result);
}
} else {
resolve(result);
}
};
});
}
addDelLog(topicName, delId, ranges) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve() : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['dellog'], 'readwrite');
trx.onsuccess = event => {
resolve(event.target.result);
};
trx.onerror = event => {
this.#logger('PCache', 'addDelLog', event.target.error);
reject(event.target.error);
};
ranges.forEach(r => trx.objectStore('dellog').add({
topic: topicName,
clear: delId,
low: r.low,
hi: r.hi || r.low + 1
}));
trx.commit();
});
}
readDelLog(topicName, query) {
query = query || {};
if (!this.isReady()) {
return this.disabled ? Promise.resolve([]) : Promise.reject(new Error("not initialized"));
}
const trx = this.db.transaction(['dellog']);
let result = [];
if (Array.isArray(query.ranges)) {
return new Promise((resolve, reject) => {
trx.onerror = event => {
this.#logger('PCache', 'readDelLog', event.target.error);
reject(event.target.error);
};
let count = 0;
query.ranges.forEach(range => {
const hi = range.hi || range.low + 1;
const key = IDBKeyRange.bound([topicName, 0, range.low], [topicName, hi, Number.MAX_SAFE_INTEGER], false, true);
trx.objectStore('dellog').getAll(key).onsuccess = event => {
const entries = event.target.result;
if (entries) {
if (Array.isArray(entries)) {
result = result.concat(entries.map(entry => {
return {
low: entry.low,
hi: entry.hi
};
}));
} else {
result.push({
low: entries.low,
hi: entries.hi
});
}
}
count++;
if (count == query.ranges.length) {
resolve(result);
}
};
});
});
}
return new Promise((resolve, reject) => {
const since = query.since > 0 ? query.since : 0;
const before = query.before > 0 ? query.before : Number.MAX_SAFE_INTEGER;
const limit = query.limit | 0;
trx.onerror = event => {
this.#logger('PCache', 'readDelLog', event.target.error);
reject(event.target.error);
};
let count = 0;
const result = [];
const range = IDBKeyRange.bound([topicName, 0, since], [topicName, before, Number.MAX_SAFE_INTEGER], false, true);
trx.objectStore('dellog').openCursor(range, 'prev').onsuccess = event => {
const cursor = event.target.result;
if (cursor) {
result.push({
low: cursor.value.low,
hi: cursor.value.hi
});
count += cursor.value.hi - cursor.value.low;
if (limit <= 0 || count < limit) {
cursor.continue();
} else {
resolve(result);
}
} else {
resolve(result);
}
};
});
}
maxDelId(topicName) {
if (!this.isReady()) {
return this.disabled ? Promise.resolve(0) : Promise.reject(new Error("not initialized"));
}
return new Promise((resolve, reject) => {
const trx = this.db.transaction(['dellog']);
trx.onerror = event => {
this.#logger('PCache', 'maxDelId', event.target.error);
reject(event.target.error);
};
const index = trx.objectStore('dellog').index('topic_clear');
index.openCursor(IDBKeyRange.bound([topicName, 0], [topicName, Number.MAX_SAFE_INTEGER]), 'prev').onsuccess = event => {
if (event.target.result) {
resolve(event.target.result.value);
}
};
});
}
static #topic_fields = ['created', 'updated', 'deleted', 'touched', 'read', 'recv', 'seq', 'clear', 'defacs', 'creds', 'public', 'trusted', 'private', '_aux', '_deleted'];
static #deserializeTopic(topic, src) {
DB.#topic_fields.forEach(f => {
if (src.hasOwnProperty(f)) {
topic[f] = src[f];
}
});
if (Array.isArray(src.tags)) {
topic._tags = src.tags;
}
if (src.acs) {
topic.setAccessMode(src.acs);
}
topic.seq |= 0;
topic.read |= 0;
topic.unread = Math.max(0, topic.seq - topic.read);
}
static #serializeTopic(dst, src) {
const res = dst || {
name: src.name
};
DB.#topic_fields.forEach(f => {
if (src.hasOwnProperty(f)) {
res[f] = src[f];
}
});
if (Array.isArray(src._tags)) {
res.tags = src._tags;
}
if (src.acs) {
res.acs = src.getAccessMode().jsonHelper();
}
return res;
}
static #serializeSubscription(dst, topicName, uid, sub) {
const fields = ['updated', 'mode', 'read', 'recv', 'clear', 'lastSeen', 'userAgent'];
const res = dst || {
topic: topicName,
uid: uid
};
fields.forEach(f => {
if (sub.hasOwnProperty(f)) {
res[f] = sub[f];
}
});
return res;
}
static #serializeMessage(dst, msg) {
const fields = ['topic', 'seq', 'ts', '_status', 'from', 'head', 'content'];
const res = dst || {};
fields.forEach(f => {
if (msg.hasOwnProperty(f)) {
res[f] = msg[f];
}
});
return res;
}
static setDatabaseProvider(idbProvider) {
IDBProvider = idbProvider;
}
}
/***/ }),
/***/ "./src/drafty.js":
/*!***********************!*\
!*** ./src/drafty.js ***!
\***********************/
/***/ ((module) => {
/**
* @copyright 2015-2024 Tinode LLC.
* @summary Minimally rich text representation and formatting for Tinode.
* @license Apache 2.0
*
* @file Basic parser and formatter for very simple text markup. Mostly targeted at
* mobile use cases similar to Telegram, WhatsApp, and FB Messenger.
*
* Supports conversion of user keyboard input to formatted text:
*
* *abc* → abc
* _abc_ → abc
* ~abc~ → abc
* `abc` → abc
*
* Also supports forms and buttons.
*
* Nested formatting is supported, e.g. *abc _def_* -> abc def
* URLs, @mentions, and #hashtags are extracted and converted into links.
* Forms and buttons can be added procedurally.
* JSON data representation is inspired by Draft.js raw formatting.
*
*
* @example
* Text:
*
* this is *bold*, `code` and _italic_, ~strike~
* combined *bold and _italic_*
* an url: https://www.example.com/abc#fragment and another _www.tinode.co_
* this is a @mention and a #hashtag in a string
* second #hashtag
*
*
* Sample JSON representation of the text above:
* {
* "txt": "this is bold, code and italic, strike combined bold and italic an url: https://www.example.com/abc#fragment " +
* "and another www.tinode.co this is a @mention and a #hashtag in a string second #hashtag",
* "fmt": [
* { "at":8, "len":4,"tp":"ST" },{ "at":14, "len":4, "tp":"CO" },{ "at":23, "len":6, "tp":"EM"},
* { "at":31, "len":6, "tp":"DL" },{ "tp":"BR", "len":1, "at":37 },{ "at":56, "len":6, "tp":"EM" },
* { "at":47, "len":15, "tp":"ST" },{ "tp":"BR", "len":1, "at":62 },{ "at":120, "len":13, "tp":"EM" },
* { "at":71, "len":36, "key":0 },{ "at":120, "len":13, "key":1 },{ "tp":"BR", "len":1, "at":133 },
* { "at":144, "len":8, "key":2 },{ "at":159, "len":8, "key":3 },{ "tp":"BR", "len":1, "at":179 },
* { "at":187, "len":8, "key":3 },{ "tp":"BR", "len":1, "at":195 }
* ],
* "ent": [
* { "tp":"LN", "data":{ "url":"https://www.example.com/abc#fragment" } },
* { "tp":"LN", "data":{ "url":"http://www.tinode.co" } },
* { "tp":"MN", "data":{ "val":"mention" } },
* { "tp":"HT", "data":{ "val":"hashtag" } }
* ]
* }
*/
const MAX_FORM_ELEMENTS = 8;
const MAX_PREVIEW_ATTACHMENTS = 3;
const MAX_PREVIEW_DATA_SIZE = 64;
const JSON_MIME_TYPE = 'application/json';
const DRAFTY_MIME_TYPE = 'text/x-drafty';
const ALLOWED_ENT_FIELDS = ['act', 'height', 'duration', 'incoming', 'mime', 'name', 'premime', 'preref', 'preview', 'ref', 'size', 'state', 'url', 'val', 'width'];
const segmenter = new Intl.Segmenter();
const INLINE_STYLES = [{
name: 'ST',
start: /(?:^|[\W_])(\*)[^\s*]/,
end: /[^\s*](\*)(?=$|[\W_])/
}, {
name: 'EM',
start: /(?:^|\W)(_)[^\s_]/,
end: /[^\s_](_)(?=$|\W)/
}, {
name: 'DL',
start: /(?:^|[\W_])(~)[^\s~]/,
end: /[^\s~](~)(?=$|[\W_])/
}, {
name: 'CO',
start: /(?:^|\W)(`)[^`]/,
end: /[^`](`)(?=$|\W)/
}];
const FMT_WEIGHT = ['QQ'];
const ENTITY_TYPES = [{
name: 'LN',
dataName: 'url',
pack: function (val) {
if (!/^[a-z]+:\/\//i.test(val)) {
val = 'http://' + val;
}
return {
url: val
};
},
re: /(?:(?:https?|ftp):\/\/|www\.|ftp\.)[-A-Z0-9+&@#\/%=~_|$?!:,.]*[A-Z0-9+&@#\/%=~_|$]/ig
}, {
name: 'MN',
dataName: 'val',
pack: function (val) {
return {
val: val.slice(1)
};
},
re: /\B@([\p{L}\p{N}][._\p{L}\p{N}]*[\p{L}\p{N}])/ug
}, {
name: 'HT',
dataName: 'val',
pack: function (val) {
return {
val: val.slice(1)
};
},
re: /\B#([\p{L}\p{N}][._\p{L}\p{N}]*[\p{L}\p{N}])/ug
}];
const FORMAT_TAGS = {
AU: {
html_tag: 'audio',
md_tag: undefined,
isVoid: false
},
BN: {
html_tag: 'button',
md_tag: undefined,
isVoid: false
},
BR: {
html_tag: 'br',
md_tag: '\n',
isVoid: true
},
CO: {
html_tag: 'tt',
md_tag: '`',
isVoid: false
},
DL: {
html_tag: 'del',
md_tag: '~',
isVoid: false
},
EM: {
html_tag: 'i',
md_tag: '_',
isVoid: false
},
EX: {
html_tag: '',
md_tag: undefined,
isVoid: true
},
FM: {
html_tag: 'div',
md_tag: undefined,
isVoid: false
},
HD: {
html_tag: '',
md_tag: undefined,
isVoid: false
},
HL: {
html_tag: 'span',
md_tag: undefined,
isVoid: false
},
HT: {
html_tag: 'a',
md_tag: undefined,
isVoid: false
},
IM: {
html_tag: 'img',
md_tag: undefined,
isVoid: false
},
LN: {
html_tag: 'a',
md_tag: undefined,
isVoid: false
},
MN: {
html_tag: 'a',
md_tag: undefined,
isVoid: false
},
RW: {
html_tag: 'div',
md_tag: undefined,
isVoid: false
},
QQ: {
html_tag: 'div',
md_tag: undefined,
isVoid: false
},
ST: {
html_tag: 'b',
md_tag: '*',
isVoid: false
},
VC: {
html_tag: 'div',
md_tag: undefined,
isVoid: false
},
VD: {
html_tag: 'video',
md_tag: undefined,
isVoid: false
}
};
function base64toObjectUrl(b64, contentType, logger) {
if (!b64) {
return null;
}
try {
const bin = atob(b64);
const length = bin.length;
const buf = new ArrayBuffer(length);
const arr = new Uint8Array(buf);
for (let i = 0; i < length; i++) {
arr[i] = bin.charCodeAt(i);
}
return URL.createObjectURL(new Blob([buf], {
type: contentType
}));
} catch (err) {
if (logger) {
logger("Drafty: failed to convert object.", err.message);
}
}
return null;
}
function base64toDataUrl(b64, contentType) {
if (!b64) {
return null;
}
contentType = contentType || 'image/jpeg';
return 'data:' + contentType + ';base64,' + b64;
}
const DECORATORS = {
ST: {
open: _ => '',
close: _ => ' '
},
EM: {
open: _ => '',
close: _ => ' '
},
DL: {
open: _ => '',
close: _ => ''
},
CO: {
open: _ => '',
close: _ => ' '
},
BR: {
open: _ => '',
close: _ => ' '
},
LN: {
open: data => {
return '';
},
close: _ => ' ',
props: data => {
return data ? {
href: data.url,
target: '_blank'
} : null;
}
},
MN: {
open: data => {
return '';
},
close: _ => ' ',
props: data => {
return data ? {
id: data.val
} : null;
}
},
HT: {
open: data => {
return '';
},
close: _ => ' ',
props: data => {
return data ? {
id: data.val
} : null;
}
},
BN: {
open: _ => '',
close: _ => ' ',
props: data => {
return data ? {
'data-act': data.act,
'data-val': data.val,
'data-name': data.name,
'data-ref': data.ref
} : null;
}
},
AU: {
open: data => {
const url = data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger);
return '';
},
close: _ => ' ',
props: data => {
if (!data) return null;
return {
src: data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger),
'data-preload': data.ref ? 'metadata' : 'auto',
'data-duration': data.duration,
'data-name': data.name,
'data-size': data.val ? data.val.length * 0.75 | 0 : data.size | 0,
'data-mime': data.mime
};
}
},
IM: {
open: data => {
const tmpPreviewUrl = base64toDataUrl(data._tempPreview, data.mime);
const previewUrl = base64toObjectUrl(data.val, data.mime, Drafty.logger);
const downloadUrl = data.ref || previewUrl;
return (data.name ? '' : '') + ' ' : '';
},
props: data => {
if (!data) return null;
return {
src: base64toDataUrl(data._tempPreview, data.mime) || data.ref || base64toObjectUrl(data.val, data.mime, Drafty.logger),
title: data.name,
alt: data.name,
'data-width': data.width,
'data-height': data.height,
'data-name': data.name,
'data-size': data.ref ? data.size | 0 : data.val ? data.val.length * 0.75 | 0 : data.size | 0,
'data-mime': data.mime
};
}
},
FM: {
open: _ => '',
close: _ => '
'
},
RW: {
open: _ => '',
close: _ => '
'
},
QQ: {
open: _ => '',
close: _ => '
',
props: data => {
return data ? {} : null;
}
},
VC: {
open: _ => '',
close: _ => '
',
props: data => {
if (!data) return {};
return {
'data-duration': data.duration,
'data-state': data.state
};
}
},
VD: {
open: data => {
const tmpPreviewUrl = base64toDataUrl(data._tempPreview, data.mime);
const previewUrl = data.ref || base64toObjectUrl(data.preview, data.premime || 'image/jpeg', Drafty.logger);
return 'https://github.com/tinode/webapp for real-life usage.
*
* @example
*
*
*
*
*
* ...
*
*
*/
let WebSocketProvider;
if (typeof WebSocket != 'undefined') {
WebSocketProvider = WebSocket;
}
let XHRProvider;
if (typeof XMLHttpRequest != 'undefined') {
XHRProvider = XMLHttpRequest;
}
let IndexedDBProvider;
if (typeof indexedDB != 'undefined') {
IndexedDBProvider = indexedDB;
}
initForNonBrowserApp();
function initForNonBrowserApp() {
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
if (typeof btoa == 'undefined') {
__webpack_require__.g.btoa = function (input = '') {
let str = input;
let output = '';
for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = '=', i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
charCode = str.charCodeAt(i += 3 / 4);
if (charCode > 0xFF) {
throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
}
block = block << 8 | charCode;
}
return output;
};
}
if (typeof atob == 'undefined') {
__webpack_require__.g.atob = function (input = '') {
let str = input.replace(/=+$/, '');
let output = '';
if (str.length % 4 == 1) {
throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
}
for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
buffer = chars.indexOf(buffer);
}
return output;
};
}
if (typeof window == 'undefined') {
__webpack_require__.g.window = {
WebSocket: WebSocketProvider,
XMLHttpRequest: XHRProvider,
indexedDB: IndexedDBProvider,
URL: {
createObjectURL: function () {
throw new Error("Unable to use URL.createObjectURL in a non-browser application");
}
}
};
}
_connection_js__WEBPACK_IMPORTED_MODULE_3__["default"].setNetworkProviders(WebSocketProvider, XHRProvider);
_large_file_js__WEBPACK_IMPORTED_MODULE_6__["default"].setNetworkProvider(XHRProvider);
_db_js__WEBPACK_IMPORTED_MODULE_4__["default"].setDatabaseProvider(IndexedDBProvider);
}
function detectTransport() {
if (typeof window == 'object') {
if (window['WebSocket']) {
return 'ws';
} else if (window['XMLHttpRequest']) {
return 'lp';
}
}
return null;
}
function b64EncodeUnicode(str) {
return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function toSolidBytes(match, p1) {
return String.fromCharCode('0x' + p1);
}));
}
function jsonBuildHelper(key, val) {
if (val instanceof Date) {
val = (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.rfc3339DateString)(val);
} else if (val instanceof _access_mode_js__WEBPACK_IMPORTED_MODULE_0__["default"]) {
val = val.jsonHelper();
} else if (val === undefined || val === null || val === false || Array.isArray(val) && val.length == 0 || typeof val == 'object' && Object.keys(val).length == 0) {
return undefined;
}
return val;
}
;
function jsonLoggerHelper(key, val) {
if (typeof val == 'string' && val.length > 128) {
return '<' + val.length + ', bytes: ' + val.substring(0, 12) + '...' + val.substring(val.length - 12) + '>';
}
return jsonBuildHelper(key, val);
}
;
function getBrowserInfo(ua, product) {
ua = ua || '';
let reactnative = '';
if (/reactnative/i.test(product)) {
reactnative = 'ReactNative; ';
}
let result;
ua = ua.replace(' (KHTML, like Gecko)', '');
let m = ua.match(/(AppleWebKit\/[.\d]+)/i);
if (m) {
const priority = ['edg', 'chrome', 'safari', 'mobile', 'version'];
let tmp = ua.substr(m.index + m[0].length).split(' ');
let tokens = [];
let version;
for (let i = 0; i < tmp.length; i++) {
let m2 = /([\w.]+)[\/]([\.\d]+)/.exec(tmp[i]);
if (m2) {
tokens.push([m2[1], m2[2], priority.findIndex(e => {
return m2[1].toLowerCase().startsWith(e);
})]);
if (m2[1] == 'Version') {
version = m2[2];
}
}
}
tokens.sort((a, b) => {
return a[2] - b[2];
});
if (tokens.length > 0) {
if (tokens[0][0].toLowerCase().startsWith('edg')) {
tokens[0][0] = 'Edge';
} else if (tokens[0][0] == 'OPR') {
tokens[0][0] = 'Opera';
} else if (tokens[0][0] == 'Safari' && version) {
tokens[0][1] = version;
}
result = tokens[0][0] + '/' + tokens[0][1];
} else {
result = m[1];
}
} else if (/firefox/i.test(ua)) {
m = /Firefox\/([.\d]+)/g.exec(ua);
if (m) {
result = 'Firefox/' + m[1];
} else {
result = 'Firefox/?';
}
} else {
m = /([\w.]+)\/([.\d]+)/.exec(ua);
if (m) {
result = m[1] + '/' + m[2];
} else {
m = ua.split(' ');
result = m[0];
}
}
m = result.split('/');
if (m.length > 1) {
const v = m[1].split('.');
const minor = v[1] ? '.' + v[1].substr(0, 2) : '';
result = `${m[0]}/${v[0]}${minor}`;
}
return reactnative + result;
}
class Tinode {
_host;
_secure;
_appName;
_apiKey;
_browser = '';
_platform;
_hwos = 'undefined';
_humanLanguage = 'xx';
_loggingEnabled = false;
_trimLongStrings = false;
_myUID = null;
_authenticated = false;
_login = null;
_authToken = null;
_inPacketCount = 0;
_messageId = Math.floor(Math.random() * 0xFFFF + 0xFFFF);
_serverInfo = null;
_deviceToken = null;
_pendingPromises = {};
_expirePromises = null;
_connection = null;
_persist = false;
_db = null;
_cache = {};
constructor(config, onComplete) {
this._host = config.host;
this._secure = config.secure;
this._appName = config.appName || "Undefined";
this._apiKey = config.apiKey;
this._platform = config.platform || 'web';
if (typeof navigator != 'undefined') {
this._browser = getBrowserInfo(navigator.userAgent, navigator.product);
this._hwos = navigator.platform;
this._humanLanguage = navigator.language || 'en-US';
}
_connection_js__WEBPACK_IMPORTED_MODULE_3__["default"].logger = this.logger;
(_drafty_js__WEBPACK_IMPORTED_MODULE_5___default().logger) = this.logger;
if (config.transport != 'lp' && config.transport != 'ws') {
config.transport = detectTransport();
}
this._connection = new _connection_js__WEBPACK_IMPORTED_MODULE_3__["default"](config, _config_js__WEBPACK_IMPORTED_MODULE_1__.PROTOCOL_VERSION, true);
this._connection.onMessage = data => {
this.#dispatchMessage(data);
};
this._connection.onOpen = _ => this.#connectionOpen();
this._connection.onDisconnect = (err, code) => this.#disconnected(err, code);
this._connection.onAutoreconnectIteration = (timeout, promise) => {
if (this.onAutoreconnectIteration) {
this.onAutoreconnectIteration(timeout, promise);
}
};
this._persist = config.persist;
this._db = new _db_js__WEBPACK_IMPORTED_MODULE_4__["default"](this.logger, this.logger);
if (this._persist) {
const prom = [];
this._db.initDatabase().then(_ => {
return this._db.mapTopics(data => {
let topic = this.#cacheGet('topic', data.name);
if (topic) {
return;
}
if (data.name == _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_ME) {
topic = new _me_topic_js__WEBPACK_IMPORTED_MODULE_10__["default"]();
} else if (data.name == _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_FND) {
topic = new _fnd_topic_js__WEBPACK_IMPORTED_MODULE_9__["default"]();
} else {
topic = new _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"](data.name);
}
this._db.deserializeTopic(topic, data);
this.#attachCacheToTopic(topic);
topic._cachePutSelf();
this._db.maxDelId(topic.name).then(clear => {
topic._maxDel = Math.max(topic._maxDel, clear || 0);
});
delete topic._new;
prom.push(topic._loadMessages(this._db));
});
}).then(_ => {
return this._db.mapUsers(data => {
this.#cachePut('user', data.uid, (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.mergeObj)({}, data.public));
});
}).then(_ => {
return Promise.all(prom);
}).then(_ => {
if (onComplete) {
onComplete();
}
this.logger("Persistent cache initialized.");
}).catch(err => {
if (onComplete) {
onComplete(err);
}
this.logger("Failed to initialize persistent cache:", err);
});
} else {
this._db.deleteDatabase().then(_ => {
if (onComplete) {
onComplete();
}
});
}
}
logger(str, ...args) {
if (this._loggingEnabled) {
const d = new Date();
const dateString = ('0' + d.getUTCHours()).slice(-2) + ':' + ('0' + d.getUTCMinutes()).slice(-2) + ':' + ('0' + d.getUTCSeconds()).slice(-2) + '.' + ('00' + d.getUTCMilliseconds()).slice(-3);
console.log('[' + dateString + ']', str, args.join(' '));
}
}
#makePromise(id) {
let promise = null;
if (id) {
promise = new Promise((resolve, reject) => {
this._pendingPromises[id] = {
'resolve': resolve,
'reject': reject,
'ts': new Date()
};
});
}
return promise;
}
#execPromise(id, code, onOK, errorText) {
const callbacks = this._pendingPromises[id];
if (callbacks) {
delete this._pendingPromises[id];
if (code >= 200 && code < 400) {
if (callbacks.resolve) {
callbacks.resolve(onOK);
}
} else if (callbacks.reject) {
callbacks.reject(new _comm_error_js__WEBPACK_IMPORTED_MODULE_2__["default"](errorText, code));
}
}
}
#send(pkt, id) {
let promise;
if (id) {
promise = this.#makePromise(id);
}
pkt = (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.simplify)(pkt);
let msg = JSON.stringify(pkt);
this.logger("out: " + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : msg));
try {
this._connection.sendText(msg);
} catch (err) {
if (id) {
this.#execPromise(id, _connection_js__WEBPACK_IMPORTED_MODULE_3__["default"].NETWORK_ERROR, null, err.message);
} else {
throw err;
}
}
return promise;
}
#dispatchMessage(data) {
if (!data) return;
this._inPacketCount++;
if (this.onRawMessage) {
this.onRawMessage(data);
}
if (data === '0') {
if (this.onNetworkProbe) {
this.onNetworkProbe();
}
return;
}
let pkt = JSON.parse(data, _utils_js__WEBPACK_IMPORTED_MODULE_11__.jsonParseHelper);
if (!pkt) {
this.logger("in: " + data);
this.logger("ERROR: failed to parse data");
} else {
this.logger("in: " + (this._trimLongStrings ? JSON.stringify(pkt, jsonLoggerHelper) : data));
if (this.onMessage) {
this.onMessage(pkt);
}
if (pkt.ctrl) {
if (this.onCtrlMessage) {
this.onCtrlMessage(pkt.ctrl);
}
if (pkt.ctrl.id) {
this.#execPromise(pkt.ctrl.id, pkt.ctrl.code, pkt.ctrl, pkt.ctrl.text);
}
setTimeout(_ => {
if (pkt.ctrl.code == 205 && pkt.ctrl.text == 'evicted') {
const topic = this.#cacheGet('topic', pkt.ctrl.topic);
if (topic) {
topic._resetSub();
if (pkt.ctrl.params && pkt.ctrl.params.unsub) {
topic._gone();
}
}
} else if (pkt.ctrl.code < 300 && pkt.ctrl.params) {
if (pkt.ctrl.params.what == 'data') {
const topic = this.#cacheGet('topic', pkt.ctrl.topic);
if (topic) {
topic._allMessagesReceived(pkt.ctrl.params.count);
}
} else if (pkt.ctrl.params.what == 'sub') {
const topic = this.#cacheGet('topic', pkt.ctrl.topic);
if (topic) {
topic._processMetaSubs([]);
}
}
}
}, 0);
} else {
setTimeout(_ => {
if (pkt.meta) {
const topic = this.#cacheGet('topic', pkt.meta.topic);
if (topic) {
topic._routeMeta(pkt.meta);
}
if (pkt.meta.id) {
this.#execPromise(pkt.meta.id, 200, pkt.meta, 'META');
}
if (this.onMetaMessage) {
this.onMetaMessage(pkt.meta);
}
} else if (pkt.data) {
const topic = this.#cacheGet('topic', pkt.data.topic);
if (topic) {
topic._routeData(pkt.data);
}
if (this.onDataMessage) {
this.onDataMessage(pkt.data);
}
} else if (pkt.pres) {
const topic = this.#cacheGet('topic', pkt.pres.topic);
if (topic) {
topic._routePres(pkt.pres);
}
if (this.onPresMessage) {
this.onPresMessage(pkt.pres);
}
} else if (pkt.info) {
const topic = this.#cacheGet('topic', pkt.info.topic);
if (topic) {
topic._routeInfo(pkt.info);
}
if (this.onInfoMessage) {
this.onInfoMessage(pkt.info);
}
} else {
this.logger("ERROR: Unknown packet received.");
}
}, 0);
}
}
}
#connectionOpen() {
if (!this._expirePromises) {
this._expirePromises = setInterval(_ => {
const err = new _comm_error_js__WEBPACK_IMPORTED_MODULE_2__["default"]("timeout", 504);
const expires = new Date(new Date().getTime() - _config_js__WEBPACK_IMPORTED_MODULE_1__.EXPIRE_PROMISES_TIMEOUT);
for (let id in this._pendingPromises) {
let callbacks = this._pendingPromises[id];
if (callbacks && callbacks.ts < expires) {
this.logger("Promise expired", id);
delete this._pendingPromises[id];
if (callbacks.reject) {
callbacks.reject(err);
}
}
}
}, _config_js__WEBPACK_IMPORTED_MODULE_1__.EXPIRE_PROMISES_PERIOD);
}
this.hello();
}
#disconnected(err, code) {
this._inPacketCount = 0;
this._serverInfo = null;
this._authenticated = false;
if (this._expirePromises) {
clearInterval(this._expirePromises);
this._expirePromises = null;
}
this.#cacheMap('topic', (topic, key) => {
topic._resetSub();
});
for (let key in this._pendingPromises) {
const callbacks = this._pendingPromises[key];
if (callbacks && callbacks.reject) {
callbacks.reject(err);
}
}
this._pendingPromises = {};
if (this.onDisconnect) {
this.onDisconnect(err);
}
}
#getUserAgent() {
return this._appName + ' (' + (this._browser ? this._browser + '; ' : '') + this._hwos + '); ' + _config_js__WEBPACK_IMPORTED_MODULE_1__.LIBRARY;
}
#initPacket(type, topic) {
switch (type) {
case 'hi':
return {
'hi': {
'id': this.getNextUniqueId(),
'ver': _config_js__WEBPACK_IMPORTED_MODULE_1__.VERSION,
'ua': this.#getUserAgent(),
'dev': this._deviceToken,
'lang': this._humanLanguage,
'platf': this._platform
}
};
case 'acc':
return {
'acc': {
'id': this.getNextUniqueId(),
'user': null,
'scheme': null,
'secret': null,
'tmpscheme': null,
'tmpsecret': null,
'login': false,
'tags': null,
'desc': {},
'cred': {}
}
};
case 'login':
return {
'login': {
'id': this.getNextUniqueId(),
'scheme': null,
'secret': null
}
};
case 'sub':
return {
'sub': {
'id': this.getNextUniqueId(),
'topic': topic,
'set': {},
'get': {}
}
};
case 'leave':
return {
'leave': {
'id': this.getNextUniqueId(),
'topic': topic,
'unsub': false
}
};
case 'pub':
return {
'pub': {
'id': this.getNextUniqueId(),
'topic': topic,
'noecho': false,
'head': null,
'content': {}
}
};
case 'get':
return {
'get': {
'id': this.getNextUniqueId(),
'topic': topic,
'what': null,
'desc': {},
'sub': {},
'data': {}
}
};
case 'set':
return {
'set': {
'id': this.getNextUniqueId(),
'topic': topic,
'desc': {},
'sub': {},
'tags': [],
'aux': {}
}
};
case 'del':
return {
'del': {
'id': this.getNextUniqueId(),
'topic': topic,
'what': null,
'delseq': null,
'user': null,
'hard': false
}
};
case 'note':
return {
'note': {
'topic': topic,
'what': null,
'seq': undefined
}
};
default:
throw new Error(`Unknown packet type requested: ${type}`);
}
}
#cachePut(type, name, obj) {
this._cache[type + ':' + name] = obj;
}
#cacheGet(type, name) {
return this._cache[type + ':' + name];
}
#cacheDel(type, name) {
delete this._cache[type + ':' + name];
}
#cacheMap(type, func, context) {
const key = type ? type + ':' : undefined;
for (let idx in this._cache) {
if (!key || idx.indexOf(key) == 0) {
if (func.call(context, this._cache[idx], idx)) {
break;
}
}
}
}
#attachCacheToTopic(topic) {
topic._tinode = this;
topic._cacheGetUser = uid => {
const pub = this.#cacheGet('user', uid);
if (pub) {
return {
user: uid,
public: (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.mergeObj)({}, pub)
};
}
return undefined;
};
topic._cachePutUser = (uid, user) => {
this.#cachePut('user', uid, (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.mergeObj)({}, user.public));
};
topic._cacheDelUser = uid => {
this.#cacheDel('user', uid);
};
topic._cachePutSelf = _ => {
this.#cachePut('topic', topic.name, topic);
};
topic._cacheDelSelf = _ => {
this.#cacheDel('topic', topic.name);
};
}
#loginSuccessful(ctrl) {
if (!ctrl.params || !ctrl.params.user) {
return ctrl;
}
this._myUID = ctrl.params.user;
this._authenticated = ctrl && ctrl.code >= 200 && ctrl.code < 300;
if (ctrl.params && ctrl.params.token && ctrl.params.expires) {
this._authToken = {
token: ctrl.params.token,
expires: ctrl.params.expires
};
} else {
this._authToken = null;
}
if (this.onLogin) {
this.onLogin(ctrl.code, ctrl.text);
}
return ctrl;
}
static credential(meth, val, params, resp) {
if (typeof meth == 'object') {
({
val,
params,
resp,
meth
} = meth);
}
if (meth && (val || resp)) {
return [{
'meth': meth,
'val': val,
'resp': resp,
'params': params
}];
}
return null;
}
static topicType(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].topicType(name);
}
static isMeTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isMeTopicName(name);
}
static isSelfTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isSelfTopicName(name);
}
static isGroupTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isGroupTopicName(name);
}
static isP2PTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isP2PTopicName(name);
}
static isCommTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isCommTopicName(name);
}
static isNewGroupTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isNewGroupTopicName(name);
}
static isChannelTopicName(name) {
return _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"].isChannelTopicName(name);
}
static getVersion() {
return _config_js__WEBPACK_IMPORTED_MODULE_1__.VERSION;
}
static setNetworkProviders(wsProvider, xhrProvider) {
WebSocketProvider = wsProvider;
XHRProvider = xhrProvider;
_connection_js__WEBPACK_IMPORTED_MODULE_3__["default"].setNetworkProviders(WebSocketProvider, XHRProvider);
_large_file_js__WEBPACK_IMPORTED_MODULE_6__["default"].setNetworkProvider(XHRProvider);
}
static setDatabaseProvider(idbProvider) {
IndexedDBProvider = idbProvider;
_db_js__WEBPACK_IMPORTED_MODULE_4__["default"].setDatabaseProvider(IndexedDBProvider);
}
static getLibrary() {
return _config_js__WEBPACK_IMPORTED_MODULE_1__.LIBRARY;
}
static isNullValue(str) {
return str === _config_js__WEBPACK_IMPORTED_MODULE_1__.DEL_CHAR;
}
static isServerAssignedSeq(seq) {
return seq > 0 && seq < _config_js__WEBPACK_IMPORTED_MODULE_1__.LOCAL_SEQID;
}
static isValidTagValue(tag) {
const ALIAS_REGEX = /^[a-z0-9][a-z0-9_\-]{3,23}$/i;
return tag && typeof tag == 'string' && tag.length > 3 && tag.length < 24 && ALIAS_REGEX.test(tag);
}
static tagSplit(tag) {
if (!tag) {
return null;
}
tag = tag.trim();
const splitAt = tag.indexOf(':');
if (splitAt <= 0) {
return null;
}
const value = tag.substring(splitAt + 1);
if (!value) {
return null;
}
return {
prefix: tag.substring(0, splitAt),
value: value
};
}
static setUniqueTag(tags, uniqueTag) {
if (!tags || tags.length == 0) {
return [uniqueTag];
}
const parts = Tinode.tagSplit(uniqueTag);
if (!parts) {
return tags;
}
tags = tags.filter(tag => tag && !tag.startsWith(parts.prefix));
tags.push(uniqueTag);
return tags;
}
static clearTagPrefix(tags, prefix) {
if (!tags || tags.length == 0) {
return [];
}
return tags.filter(tag => tag && !tag.startsWith(prefix));
}
static tagByPrefix(tags, prefix) {
if (!tags) {
return undefined;
}
return tags.find(tag => tag && tag.startsWith(prefix));
}
getNextUniqueId() {
return this._messageId != 0 ? '' + this._messageId++ : undefined;
}
connect(host_) {
return this._connection.connect(host_);
}
reconnect(force) {
this._connection.reconnect(force);
}
disconnect() {
this._connection.disconnect();
}
clearStorage() {
if (this._db.isReady()) {
return this._db.deleteDatabase();
}
return Promise.resolve();
}
initStorage() {
if (!this._db.isReady()) {
return this._db.initDatabase();
}
return Promise.resolve();
}
networkProbe() {
this._connection.probe();
}
isConnected() {
return this._connection.isConnected();
}
isAuthenticated() {
return this._authenticated;
}
authorizeURL(url) {
if (typeof url != 'string') {
return url;
}
if ((0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.isUrlRelative)(url)) {
const base = 'scheme://host/';
const parsed = new URL(url, base);
if (this._apiKey) {
parsed.searchParams.append('apikey', this._apiKey);
}
if (this._authToken && this._authToken.token) {
parsed.searchParams.append('auth', 'token');
parsed.searchParams.append('secret', this._authToken.token);
}
url = parsed.toString().substring(base.length - 1);
}
return url;
}
account(uid, scheme, secret, login, params) {
const pkt = this.#initPacket('acc');
pkt.acc.user = uid;
pkt.acc.scheme = scheme;
pkt.acc.secret = secret;
pkt.acc.login = login;
if (params) {
pkt.acc.desc.defacs = params.defacs;
pkt.acc.desc.public = params.public;
pkt.acc.desc.private = params.private;
pkt.acc.desc.trusted = params.trusted;
pkt.acc.tags = params.tags;
pkt.acc.cred = params.cred;
pkt.acc.tmpscheme = params.scheme;
pkt.acc.tmpsecret = params.secret;
if (Array.isArray(params.attachments) && params.attachments.length > 0) {
pkt.extra = {
attachments: params.attachments.filter(ref => (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.isUrlRelative)(ref))
};
}
}
return this.#send(pkt, pkt.acc.id);
}
createAccount(scheme, secret, login, params) {
let promise = this.account(_config_js__WEBPACK_IMPORTED_MODULE_1__.USER_NEW, scheme, secret, login, params);
if (login) {
promise = promise.then(ctrl => this.#loginSuccessful(ctrl));
}
return promise;
}
createAccountBasic(username, password, params) {
username = username || '';
password = password || '';
return this.createAccount('basic', b64EncodeUnicode(username + ':' + password), true, params);
}
updateAccountBasic(uid, username, password, params) {
username = username || '';
password = password || '';
return this.account(uid, 'basic', b64EncodeUnicode(username + ':' + password), false, params);
}
hello() {
const pkt = this.#initPacket('hi');
return this.#send(pkt, pkt.hi.id).then(ctrl => {
this._connection.backoffReset();
if (ctrl.params) {
this._serverInfo = ctrl.params;
}
if (this.onConnect) {
this.onConnect();
}
return ctrl;
}).catch(err => {
this._connection.reconnect(true);
if (this.onDisconnect) {
this.onDisconnect(err);
}
});
}
setDeviceToken(dt) {
let sent = false;
dt = dt || null;
if (dt != this._deviceToken) {
this._deviceToken = dt;
if (this.isConnected() && this.isAuthenticated()) {
this.#send({
'hi': {
'dev': dt || Tinode.DEL_CHAR
}
});
sent = true;
}
}
return sent;
}
login(scheme, secret, cred) {
const pkt = this.#initPacket('login');
pkt.login.scheme = scheme;
pkt.login.secret = secret;
pkt.login.cred = cred;
return this.#send(pkt, pkt.login.id).then(ctrl => this.#loginSuccessful(ctrl));
}
loginBasic(uname, password, cred) {
return this.login('basic', b64EncodeUnicode(uname + ':' + password), cred).then(ctrl => {
this._login = uname;
return ctrl;
});
}
loginToken(token, cred) {
return this.login('token', token, cred);
}
requestResetAuthSecret(scheme, method, value) {
return this.login('reset', b64EncodeUnicode(scheme + ':' + method + ':' + value));
}
getAuthToken() {
if (this._authToken && this._authToken.expires.getTime() > Date.now()) {
return this._authToken;
} else {
this._authToken = null;
}
return null;
}
setAuthToken(token) {
this._authToken = token;
}
subscribe(topicName, getParams, setParams) {
const pkt = this.#initPacket('sub', topicName);
if (!topicName) {
topicName = _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_NEW;
}
pkt.sub.get = getParams;
if (setParams) {
if (setParams.sub) {
pkt.sub.set.sub = setParams.sub;
}
if (setParams.desc) {
const desc = setParams.desc;
if (Tinode.isNewGroupTopicName(topicName)) {
pkt.sub.set.desc = desc;
} else if (Tinode.isP2PTopicName(topicName) && desc.defacs) {
pkt.sub.set.desc = {
defacs: desc.defacs
};
}
}
if (Array.isArray(setParams.attachments) && setParams.attachments.length > 0) {
pkt.extra = {
attachments: setParams.attachments.filter(ref => (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.isUrlRelative)(ref))
};
}
if (setParams.tags) {
pkt.sub.set.tags = setParams.tags;
}
if (setParams.aux) {
pkt.sub.set.aux = setParams.aux;
}
}
return this.#send(pkt, pkt.sub.id);
}
leave(topic, unsub) {
const pkt = this.#initPacket('leave', topic);
pkt.leave.unsub = unsub;
return this.#send(pkt, pkt.leave.id);
}
createMessage(topic, content, noEcho) {
const pkt = this.#initPacket('pub', topic);
let dft = typeof content == 'string' ? _drafty_js__WEBPACK_IMPORTED_MODULE_5___default().parse(content) : content;
if (dft && !_drafty_js__WEBPACK_IMPORTED_MODULE_5___default().isPlainText(dft)) {
pkt.pub.head = {
mime: _drafty_js__WEBPACK_IMPORTED_MODULE_5___default().getContentType()
};
content = dft;
}
pkt.pub.noecho = noEcho;
pkt.pub.content = content;
return pkt.pub;
}
publish(topicName, content, noEcho) {
return this.publishMessage(this.createMessage(topicName, content, noEcho));
}
publishMessage(pub, attachments) {
pub = Object.assign({}, pub);
pub.seq = undefined;
pub.from = undefined;
pub.ts = undefined;
const msg = {
pub: pub
};
if (attachments) {
msg.extra = {
attachments: attachments.filter(ref => (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.isUrlRelative)(ref))
};
}
return this.#send(msg, pub.id);
}
oobNotification(data) {
this.logger('oob: ' + (this._trimLongStrings ? JSON.stringify(data, jsonLoggerHelper) : data));
switch (data.what) {
case 'msg':
if (!data.seq || data.seq < 1 || !data.topic) {
break;
}
if (!this.isConnected()) {
break;
}
const topic = this.#cacheGet('topic', data.topic);
if (!topic) {
break;
}
if (topic.isSubscribed()) {
break;
}
if (topic.maxMsgSeq() < data.seq) {
if (topic.isChannelType()) {
topic._updateReceived(data.seq, 'fake-uid');
}
if (data.xfrom && !this.#cacheGet('user', data.xfrom)) {
this.getMeta(data.xfrom, new _meta_builder_js__WEBPACK_IMPORTED_MODULE_7__["default"]().withDesc().build()).catch(err => {
this.logger("Failed to get the name of a new sender", err);
});
}
topic.subscribe(null).then(_ => {
return topic.getMeta(new _meta_builder_js__WEBPACK_IMPORTED_MODULE_7__["default"](topic).withLaterData(24).withLaterDel(24).build());
}).then(_ => {
topic.leaveDelayed(false, 1000);
}).catch(err => {
this.logger("On push data fetch failed", err);
}).finally(_ => {
this.getMeTopic()._refreshContact('msg', topic);
});
}
break;
case 'read':
this.getMeTopic()._routePres({
what: 'read',
seq: data.seq
});
break;
case 'sub':
if (!this.isMe(data.xfrom)) {
break;
}
const mode = {
given: data.modeGiven,
want: data.modeWant
};
const acs = new _access_mode_js__WEBPACK_IMPORTED_MODULE_0__["default"](mode);
const pres = !acs.mode || acs.mode == _access_mode_js__WEBPACK_IMPORTED_MODULE_0__["default"]._NONE ? {
what: 'gone',
src: data.topic
} : {
what: 'acs',
src: data.topic,
dacs: mode
};
this.getMeTopic()._routePres(pres);
break;
default:
this.logger("Unknown push type ignored", data.what);
}
}
getMeta(topic, params) {
const pkt = this.#initPacket('get', topic);
pkt.get = (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.mergeObj)(pkt.get, params);
return this.#send(pkt, pkt.get.id);
}
setMeta(topic, params) {
const pkt = this.#initPacket('set', topic);
const what = [];
if (params) {
['desc', 'sub', 'tags', 'cred', 'aux'].forEach(key => {
if (params.hasOwnProperty(key)) {
what.push(key);
pkt.set[key] = params[key];
}
});
if (Array.isArray(params.attachments) && params.attachments.length > 0) {
pkt.extra = {
attachments: params.attachments.filter(ref => (0,_utils_js__WEBPACK_IMPORTED_MODULE_11__.isUrlRelative)(ref))
};
}
}
if (what.length == 0) {
return Promise.reject(new Error("Invalid {set} parameters"));
}
return this.#send(pkt, pkt.set.id);
}
delMessages(topic, ranges, hard) {
const pkt = this.#initPacket('del', topic);
pkt.del.what = 'msg';
pkt.del.delseq = ranges;
pkt.del.hard = hard;
return this.#send(pkt, pkt.del.id);
}
delTopic(topicName, hard) {
const pkt = this.#initPacket('del', topicName);
pkt.del.what = 'topic';
pkt.del.hard = hard;
return this.#send(pkt, pkt.del.id);
}
delSubscription(topicName, user) {
const pkt = this.#initPacket('del', topicName);
pkt.del.what = 'sub';
pkt.del.user = user;
return this.#send(pkt, pkt.del.id);
}
delCredential(method, value) {
const pkt = this.#initPacket('del', _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_ME);
pkt.del.what = 'cred';
pkt.del.cred = {
meth: method,
val: value
};
return this.#send(pkt, pkt.del.id);
}
delCurrentUser(hard) {
const pkt = this.#initPacket('del', null);
pkt.del.what = 'user';
pkt.del.hard = hard;
return this.#send(pkt, pkt.del.id).then(_ => {
this._myUID = null;
});
}
note(topicName, what, seq) {
if (seq <= 0 || seq >= _config_js__WEBPACK_IMPORTED_MODULE_1__.LOCAL_SEQID) {
throw new Error(`Invalid message id ${seq}`);
}
const pkt = this.#initPacket('note', topicName);
pkt.note.what = what;
pkt.note.seq = seq;
this.#send(pkt);
}
noteKeyPress(topicName, type) {
const pkt = this.#initPacket('note', topicName);
pkt.note.what = type || 'kp';
this.#send(pkt);
}
videoCall(topicName, seq, evt, payload) {
const pkt = this.#initPacket('note', topicName);
pkt.note.seq = seq;
pkt.note.what = 'call';
pkt.note.event = evt;
pkt.note.payload = payload;
this.#send(pkt, pkt.note.id);
}
getTopic(topicName) {
let topic = this.#cacheGet('topic', topicName);
if (!topic && topicName) {
if (topicName == _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_ME) {
topic = new _me_topic_js__WEBPACK_IMPORTED_MODULE_10__["default"]();
} else if (topicName == _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_FND) {
topic = new _fnd_topic_js__WEBPACK_IMPORTED_MODULE_9__["default"]();
} else {
topic = new _topic_js__WEBPACK_IMPORTED_MODULE_8__["default"](topicName);
}
this.#attachCacheToTopic(topic);
topic._cachePutSelf();
}
return topic;
}
cacheGetTopic(topicName) {
return this.#cacheGet('topic', topicName);
}
cacheRemTopic(topicName) {
this.#cacheDel('topic', topicName);
}
mapTopics(func, context) {
this.#cacheMap('topic', func, context);
}
isTopicCached(topicName) {
return !!this.#cacheGet('topic', topicName);
}
newGroupTopicName(isChan) {
return (isChan ? _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_NEW_CHAN : _config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_NEW) + this.getNextUniqueId();
}
getMeTopic() {
return this.getTopic(_config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_ME);
}
getFndTopic() {
return this.getTopic(_config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_FND);
}
getLargeFileHelper() {
return new _large_file_js__WEBPACK_IMPORTED_MODULE_6__["default"](this, _config_js__WEBPACK_IMPORTED_MODULE_1__.PROTOCOL_VERSION);
}
getCurrentUserID() {
return this._myUID;
}
isMe(uid) {
return this._myUID === uid;
}
getCurrentLogin() {
return this._login;
}
getServerInfo() {
return this._serverInfo;
}
report(action, target) {
return this.publish(_config_js__WEBPACK_IMPORTED_MODULE_1__.TOPIC_SYS, _drafty_js__WEBPACK_IMPORTED_MODULE_5___default().attachJSON(null, {
'action': action,
'target': target
}));
}
getServerParam(name, defaultValue) {
return this._serverInfo && this._serverInfo[name] || defaultValue;
}
enableLogging(enabled, trimLongStrings) {
this._loggingEnabled = enabled;
this._trimLongStrings = enabled && trimLongStrings;
}
setHumanLanguage(hl) {
if (hl) {
this._humanLanguage = hl;
}
}
isTopicOnline(name) {
const topic = this.#cacheGet('topic', name);
return topic && topic.online;
}
getTopicAccessMode(name) {
const topic = this.#cacheGet('topic', name);
return topic ? topic.acs : null;
}
wantAkn(status) {
if (status) {
this._messageId = Math.floor(Math.random() * 0xFFFFFF + 0xFFFFFF);
} else {
this._messageId = 0;
}
}
onWebsocketOpen = undefined;
onConnect = undefined;
onDisconnect = undefined;
onLogin = undefined;
onCtrlMessage = undefined;
onDataMessage = undefined;
onPresMessage = undefined;
onMessage = undefined;
onRawMessage = undefined;
onNetworkProbe = undefined;
onAutoreconnectIteration = undefined;
}
;
Tinode.MESSAGE_STATUS_NONE = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_NONE;
Tinode.MESSAGE_STATUS_QUEUED = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_QUEUED;
Tinode.MESSAGE_STATUS_SENDING = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_SENDING;
Tinode.MESSAGE_STATUS_FAILED = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_FAILED;
Tinode.MESSAGE_STATUS_FATAL = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_FATAL;
Tinode.MESSAGE_STATUS_SENT = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_SENT;
Tinode.MESSAGE_STATUS_RECEIVED = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_RECEIVED;
Tinode.MESSAGE_STATUS_READ = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_READ;
Tinode.MESSAGE_STATUS_TO_ME = _config_js__WEBPACK_IMPORTED_MODULE_1__.MESSAGE_STATUS_TO_ME;
Tinode.DEL_CHAR = _config_js__WEBPACK_IMPORTED_MODULE_1__.DEL_CHAR;
Tinode.MAX_MESSAGE_SIZE = 'maxMessageSize';
Tinode.MAX_SUBSCRIBER_COUNT = 'maxSubscriberCount';
Tinode.MIN_TAG_LENGTH = 'minTagLength';
Tinode.MAX_TAG_LENGTH = 'maxTagLength';
Tinode.MAX_TAG_COUNT = 'maxTagCount';
Tinode.MAX_FILE_UPLOAD_SIZE = 'maxFileUploadSize';
Tinode.REQ_CRED_VALIDATORS = 'reqCred';
Tinode.MSG_DELETE_AGE = 'msgDelAge';
Tinode.URI_TOPIC_ID_PREFIX = 'tinode:topic/';
Tinode.TAG_ALIAS = _config_js__WEBPACK_IMPORTED_MODULE_1__.TAG_ALIAS;
Tinode.TAG_EMAIL = _config_js__WEBPACK_IMPORTED_MODULE_1__.TAG_EMAIL;
Tinode.TAG_PHONE = _config_js__WEBPACK_IMPORTED_MODULE_1__.TAG_PHONE;
})();
/******/ return __webpack_exports__;
/******/ })()
;
});
//# sourceMappingURL=tinode.dev.js.map