@venizia/ignis-helpers 0.0.1-2 → 0.0.1-4

package/dist/helpers/network/http-request/fetcher/axios-fetcher.js

@@ -11,16 +11,16 @@ const base_fetcher_1 = require("./base-fetcher");
 // -------------------------------------------------------------
 class AxiosFetcher extends base_fetcher_1.AbstractNetworkFetchableHelper {
     constructor(opts) {
-        super({ name: opts.name, variant: "axios" });
+        super({ name: opts.name, variant: 'axios' });
         const { defaultConfigs } = opts;
-        opts?.logger?.info("Creating new network request worker instance! Name: %s", this.name);
+        opts?.logger?.info('Creating new network request worker instance! Name: %s', this.name);
         this.worker = axios_1.default.create({ ...defaultConfigs });
     }
     // -------------------------------------------------------------
     // SEND REQUEST
     // -------------------------------------------------------------
     send(opts, logger) {
-        const { url, method = "get", params = {}, body: data, headers, ...rest } = opts;
+        const { url, method = 'get', params = {}, body: data, headers, ...rest } = opts;
         const props = {
             url,
             method,
@@ -31,12 +31,12 @@ class AxiosFetcher extends base_fetcher_1.AbstractNetworkFetchableHelper {
             ...rest,
         };
         const protocol = this.getProtocol(url);
-        if (protocol === "https") {
+        if (protocol === 'https') {
             props.httpsAgent = new node_https_1.default.Agent({
                 rejectUnauthorized: false,
             });
         }
-        logger?.info("[send] URL: %s | Props: %o", url, props);
+        logger?.info('[send] URL: %s | Props: %o', url, props);
         return this.worker.request(props);
     }
 }

package/dist/helpers/network/http-request/fetcher/base-fetcher.d.ts

@@ -1,4 +1,4 @@
-import { TFetcherResponse, TFetcherVariant, TFetcherWorker } from "../types";
+import { TFetcherResponse, TFetcherVariant, TFetcherWorker } from '../types';
 export interface IRequestOptions {
     url: string;
     params?: Record<string | symbol, any>;

package/dist/helpers/network/http-request/fetcher/base-fetcher.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractNetworkFetchableHelper = void 0;
-const HTTP = "http";
-const HTTPS = "https";
+const HTTP = 'http';
+const HTTPS = 'https';
 class AbstractNetworkFetchableHelper {
     constructor(opts) {
         this.name = opts.name;
         this.variant = opts.variant;
     }
     getProtocol(url) {
-        return url.startsWith("http:") ? HTTP : HTTPS;
+        return url.startsWith('http:') ? HTTP : HTTPS;
     }
     getWorker() {
         return this.worker;
@@ -19,35 +19,35 @@ class AbstractNetworkFetchableHelper {
     // -------------------------------------------------------------
     get(opts, logger) {
         const { ...rest } = opts;
-        return this.send({ ...rest, method: "get" }, logger);
+        return this.send({ ...rest, method: 'get' }, logger);
     }
     // -------------------------------------------------------------
     // POST REQUEST
     // -------------------------------------------------------------
     post(opts, logger) {
         const { ...rest } = opts;
-        return this.send({ ...rest, method: "post" }, logger);
+        return this.send({ ...rest, method: 'post' }, logger);
     }
     // -------------------------------------------------------------
     // PUT REQUEST
     // -------------------------------------------------------------
     put(opts, logger) {
         const { ...rest } = opts;
-        return this.send({ ...rest, method: "put" }, logger);
+        return this.send({ ...rest, method: 'put' }, logger);
     }
     // -------------------------------------------------------------
     // PATCH REQUEST
     // -------------------------------------------------------------
     patch(opts, logger) {
         const { ...rest } = opts;
-        return this.send({ ...rest, method: "patch" }, logger);
+        return this.send({ ...rest, method: 'patch' }, logger);
     }
     // -------------------------------------------------------------
     // DELETE REQUEST
     // -------------------------------------------------------------
     delete(opts, logger) {
         const { ...rest } = opts;
-        return this.send({ ...rest, method: "delete" }, logger);
+        return this.send({ ...rest, method: 'delete' }, logger);
     }
 }
 exports.AbstractNetworkFetchableHelper = AbstractNetworkFetchableHelper;

package/dist/helpers/network/http-request/fetcher/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./axios-fetcher";
-export * from "./base-fetcher";
-export * from "./node-fetcher";
+export * from './axios-fetcher';
+export * from './base-fetcher';
+export * from './node-fetcher';
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/network/http-request/fetcher/node-fetcher.d.ts

@@ -1,9 +1,9 @@
-import { AbstractNetworkFetchableHelper, IRequestOptions } from "./base-fetcher";
+import { AbstractNetworkFetchableHelper, IRequestOptions } from './base-fetcher';
 export interface INodeFetchRequestOptions extends RequestInit, IRequestOptions {
     url: string;
     params?: Record<string | symbol, any>;
 }
-export declare class NodeFetcher extends AbstractNetworkFetchableHelper<"node-fetch", INodeFetchRequestOptions, Awaited<ReturnType<typeof fetch>>> {
+export declare class NodeFetcher extends AbstractNetworkFetchableHelper<'node-fetch', INodeFetchRequestOptions, Awaited<ReturnType<typeof fetch>>> {
     private defaultConfigs;
     constructor(opts: {
         name: string;

package/dist/helpers/network/http-request/fetcher/node-fetcher.js

@@ -6,17 +6,17 @@ const base_fetcher_1 = require("./base-fetcher");
 // -------------------------------------------------------------
 class NodeFetcher extends base_fetcher_1.AbstractNetworkFetchableHelper {
     constructor(opts) {
-        super({ name: opts.name, variant: "node-fetch" });
+        super({ name: opts.name, variant: 'node-fetch' });
         const { name, defaultConfigs } = opts;
         this.name = name;
-        opts?.logger?.info("Creating new network request worker instance! Name: %s", this.name);
+        opts?.logger?.info('Creating new network request worker instance! Name: %s', this.name);
         this.defaultConfigs = defaultConfigs;
     }
     // -------------------------------------------------------------
     // SEND REQUEST
     // -------------------------------------------------------------
     async send(opts, logger) {
-        const { url, method = "get", params, body, headers, timeout, signal, ...rest } = opts;
+        const { url, method = 'get', params, body, headers, timeout, signal, ...rest } = opts;
         let timeoutId;
         let abortController;
         if (timeout) {
@@ -33,16 +33,16 @@ class NodeFetcher extends base_fetcher_1.AbstractNetworkFetchableHelper {
             headers,
             signal: abortController?.signal ?? signal,
         };
-        let requestUrl = "";
+        let requestUrl = '';
         const urlParts = [url];
         if (params) {
             urlParts.push((0, node_querystring_1.stringify)(params));
-            requestUrl = urlParts.join("?");
+            requestUrl = urlParts.join('?');
         }
         else {
             requestUrl = urlParts.join();
         }
-        logger?.info("[send] URL: %s | Props: %o | Timeout: %s", url, requestConfigs, timeout);
+        logger?.info('[send] URL: %s | Props: %o | Timeout: %s', url, requestConfigs, timeout);
         try {
             return await fetch(requestUrl, requestConfigs);
         }

package/dist/helpers/network/http-request/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./fetcher/";
-export * from "./base-network-request.helper";
+export * from './fetcher/';
+export * from './base-network-request.helper';
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/network/http-request/types.d.ts

@@ -1,5 +1,5 @@
-import { AxiosInstance, AxiosResponse } from "axios";
-export type TFetcherVariant = "node-fetch" | "axios";
-export type TFetcherResponse<T extends TFetcherVariant> = T extends "node-fetch" ? Response : AxiosResponse;
-export type TFetcherWorker<T extends TFetcherVariant> = T extends "axios" ? AxiosInstance : typeof fetch;
+import { AxiosInstance, AxiosResponse } from 'axios';
+export type TFetcherVariant = 'node-fetch' | 'axios';
+export type TFetcherResponse<T extends TFetcherVariant> = T extends 'node-fetch' ? Response : AxiosResponse;
+export type TFetcherWorker<T extends TFetcherVariant> = T extends 'axios' ? AxiosInstance : typeof fetch;
 //# sourceMappingURL=types.d.ts.map

package/dist/helpers/network/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./http-request";
-export * from "./tcp-socket";
-export * from "./udp-socket";
+export * from './http-request';
+export * from './tcp-socket';
+export * from './udp-socket';
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/network/tcp-socket/base-tcp-client.helper.d.ts

@@ -1,7 +1,7 @@
-import { BaseHelper } from "../../../helpers/base";
-import { ValueOrPromise } from "../../../common";
-import { TcpSocketConnectOpts as PlainConnectionOptions, Socket as PlainSocketClient } from "node:net";
-import { ConnectionOptions as TlsConnectionOptions, TLSSocket as TlsSocketClient } from "node:tls";
+import { BaseHelper } from '../../../helpers/base';
+import { ValueOrPromise } from '../../../common';
+import { TcpSocketConnectOpts as PlainConnectionOptions, Socket as PlainSocketClient } from 'node:net';
+import { ConnectionOptions as TlsConnectionOptions, TLSSocket as TlsSocketClient } from 'node:tls';
 export interface INetworkTcpClientProps<SocketClientOptions extends PlainConnectionOptions | TlsConnectionOptions, SocketClientType extends PlainSocketClient | TlsSocketClient> {
     identifier: string;
     scope?: string;

package/dist/helpers/network/tcp-socket/base-tcp-client.helper.js

@@ -34,41 +34,41 @@ class BaseNetworkTcpClient extends base_1.BaseHelper {
         return this.client;
     }
     handleConnected() {
-        this.logger.info("[handleConnected][%s] Connected to TCP Server | Options: %j", this.identifier, this.options);
+        this.logger.info('[handleConnected][%s] Connected to TCP Server | Options: %j', this.identifier, this.options);
         this.retry.currentReconnect = 0;
     }
     handleData(_opts) { }
     handleClosed() {
-        this.logger.info("[handleClosed][%s] Closed connection TCP Server | Options: %j", this.identifier, this.options);
+        this.logger.info('[handleClosed][%s] Closed connection TCP Server | Options: %j', this.identifier, this.options);
     }
     handleError(error) {
-        this.logger.error("[handleError][%s] Connection error | Options: %j | Error: %s", this.identifier, this.options, error);
+        this.logger.error('[handleError][%s] Connection error | Options: %j | Error: %s', this.identifier, this.options, error);
         if (!this.reconnect || this.retry.currentReconnect >= this.retry.maxReconnect) {
             return;
         }
         const { currentReconnect, maxReconnect } = this.retry;
         if (maxReconnect > -1 && currentReconnect >= maxReconnect) {
-            this.logger.info("[handleData] Exceeded max retry to reconnect! Max: %d | Current: %d", maxReconnect, currentReconnect);
+            this.logger.info('[handleData] Exceeded max retry to reconnect! Max: %d | Current: %d', maxReconnect, currentReconnect);
             return;
         }
         this.reconnectTimeout = setTimeout(() => {
             this.client?.destroy();
             this.client = null;
-            this.logger.info("[handleClosed][%s] Retrying to establish TCP Connection | Options: %j", this.identifier, this.options);
+            this.logger.info('[handleClosed][%s] Retrying to establish TCP Connection | Options: %j', this.identifier, this.options);
             this.connect({ resetReconnectCounter: false });
             this.retry.currentReconnect++;
         }, 5000);
     }
     connect(opts) {
         if (this.isConnected()) {
-            this.logger.info("[connect][%s] NetworkTcpClient is already initialized!", this.identifier);
+            this.logger.info('[connect][%s] NetworkTcpClient is already initialized!', this.identifier);
             return;
         }
         if ((0, isEmpty_1.default)(this.options)) {
-            this.logger.info("[connect][%s] Cannot init TCP Client with null options", this.identifier);
+            this.logger.info('[connect][%s] Cannot init TCP Client with null options', this.identifier);
             return;
         }
-        this.logger.info("[connect][%s] New network tcp client | Options: %s", this.identifier, this.options);
+        this.logger.info('[connect][%s] New network tcp client | Options: %s', this.identifier, this.options);
         if (opts?.resetReconnectCounter) {
             this.retry.currentReconnect = 0;
         }
@@ -78,7 +78,7 @@ class BaseNetworkTcpClient extends base_1.BaseHelper {
         }
         this.client = this.createClientFn(this.options, () => {
             if (!this.client) {
-                this.logger.error("[createClientFn] Failed to initialize socket client!");
+                this.logger.error('[createClientFn] Failed to initialize socket client!');
                 return;
             }
             this.onConnected?.({ client: this.client });
@@ -86,45 +86,45 @@ class BaseNetworkTcpClient extends base_1.BaseHelper {
         if (this.encoding) {
             this.client.setEncoding(this.encoding);
         }
-        this.client.on("data", (message) => {
+        this.client.on('data', (message) => {
             this.onData({ identifier: this.identifier, message });
         });
-        this.client.on("close", () => {
+        this.client.on('close', () => {
             if (!this.client) {
                 return;
             }
             this.onClosed?.({ client: this.client });
         });
-        this.client.on("error", error => {
+        this.client.on('error', error => {
             this.onError?.(error);
         });
     }
     disconnect() {
         if (!this.client) {
-            this.logger.info("[disconnect][%s] NetworkTcpClient is not initialized yet!", this.identifier);
+            this.logger.info('[disconnect][%s] NetworkTcpClient is not initialized yet!', this.identifier);
             return;
         }
         this.client?.destroy();
         this.client = null;
         clearTimeout(this.reconnectTimeout);
         this.reconnectTimeout = null;
-        this.logger.info("[disconnect][%s] NetworkTcpClient is destroyed!", this.identifier);
+        this.logger.info('[disconnect][%s] NetworkTcpClient is destroyed!', this.identifier);
     }
     forceReconnect() {
         this.disconnect();
         this.connect({ resetReconnectCounter: true });
     }
     isConnected() {
-        return this.client && this.client.readyState !== "closed";
+        return this.client && this.client.readyState !== 'closed';
     }
     emit(opts) {
         if (!this.client) {
-            this.logger.info("[emit][%s] TPC Client is not configured yet!", this.identifier);
+            this.logger.info('[emit][%s] TPC Client is not configured yet!', this.identifier);
             return;
         }
         const { payload } = opts;
         if (!payload?.length) {
-            this.logger.info("[emit][%s] Invalid payload to write to TCP Socket!", this.identifier);
+            this.logger.info('[emit][%s] Invalid payload to write to TCP Socket!', this.identifier);
             return;
         }
         this.client.write(payload);

package/dist/helpers/network/tcp-socket/base-tcp-server.helper.d.ts

@@ -1,11 +1,11 @@
-import { BaseHelper } from "../../../helpers/base";
-import { ValueOrPromise } from "../../../common/types";
-import { dayjs } from "../../../utilities/date.utility";
-import { ListenOptions, ServerOpts, Socket as SocketClient, Server as SocketServer } from "node:net";
+import { BaseHelper } from '../../../helpers/base';
+import { ValueOrPromise } from '../../../common/types';
+import { dayjs } from '../../../utilities/date.utility';
+import { ListenOptions, ServerOpts, Socket as SocketClient, Server as SocketServer } from 'node:net';
 export interface ITcpSocketClient<SocketClientType> {
     id: string;
     socket: SocketClientType;
-    state: "unauthorized" | "authenticating" | "authenticated";
+    state: 'unauthorized' | 'authenticating' | 'authenticated';
     subscriptions: Set<string>;
     storage: {
         connectedAt: dayjs.Dayjs;
@@ -98,7 +98,7 @@ export declare class BaseNetworkTcpServer<SocketServerOptions extends ServerOpts
     getServer(): SocketServerType;
     doAuthenticate(opts: {
         id: string;
-        state: "unauthorized" | "authenticating" | "authenticated";
+        state: 'unauthorized' | 'authenticating' | 'authenticated';
     }): void;
     emit(opts: {
         clientId: string;

package/dist/helpers/network/tcp-socket/base-tcp-server.helper.js

@@ -24,7 +24,7 @@ class BaseNetworkTcpServer extends base_1.BaseHelper {
         if (this.authenticateOptions.required &&
             (!this.authenticateOptions.duration || this.authenticateOptions.duration < 0)) {
             throw (0, error_1.getError)({
-                message: "TCP Server | Invalid authenticate duration | Required duration for authenticateOptions",
+                message: 'TCP Server | Invalid authenticate duration | Required duration for authenticateOptions',
             });
         }
         this.extraEvents = opts.extraEvents ?? {};
@@ -40,23 +40,23 @@ class BaseNetworkTcpServer extends base_1.BaseHelper {
             this.onNewConnection({ socket });
         });
         this.server.listen(this.listenOptions, () => {
-            this.logger.info("[configure] TCP Socket Server is now listening | Options: %j", this.listenOptions);
+            this.logger.info('[configure] TCP Socket Server is now listening | Options: %j', this.listenOptions);
             this.onServerReady?.({ server: this.server });
         });
     }
     onNewConnection(opts) {
         const { socket } = opts;
         const id = (0, parse_utility_1.getUID)();
-        socket.on("data", (data) => {
+        socket.on('data', (data) => {
             this.onClientData?.({ id, socket, data });
         });
-        socket.on("error", (error) => {
-            this.logger.error("[onClientConnect][error] ID: %s | Error: %s", id, error);
+        socket.on('error', (error) => {
+            this.logger.error('[onClientConnect][error] ID: %s | Error: %s', id, error);
             this.onClientError?.({ id, socket, error });
             socket.end();
         });
-        socket.on("close", (hasError) => {
-            this.logger.info("[onClientConnect][close] ID: %s | hasError: %s", id, hasError);
+        socket.on('close', (hasError) => {
+            this.logger.info('[onClientConnect][close] ID: %s | hasError: %s', id, hasError);
             this.onClientClose?.({ id, socket });
             this.clients = (0, omit_1.default)(this.clients, [id]);
         });
@@ -68,14 +68,14 @@ class BaseNetworkTcpServer extends base_1.BaseHelper {
         this.clients[id] = {
             id,
             socket,
-            state: this.authenticateOptions.required ? "unauthorized" : "authenticated",
+            state: this.authenticateOptions.required ? 'unauthorized' : 'authenticated',
             subscriptions: new Set([]),
             storage: {
                 connectedAt: (0, date_utility_1.dayjs)(),
                 authenticatedAt: this.authenticateOptions.required ? null : (0, date_utility_1.dayjs)(),
             },
         };
-        this.logger.info("[onClientConnect] New TCP SocketClient | Client: %s | authenticateOptions: %s %s", `${id} - ${socket.remoteAddress} - ${socket.remotePort} - ${socket.remoteFamily}`, this.authenticateOptions.required, this.authenticateOptions.duration);
+        this.logger.info('[onClientConnect] New TCP SocketClient | Client: %s | authenticateOptions: %s %s', `${id} - ${socket.remoteAddress} - ${socket.remotePort} - ${socket.remoteFamily}`, this.authenticateOptions.required, this.authenticateOptions.duration);
         this.onClientConnected?.({ id, socket });
         // Check client authentication
         if (this.authenticateOptions.required &&
@@ -86,10 +86,10 @@ class BaseNetworkTcpServer extends base_1.BaseHelper {
                 if (!client) {
                     return;
                 }
-                if (client.state === "authenticated") {
+                if (client.state === 'authenticated') {
                     return;
                 }
-                this.emit({ clientId: id, payload: "Unauthorized Client" });
+                this.emit({ clientId: id, payload: 'Unauthorized Client' });
                 client.socket.end();
             }, this.authenticateOptions.duration);
         }
@@ -107,17 +107,17 @@ class BaseNetworkTcpServer extends base_1.BaseHelper {
         const { id, state } = opts;
         const client = this.getClient({ id });
         if (!client) {
-            this.logger.error("[authenticateClient][%s] Client %s NOT FOUND", id);
+            this.logger.error('[authenticateClient][%s] Client %s NOT FOUND', id);
             return;
         }
         client.state = state;
         switch (state) {
-            case "unauthorized":
-            case "authenticating": {
+            case 'unauthorized':
+            case 'authenticating': {
                 client.storage.authenticatedAt = null;
                 break;
             }
-            case "authenticated": {
+            case 'authenticated': {
                 client.storage.authenticatedAt = (0, date_utility_1.dayjs)();
                 break;
             }
@@ -130,16 +130,16 @@ class BaseNetworkTcpServer extends base_1.BaseHelper {
         const { clientId, payload } = opts;
         const client = this.getClient({ id: clientId });
         if (!client) {
-            this.logger.error("[emit][%s] Client %s NOT FOUND", clientId);
+            this.logger.error('[emit][%s] Client %s NOT FOUND', clientId);
             return;
         }
         const { socket } = client;
         if (!socket.writable) {
-            this.logger.error("[emit][%s] Client %s NOT WRITABLE", clientId);
+            this.logger.error('[emit][%s] Client %s NOT WRITABLE', clientId);
             return;
         }
         if (!payload?.length) {
-            this.logger.info("[emit][%s] Client %s | Invalid payload to write to TCP Socket!", this.identifier, clientId);
+            this.logger.info('[emit][%s] Client %s | Invalid payload to write to TCP Socket!', this.identifier, clientId);
             return;
         }
         socket.write(payload);

package/dist/helpers/network/tcp-socket/index.d.ts

@@ -1,7 +1,7 @@
-export * from "./base-tcp-client.helper";
-export * from "./base-tcp-server.helper";
-export * from "./network-tcp-client.helper";
-export * from "./network-tcp-server.helper";
-export * from "./network-tls-tcp-client.helper";
-export * from "./network-tls-tcp-server.helper";
+export * from './base-tcp-client.helper';
+export * from './base-tcp-server.helper';
+export * from './network-tcp-client.helper';
+export * from './network-tcp-server.helper';
+export * from './network-tls-tcp-client.helper';
+export * from './network-tls-tcp-server.helper';
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/network/tcp-socket/network-tcp-client.helper.d.ts

@@ -1,7 +1,7 @@
-import { Socket, TcpSocketConnectOpts } from "node:net";
-import { BaseNetworkTcpClient, INetworkTcpClientProps } from "./base-tcp-client.helper";
+import { Socket, TcpSocketConnectOpts } from 'node:net';
+import { BaseNetworkTcpClient, INetworkTcpClientProps } from './base-tcp-client.helper';
 export declare class NetworkTcpClient extends BaseNetworkTcpClient<TcpSocketConnectOpts, Socket> {
-    constructor(opts: Omit<INetworkTcpClientProps<TcpSocketConnectOpts, Socket>, "createClientFn">);
-    static newInstance(opts: Omit<INetworkTcpClientProps<TcpSocketConnectOpts, Socket>, "createClientFn">): NetworkTcpClient;
+    constructor(opts: Omit<INetworkTcpClientProps<TcpSocketConnectOpts, Socket>, 'createClientFn'>);
+    static newInstance(opts: Omit<INetworkTcpClientProps<TcpSocketConnectOpts, Socket>, 'createClientFn'>): NetworkTcpClient;
 }
 //# sourceMappingURL=network-tcp-client.helper.d.ts.map

package/dist/helpers/network/tcp-socket/network-tcp-server.helper.d.ts

@@ -1,7 +1,7 @@
-import { ServerOpts, Socket as SocketClient, Server as SocketServer } from "node:net";
-import { BaseNetworkTcpServer, ITcpSocketServerOptions } from "./base-tcp-server.helper";
+import { ServerOpts, Socket as SocketClient, Server as SocketServer } from 'node:net';
+import { BaseNetworkTcpServer, ITcpSocketServerOptions } from './base-tcp-server.helper';
 export declare class NetworkTcpServer extends BaseNetworkTcpServer<ServerOpts, SocketServer, SocketClient> {
-    constructor(opts: Omit<ITcpSocketServerOptions, "createServerFn">);
-    static newInstance(opts: Omit<ITcpSocketServerOptions, "createServerFn">): NetworkTcpServer;
+    constructor(opts: Omit<ITcpSocketServerOptions, 'createServerFn'>);
+    static newInstance(opts: Omit<ITcpSocketServerOptions, 'createServerFn'>): NetworkTcpServer;
 }
 //# sourceMappingURL=network-tcp-server.helper.d.ts.map

package/dist/helpers/network/tcp-socket/network-tls-tcp-client.helper.d.ts

@@ -1,7 +1,7 @@
-import { ConnectionOptions, TLSSocket } from "node:tls";
-import { BaseNetworkTcpClient, INetworkTcpClientProps } from "./base-tcp-client.helper";
+import { ConnectionOptions, TLSSocket } from 'node:tls';
+import { BaseNetworkTcpClient, INetworkTcpClientProps } from './base-tcp-client.helper';
 export declare class NetworkTlsTcpClient extends BaseNetworkTcpClient<ConnectionOptions, TLSSocket> {
-    constructor(opts: Omit<INetworkTcpClientProps<ConnectionOptions, TLSSocket>, "createClientFn">);
-    static newInstance(opts: Omit<INetworkTcpClientProps<ConnectionOptions, TLSSocket>, "createClientFn">): NetworkTlsTcpClient;
+    constructor(opts: Omit<INetworkTcpClientProps<ConnectionOptions, TLSSocket>, 'createClientFn'>);
+    static newInstance(opts: Omit<INetworkTcpClientProps<ConnectionOptions, TLSSocket>, 'createClientFn'>): NetworkTlsTcpClient;
 }
 //# sourceMappingURL=network-tls-tcp-client.helper.d.ts.map

package/dist/helpers/network/tcp-socket/network-tls-tcp-server.helper.d.ts

@@ -1,7 +1,7 @@
-import { Server, TLSSocket as SocketClient, TlsOptions } from "node:tls";
-import { BaseNetworkTcpServer, ITcpSocketServerOptions } from "./base-tcp-server.helper";
+import { Server, TLSSocket as SocketClient, TlsOptions } from 'node:tls';
+import { BaseNetworkTcpServer, ITcpSocketServerOptions } from './base-tcp-server.helper';
 export declare class NetworkTlsTcpServer extends BaseNetworkTcpServer<TlsOptions, Server, SocketClient> {
-    constructor(opts: Omit<ITcpSocketServerOptions, "createServerFn">);
-    static newInstance(opts: Omit<ITcpSocketServerOptions, "createServerFn">): NetworkTlsTcpServer;
+    constructor(opts: Omit<ITcpSocketServerOptions, 'createServerFn'>);
+    static newInstance(opts: Omit<ITcpSocketServerOptions, 'createServerFn'>): NetworkTlsTcpServer;
 }
 //# sourceMappingURL=network-tls-tcp-server.helper.d.ts.map

package/dist/helpers/network/udp-socket/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./network-udp-client.helper";
+export * from './network-udp-client.helper';
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/network/udp-socket/network-udp-client.helper.d.ts

@@ -1,6 +1,6 @@
-import { BaseHelper } from "../../../helpers/base";
-import { ValueOrPromise } from "../../../common";
-import dgram from "node:dgram";
+import { BaseHelper } from '../../../helpers/base';
+import { ValueOrPromise } from '../../../common';
+import dgram from 'node:dgram';
 interface INetworkUdpClientProps {
     identifier: string;
     host?: string;

package/dist/helpers/network/udp-socket/network-udp-client.helper.js

@@ -26,52 +26,52 @@ class NetworkUdpClient extends base_1.BaseHelper {
         return this.client;
     }
     handleConnected() {
-        this.logger.info("[handleConnected][%s] Successfully bind connection | Options: %j", this.identifier, {
+        this.logger.info('[handleConnected][%s] Successfully bind connection | Options: %j', this.identifier, {
             host: this.host,
             port: this.port,
             multicastAddress: this.multicastAddress,
         });
     }
     handleData(opts) {
-        this.logger.info("[handleData][%s][%s:%d][<==] Raw: %s", this.identifier, this.host, this.port, {
+        this.logger.info('[handleData][%s][%s:%d][<==] Raw: %s', this.identifier, this.host, this.port, {
             message: opts.message,
             remoteInfo: opts.remoteInfo,
         });
     }
     handleClosed() {
-        this.logger.info("[handleClosed][%s] Closed connection TCP Server | Options: %j", this.identifier, {
+        this.logger.info('[handleClosed][%s] Closed connection TCP Server | Options: %j', this.identifier, {
             host: this.host,
             port: this.port,
             multicastAddress: this.multicastAddress,
         });
     }
     handleError(opts) {
-        this.logger.error("[handleError][%s] Connection error | Options: %j | Error: %s", this.identifier, {
+        this.logger.error('[handleError][%s] Connection error | Options: %j | Error: %s', this.identifier, {
             host: this.host,
             port: this.port,
         }, opts.error);
     }
     connect() {
         if (this.client) {
-            this.logger.info("[connect][%s] UdpClient is already initialized!", this.identifier);
+            this.logger.info('[connect][%s] UdpClient is already initialized!', this.identifier);
             return;
         }
         if (!this.port) {
-            this.logger.info("[connect][%s] Cannot init UDP Client with null options", this.identifier);
+            this.logger.info('[connect][%s] Cannot init UDP Client with null options', this.identifier);
             return;
         }
-        this.logger.info("[connect][%s] New network udp client | Host: %s | Port: %s | multicastAddress: %j", this.identifier, this.host, this.port, this.multicastAddress);
-        this.client = node_dgram_1.default.createSocket({ type: "udp4", reuseAddr: this.reuseAddr });
-        this.client.on("close", () => {
+        this.logger.info('[connect][%s] New network udp client | Host: %s | Port: %s | multicastAddress: %j', this.identifier, this.host, this.port, this.multicastAddress);
+        this.client = node_dgram_1.default.createSocket({ type: 'udp4', reuseAddr: this.reuseAddr });
+        this.client.on('close', () => {
             this.onClosed?.({ identifier: this.identifier, host: this.host, port: this.port });
         });
-        this.client.on("error", error => {
+        this.client.on('error', error => {
             this.onError?.({ identifier: this.identifier, host: this.host, port: this.port, error });
         });
-        this.client.on("listening", () => {
+        this.client.on('listening', () => {
             this.onConnected?.({ identifier: this.identifier, host: this.host, port: this.port });
         });
-        this.client.on("message", (message, remoteInfo) => {
+        this.client.on('message', (message, remoteInfo) => {
             this.onData?.({ identifier: this.identifier, message, remoteInfo });
         });
         this.client.bind({ port: this.port, address: this.host }, () => {
@@ -87,12 +87,12 @@ class NetworkUdpClient extends base_1.BaseHelper {
     }
     disconnect() {
         if (!this.client) {
-            this.logger.info("[disconnect][%s] UdpClient is not initialized yet!", this.identifier);
+            this.logger.info('[disconnect][%s] UdpClient is not initialized yet!', this.identifier);
             return;
         }
         this.client?.close();
         this.client = null;
-        this.logger.info("[disconnect][%s] UdpClient is destroyed!", this.identifier);
+        this.logger.info('[disconnect][%s] UdpClient is destroyed!', this.identifier);
     }
     isConnected() {
         return this.client;