Your IP : 216.73.216.86
/* eslint-disable */
this.BX = this.BX || {};
(function (exports) {
'use strict';
/* eslint-disable @bitrix24/bitrix24-rules/no-typeof */
function isString(item) {
return item === '' ? true : item ? typeof item === 'string' || item instanceof String : false;
}
function isArray(item) {
return item && Object.prototype.toString.call(item) === '[object Array]';
}
function isNotEmptyString(item) {
return isString(item) ? item.length > 0 : false;
}
function isJsonRpcRequest(item) {
return typeof item === 'object' && item && 'jsonrpc' in item && isNotEmptyString(item.jsonrpc) && 'method' in item && isNotEmptyString(item.method);
}
function isJsonRpcResponse(item) {
return typeof item === 'object' && item && 'jsonrpc' in item && isNotEmptyString(item.jsonrpc) && 'id' in item && ('result' in item || 'error' in item);
}
class ErrorNotConnected extends Error {
constructor(message) {
super(message);
this.name = 'ErrorNotConnected';
}
}
class ErrorTimeout extends Error {
constructor(message) {
super(message);
this.name = 'ErrorTimeout';
}
}
const JSON_RPC_VERSION = '2.0';
const RpcError = {
Parse: {
code: -32700,
message: 'Parse error'
},
InvalidRequest: {
code: -32600,
message: 'Invalid Request'
},
MethodNotFound: {
code: -32601,
message: 'Method not found'
},
InvalidParams: {
code: -32602,
message: 'Invalid params'
},
Internal: {
code: -32603,
message: 'Internal error'
}
};
class JsonRpc extends EventTarget {
constructor(options) {
super();
this.idCounter = 0;
this.handlers = {};
this.rpcResponseAwaiters = new Map();
this.sender = options.sender;
for (const method of Object.keys(options.handlers || {})) {
this.handle(method, options.handlers[method]);
}
for (const eventType of Object.keys(options.events || {})) {
// eslint-disable-next-line @bitrix24/bitrix24-rules/no-native-events-binding
this.addEventListener(eventType, options.events[eventType]);
}
}
/**
* @param {string} method
* @param {function} handler
*/
handle(method, handler) {
this.handlers[method] = handler;
}
/**
* Sends RPC command to the server.
*
* @param {string} method Method name
* @param {object} params
* @param {int} timeout
* @returns {Promise}
*/
executeOutgoingRpcCommand(method, params, timeout = 5) {
return new Promise((resolve, reject) => {
const request = this.createRequest(method, params);
if (this.sender.send(JSON.stringify(request)) === false) {
reject(new ErrorNotConnected('send failed'));
}
if (timeout > 0) {
const t = setTimeout(() => {
this.rpcResponseAwaiters.delete(request.id);
reject(new ErrorTimeout('no response'));
}, timeout * 1000);
this.rpcResponseAwaiters.set(request.id, {
resolve,
reject,
timeout: t
});
} else {
resolve();
}
});
}
/**
* Executes array or rpc commands. Returns array of promises, each promise will be resolved individually.
*
* @param {JsonRpcRequest[]} batch
* @returns {Promise[]}
*/
executeOutgoingRpcBatch(batch) {
const requests = [];
const promises = [];
batch.forEach(({
method,
params,
id
}) => {
const request = this.createRequest(method, params, id);
requests.push(request);
promises.push(new Promise((resolve, reject) => {
this.rpcResponseAwaiters.set(request.id, {
resolve,
reject
});
}));
});
this.sender.send(JSON.stringify(requests));
return promises;
}
processRpcResponse(response) {
if ('id' in response && this.rpcResponseAwaiters.has(response.id)) {
const awaiter = this.rpcResponseAwaiters.get(response.id);
if ('result' in response) {
awaiter.resolve(response.result);
} else if ('error' in response) {
awaiter.reject(response.error);
} else {
awaiter.reject(new Error('wrong response structure'));
}
clearTimeout(awaiter.timeout);
this.rpcResponseAwaiters.delete(response.id);
} else {
this.dispatchEvent(new CustomEvent('error', {
error: new Error(`received rpc response with unknown id ${response}`)
}));
}
}
async handleIncomingMessage(message) {
let decoded = {};
try {
decoded = JSON.parse(message);
} catch (e) {
throw new Error(`could not decode json rpc message: ${e}`);
}
if (isArray(decoded)) {
this.executeIncomingRpcBatch(decoded);
} else if (isJsonRpcRequest(decoded)) {
const commandResult = await this.executeIncomingRpcCommand(decoded);
if (commandResult !== null && commandResult !== undefined) {
const response = commandResult.error ? this.createErrorResponse(decoded.id, commandResult.error) : this.createResponse(decoded.id, commandResult);
this.sender.send(JSON.stringify(response));
} else {
this.sender.send(JSON.stringify(this.createResponse(decoded.id, null)));
}
} else if (isJsonRpcResponse(decoded)) {
this.processRpcResponse(decoded);
} else {
throw new Error(`unknown rpc packet: ${decoded}`);
}
}
/**
* Executes RPC command, received from the server
*
* @param {string} method
* @param {object} params
* @returns {object}
*/
async executeIncomingRpcCommand({
method,
params
}) {
if (method in this.handlers) {
try {
return this.handlers[method].call(this, params);
} catch (e) {
return {
jsonrpc: '2.0',
error: e.toString()
};
}
}
return {
error: RpcError.MethodNotFound
};
}
async executeIncomingRpcBatch(batch) {
const result = [];
for (const command of batch) {
if ('jsonrpc' in command) {
if ('method' in command) {
const commandResult = this.executeIncomingRpcCommand(command);
if (commandResult) {
commandResult.jsonrpc = JSON_RPC_VERSION;
commandResult.id = command.id;
result.push(commandResult);
}
} else {
this.processRpcResponse(command);
}
} else {
this.dispatchEvent(new CustomEvent('error', {
error: new Error(`unknown rpc command in batch: ${command}`)
}));
result.push({
jsonrpc: '2.0',
error: RpcError.InvalidRequest
});
}
}
return result;
}
nextId() {
this.idCounter++;
return this.idCounter;
}
createPublishRequest(messageBatch) {
const result = messageBatch.map(message => this.createRequest('publish', message));
if (result.length === 0) {
return result[0];
}
return result;
}
createRequest(method, params, id) {
return {
jsonrpc: JSON_RPC_VERSION,
method,
params,
id: id != null ? id : this.nextId()
};
}
createResponse(id, result) {
return {
jsonrpc: JSON_RPC_VERSION,
id,
result
};
}
createErrorResponse(id, error) {
return {
jsonrpc: JSON_RPC_VERSION,
id,
error
};
}
}
exports.RpcError = RpcError;
exports.JsonRpc = JsonRpc;
}((this.BX.Pull = this.BX.Pull || {})));
//# sourceMappingURL=pull.jsonrpc.bundle.js.map