@factset/frontgate-js-sdk 6.11.1 → 7.0.1

package/dist/lib/esnext/core/RequestModule.js

@@ -1,349 +0,0 @@
-import { ReplaySubject, Subscription } from 'rxjs';
-import { AuthenticationTokenRequest, ErrorResponse, HighLevelRequest, HTTPProxyRequest, TransportLayerClientRequestHeader, isErrorResponse, isPermissionDeniedResponse, isRejectResponse, isHighLevelResponseMessage, } from '../message';
-import { MessageFactory } from '../message/MessageFactory';
-import { CookieTokenAuthenticationFactors } from '../authentication';
-import { TimeoutWrapper } from '../util/TimeOutWrapper';
-import { errorHandler } from '../common/functions';
-import { trace } from '@opentelemetry/api';
-import { DEFAULT_FLAG_PERMISSION_DENIED, DEFAULT_MAX_TIMEOUTS_BEFORE_RECONNECT, DEFAULT_REPLAY_SUBJECT_BUFFER_SIZE, DEFAULT_TIMEOUT_IN_MS, DEFAULT_TIMEOUT_TOKEN_IN_MS, } from '../common/constants';
-export const DEFAULT_REQUEST_MODULE_OPTIONS = {
-    defaultTimeoutInMs: DEFAULT_TIMEOUT_IN_MS,
-    defaultTimeoutTokenInMs: DEFAULT_TIMEOUT_TOKEN_IN_MS,
-    maxTimeoutsBeforeReconnect: DEFAULT_MAX_TIMEOUTS_BEFORE_RECONNECT,
-    flagPermissionDenied: DEFAULT_FLAG_PERMISSION_DENIED,
-    replaySubjectBufferSize: DEFAULT_REPLAY_SUBJECT_BUFFER_SIZE,
-};
-export class RequestModule {
-    constructor(getConnection, logger, options = DEFAULT_REQUEST_MODULE_OPTIONS) {
-        this.getConnection = getConnection;
-        this.logger = logger;
-        this.options = options;
-        this.rejectResponsesTimeout = [50, 100, 200, 400, 800, 1600, 3200];
-        this.timeoutCounter = 0;
-        this.subscription = Subscription.EMPTY;
-        this.chunks = new Map();
-        this.replaySubjectBufferSize = options.replaySubjectBufferSize;
-        this.requestSubject = new ReplaySubject(this.replaySubjectBufferSize);
-        this.jobs = new Map();
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    reset() {
-        this.logger.trace('requestModule.reset()');
-        this.requestSubject.complete();
-        this.requestSubject = new ReplaySubject(this.replaySubjectBufferSize);
-        this.chunks.clear();
-    }
-    async requestWithQuality(msg, quality, timeOutInMs = this.options.defaultTimeoutInMs) {
-        if (quality === 'BST') {
-            return this.requestBestQuality(msg, timeOutInMs);
-        }
-        if (quality && Object.keys(TransportLayerClientRequestHeader.PRICE_QUALITY).includes(quality)) {
-            msg.header.setQuality(quality);
-        }
-        return this.request(msg, timeOutInMs);
-    }
-    async requestEndpoint(method, path, data, options, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const highLevelRequest = new HighLevelRequest(method, path, data, options);
-        try {
-            const response = await this.request(highLevelRequest, timeOutInMs);
-            this.logger.info(`Endpoint Response: [${method}] ${path}`, { request: data, response: response.data });
-            return { response, data: response.data };
-        }
-        catch (err) {
-            const error = errorHandler(err);
-            this.logger.warn(`Endpoint Request Failed. ${error.message}`, err);
-            throw error;
-        }
-    }
-    async requestProxyEndpoint(method, path, body, options, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const httpProxyRequest = new HTTPProxyRequest(method, path, options);
-        if (body) {
-            httpProxyRequest.setBody(body);
-        }
-        try {
-            const response = await this.request(httpProxyRequest, timeOutInMs);
-            this.logger.info(`Proxy Endpoint Response: [${method}] ${path}`, { request: body, response: response.data });
-            return { response, data: response.data };
-        }
-        catch (err) {
-            const error = errorHandler(err);
-            this.logger.warn(`Proxy Endpoint Request Failed. ${error.message}`, err);
-            throw error;
-        }
-    }
-    async requestAuthenticationToken(lifetimeSeconds, idUser, idApplication, timeOutInMs = this.options.defaultTimeoutTokenInMs) {
-        const request = new AuthenticationTokenRequest(lifetimeSeconds, idUser, idApplication, timeOutInMs);
-        const response = await this.request(request, timeOutInMs);
-        return response.getToken();
-    }
-    async requestAuthenticationTokenExpiry(lifetimeSeconds, idUser, idApplication, timeOutInMs = this.options.defaultTimeoutTokenInMs, otp = false) {
-        const request = new AuthenticationTokenRequest(lifetimeSeconds, idUser, idApplication, timeOutInMs, otp);
-        const res = (await this.request(request, timeOutInMs));
-        const token = res.getToken();
-        const expiry = res.getExpiry();
-        return { token, expiry };
-    }
-    async requestAuthenticationTokenFactorsForCookieAuthentication(lifetimeSeconds, idUser, idApplication, timeOutInMs = this.options.defaultTimeoutTokenInMs) {
-        const token = await this.requestAuthenticationToken(lifetimeSeconds, idUser, idApplication, timeOutInMs);
-        return new CookieTokenAuthenticationFactors(token);
-    }
-    onConnection() {
-        const connection = this.getConnection();
-        if (!connection) {
-            throw new Error('Runtime error: Please assign a connection to the client instance.');
-        }
-        if (this.subscription.closed) {
-            connection.onMessage = this.handleMessage.bind(this);
-            this.subscription = this.requestSubject.subscribe(this.sendRequest.bind(this));
-            this.logger.trace('onConnection');
-        }
-    }
-    setUpdateMessageHandler(handler) {
-        this.updateMessageHandler = handler;
-    }
-    setLossMessageHandler(handler) {
-        this.lossMessageHandler = handler;
-    }
-    async request(msg, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const connection = this.getConnection();
-        if (!connection) {
-            throw new Error('Runtime error: Please assign a connection to the client instance.');
-        }
-        if (RequestModule.supportedPermissionDeniedResponseMessages(msg) && this.options.flagPermissionDenied) {
-            msg.header.setFlag('permission_denied_response');
-        }
-        if (RequestModule.supportsChunkedResponse(msg)) {
-            msg.header.setFlag('allow_chunked_response');
-        }
-        msg.header.setTimeout(timeOutInMs);
-        return trace.getTracer('MDG2Client').startActiveSpan('RequestModule.request', async (span) => {
-            msg.header.setTracing(span.spanContext());
-            const rejectReason = `Request timeout reached (${timeOutInMs} ms) for ${msg.getPtlMessage().Message}`;
-            const promise = new Promise((resolve, reject) => {
-                this.requestSubject.next({
-                    msg,
-                    insertedAt: Date.now(),
-                    resolve,
-                    reject,
-                });
-            });
-            return TimeoutWrapper.wrap(promise, timeOutInMs, rejectReason)
-                .then((message) => {
-                this.logger.trace('Reset timeout counter');
-                this.timeoutCounter = 0;
-                return message;
-            })
-                .catch((e) => {
-                if (e.code === 408) {
-                    this.timeoutCounter++;
-                    this.logger.trace(`Increment timeout counter to ${this.timeoutCounter}`);
-                    const maxTimeouts = this.options.maxTimeoutsBeforeReconnect;
-                    if (this.timeoutCounter === maxTimeouts) {
-                        this.logger.warn(`Closing connection due to max number of timeouts reached (${maxTimeouts})`);
-                        connection.close(true).catch((err) => {
-                            this.logger.error('Error while closing connection', err);
-                        });
-                        this.timeoutCounter = 0;
-                    }
-                }
-                else {
-                    const error = errorHandler(e);
-                    this.logger.trace(`Endpoint Request Failed. ${error.message}`);
-                }
-                throw e;
-            })
-                .finally(() => {
-                span.end();
-            });
-        });
-    }
-    reRequest(job) {
-        this.requestSubject.next({ msg: job.msg, resolve: job.resolve, reject: job.reject });
-    }
-    async requestBestQuality(msg, timeOutInMs = this.options.defaultTimeoutInMs) {
-        const orderedPriceQuality = ['RLT', 'DLY', 'EOD'];
-        for (let i = 0; i < orderedPriceQuality.length; i++) {
-            msg.header.setQuality(orderedPriceQuality[i]);
-            const promise = this.request(msg, timeOutInMs);
-            try {
-                return await promise;
-            }
-            catch (err) {
-                this.logger.debug(`Failed to perform request in "${orderedPriceQuality[i]}" quality.`, err, msg);
-            }
-            if (i === orderedPriceQuality.length - 1) {
-                return promise;
-            }
-        }
-        return { Message: 'Should never happen', Version: 1 };
-    }
-    prependCollectedChunks(finalResponse) {
-        const chunks = this.chunks.get(finalResponse.header.id_job);
-        if (chunks === undefined) {
-            return;
-        }
-        this.logger.trace('Prepending previous chunks to message', finalResponse);
-        let chunkedContent = '';
-        chunks.forEach((partialResponse) => {
-            this.logger.trace('Prepending previous chunk to message', partialResponse);
-            chunkedContent += partialResponse.body.value;
-            finalResponse.header.processingTime += partialResponse.header.processingTime;
-        });
-        chunkedContent += finalResponse.body.value;
-        finalResponse.body.value = chunkedContent;
-        this.chunks.delete(finalResponse.header.id_job);
-    }
-    collectChunk(partialResponse) {
-        if (this.chunks.has(partialResponse.header.id_job)) {
-            this.chunks.get(partialResponse.header.id_job)?.push(partialResponse);
-        }
-        else {
-            this.chunks.set(partialResponse.header.id_job, [partialResponse]);
-        }
-    }
-    handleMessage(rawMessage) {
-        let msg;
-        if (isHighLevelResponseMessage(rawMessage)) {
-            if (MessageFactory.hasNextChunk(rawMessage)) {
-                this.logger.trace('Received message chunk', rawMessage);
-                this.collectChunk(rawMessage);
-                return;
-            }
-            this.prependCollectedChunks(rawMessage);
-        }
-        try {
-            msg = MessageFactory.createMessage(rawMessage);
-        }
-        catch (createMessageError) {
-            this.logger.error('Problem while creating message', createMessageError, rawMessage);
-            return;
-        }
-        const { jobId } = msg;
-        const job = this.jobs.get(jobId);
-        if (msg.isUpdateMessage() && this.updateMessageHandler) {
-            this.updateMessageHandler(msg, jobId);
-            return;
-        }
-        if (msg.isLossMessage() && this.lossMessageHandler) {
-            this.lossMessageHandler(msg, jobId);
-            this.jobs.delete(jobId);
-            return;
-        }
-        if (!job) {
-            this.logger.error(`Could not find idJob ${jobId}`, rawMessage);
-            return;
-        }
-        if (isRejectResponse(msg)) {
-            this.logger.debug(`RejectResponse received for idJob ${jobId}`, rawMessage);
-            this.rejectResponseHandler(job);
-            return;
-        }
-        if (isErrorResponse(msg) || isPermissionDeniedResponse(msg)) {
-            const debugObject = {
-                request: job.request,
-                response: msg,
-            };
-            this.logger.warn(`Received ${msg.name} with idJob: ${jobId}`, debugObject);
-            job.reject(msg);
-            this.jobs.delete(jobId);
-            return;
-        }
-        this.logger.trace(`Received ${msg.name} with idJob: ${jobId}`, msg);
-        this.jobs.delete(jobId);
-        job.resolve(msg);
-    }
-    rejectResponseHandler(job) {
-        const rejectResponseTimeout = this.getRejectResponseTimeout(job.msg.header.getResendCounter());
-        const calculatedTimeout = job.expirationTime - Date.now() - rejectResponseTimeout;
-        if (calculatedTimeout < 1) {
-            const errorMessage = `Timeout for idJob ${job.msg.header.getJobId()}`;
-            this.logger.error(errorMessage);
-            job.reject(new ErrorResponse({
-                Message: 'Foundation::ErrorResponse',
-                Version: 1,
-                id_job: job.msg.header.getJobId(),
-                reason: 8,
-                details: errorMessage,
-            }));
-        }
-        this.logger.debug(`Retry request after ${rejectResponseTimeout}ms for idJob ${job.msg.header.getJobId()}`);
-        setTimeout(() => {
-            job.msg.header.setTimeout(calculatedTimeout);
-            job.msg.header.countResend();
-            this.reRequest(job);
-        }, rejectResponseTimeout);
-    }
-    getRejectResponseTimeout(resendCounter = 0) {
-        const lastIndex = this.rejectResponsesTimeout.length - 1;
-        return this.rejectResponsesTimeout[resendCounter] ?? this.rejectResponsesTimeout[lastIndex];
-    }
-    async sendRequest(req) {
-        const connection = this.getConnection();
-        if (!connection) {
-            req.reject('Runtime error: Please assign a connection to the client instance.');
-            return;
-        }
-        while (!connection.isAuthenticated()) {
-            if (req.insertedAt && req.insertedAt + req.msg.header.getTimeout() < Date.now()) {
-                req.reject('sendRequest timeout reached');
-                return;
-            }
-            await new Promise((resolve) => {
-                setTimeout(() => {
-                    resolve('Timeout reached');
-                }, 1000);
-            });
-        }
-        req.msg.header.setIdApplication(connection.auth.idApplication);
-        req.msg.header.setIdUser(connection.auth.idUser);
-        const json = req.msg.getPtlMessage();
-        const jobId = connection.send(json).idJob;
-        req.msg.header.setJobId(jobId);
-        const debugMsg = {
-            json,
-        };
-        if ((json.Message === HighLevelRequest.NAME || json.Message === HTTPProxyRequest.NAME) && typeof req.msg.getData === 'function') {
-            debugMsg.data = req.msg.getData();
-        }
-        const job = {
-            msg: req.msg,
-            expirationTime: Date.now() + req.msg.header.getTimeout(),
-            resolve: req.resolve,
-            reject: req.reject,
-            request: debugMsg,
-        };
-        this.jobs.set(jobId, job);
-        this.logger.trace(`Sending ${json.Message} with idJob: ${jobId}`, debugMsg);
-    }
-    clearPendingRequests() {
-        this.jobs.forEach((job, jobId) => {
-            const errorResponse = new ErrorResponse({
-                Message: 'Foundation::ErrorResponse',
-                header: {
-                    id_job: jobId,
-                    id_service: '0',
-                },
-                reason: {
-                    value: 1001,
-                },
-            });
-            job.reject(errorResponse);
-        });
-        this.jobs.clear();
-        this.reset();
-    }
-    static supportedPermissionDeniedResponseMessages(msg) {
-        const supportedMessages = [HighLevelRequest];
-        for (const supportedMessage of supportedMessages) {
-            if (msg instanceof supportedMessage) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static supportsChunkedResponse(msg) {
-        return msg instanceof HighLevelRequest && !msg.header.isFlagValueSet('add_subscription');
-    }
-}

package/dist/lib/esnext/core/SubscriptionModule.js

@@ -1,104 +0,0 @@
-import { DEFAULT_QUALITY } from '../common/constants';
-import { SubscriptionLossMessage, isHighLevelUpdate, isSubscriptionLossMessage } from '../message';
-import { EndpointHandler } from './subscription/EndpointHandler';
-import { SubjectManager } from './subscription/SubjectManager';
-export const DEFAULT_SUBSCRIPTION_MODULE_OPTIONS = {
-    shouldRestartSubscriptions: false,
-};
-export class SubscriptionModule {
-    constructor(requestModule, logger, options = DEFAULT_SUBSCRIPTION_MODULE_OPTIONS) {
-        this.logger = logger;
-        this.options = options;
-        this.subjectManager = new SubjectManager(this.logger);
-        this.handler = {
-            endpoint: new EndpointHandler(requestModule, this.subjectManager, this.logger),
-        };
-        requestModule.setUpdateMessageHandler(this.updateHandler.bind(this));
-        requestModule.setLossMessageHandler(this.lossHandler.bind(this));
-    }
-    setLogger(logger) {
-        this.logger = logger;
-        this.handler.endpoint.setLogger(logger);
-    }
-    observeEndpoint(method, path, data, options, requestOptions) {
-        return this.handler.endpoint.observe(method, path, data, options, requestOptions);
-    }
-    async unobserveEndpoint(idJob) {
-        return this.handler.endpoint.unobserve(idJob);
-    }
-    restartSubscriptions() {
-        this.handler.endpoint.restartSubscriptions();
-    }
-    clearPendingSubscriptions() {
-        this.subjectManager.jobs.forEach((subject, jobId) => {
-            const lossMsg = new SubscriptionLossMessage({
-                Message: 'Foundation::SubscriptionLossMessage',
-                Version: 2,
-                header: {
-                    id_job: parseInt(jobId, 10),
-                    id_service: 0,
-                },
-                reason: {
-                    value: 1,
-                },
-            });
-            subject.error(lossMsg);
-        });
-        this.subjectManager.jobs.clear();
-    }
-    clearPendingSubscription(idJob) {
-        this.subjectManager.jobs.forEach((subject, jobId) => {
-            if (idJob === Number(jobId)) {
-                const lossMsg = new SubscriptionLossMessage({
-                    Message: 'Foundation::SubscriptionLossMessage',
-                    Version: 2,
-                    header: {
-                        id_job: parseInt(jobId, 10),
-                        id_service: 0,
-                    },
-                    reason: {
-                        value: 1,
-                    },
-                });
-                subject.error(lossMsg);
-            }
-        });
-        this.subjectManager.jobs.delete(idJob.toString());
-    }
-    lossHandler(msg) {
-        try {
-            const subject = this.findSubject(msg);
-            const { jobId } = msg;
-            this.logger.debug(`Received Loss Message ${msg.name}`, msg);
-            subject.error(`Subscription lost: ${JSON.stringify(msg)}`);
-            if (this.options.shouldRestartSubscriptions) {
-                this.handler.endpoint.restartSubscription(jobId);
-            }
-        }
-        catch (err) {
-            this.logger.warn('Received Loss Message but could not find corresponding subject', msg);
-        }
-    }
-    updateHandler(msg) {
-        try {
-            const subject = this.findSubject(msg);
-            this.logger.debug(`Received Update Message ${msg.name}`, msg);
-            subject.next(msg);
-        }
-        catch (err) {
-            this.logger.warn('Received Update Message but could not find corresponding subject', msg);
-        }
-    }
-    findSubject(msg) {
-        if (isHighLevelUpdate(msg) || isSubscriptionLossMessage(msg)) {
-            const subject = this.subjectManager.findJobSubject(msg.jobId);
-            if (subject) {
-                return subject;
-            }
-        }
-        throw new Error(`Received unknown message: ${msg.name}`);
-    }
-}
-SubscriptionModule.defaultObserveOptions = {
-    quality: DEFAULT_QUALITY,
-};

package/dist/lib/esnext/core/subscription/EndpointHandler.js

@@ -1,121 +0,0 @@
-import { applyPatch } from 'fast-json-patch';
-import { ReplaySubject, Subject } from 'rxjs';
-import { filter, map, shareReplay, switchAll } from 'rxjs/operators';
-import { CancelSubscriptionRequest, isHighLevelResponse, isHighLevelUpdate } from '../../message';
-import { SubscriptionModule } from '../SubscriptionModule';
-import { DEFAULT_RESUBSCRIBE_WAIT_TIME_IN_MS } from '../../common/constants';
-export class EndpointHandler {
-    constructor(requestModule, subjectManager, logger) {
-        this.resultMapper = map((response) => {
-            if (isHighLevelUpdate(response)) {
-                const patchedResponse = this.applyEndpointJsonPatchUpdate(response.jobId, response.data);
-                return { response: patchedResponse, data: patchedResponse.data };
-            }
-            return { response, data: response.data };
-        });
-        this.requestToJobMapper = new Map();
-        this.requestModule = requestModule;
-        this.subjectManager = subjectManager;
-        this.responses = {};
-        this.logger = logger;
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    observe(method, path, data, options, requestOptions) {
-        this.validateOptions(options);
-        const subject = new Subject();
-        const mainSubject = new ReplaySubject(1);
-        const mainObservable = mainSubject.pipe(switchAll());
-        const observable = subject.asObservable().pipe(EndpointHandler.highLevelResponseFilter, this.resultMapper.bind(this));
-        this.requestModule
-            .requestEndpoint(method, path, data, { ...requestOptions, subscribe: true })
-            .then((result) => {
-            this.subjectManager.registerJobSubject(result.response.jobId, subject);
-            this.registerEndpointRequest(result.response.jobId, mainSubject, mainObservable, method, path, data, options);
-            this.registerEndpointResponse(result.response.jobId, result.response);
-            observable.idJob = result.response.jobId;
-            mainSubject.next(observable.pipe(shareReplay(1)));
-            mainObservable.idJob = result.response.jobId;
-            subject.next(result.response);
-        })
-            .catch((err) => {
-            this.logger.warn('Subscription request failed.', err);
-            mainSubject.error(err);
-        });
-        return mainObservable;
-    }
-    async unobserve(idJob) {
-        if (!this.subjectManager.hasJobSubject(idJob)) {
-            this.logger.warn(`Could not find subscription for idJob "${idJob}".`);
-            return;
-        }
-        await this.requestModule.request(new CancelSubscriptionRequest(idJob));
-        this.requestToJobMapper.delete(idJob.toString());
-        this.subjectManager.removeJobSubject(idJob);
-    }
-    findSubject(idJob) {
-        return this.subjectManager.getJobSubject(idJob);
-    }
-    registerEndpointResponse(idJob, response) {
-        this.responses[idJob] = response;
-    }
-    registerEndpointRequest(idJob, subject, observable, method, path, data, options, requestOptions) {
-        this.requestToJobMapper.set(idJob.toString(), { path, subject, observable, data, method, options, requestOptions });
-    }
-    applyEndpointJsonPatchUpdate(idJob, patch) {
-        const response = this.responses[idJob];
-        const result = applyPatch(response, patch).newDocument;
-        this.responses[idJob] = result;
-        return result;
-    }
-    restartSubscriptions() {
-        const oldSubscriptions = Array.from(this.subjectManager.jobs.keys());
-        const oldRequests = new Map(this.requestToJobMapper);
-        this.requestToJobMapper.clear();
-        this.subjectManager.jobs.clear();
-        oldSubscriptions.forEach((idJob) => {
-            const request = oldRequests.get(idJob);
-            if (request) {
-                this.resubscribe(request);
-            }
-        });
-    }
-    restartSubscription(jobId) {
-        const oldRequests = new Map(this.requestToJobMapper);
-        this.requestToJobMapper.clear();
-        if (jobId) {
-            const request = oldRequests.get(jobId.toString());
-            if (request) {
-                setTimeout(() => {
-                    this.resubscribe(request);
-                }, DEFAULT_RESUBSCRIBE_WAIT_TIME_IN_MS);
-            }
-        }
-    }
-    resubscribe(request) {
-        this.validateOptions(request.options);
-        const subject = new Subject();
-        const observable = subject.asObservable().pipe(EndpointHandler.highLevelResponseFilter, this.resultMapper.bind(this));
-        this.requestModule
-            .requestEndpoint(request.method, request.path, request.data, { ...request.requestOptions, subscribe: true })
-            .then((result) => {
-            this.subjectManager.registerJobSubject(result.response.jobId, subject);
-            this.registerEndpointResponse(result.response.jobId, result.response);
-            request.observable.idJob = result.response.jobId;
-            request.subject.next(observable.pipe(shareReplay(1)));
-            subject.next(result.response);
-            this.registerEndpointRequest(result.response.jobId, request.subject, request.observable, request.method, request.path, request.data, request.options, request.requestOptions);
-        })
-            .catch((err) => {
-            this.logger.warn('Request failed during initial request for restarting endpoint subscription', err);
-        });
-    }
-    validateOptions(options) {
-        const opts = { ...SubscriptionModule.defaultObserveOptions, ...options };
-        if (opts.minInterval) {
-            this.logger.warn('Option `minInterval` is deprecated. Use _subscriptionMinimumInterval (GET) or meta.subscription.minimumInterval (POST) for server side throttling.');
-        }
-    }
-}
-EndpointHandler.highLevelResponseFilter = filter((response) => isHighLevelResponse(response) || isHighLevelUpdate(response));

package/dist/lib/esnext/core/subscription/SubjectManager.js

@@ -1,39 +0,0 @@
-export class SubjectManager {
-    constructor(logger) {
-        this.job = new Map();
-        this.logger = logger;
-    }
-    hasJobSubject(idJob) {
-        return this.job.has(String(idJob));
-    }
-    registerJobSubject(idJob, subject) {
-        const key = String(idJob);
-        this.job.set(key, subject);
-    }
-    findJobSubject(identifier) {
-        const id = String(identifier);
-        if (!this.job.has(id)) {
-            throw new Error(`could not find job subject for id=${identifier}`);
-        }
-        return this.job.get(id);
-    }
-    removeJobSubject(idJob) {
-        const id = String(idJob);
-        if (!this.job.has(id)) {
-            this.logger.warn(`No subject found for idJob ${id}`);
-            return;
-        }
-        this.job.delete(id);
-    }
-    getJobSubject(idJob) {
-        const id = String(idJob);
-        if (!this.job.has(id)) {
-            this.logger.warn(`No subject found for idJob ${id}`);
-            return undefined;
-        }
-        return this.job.get(id);
-    }
-    get jobs() {
-        return this.job;
-    }
-}

package/dist/lib/esnext/message/MessageFactory.js

@@ -1,36 +0,0 @@
-import * as responses from './response';
-import * as updates from './update';
-export const FLAG_HAS_NEXT_CHUNK = 8;
-const message = { ...responses, ...updates };
-export class MessageFactory {
-    static createMessage(msg) {
-        if (!msg) {
-            throw new Error(`Could not create message because msg is "${msg}"`);
-        }
-        if (!msg.Message || typeof msg.Message !== 'string') {
-            throw new Error(`Could not create message because msg.Message is "${msg.Message}"`);
-        }
-        const separatorIdx = msg.Message.indexOf(MessageFactory.msgNameSeparator);
-        if (separatorIdx === -1) {
-            throw new Error(`Could not create message for invalid msg.Message "${msg.Message}"`);
-        }
-        if (!msg?.header) {
-            throw new Error(`Could not create message because the header is missing in the msg`);
-        }
-        try {
-            const className = msg.Message.substring(separatorIdx + MessageFactory.msgNameSeparatorLength);
-            if (message[className]) {
-                return new message[className](msg);
-            }
-            return new responses.Mdg2Response(msg);
-        }
-        catch (e) {
-            throw new Error(`Could not create message "${msg.Message}": ${e.message}`);
-        }
-    }
-    static hasNextChunk(msg) {
-        return ((msg.header?.flags ?? 0) & FLAG_HAS_NEXT_CHUNK) === FLAG_HAS_NEXT_CHUNK;
-    }
-}
-MessageFactory.msgNameSeparator = '::';
-MessageFactory.msgNameSeparatorLength = 2;

package/dist/lib/esnext/message/guards.js

@@ -1,21 +0,0 @@
-export function isErrorResponse(response) {
-    return response.name === 'Foundation::ErrorResponse';
-}
-export function isPermissionDeniedResponse(response) {
-    return response.name === 'Foundation::PermissionDeniedResponse';
-}
-export function isHighLevelResponse(response) {
-    return response.name === 'Foundation::HighLevelResponse';
-}
-export function isHighLevelResponseMessage(response) {
-    return response.Message === 'Foundation::HighLevelResponse';
-}
-export function isRejectResponse(response) {
-    return response.name === 'Foundation::RejectResponse';
-}
-export function isHighLevelUpdate(response) {
-    return response.name === 'Foundation::HighLevelUpdate';
-}
-export function isSubscriptionLossMessage(response) {
-    return response.name === 'Foundation::SubscriptionLossMessage';
-}

package/dist/lib/esnext/message/interfaces/JobObservable.js

@@ -1 +0,0 @@
-export {};