js-gei 1.0.0 → 1.0.2

package/Library/RpcClient.ts

@@ -0,0 +1,362 @@
+import axios, { AxiosResponse } from 'axios';
+
+interface RpcPacket {
+    method: string;
+    params: any;
+    id?: number;
+}
+
+interface ConfigTemplate {
+    url: string;
+    cors:boolean;
+    batch: boolean;
+    jsonRpcPreemptAfter: number;
+    autoQueryPreempted: boolean;
+    log: (message?: any, ...optionalParams: any[]) => void;
+    unhandledError: (error: any) => void;
+    headers?: Record<string, string>;
+}
+
+interface PreemptedItem {
+    id: number;
+    ticket: string;
+    processor: Processor;
+    progressor: Progressor | null;
+    context: RpcContext;
+    queue: any[];
+}
+
+interface Processor {
+    process: (response: any, xhr?: XMLHttpRequest) => void;
+    context: RpcContext;
+    callbacks: ((response: any, xhr?: XMLHttpRequest) => void)[];
+}
+
+interface Progressor {
+    progress: (report: any) => void;
+}
+
+interface RpcContext {
+    id: number;
+    count: number;
+    rpcErrorHandlers: ((error: any) => void)[];
+    apiErrorHandlers: ((error: any) => void)[];
+    apiSuccessHandlers: ((response: any) => void)[];
+    responsePreviewers: ((response: any) => boolean)[];
+    finallyHandlers: (() => void)[];
+    preempted?: string[] | null;
+
+    onRpcError(callback: (error: any) => void): RpcContext;
+    onDefaultApiError(callback: (error: any) => void): RpcContext;
+    onDefaultApiSuccess(callback: (response: any) => void): RpcContext;
+    onFinally(callback: () => void): RpcContext;
+    onPreviewResponse(callback: (response: any) => boolean): RpcContext;
+    __enter(): void;
+    __preview(response: any): boolean;
+    __rpcFail(error: any): void;
+    __defaultApiFail(error: any): void;
+    __defaultApiSucceed(response: any): void;
+    __leave(): void;
+}
+
+export const RpcClient = (() => {
+    let _id = Date.now();
+    let _ctxid = 0;
+    let _preempted: PreemptedItem[] | null = null;
+    let _pendingAjaxCount = 0;
+
+    const _currentPath = window.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
+    const _currentPathTopLevel = (() => {
+        try {
+            return window.top?.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "") || '(unavailable)';
+        } catch {
+            return '(unavailable)';
+        }
+    })();
+
+    const configTemplate: 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: string[]): string =>
+        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: string, ...args: any[]): RpcPacket => ({
+        method,
+        params: args.length === 1 && (Array.isArray(args[0]) || typeof args[0] === 'object') ? args[0] : args
+    });
+
+    const schedulePreemptedQuery = (
+        id: number,
+        ticket: string,
+        processor: Processor,
+        progressor: Progressor | null,
+        context: RpcContext,
+        queue: any[]
+    ) => {
+        if (!_preempted) _preempted = [];
+        _preempted.push({ id, ticket, processor, progressor, context, queue });
+
+        const query = () => {
+            if (!_preempted || !_preempted.length) {
+                _preempted = null;
+                return;
+            }
+
+            const ctx = RpcClient.context().onFinally(() => setTimeout(query, 2000));
+            const tickets = _preempted.map(item => item.ticket);
+
+            RpcClient.call('$.QueryPreemptedResponses', { tickets })
+                .done((response: any) => {
+                    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]: [string, any]) => {
+                        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') {
+                            RpcClient.call('$.RetrievePreemptedResponse', { ticket })
+                                .done((realResponse: any) => 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: { batch: any[]; context: RpcContext; fail: (rpc: boolean, e: any) => void }[] = [];
+        let _last: Date | null = null;
+        const _delay = 700;
+
+        const postQueue = (config: ConfigTemplate) => {
+            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: any, xhr?: XMLHttpRequest) => {
+                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: Processor = {
+                        context: item.context,
+                        callbacks: item.batch.find(b => b.request.id === response.id)!.callbacks,
+                        process: (response: any) => {
+                            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.post(config.url, request, { headers: config.headers, timeout: 0, responseType: 'blob', withCredentials: true })
+                .then((response: AxiosResponse) => handler(JSON.parse(response.data), response.request))
+                .catch(error => handler({ error: { status: error.code, details: error.message }, ajaxCallFailed: true }));
+        };
+
+        return {
+            dispatch: (
+                batch: any[],
+                context: RpcContext,
+                fail: (rpc: boolean, e: any) => void,
+                config: ConfigTemplate
+            ) => {
+                const now = new Date();
+                if (!_queue.length) (_queue as any).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 as any).created.getTime();
+                if (span < 3000 && (_pendingAjaxCount > 3 || diff < _delay)) {
+                    clearTimeout((_queue as any).timeoutHandle);
+                }
+
+                (_queue as any).timeoutHandle = setTimeout(() => postQueue(config), _delay + 50);
+                _last = now;
+            }
+        };
+    })();
+
+    const main = (packet: RpcPacket, config: ConfigTemplate) => {
+        const batch: { request: RpcPacket; callbacks: ((response: any) => void)[]; progressCallbacks: any[] }[] = [
+            { request: packet, callbacks: [], progressCallbacks: [] }
+        ];
+        let context: RpcContext | null = null;
+
+        const fail = (rpc: boolean, e: any) => {
+            if (context && rpc === true && context.__rpcFail(e)) return;
+            if (config && config.unhandledError) config.unhandledError(e);
+            else console.log(e);
+        };
+
+        return {
+            call: function (...args: [string, ...any[]]) {
+                const p = preparePacket(...args);
+                _id++;
+                p.id = _id;
+                batch.push({ request: p, callbacks: [], progressCallbacks: [] });
+                return this;
+            },
+            notify: function (...args: [string, ...any[]]) {
+                const p = preparePacket(...args);
+                batch.push({ request: p, callbacks: [], progressCallbacks: [] });
+                return this;
+            },
+            done: function (callback: (response: any) => void) {
+                if (typeof callback === 'function') batch[batch.length - 1].callbacks.push(callback);
+                return this;
+            },
+            post: function (ctx?: RpcContext, customConfig?: ConfigTemplate) {
+                context = ctx || RpcClient.context();
+                context.__enter();
+
+                const config = customConfig || 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: [string, ...any[]]) {
+            const packet = preparePacket(...args);
+            _id++;
+            packet.id = _id;
+            return main(packet, this.config);
+        },
+        notify: function (...args: [string, ...any[]]) {
+            const packet = preparePacket(...args);
+            return main(packet, this.config);
+        },
+        context: function (): RpcContext {
+            _ctxid++;
+            const ctx: RpcContext = {
+                id: _ctxid,
+                count: 0,
+                rpcErrorHandlers: [],
+                apiErrorHandlers: [],
+                apiSuccessHandlers: [],
+                responsePreviewers: [],
+                finallyHandlers: [],
+                onRpcError(callback: (error: any) => void) {
+                    if (typeof callback === 'function') this.rpcErrorHandlers.push(callback);
+                    return this;
+                },
+                onDefaultApiError(callback: (error: any) => void) {
+                    if (typeof callback === 'function') this.apiErrorHandlers.push(callback);
+                    return this;
+                },
+                onDefaultApiSuccess(callback: (response: any) => void) {
+                    if (typeof callback === 'function') this.apiSuccessHandlers.push(callback);
+                    return this;
+                },
+                onFinally(callback: () => void) {
+                    if (typeof callback === 'function') this.finallyHandlers.push(callback);
+                    return this;
+                },
+                onPreviewResponse(callback: (response: any) => boolean) {
+                    if (typeof callback === 'function') this.responsePreviewers.push(callback);
+                    return this;
+                },
+                __enter() {
+                    this.count++;
+                },
+                __preview(response: any) {
+                    return this.responsePreviewers.every(callback => callback(response));
+                },
+                __rpcFail(error: any) {
+                    this.rpcErrorHandlers.forEach(callback => callback(error));
+                },
+                __defaultApiFail(error: any) {
+                    this.apiErrorHandlers.forEach(callback => callback(error));
+                },
+                __defaultApiSucceed(response: any) {
+                    this.apiSuccessHandlers.forEach(callback => callback(response));
+                },
+                __leave() {
+                    if (--this.count === 0) this.finallyHandlers.forEach(callback => callback());
+                }
+            };
+
+            return ctx;
+        }
+    };
+})();

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

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetConfig = SetConfig;
 exports.GetViewObject = GetViewObject;
-function GetViewObject(obj) {
+const RpcClient_1 = require("./Library/RpcClient");
+function SetConfig(url) {
+    RpcClient_1.RpcClient.config.url = url;
+    RpcClient_1.RpcClient.config.cors = true;
+}
+function GetViewObject(legislation, seller, buyer, properties, document, payments, ctx, cb) {
+    CallRT("GEI.EvaluateObject1", {
+        Legislation: legislation,
+        ReturnType: ["View"],
+        Seller: seller,
+        Buyer: buyer,
+        Properties: properties,
+        Document: document,
+        Payments: payments
+    }, ctx, cb);
 }
 function CallRT(method, params, ctx, cb) {
-    RpcClient.call(method, params)
+    RpcClient_1.RpcClient.call(method, params)
         .done(function (response) {
         console.log(response);
         cb(response);
@@ -12,7 +27,7 @@ function CallRT(method, params, ctx, cb) {
         .post(getStdRpcContext());
 }
 function getStdRpcContext() {
-    return RpcClient.context().onRpcError(function (e) {
+    return RpcClient_1.RpcClient.context().onRpcError(function (e) {
     }).onDefaultApiError(function (e) {
     }).onDefaultApiSuccess(function (res) {
     });