js-gei 1.0.1 → 1.0.3

package/Library/jsonrpc-2.0.js

@@ -1,5 +1,6 @@
 import axios from 'axios';
-var RpcClient = initRpcClient();
+
+let RpcClient = initRpcClient();
 
 function initRpcClient() {
     let dt = new Date();
@@ -8,7 +9,7 @@ function initRpcClient() {
     let _preempted = null;
     let _pendingAjaxCount = 0;
 
-    let _currentPath = window.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
+    let _currentPath = window.location.pathname.trim().replace(/(^[/]*|[/]*$)/g, "");
     let _currentPathTopLevel = '(unavailable)';
     try {
         _currentPathTopLevel = window.top.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
@@ -866,4 +867,7 @@ function initRpcClient() {
             };
         }
     };
-}
+}
+
+// Export RpcClient for use in other modules
+export { RpcClient };

package/dist/Library/RpcClient.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+exports.RpcClient = (() => {
+    let _id = Date.now();
+    let _ctxid = 0;
+    let _preempted = null;
+    let _pendingAjaxCount = 0;
+    const _currentPath = window.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
+    const _currentPathTopLevel = (() => {
+        var _a;
+        try {
+            return ((_a = window.top) === null || _a === void 0 ? void 0 : _a.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "")) || '(unavailable)';
+        }
+        catch (_b) {
+            return '(unavailable)';
+        }
+    })();
+    const configTemplate = {
+        url: "json.rpc",
+        batch: true,
+        cors: false,
+        jsonRpcPreemptAfter: 7,
+        autoQueryPreempted: true,
+        log: console.log,
+        unhandledError: console.log
+    };
+    const baseUrl = (() => {
+        const baseElement = document.querySelector("head base");
+        return baseElement ? baseElement.getAttribute("href") : null;
+    })();
+    const urlCombine = (parts) => parts.map(part => part.trim().replace(/(^[\/]*|[\/]*$)/g, "")).join("/");
+    if (_currentPath) {
+        configTemplate.url = baseUrl
+            ? urlCombine([baseUrl, _currentPath, configTemplate.url])
+            : urlCombine([_currentPath, configTemplate.url]);
+    }
+    else if (baseUrl) {
+        configTemplate.url = urlCombine([baseUrl, configTemplate.url]);
+    }
+    const preparePacket = (method, ...args) => ({
+        method,
+        params: args.length === 1 && (Array.isArray(args[0]) || typeof args[0] === 'object') ? args[0] : args
+    });
+    const schedulePreemptedQuery = (id, ticket, processor, progressor, context, queue) => {
+        if (!_preempted)
+            _preempted = [];
+        _preempted.push({ id, ticket, processor, progressor, context, queue });
+        const query = () => {
+            if (!_preempted || !_preempted.length) {
+                _preempted = null;
+                return;
+            }
+            const ctx = exports.RpcClient.context().onFinally(() => setTimeout(query, 2000));
+            const tickets = _preempted.map(item => item.ticket);
+            exports.RpcClient.call('$.QueryPreemptedResponses', { tickets })
+                .done((response) => {
+                if (response.error) {
+                    const items = _preempted.splice(0, tickets.length);
+                    items.forEach(item => item.processor.process(response));
+                    items.forEach(item => {
+                        if (item.context.preempted) {
+                            item.context.preempted = null;
+                            item.context.__leave();
+                        }
+                    });
+                    return false;
+                }
+                Object.entries(response.result).forEach(([ticket, report]) => {
+                    const idx = _preempted.findIndex(p => p.ticket === ticket);
+                    if (idx === -1)
+                        return;
+                    const item = _preempted[idx];
+                    if (report.status === 'error') {
+                        _preempted.splice(idx, 1);
+                        item.processor.process({ id: item.id, error: { code: -1, message: report.reason } });
+                    }
+                    else if (report.status === 'ok') {
+                        exports.RpcClient.call('$.RetrievePreemptedResponse', { ticket })
+                            .done((realResponse) => item.processor.process(realResponse))
+                            .post(ctx);
+                    }
+                    else if (item.progressor) {
+                        item.progressor.progress(report);
+                    }
+                });
+                return false;
+            })
+                .post(ctx);
+        };
+        setTimeout(query, 2000);
+    };
+    const dispatcher = (() => {
+        let _queue = [];
+        let _last = null;
+        const _delay = 700;
+        const postQueue = (config) => {
+            const queue = _queue;
+            _queue = [];
+            if (!queue.length)
+                return;
+            const batch = queue.length === 1 ? queue[0].batch : queue.flatMap(q => q.batch);
+            const request = batch.length === 1
+                ? batch[0].request
+                : [{ method: '$.BeginSynchronizedBatch', params: [] }, ...batch.map(b => b.request)];
+            const handler = (data, xhr) => {
+                if (!data) {
+                    queue.forEach(q => q.fail(true, "Server returned an empty response."));
+                    return;
+                }
+                const responses = Array.isArray(data) ? data : [data];
+                responses.forEach(response => {
+                    const item = queue.find(q => q.batch.some(b => b.request.id === response.id));
+                    if (!item)
+                        return;
+                    const processor = {
+                        context: item.context,
+                        callbacks: item.batch.find(b => b.request.id === response.id).callbacks,
+                        process: (response) => {
+                            const doDefaultProcessing = processor.context.__preview(response);
+                            if (!doDefaultProcessing)
+                                return;
+                            processor.callbacks.forEach(callback => callback(response, xhr));
+                        }
+                    };
+                    if (response.error && response.error.code === -32099 && config.autoQueryPreempted) {
+                        const ticket = response.error.data;
+                        if (!item.context.preempted)
+                            item.context.preempted = [];
+                        item.context.preempted.push(ticket);
+                        schedulePreemptedQuery(response.id, ticket, processor, null, item.context, queue);
+                    }
+                    else {
+                        processor.process(response, xhr);
+                    }
+                });
+                queue.forEach(q => {
+                    if (!q.context.preempted)
+                        q.context.__leave();
+                });
+            };
+            axios_1.default.post(config.url, request, { headers: config.headers, timeout: 0, responseType: 'blob', withCredentials: true })
+                .then((response) => handler(JSON.parse(response.data), response.request))
+                .catch(error => handler({ error: { status: error.code, details: error.message }, ajaxCallFailed: true }));
+        };
+        return {
+            dispatch: (batch, context, fail, config) => {
+                const now = new Date();
+                if (!_queue.length)
+                    _queue.created = now;
+                _queue.push({ batch, context, fail });
+                if (!config.batch || !_pendingAjaxCount) {
+                    postQueue(config);
+                    return;
+                }
+                const diff = _last ? now.getTime() - _last.getTime() : 0;
+                const span = now.getTime() - _queue.created.getTime();
+                if (span < 3000 && (_pendingAjaxCount > 3 || diff < _delay)) {
+                    clearTimeout(_queue.timeoutHandle);
+                }
+                _queue.timeoutHandle = setTimeout(() => postQueue(config), _delay + 50);
+                _last = now;
+            }
+        };
+    })();
+    const main = (packet, config) => {
+        const batch = [
+            { request: packet, callbacks: [], progressCallbacks: [] }
+        ];
+        let context = null;
+        const fail = (rpc, e) => {
+            if (context && rpc === true && context.__rpcFail(e))
+                return;
+            if (config && config.unhandledError)
+                config.unhandledError(e);
+            else
+                console.log(e);
+        };
+        return {
+            call: function (...args) {
+                const p = preparePacket(...args);
+                _id++;
+                p.id = _id;
+                batch.push({ request: p, callbacks: [], progressCallbacks: [] });
+                return this;
+            },
+            notify: function (...args) {
+                const p = preparePacket(...args);
+                batch.push({ request: p, callbacks: [], progressCallbacks: [] });
+                return this;
+            },
+            done: function (callback) {
+                if (typeof callback === 'function')
+                    batch[batch.length - 1].callbacks.push(callback);
+                return this;
+            },
+            post: function (ctx, customConfig) {
+                context = ctx || exports.RpcClient.context();
+                context.__enter();
+                const config = customConfig || exports.RpcClient.config;
+                if (!config) {
+                    fail(true, "RpcClient was invoked without a valid config object!");
+                    context.__leave();
+                    return;
+                }
+                dispatcher.dispatch(batch, context, fail, config);
+            }
+        };
+    };
+    return {
+        config: configTemplate,
+        call: function (...args) {
+            const packet = preparePacket(...args);
+            _id++;
+            packet.id = _id;
+            return main(packet, this.config);
+        },
+        notify: function (...args) {
+            const packet = preparePacket(...args);
+            return main(packet, this.config);
+        },
+        context: function () {
+            _ctxid++;
+            const ctx = {
+                id: _ctxid,
+                count: 0,
+                rpcErrorHandlers: [],
+                apiErrorHandlers: [],
+                apiSuccessHandlers: [],
+                responsePreviewers: [],
+                finallyHandlers: [],
+                onRpcError(callback) {
+                    if (typeof callback === 'function')
+                        this.rpcErrorHandlers.push(callback);
+                    return this;
+                },
+                onDefaultApiError(callback) {
+                    if (typeof callback === 'function')
+                        this.apiErrorHandlers.push(callback);
+                    return this;
+                },
+                onDefaultApiSuccess(callback) {
+                    if (typeof callback === 'function')
+                        this.apiSuccessHandlers.push(callback);
+                    return this;
+                },
+                onFinally(callback) {
+                    if (typeof callback === 'function')
+                        this.finallyHandlers.push(callback);
+                    return this;
+                },
+                onPreviewResponse(callback) {
+                    if (typeof callback === 'function')
+                        this.responsePreviewers.push(callback);
+                    return this;
+                },
+                __enter() {
+                    this.count++;
+                },
+                __preview(response) {
+                    return this.responsePreviewers.every(callback => callback(response));
+                },
+                __rpcFail(error) {
+                    this.rpcErrorHandlers.forEach(callback => callback(error));
+                },
+                __defaultApiFail(error) {
+                    this.apiErrorHandlers.forEach(callback => callback(error));
+                },
+                __defaultApiSucceed(response) {
+                    this.apiSuccessHandlers.forEach(callback => callback(response));
+                },
+                __leave() {
+                    if (--this.count === 0)
+                        this.finallyHandlers.forEach(callback => callback());
+                }
+            };
+            return ctx;
+        }
+    };
+})();

package/dist/index.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetConfig = SetConfig;
 exports.GetViewObject = GetViewObject;
+// @ts-ignore
+const jsonrpc_2_0_1 = require("./Library/jsonrpc-2.0");
 function SetConfig(url) {
-    RpcClient.config.url = url;
-    RpcClient.config.cors = true;
+    jsonrpc_2_0_1.RpcClient.config.url = url;
+    jsonrpc_2_0_1.RpcClient.config.cors = true;
 }
 function GetViewObject(legislation, seller, buyer, properties, document, payments, ctx, cb) {
     CallRT("GEI.EvaluateObject1", {
@@ -18,7 +20,7 @@ function GetViewObject(legislation, seller, buyer, properties, document, payment
     }, ctx, cb);
 }
 function CallRT(method, params, ctx, cb) {
-    RpcClient.call(method, params)
+    jsonrpc_2_0_1.RpcClient.call(method, params)
         .done(function (response) {
         console.log(response);
         cb(response);
@@ -26,7 +28,7 @@ function CallRT(method, params, ctx, cb) {
         .post(getStdRpcContext());
 }
 function getStdRpcContext() {
-    return RpcClient.context().onRpcError(function (e) {
+    return jsonrpc_2_0_1.RpcClient.context().onRpcError(function (e) {
     }).onDefaultApiError(function (e) {
     }).onDefaultApiSuccess(function (res) {
     });

package/index.ts

@@ -1,4 +1,5 @@
-declare var RpcClient:any;
+// @ts-ignore
+import { RpcClient } from './Library/jsonrpc-2.0';
 
 
 export function SetConfig(url:string)

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "js-gei",
-  "version": "1.0.1",
+  "version": "1.0.3",
  "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "dev": "vite"
   },
   "keywords": [],
   "author": "",