@factset/frontgate-js-sdk 7.0.0 → 7.0.2

package/dist/lib/node/mixins/subscription/EndpointSubscriptionMixin.js

@@ -12,23 +12,33 @@ const message_1 = require("../../message");
 const functions_1 = require("../../util/functions");
 const endpointSubscriptions = (originalConfig) => {
     const mixinEndpointSubscribable = (Base) => {
-        var _subscriptions, _a;
+        var _subscriptions, _subscriptionCounts, _inFlights, _a;
         const config = { ...originalConfig };
         return _a = class extends Base {
                 constructor() {
                     super(...arguments);
                     _subscriptions.set(this, new Map());
+                    _subscriptionCounts.set(this, new Map());
+                    _inFlights.set(this, new Map());
                 }
                 async observeEndpoint(method, path, data, requestOptions) {
                     const key = `${method}:${path}:${JSON.stringify(data)}:${JSON.stringify(requestOptions ?? {})}`;
+                    if (__classPrivateFieldGet(this, _inFlights, "f").has(key)) {
+                        const inFlightPromise = __classPrivateFieldGet(this, _inFlights, "f").get(key);
+                        this.log(logger_1.LogLevel.INFO, `Catching inflight subscription for ${key}`);
+                        const subscriptionCount = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                        __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subscriptionCount + 1);
+                        return inFlightPromise;
+                    }
                     const timeOutInMs = config.timeout ?? this.defaultTimeoutInMs;
                     const resubscribeTimeout = config.subscriptionResubscribeTimeout ?? 1000;
                     if (__classPrivateFieldGet(this, _subscriptions, "f").has(key)) {
                         const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
+                        const subscriptionCount = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
                         if (subscription) {
-                            subscription.count++;
+                            __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subscriptionCount + 1);
                             this.log(logger_1.LogLevel.INFO, `Reusing existing subscription for ${key}`);
-                            return subscription.observer;
+                            return subscription;
                         }
                     }
                     this.log(logger_1.LogLevel.INFO, `Creating new subscription for ${key}`);
@@ -39,153 +49,170 @@ const endpointSubscriptions = (originalConfig) => {
                         callbackType: 'job',
                         callbackId: '',
                     };
-                    await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
                     const promise = new Promise((resolve, reject) => {
-                        this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (response) => {
-                            if (!response.Message.includes('HighLevelResponse')) {
-                                this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${response.Message}`);
-                                reject(new message_1.ErrorResponse(JSON.stringify(response)));
-                                return;
-                            }
-                            let hlResponseData;
-                            try {
-                                hlResponseData = JSON.parse(response.body.value);
-                            }
-                            catch (e) {
-                                this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${response.body.value}`);
-                                this.log(logger_1.LogLevel.ERROR, e);
-                                reject(e);
-                                return;
-                            }
-                            const observer = new __1.FrontgateClientEndpointDataObserver(response.header.id_job, hlResponseData);
-                            let removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (update) => {
-                                if (!update.Message.includes('HighLevelUpdate')) {
-                                    if (update.Message.includes('SubscriptionLoss')) {
-                                        this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
-                                        setTimeout(() => {
-                                            void resubscribe();
-                                        }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
-                                        removeMessageUpdateHook();
-                                        return;
-                                    }
+                        this.hooks
+                            .callHook('frontgateConnection:sendMessage', subscriptionMsg)
+                            .then(() => {
+                            this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (response) => {
+                                if (!response.Message.includes('HighLevelResponse')) {
                                     this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${response.Message}`);
-                                    observer.pushError(new message_1.ErrorResponse(JSON.stringify(update)));
-                                    removeMessageUpdateHook();
+                                    reject(new message_1.ErrorResponse(JSON.stringify(response)));
                                     return;
                                 }
-                                let hlUpdate;
+                                let hlResponseData;
                                 try {
-                                    hlUpdate = new message_1.HighLevelUpdate(update);
+                                    hlResponseData = JSON.parse(response.body.value);
                                 }
                                 catch (e) {
-                                    this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
-                                    observer.pushError(e);
+                                    this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${response.body.value}`);
+                                    this.log(logger_1.LogLevel.ERROR, e);
+                                    reject(e);
                                     return;
                                 }
-                                observer.pushPatchData(hlUpdate.data);
-                            });
-                            const resubscribe = async () => {
-                                removeMessageUpdateHook();
-                                this.log(logger_1.LogLevel.INFO, `Resubscribing to ${key} due to reconnect`);
-                                await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
-                                const resubscribePromise = new Promise((res, rej) => {
-                                    this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (resp) => {
-                                        if (!response.Message.includes('HighLevelResponse')) {
-                                            const err = new message_1.ErrorResponse(resp);
-                                            this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${resp.Message}`);
+                                const observer = new __1.FrontgateClientEndpointDataObserver(response.header.id_job, hlResponseData);
+                                let removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (update) => {
+                                    if (!update.Message.includes('HighLevelUpdate')) {
+                                        if (update.Message.includes('SubscriptionLoss')) {
+                                            this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
+                                            setTimeout(() => {
+                                                void resubscribe();
+                                            }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
                                             removeMessageUpdateHook();
-                                            rej(err);
                                             return;
                                         }
-                                        this.log(logger_1.LogLevel.INFO, `Resubscribed to ${key} with ${resp.header.id_job}`);
-                                        observer.idJob = resp.header.id_job;
-                                        removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resp.header.id_job}`, (update) => {
-                                            if (!update.Message.includes('HighLevelUpdate')) {
-                                                if (update.Message.includes('SubscriptionLoss')) {
-                                                    this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
-                                                    setTimeout(() => {
-                                                        void resubscribe();
-                                                    }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
-                                                    return;
-                                                }
-                                                this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${update.Message}`);
-                                                const err = new message_1.ErrorResponse(update);
-                                                observer.pushError(err);
-                                                return;
-                                            }
-                                            let hlUpdate;
-                                            try {
-                                                hlUpdate = new message_1.HighLevelUpdate(update);
-                                            }
-                                            catch (e) {
-                                                this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
-                                                observer.pushError(e);
+                                        this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${response.Message}`);
+                                        observer.pushError(new message_1.ErrorResponse(JSON.stringify(update)));
+                                        removeMessageUpdateHook();
+                                        return;
+                                    }
+                                    let hlUpdate;
+                                    try {
+                                        hlUpdate = new message_1.HighLevelUpdate(update);
+                                    }
+                                    catch (e) {
+                                        this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
+                                        observer.pushError(e);
+                                        return;
+                                    }
+                                    observer.pushPatchData(hlUpdate.data);
+                                });
+                                const resubscribe = async () => {
+                                    removeMessageUpdateHook();
+                                    this.log(logger_1.LogLevel.INFO, `Resubscribing to ${key} due to reconnect`);
+                                    await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
+                                    const resubscribePromise = new Promise((res, rej) => {
+                                        this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (resp) => {
+                                            if (!response.Message.includes('HighLevelResponse')) {
+                                                const err = new message_1.ErrorResponse(resp);
+                                                this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${resp.Message}`);
+                                                removeMessageUpdateHook();
+                                                rej(err);
                                                 return;
                                             }
-                                            observer.unsubscribe = () => {
-                                                const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
-                                                if (subscription) {
-                                                    subscription.count--;
-                                                    if (subscription.count > 0) {
-                                                        this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subscription.count} subscribers`);
+                                            this.log(logger_1.LogLevel.INFO, `Resubscribed to ${key} with ${resp.header.id_job}`);
+                                            observer.idJob = resp.header.id_job;
+                                            removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resp.header.id_job}`, (update) => {
+                                                if (!update.Message.includes('HighLevelUpdate')) {
+                                                    if (update.Message.includes('SubscriptionLoss')) {
+                                                        this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
+                                                        setTimeout(() => {
+                                                            void resubscribe();
+                                                        }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
                                                         return;
                                                     }
-                                                    __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
+                                                    this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${update.Message}`);
+                                                    const err = new message_1.ErrorResponse(update);
+                                                    observer.pushError(err);
+                                                    return;
+                                                }
+                                                let hlUpdate;
+                                                try {
+                                                    hlUpdate = new message_1.HighLevelUpdate(update);
                                                 }
-                                                this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
-                                                const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
-                                                const unsubscribeMsg = {
-                                                    message: cancelationRequest.getPtlMessage(),
-                                                    callbackType: 'job',
-                                                    callbackId: '',
+                                                catch (e) {
+                                                    this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
+                                                    observer.pushError(e);
+                                                    return;
+                                                }
+                                                observer.unsubscribe = () => {
+                                                    const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
+                                                    if (subscription) {
+                                                        const subcounts = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subcounts - 1);
+                                                        if (subcounts - 1 > 0) {
+                                                            this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subcounts} subscribers`);
+                                                            return;
+                                                        }
+                                                        __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
+                                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").delete(key);
+                                                    }
+                                                    this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
+                                                    const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
+                                                    const unsubscribeMsg = {
+                                                        message: cancelationRequest.getPtlMessage(),
+                                                        callbackType: 'job',
+                                                        callbackId: '',
+                                                    };
+                                                    void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
+                                                    removeMessageUpdateHook();
+                                                    removeReconnectHook();
                                                 };
-                                                void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
-                                                removeMessageUpdateHook();
-                                                removeReconnectHook();
-                                            };
-                                            observer.pushPatchData(hlUpdate.data);
+                                                observer.pushPatchData(hlUpdate.data);
+                                            });
+                                            res();
                                         });
-                                        res();
                                     });
-                                });
-                                try {
-                                    await (0, functions_1.useTimeout)(timeOutInMs, 'Request timeout reached', resubscribePromise);
-                                }
-                                catch (e) {
-                                    observer.pushError(new message_1.ErrorResponse({ Message: 'Reconnect failed', Error: e }));
-                                }
-                            };
-                            const removeReconnectHook = this.hooks.hook('reconnect:success', resubscribe);
-                            observer.unsubscribe = () => {
-                                const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
-                                if (subscription) {
-                                    subscription.count--;
-                                    if (subscription.count > 0) {
-                                        this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subscription.count} subscribers`);
-                                        return;
+                                    try {
+                                        await (0, functions_1.useTimeout)(timeOutInMs, 'Request timeout reached', resubscribePromise);
                                     }
-                                    __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
-                                }
-                                this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
-                                const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
-                                const unsubscribeMsg = {
-                                    message: cancelationRequest.getPtlMessage(),
-                                    callbackType: 'job',
-                                    callbackId: '',
+                                    catch (e) {
+                                        observer.pushError(new message_1.ErrorResponse({ Message: 'Reconnect failed', Error: e }));
+                                    }
+                                };
+                                const removeReconnectHook = this.hooks.hook('reconnect:success', resubscribe);
+                                observer.unsubscribe = () => {
+                                    const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
+                                    if (subscription) {
+                                        const subcounts = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subcounts - 1);
+                                        if (subcounts - 1 > 0) {
+                                            this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subcounts} subscribers`);
+                                            return;
+                                        }
+                                        __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
+                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").delete(key);
+                                    }
+                                    this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
+                                    const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
+                                    const unsubscribeMsg = {
+                                        message: cancelationRequest.getPtlMessage(),
+                                        callbackType: 'job',
+                                        callbackId: '',
+                                    };
+                                    void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
+                                    removeMessageUpdateHook();
+                                    removeReconnectHook();
                                 };
-                                void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
-                                removeMessageUpdateHook();
-                                removeReconnectHook();
-                            };
-                            __classPrivateFieldGet(this, _subscriptions, "f").set(key, { observer, count: 1 });
-                            resolve(observer);
+                                __classPrivateFieldGet(this, _subscriptions, "f").set(key, observer);
+                                const currentSubscounts = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                                __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, currentSubscounts + 1);
+                                __classPrivateFieldGet(this, _inFlights, "f").delete(key);
+                                resolve(observer);
+                            });
+                        })
+                            .catch((e) => {
+                            reject(e);
                         });
                     });
                     const rejectReason = `Request timeout reached (${timeOutInMs} ms) for ${subscriptionMsg.message.Message}`;
-                    return (0, functions_1.useTimeout)(timeOutInMs, rejectReason, promise);
+                    const wrappedTimeoutPromise = (0, functions_1.useTimeout)(timeOutInMs, rejectReason, promise);
+                    __classPrivateFieldGet(this, _inFlights, "f").set(key, wrappedTimeoutPromise);
+                    return wrappedTimeoutPromise;
                 }
             },
             _subscriptions = new WeakMap(),
+            _subscriptionCounts = new WeakMap(),
+            _inFlights = new WeakMap(),
             _a;
     };
     return (0, __1.createExtendedMixinFactory)(mixinEndpointSubscribable, {
@@ -194,4 +221,3 @@ const endpointSubscriptions = (originalConfig) => {
     });
 };
 exports.endpointSubscriptions = endpointSubscriptions;
-//# sourceMappingURL=EndpointSubscriptionMixin.js.map

package/dist/lib/node/mixins/subscription/RawSubscriptionMixin.js

@@ -71,19 +71,19 @@ const rawSubscriptions = () => {
                             this.log(logger_1.LogLevel.INFO, `Resubscribing to ${key} due to reconnect`);
                             await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
                             const resubscribePromise = new Promise((res, rej) => {
-                                this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (response) => {
-                                    if (response.Message.includes('Error') || response.Message.includes('PermissionDenied')) {
-                                        const err = new message_1.ErrorResponse(response);
-                                        this.log(logger_1.LogLevel.ERROR, `Unexpected resp: ${response.Message}`);
+                                this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (resubscribeResponse) => {
+                                    if (resubscribeResponse.Message.includes('Error') || resubscribeResponse.Message.includes('PermissionDenied')) {
+                                        const err = new message_1.ErrorResponse(resubscribeResponse);
+                                        this.log(logger_1.LogLevel.ERROR, `Unexpected resp: ${resubscribeResponse.Message}`);
                                         rej(err);
                                         return;
                                     }
-                                    const subscriptionKey = subscriptionType === 'connection' ? `${response.header.id_service}-${request.getPtlMessage().id_notation}` : response.header.id_job;
-                                    const cancelationRequest = typeof CancelationRequestConstructor === 'undefined'
-                                        ? new message_1.CancelSubscriptionRequest(response.header.id_job)
-                                        : new CancelationRequestConstructor(response.header.id_service, request.getPtlMessage().id_notation);
-                                    observer.idJob = response.header.id_job;
-                                    removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${subscriptionKey}`, (update) => {
+                                    const resubscriptionKey = subscriptionType === 'connection' ? `${resubscribeResponse.header.id_service}-${request.getPtlMessage().id_notation}` : resubscribeResponse.header.id_job;
+                                    const resubscriptionCancelationRequest = typeof CancelationRequestConstructor === 'undefined'
+                                        ? new message_1.CancelSubscriptionRequest(resubscribeResponse.header.id_job)
+                                        : new CancelationRequestConstructor(resubscribeResponse.header.id_service, request.getPtlMessage().id_notation);
+                                    observer.idJob = resubscribeResponse.header.id_job;
+                                    removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resubscriptionKey}`, (update) => {
                                         if (update.Message.includes('Error') || update.Message.includes('PermissionDenied')) {
                                             this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${update.Message}`);
                                             const err = new message_1.ErrorResponse(update);
@@ -102,7 +102,7 @@ const rawSubscriptions = () => {
                                             }
                                             this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
                                             const unsubscribeMsg = {
-                                                message: cancelationRequest.getPtlMessage(),
+                                                message: resubscriptionCancelationRequest.getPtlMessage(),
                                                 callbackType: 'job',
                                                 callbackId: '',
                                             };
@@ -157,4 +157,3 @@ const rawSubscriptions = () => {
     });
 };
 exports.rawSubscriptions = rawSubscriptions;
-//# sourceMappingURL=RawSubscriptionMixin.js.map

package/dist/lib/node/mixins/subscription/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./EndpointSubscriptionMixin"), exports);
 __exportStar(require("./RawSubscriptionMixin"), exports);
 __exportStar(require("./DataObserver"), exports);
-//# sourceMappingURL=index.js.map

package/dist/lib/node/util/functions.js

@@ -18,11 +18,11 @@ function getUuid2() {
 function getClientInformation() {
     const navigator = getNavigator();
     return {
-        userAgent: navigator.userAgent,
-        platform: navigator.platform,
+        userAgent: navigator.userAgent ?? 'unknown',
+        platform: 'frontgate-js-sdk',
         version: version_1.PACKAGE_JSON.version,
         package: version_1.PACKAGE_JSON.package,
-        mobile: /Mobi/i.test(navigator.userAgent),
+        mobile: /Mobi/i.test(navigator.userAgent ?? 'unknown'),
     };
 }
 function getNavigator() {
@@ -32,10 +32,9 @@ function getNavigator() {
     if (typeof process !== 'undefined') {
         return {
             userAgent: `node.js/io.js, ${process.version}`,
-            platform: `${process.platform}_${process.arch}`,
         };
     }
-    return { userAgent: 'unknown', platform: 'unknown' };
+    return { userAgent: 'unknown' };
 }
 const encodeSpanContext = (spanContext) => {
     const buffer = [18, 20, 9];
@@ -72,4 +71,3 @@ const addRandomnessToTime = (time) => {
     return time + Math.random() * 100;
 };
 exports.addRandomnessToTime = addRandomnessToTime;
-//# sourceMappingURL=functions.js.map

package/dist/lib/node/version.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_JSON = void 0;
-exports.PACKAGE_JSON = { version: '7.0.0', package: '@factset/frontgate-js-sdk' };
-//# sourceMappingURL=version.js.map
+exports.PACKAGE_JSON = { version: '7.0.2', package: '@factset/frontgate-js-sdk' };

package/dist/lib/types/mixins/AuthTokenRequestMixin.d.ts

@@ -18,8 +18,8 @@ export declare const authTokenRequest: () => (<T extends AConstructorTypeOf<Fron
         requestAuthenticationTokenForCookieTokenAuthentication(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<CookieTokenAuthenticationFactors>;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/EndpointRequestMixin.d.ts

@@ -13,11 +13,11 @@ export interface EndpointRequestMixinOptions {
 export declare const endpointRequest: (config?: EndpointRequestMixinOptions) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointRequest & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
         requestEndpoint<ResponseData = any>(method: HighLevelRequestMethod, path: string, data?: Record<string, unknown>, options?: HighLevelRequestOptions, timeOutInMs?: number): Promise<HighLevelRequestResult<ResponseData>>;
-        "__#1@#hasNextChunk"(msg: PtlMessage): boolean;
+        "__#private@#hasNextChunk"(msg: PtlMessage): boolean;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/HTTPProxyRequestMixin.d.ts

@@ -12,8 +12,8 @@ export declare const httpProxyRequest: () => (<T extends AConstructorTypeOf<Fron
         requestProxyEndpoint(method: HTTPMethod, path: string, body?: HTTPProxyRequestBody, options?: HTTPProxyRequestOptions, timeOutInMs?: number): Promise<HTTPProxyRequestResult>;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/LoggerMixin.d.ts

@@ -1,12 +1,12 @@
 import { type AConstructorTypeOf } from '.';
 import type { FrontgateClient } from '../FrontgateClient';
 import type { LogLevel, LoggerInterface } from '../logger';
-export declare const logger: (logger: LoggerInterface, logLevel?: LogLevel) => (<T extends AConstructorTypeOf<FrontgateClient>>(Base: T) => {
+export declare const logger: (loggerInstance: LoggerInterface, logLevel?: LogLevel) => (<T extends AConstructorTypeOf<FrontgateClient>>(Base: T) => {
     new (...args: any[]): {
         logger: LoggerInterface | undefined;
         hooks: import("hookable").Hookable<import("../FrontgateClient").CalledHooksByBase, "base:log">;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/MessageCompressorMixin.d.ts

@@ -4,11 +4,11 @@ import { Compressor } from '../connection/util/Compressor';
 export type usedHooksByMessageCompressor = CalledHooksByConnection;
 export declare const messageCompressor: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByMessageCompressor & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        readonly "__#3@#compressor": Compressor;
+        readonly "__#private@#compressor": Compressor;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/OpenTelemetryMixin.d.ts

@@ -3,7 +3,7 @@ import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
 export declare const openTelemetry: () => (<T extends AConstructorTypeOf<FrontgateClient<CalledHooksByConnection & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        "__#10@#createSpanHeader"(tracing: SpanContext): {
+        "__#private@#createSpanHeader"(tracing: SpanContext): {
             tracing: {
                 value: {
                     value: number[];
@@ -12,8 +12,8 @@ export declare const openTelemetry: () => (<T extends AConstructorTypeOf<Frontga
         } | undefined;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/PingMixin.d.ts

@@ -10,8 +10,8 @@ export declare const pingRequests: () => (<T extends AConstructorTypeOf<Frontgat
         ping(timeOutInMs?: number): Promise<PingResponse>;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/ReconnectMixin.d.ts

@@ -10,13 +10,13 @@ export interface CalledHooksByReconnect {
 }
 export declare const reconnect: (reconnectDelaysInMs?: number[]) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByReconnect & CalledHooksByReconnect & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        "__#9@#reconnectAttempts": number;
-        readonly "__#9@#reconnectDelays": number[];
-        "__#9@#reconnectTimer": NodeJS.Timeout | undefined;
+        "__#private@#reconnectAttempts": number;
+        readonly "__#private@#reconnectDelays": number[];
+        "__#private@#reconnectTimer": NodeJS.Timeout | undefined;
         logger: import("../logger").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByReconnect & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByReconnect & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/RemoteLoggerMixin.d.ts

@@ -9,8 +9,8 @@ export declare const remotelogger: (identifier?: number) => (<T extends AConstru
         logRemotely(message: string): Promise<any>;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/RequestMixin.d.ts

@@ -10,8 +10,8 @@ export declare const requests: () => (<T extends AConstructorTypeOf<FrontgateCli
         request(request: AbstractMdg2Request, timeOutInMs?: number): Promise<Mdg2Response>;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#11@#defaultTimeoutInMs": number;
-        readonly defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;