@pallasoft/ps-utilities 2.19.1 → 2.21.0

package/dist/common/constants/index.d.ts

@@ -17,3 +17,4 @@ export * from './http-method';
 export * from './relative-time-config';
 export * from './request-client-config';
 export * from './portable-text-config';
+export * from './text-tidy-config';

package/dist/common/constants/index.js

@@ -33,3 +33,4 @@ __exportStar(require("./http-method"), exports);
 __exportStar(require("./relative-time-config"), exports);
 __exportStar(require("./request-client-config"), exports);
 __exportStar(require("./portable-text-config"), exports);
+__exportStar(require("./text-tidy-config"), exports);

package/dist/common/constants/text-tidy-config.d.ts

@@ -0,0 +1,8 @@
+export declare const TextTidyConfig: {
+    readonly emptyBrackets: RegExp;
+    readonly lineEndSpace: RegExp;
+    readonly lineStartSpace: RegExp;
+    readonly manyBlankLines: RegExp;
+    readonly manySpaces: RegExp;
+    readonly spaceBeforePunctuation: RegExp;
+};

package/dist/common/constants/text-tidy-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextTidyConfig = void 0;
+exports.TextTidyConfig = {
+    emptyBrackets: /\(\s*\)|\[\s*\]|\{\s*\}/g,
+    lineEndSpace: /[^\S\n]+\n/g,
+    lineStartSpace: /\n[^\S\n]+/g,
+    manyBlankLines: /\n{3,}/g,
+    manySpaces: /[^\S\n]{2,}/g,
+    spaceBeforePunctuation: /[^\S\n]+([,.;:!?])/g,
+};

package/dist/common/index.d.ts

@@ -25,3 +25,4 @@ export * from './relative-time-service';
 export * from './request-client-service';
 export * from './json-service';
 export * from './portable-text-service';
+export * from './text-tidy-service';

package/dist/common/index.js

@@ -41,3 +41,4 @@ __exportStar(require("./relative-time-service"), exports);
 __exportStar(require("./request-client-service"), exports);
 __exportStar(require("./json-service"), exports);
 __exportStar(require("./portable-text-service"), exports);
+__exportStar(require("./text-tidy-service"), exports);

package/dist/common/text-tidy-service.d.ts

@@ -0,0 +1,4 @@
+export declare class TextTidyService {
+    static run(text: string): string;
+    static tidy(text: string): string;
+}

package/dist/common/text-tidy-service.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextTidyService = void 0;
+var text_tidy_config_1 = require("./constants/text-tidy-config");
+var TextTidyService = /** @class */ (function () {
+    function TextTidyService() {
+    }
+    TextTidyService.run = function (text) {
+        return text
+            .replace(text_tidy_config_1.TextTidyConfig.emptyBrackets, '')
+            .replace(text_tidy_config_1.TextTidyConfig.manySpaces, ' ')
+            .replace(text_tidy_config_1.TextTidyConfig.spaceBeforePunctuation, '$1');
+    };
+    TextTidyService.tidy = function (text) {
+        return TextTidyService.run(text)
+            .replace(text_tidy_config_1.TextTidyConfig.lineEndSpace, '\n')
+            .replace(text_tidy_config_1.TextTidyConfig.lineStartSpace, '\n')
+            .replace(text_tidy_config_1.TextTidyConfig.manyBlankLines, '\n\n')
+            .trim();
+    };
+    return TextTidyService;
+}());
+exports.TextTidyService = TextTidyService;

package/dist/edge-logs/edge-log-level.d.ts

@@ -0,0 +1,5 @@
+export declare enum EdgeLogLevel {
+    Info = "INFO",
+    Warn = "WARN",
+    Error = "ERROR"
+}

package/dist/edge-logs/edge-log-level.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeLogLevel = void 0;
+var EdgeLogLevel;
+(function (EdgeLogLevel) {
+    EdgeLogLevel["Info"] = "INFO";
+    EdgeLogLevel["Warn"] = "WARN";
+    EdgeLogLevel["Error"] = "ERROR";
+})(EdgeLogLevel || (exports.EdgeLogLevel = EdgeLogLevel = {}));

package/dist/edge-logs/edge-logs-config.d.ts

@@ -0,0 +1,30 @@
+export declare const EdgeLogsConfig: {
+    readonly bearerPattern: RegExp;
+    readonly defaultEnvironment: "development";
+    readonly defaultScheme: "https://";
+    readonly emailPattern: RegExp;
+    readonly flushTimeoutMilliseconds: 5000;
+    readonly maxBufferedEntries: 200;
+    readonly maxDepth: 3;
+    readonly maxTextLength: 2000;
+    readonly nanosPerMillisecondSuffix: "000000";
+    readonly offValues: readonly ["", "_"];
+    readonly queryPattern: RegExp;
+    readonly redactedValue: "[redacted]";
+    readonly resourceKeys: {
+        readonly environment: "deployment.environment";
+        readonly serviceName: "service.name";
+        readonly serviceNamespace: "service.namespace";
+        readonly serviceVersion: "service.version";
+    };
+    readonly scopeName: "ps-utilities.edge-logs";
+    readonly schemePattern: RegExp;
+    readonly sensitiveKeyPattern: RegExp;
+    readonly severityNumbers: {
+        readonly INFO: 9;
+        readonly WARN: 13;
+        readonly ERROR: 17;
+    };
+    readonly signalPath: "/v1/logs";
+    readonly trailingSlashesPattern: RegExp;
+};

package/dist/edge-logs/edge-logs-config.js

@@ -0,0 +1,35 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeLogsConfig = void 0;
+var edge_log_level_1 = require("./edge-log-level");
+exports.EdgeLogsConfig = {
+    bearerPattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+    defaultEnvironment: 'development',
+    defaultScheme: 'https://',
+    emailPattern: /[^\s@"']+@[^\s@"']+\.[^\s@"']+/g,
+    flushTimeoutMilliseconds: 5000,
+    maxBufferedEntries: 200,
+    maxDepth: 3,
+    maxTextLength: 2000,
+    nanosPerMillisecondSuffix: '000000',
+    offValues: ['', '_'],
+    queryPattern: /(https?:\/\/[^\s?#"']+|\/[^\s?#"']*)\?[^\s#"']*/g,
+    redactedValue: '[redacted]',
+    resourceKeys: {
+        environment: 'deployment.environment',
+        serviceName: 'service.name',
+        serviceNamespace: 'service.namespace',
+        serviceVersion: 'service.version',
+    },
+    scopeName: 'ps-utilities.edge-logs',
+    schemePattern: /^[a-z][a-z0-9+.-]*:\/\//i,
+    sensitiveKeyPattern: /token|secret|password|passwd|authorization|cookie|credential|api[-_]?key|email|body|session|phone|header/i,
+    severityNumbers: (_a = {},
+        _a[edge_log_level_1.EdgeLogLevel.Info] = 9,
+        _a[edge_log_level_1.EdgeLogLevel.Warn] = 13,
+        _a[edge_log_level_1.EdgeLogLevel.Error] = 17,
+        _a),
+    signalPath: '/v1/logs',
+    trailingSlashesPattern: /\/+$/,
+};

package/dist/edge-logs/edge-logs-service.d.ts

@@ -0,0 +1,22 @@
+import type { EdgeLogEntry } from '../models/edge-log-entry';
+import type { EdgeLogOptions } from '../models/edge-log-options';
+import type { EdgeLogPayload } from '../models/edge-log-payload';
+import type { EdgeLogRecord } from '../models/edge-log-record';
+export declare class EdgeLogsService {
+    private static buffer;
+    static isOff(value: string | undefined): boolean;
+    static baseUrl(host: string | undefined): string | null;
+    static endpoint(host: string | undefined): string | null;
+    static isEnabled(options: EdgeLogOptions): boolean;
+    static enqueue(options: EdgeLogOptions, entry: EdgeLogEntry): boolean;
+    static pending(): number;
+    static reset(): void;
+    static flush(options: EdgeLogOptions): Promise<boolean>;
+    static payload(options: EdgeLogOptions, entries: EdgeLogEntry[]): EdgeLogPayload;
+    static record(entry: EdgeLogEntry): EdgeLogRecord;
+    static sanitize(source: Record<string, unknown>, depth?: number): Record<string, unknown>;
+    static text(value: string): string;
+    private static value;
+    private static attribute;
+    private static attributeValue;
+}

package/dist/edge-logs/edge-logs-service.js

@@ -0,0 +1,208 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeLogsService = void 0;
+var http_auth_scheme_1 = require("../common/constants/http-auth-scheme");
+var http_content_type_1 = require("../common/constants/http-content-type");
+var http_header_1 = require("../common/constants/http-header");
+var http_method_1 = require("../common/constants/http-method");
+var edge_logs_config_1 = require("./edge-logs-config");
+var EdgeLogsService = /** @class */ (function () {
+    function EdgeLogsService() {
+    }
+    EdgeLogsService.isOff = function (value) {
+        if (typeof value !== 'string')
+            return true;
+        return edge_logs_config_1.EdgeLogsConfig.offValues.includes(value.trim());
+    };
+    EdgeLogsService.baseUrl = function (host) {
+        if (EdgeLogsService.isOff(host))
+            return null;
+        var trimmed = host.trim().replace(edge_logs_config_1.EdgeLogsConfig.trailingSlashesPattern, '');
+        var withScheme = edge_logs_config_1.EdgeLogsConfig.schemePattern.test(trimmed)
+            ? trimmed
+            : "".concat(edge_logs_config_1.EdgeLogsConfig.defaultScheme).concat(trimmed);
+        return URL.canParse(withScheme) ? withScheme : null;
+    };
+    EdgeLogsService.endpoint = function (host) {
+        var base = EdgeLogsService.baseUrl(host);
+        return base === null ? null : "".concat(base).concat(edge_logs_config_1.EdgeLogsConfig.signalPath);
+    };
+    EdgeLogsService.isEnabled = function (options) {
+        return EdgeLogsService.endpoint(options.host) !== null && !EdgeLogsService.isOff(options.token);
+    };
+    EdgeLogsService.enqueue = function (options, entry) {
+        if (!EdgeLogsService.isEnabled(options))
+            return false;
+        EdgeLogsService.buffer.push(entry);
+        if (EdgeLogsService.buffer.length > edge_logs_config_1.EdgeLogsConfig.maxBufferedEntries)
+            EdgeLogsService.buffer.shift();
+        return true;
+    };
+    EdgeLogsService.pending = function () {
+        return EdgeLogsService.buffer.length;
+    };
+    EdgeLogsService.reset = function () {
+        EdgeLogsService.buffer = [];
+    };
+    EdgeLogsService.flush = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entries, url, controller, timer, response, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        entries = EdgeLogsService.buffer;
+                        EdgeLogsService.buffer = [];
+                        url = EdgeLogsService.endpoint(options.host);
+                        if (entries.length === 0 || url === null || EdgeLogsService.isOff(options.token))
+                            return [2 /*return*/, false];
+                        controller = new AbortController();
+                        timer = setTimeout(function () { return controller.abort(); }, edge_logs_config_1.EdgeLogsConfig.flushTimeoutMilliseconds);
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, fetch(url, {
+                                body: JSON.stringify(EdgeLogsService.payload(options, entries)),
+                                headers: (_b = {},
+                                    _b[http_header_1.HttpHeader.authorization] = "".concat(http_auth_scheme_1.HttpAuthScheme.bearerPrefix).concat(options.token.trim()),
+                                    _b[http_header_1.HttpHeader.contentType] = http_content_type_1.HttpContentType.json,
+                                    _b),
+                                method: http_method_1.HttpMethod.Post,
+                                signal: controller.signal,
+                            })];
+                    case 2:
+                        response = _c.sent();
+                        return [2 /*return*/, response.ok];
+                    case 3:
+                        _a = _c.sent();
+                        return [2 /*return*/, false];
+                    case 4:
+                        clearTimeout(timer);
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EdgeLogsService.payload = function (options, entries) {
+        var environment = typeof options.environment === 'string' && options.environment.trim() !== ''
+            ? options.environment.trim()
+            : edge_logs_config_1.EdgeLogsConfig.defaultEnvironment;
+        return {
+            resourceLogs: [
+                {
+                    resource: {
+                        attributes: [
+                            EdgeLogsService.attribute(edge_logs_config_1.EdgeLogsConfig.resourceKeys.serviceName, options.serviceName),
+                            EdgeLogsService.attribute(edge_logs_config_1.EdgeLogsConfig.resourceKeys.serviceNamespace, options.serviceNamespace),
+                            EdgeLogsService.attribute(edge_logs_config_1.EdgeLogsConfig.resourceKeys.serviceVersion, options.serviceVersion),
+                            EdgeLogsService.attribute(edge_logs_config_1.EdgeLogsConfig.resourceKeys.environment, environment),
+                        ],
+                    },
+                    scopeLogs: [
+                        {
+                            scope: { name: edge_logs_config_1.EdgeLogsConfig.scopeName },
+                            logRecords: entries.map(function (entry) { return EdgeLogsService.record(entry); }),
+                        },
+                    ],
+                },
+            ],
+        };
+    };
+    EdgeLogsService.record = function (entry) {
+        var timestamp = typeof entry.timestamp === 'number' ? entry.timestamp : Date.now();
+        var attributes = EdgeLogsService.sanitize(entry.attributes === undefined ? {} : entry.attributes);
+        return {
+            attributes: Object.keys(attributes).map(function (key) {
+                return EdgeLogsService.attribute(key, attributes[key]);
+            }),
+            body: { stringValue: EdgeLogsService.text(entry.event) },
+            severityNumber: edge_logs_config_1.EdgeLogsConfig.severityNumbers[entry.level],
+            severityText: entry.level,
+            timeUnixNano: "".concat(Math.floor(timestamp)).concat(edge_logs_config_1.EdgeLogsConfig.nanosPerMillisecondSuffix),
+        };
+    };
+    EdgeLogsService.sanitize = function (source, depth) {
+        if (depth === void 0) { depth = 0; }
+        var result = {};
+        Object.keys(source).forEach(function (key) {
+            result[key] = edge_logs_config_1.EdgeLogsConfig.sensitiveKeyPattern.test(key)
+                ? edge_logs_config_1.EdgeLogsConfig.redactedValue
+                : EdgeLogsService.value(source[key], depth);
+        });
+        return result;
+    };
+    EdgeLogsService.text = function (value) {
+        return value
+            .replace(edge_logs_config_1.EdgeLogsConfig.bearerPattern, edge_logs_config_1.EdgeLogsConfig.redactedValue)
+            .replace(edge_logs_config_1.EdgeLogsConfig.emailPattern, edge_logs_config_1.EdgeLogsConfig.redactedValue)
+            .replace(edge_logs_config_1.EdgeLogsConfig.queryPattern, '$1')
+            .slice(0, edge_logs_config_1.EdgeLogsConfig.maxTextLength);
+    };
+    EdgeLogsService.value = function (value, depth) {
+        if (value === null || value === undefined)
+            return '';
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string')
+            return EdgeLogsService.text(value);
+        if (value instanceof Error)
+            return EdgeLogsService.text("".concat(value.name, ": ").concat(value.message));
+        if (depth >= edge_logs_config_1.EdgeLogsConfig.maxDepth)
+            return edge_logs_config_1.EdgeLogsConfig.redactedValue;
+        if (Array.isArray(value))
+            return EdgeLogsService.text(JSON.stringify(value.map(function (item) { return EdgeLogsService.value(item, depth + 1); })));
+        if (typeof value === 'object')
+            return EdgeLogsService.text(JSON.stringify(EdgeLogsService.sanitize(value, depth + 1)));
+        return EdgeLogsService.text(String(value));
+    };
+    EdgeLogsService.attribute = function (key, value) {
+        return { key: key, value: EdgeLogsService.attributeValue(value) };
+    };
+    EdgeLogsService.attributeValue = function (value) {
+        if (typeof value === 'boolean')
+            return { boolValue: value };
+        if (typeof value === 'number' && Number.isFinite(value))
+            return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+        return { stringValue: String(value) };
+    };
+    EdgeLogsService.buffer = [];
+    return EdgeLogsService;
+}());
+exports.EdgeLogsService = EdgeLogsService;

package/dist/edge-logs/index.d.ts

@@ -0,0 +1,11 @@
+export * from './edge-log-level';
+export * from './edge-logs-config';
+export * from './edge-logs-service';
+export type { EdgeLogAttribute } from '../models/edge-log-attribute';
+export type { EdgeLogAttributeValue } from '../models/edge-log-attribute-value';
+export type { EdgeLogEntry } from '../models/edge-log-entry';
+export type { EdgeLogOptions } from '../models/edge-log-options';
+export type { EdgeLogPayload } from '../models/edge-log-payload';
+export type { EdgeLogRecord } from '../models/edge-log-record';
+export type { EdgeLogResourceLogs } from '../models/edge-log-resource-logs';
+export type { EdgeLogScopeLogs } from '../models/edge-log-scope-logs';

package/dist/edge-logs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./edge-log-level"), exports);
+__exportStar(require("./edge-logs-config"), exports);
+__exportStar(require("./edge-logs-service"), exports);

package/dist/esm/common/constants/index.js

@@ -17,3 +17,4 @@ export * from './http-method.js';
 export * from './relative-time-config.js';
 export * from './request-client-config.js';
 export * from './portable-text-config.js';
+export * from './text-tidy-config.js';

package/dist/esm/common/constants/text-tidy-config.js

@@ -0,0 +1,8 @@
+export const TextTidyConfig = {
+    emptyBrackets: /\(\s*\)|\[\s*\]|\{\s*\}/g,
+    lineEndSpace: /[^\S\n]+\n/g,
+    lineStartSpace: /\n[^\S\n]+/g,
+    manyBlankLines: /\n{3,}/g,
+    manySpaces: /[^\S\n]{2,}/g,
+    spaceBeforePunctuation: /[^\S\n]+([,.;:!?])/g,
+};

package/dist/esm/common/index.js

@@ -25,3 +25,4 @@ export * from './relative-time-service.js';
 export * from './request-client-service.js';
 export * from './json-service.js';
 export * from './portable-text-service.js';
+export * from './text-tidy-service.js';

package/dist/esm/common/text-tidy-service.js

@@ -0,0 +1,16 @@
+import { TextTidyConfig } from './constants/text-tidy-config.js';
+export class TextTidyService {
+    static run(text) {
+        return text
+            .replace(TextTidyConfig.emptyBrackets, '')
+            .replace(TextTidyConfig.manySpaces, ' ')
+            .replace(TextTidyConfig.spaceBeforePunctuation, '$1');
+    }
+    static tidy(text) {
+        return TextTidyService.run(text)
+            .replace(TextTidyConfig.lineEndSpace, '\n')
+            .replace(TextTidyConfig.lineStartSpace, '\n')
+            .replace(TextTidyConfig.manyBlankLines, '\n\n')
+            .trim();
+    }
+}

package/dist/esm/edge-logs/edge-log-level.js

@@ -0,0 +1,6 @@
+export var EdgeLogLevel;
+(function (EdgeLogLevel) {
+    EdgeLogLevel["Info"] = "INFO";
+    EdgeLogLevel["Warn"] = "WARN";
+    EdgeLogLevel["Error"] = "ERROR";
+})(EdgeLogLevel || (EdgeLogLevel = {}));

package/dist/esm/edge-logs/edge-logs-config.js

@@ -0,0 +1,31 @@
+import { EdgeLogLevel } from './edge-log-level.js';
+export const EdgeLogsConfig = {
+    bearerPattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
+    defaultEnvironment: 'development',
+    defaultScheme: 'https://',
+    emailPattern: /[^\s@"']+@[^\s@"']+\.[^\s@"']+/g,
+    flushTimeoutMilliseconds: 5000,
+    maxBufferedEntries: 200,
+    maxDepth: 3,
+    maxTextLength: 2000,
+    nanosPerMillisecondSuffix: '000000',
+    offValues: ['', '_'],
+    queryPattern: /(https?:\/\/[^\s?#"']+|\/[^\s?#"']*)\?[^\s#"']*/g,
+    redactedValue: '[redacted]',
+    resourceKeys: {
+        environment: 'deployment.environment',
+        serviceName: 'service.name',
+        serviceNamespace: 'service.namespace',
+        serviceVersion: 'service.version',
+    },
+    scopeName: 'ps-utilities.edge-logs',
+    schemePattern: /^[a-z][a-z0-9+.-]*:\/\//i,
+    sensitiveKeyPattern: /token|secret|password|passwd|authorization|cookie|credential|api[-_]?key|email|body|session|phone|header/i,
+    severityNumbers: {
+        [EdgeLogLevel.Info]: 9,
+        [EdgeLogLevel.Warn]: 13,
+        [EdgeLogLevel.Error]: 17,
+    },
+    signalPath: '/v1/logs',
+    trailingSlashesPattern: /\/+$/,
+};

package/dist/esm/edge-logs/edge-logs-service.js

@@ -0,0 +1,149 @@
+import { HttpAuthScheme } from '../common/constants/http-auth-scheme.js';
+import { HttpContentType } from '../common/constants/http-content-type.js';
+import { HttpHeader } from '../common/constants/http-header.js';
+import { HttpMethod } from '../common/constants/http-method.js';
+import { EdgeLogsConfig } from './edge-logs-config.js';
+export class EdgeLogsService {
+    static isOff(value) {
+        if (typeof value !== 'string')
+            return true;
+        return EdgeLogsConfig.offValues.includes(value.trim());
+    }
+    static baseUrl(host) {
+        if (EdgeLogsService.isOff(host))
+            return null;
+        const trimmed = host.trim().replace(EdgeLogsConfig.trailingSlashesPattern, '');
+        const withScheme = EdgeLogsConfig.schemePattern.test(trimmed)
+            ? trimmed
+            : `${EdgeLogsConfig.defaultScheme}${trimmed}`;
+        return URL.canParse(withScheme) ? withScheme : null;
+    }
+    static endpoint(host) {
+        const base = EdgeLogsService.baseUrl(host);
+        return base === null ? null : `${base}${EdgeLogsConfig.signalPath}`;
+    }
+    static isEnabled(options) {
+        return EdgeLogsService.endpoint(options.host) !== null && !EdgeLogsService.isOff(options.token);
+    }
+    static enqueue(options, entry) {
+        if (!EdgeLogsService.isEnabled(options))
+            return false;
+        EdgeLogsService.buffer.push(entry);
+        if (EdgeLogsService.buffer.length > EdgeLogsConfig.maxBufferedEntries)
+            EdgeLogsService.buffer.shift();
+        return true;
+    }
+    static pending() {
+        return EdgeLogsService.buffer.length;
+    }
+    static reset() {
+        EdgeLogsService.buffer = [];
+    }
+    static async flush(options) {
+        const entries = EdgeLogsService.buffer;
+        EdgeLogsService.buffer = [];
+        const url = EdgeLogsService.endpoint(options.host);
+        if (entries.length === 0 || url === null || EdgeLogsService.isOff(options.token))
+            return false;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), EdgeLogsConfig.flushTimeoutMilliseconds);
+        try {
+            const response = await fetch(url, {
+                body: JSON.stringify(EdgeLogsService.payload(options, entries)),
+                headers: {
+                    [HttpHeader.authorization]: `${HttpAuthScheme.bearerPrefix}${options.token.trim()}`,
+                    [HttpHeader.contentType]: HttpContentType.json,
+                },
+                method: HttpMethod.Post,
+                signal: controller.signal,
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    static payload(options, entries) {
+        const environment = typeof options.environment === 'string' && options.environment.trim() !== ''
+            ? options.environment.trim()
+            : EdgeLogsConfig.defaultEnvironment;
+        return {
+            resourceLogs: [
+                {
+                    resource: {
+                        attributes: [
+                            EdgeLogsService.attribute(EdgeLogsConfig.resourceKeys.serviceName, options.serviceName),
+                            EdgeLogsService.attribute(EdgeLogsConfig.resourceKeys.serviceNamespace, options.serviceNamespace),
+                            EdgeLogsService.attribute(EdgeLogsConfig.resourceKeys.serviceVersion, options.serviceVersion),
+                            EdgeLogsService.attribute(EdgeLogsConfig.resourceKeys.environment, environment),
+                        ],
+                    },
+                    scopeLogs: [
+                        {
+                            scope: { name: EdgeLogsConfig.scopeName },
+                            logRecords: entries.map((entry) => EdgeLogsService.record(entry)),
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    static record(entry) {
+        const timestamp = typeof entry.timestamp === 'number' ? entry.timestamp : Date.now();
+        const attributes = EdgeLogsService.sanitize(entry.attributes === undefined ? {} : entry.attributes);
+        return {
+            attributes: Object.keys(attributes).map((key) => EdgeLogsService.attribute(key, attributes[key])),
+            body: { stringValue: EdgeLogsService.text(entry.event) },
+            severityNumber: EdgeLogsConfig.severityNumbers[entry.level],
+            severityText: entry.level,
+            timeUnixNano: `${Math.floor(timestamp)}${EdgeLogsConfig.nanosPerMillisecondSuffix}`,
+        };
+    }
+    static sanitize(source, depth = 0) {
+        const result = {};
+        Object.keys(source).forEach((key) => {
+            result[key] = EdgeLogsConfig.sensitiveKeyPattern.test(key)
+                ? EdgeLogsConfig.redactedValue
+                : EdgeLogsService.value(source[key], depth);
+        });
+        return result;
+    }
+    static text(value) {
+        return value
+            .replace(EdgeLogsConfig.bearerPattern, EdgeLogsConfig.redactedValue)
+            .replace(EdgeLogsConfig.emailPattern, EdgeLogsConfig.redactedValue)
+            .replace(EdgeLogsConfig.queryPattern, '$1')
+            .slice(0, EdgeLogsConfig.maxTextLength);
+    }
+    static value(value, depth) {
+        if (value === null || value === undefined)
+            return '';
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string')
+            return EdgeLogsService.text(value);
+        if (value instanceof Error)
+            return EdgeLogsService.text(`${value.name}: ${value.message}`);
+        if (depth >= EdgeLogsConfig.maxDepth)
+            return EdgeLogsConfig.redactedValue;
+        if (Array.isArray(value))
+            return EdgeLogsService.text(JSON.stringify(value.map((item) => EdgeLogsService.value(item, depth + 1))));
+        if (typeof value === 'object')
+            return EdgeLogsService.text(JSON.stringify(EdgeLogsService.sanitize(value, depth + 1)));
+        return EdgeLogsService.text(String(value));
+    }
+    static attribute(key, value) {
+        return { key, value: EdgeLogsService.attributeValue(value) };
+    }
+    static attributeValue(value) {
+        if (typeof value === 'boolean')
+            return { boolValue: value };
+        if (typeof value === 'number' && Number.isFinite(value))
+            return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+        return { stringValue: String(value) };
+    }
+}
+EdgeLogsService.buffer = [];

package/dist/esm/edge-logs/index.js

@@ -0,0 +1,3 @@
+export * from './edge-log-level.js';
+export * from './edge-logs-config.js';
+export * from './edge-logs-service.js';

package/dist/esm/models/edge-log-attribute-value.js

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

package/dist/esm/models/edge-log-attribute.js

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

package/dist/esm/models/edge-log-entry.js

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

package/dist/esm/models/edge-log-options.js

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

package/dist/esm/models/edge-log-payload.js

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

package/dist/esm/models/edge-log-record.js

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

package/dist/esm/models/edge-log-resource-logs.js

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

package/dist/esm/models/edge-log-scope-logs.js

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

package/dist/esm/models/socket-live-options.js

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

package/dist/esm/sockets/index.js

@@ -1 +1,2 @@
 export * from './socket-client-service.js';
+export * from './socket-live-service.js';

package/dist/esm/sockets/socket-live-config.js

@@ -0,0 +1,8 @@
+export const SocketLiveConfig = {
+    connectErrorEvent: 'connect_error',
+    connectEvent: 'connect',
+    hiddenDelayMilliseconds: 60000,
+    maxRetryMilliseconds: 30000,
+    retryBaseMilliseconds: 1000,
+    visibilityEvent: 'visibilitychange',
+};

package/dist/esm/sockets/socket-live-service.js

@@ -0,0 +1,96 @@
+import { SocketClientService } from './socket-client-service.js';
+import { SocketLiveConfig } from './socket-live-config.js';
+export class SocketLiveService {
+    constructor(options) {
+        this.options = options;
+        this.socket = null;
+        this.token = null;
+        this.isClosed = false;
+        this.hasConnected = false;
+        this.failures = 0;
+        this.retryTimer = null;
+        this.hiddenTimer = null;
+        this.visibility = () => {
+            if (this.isClosed || this.socket === null)
+                return;
+            if (document.visibilityState === 'hidden') {
+                const delay = this.options.hiddenDelayMilliseconds === undefined
+                    ? SocketLiveConfig.hiddenDelayMilliseconds
+                    : this.options.hiddenDelayMilliseconds;
+                this.hiddenTimer = setTimeout(() => {
+                    this.hiddenTimer = null;
+                    if (this.socket !== null)
+                        this.socket.disconnect();
+                }, delay);
+                return;
+            }
+            if (this.hiddenTimer !== null) {
+                clearTimeout(this.hiddenTimer);
+                this.hiddenTimer = null;
+            }
+            if (!this.socket.connected)
+                void this.reconnect();
+        };
+    }
+    static async open(options) {
+        const live = new SocketLiveService(options);
+        await live.start();
+        return live;
+    }
+    async start() {
+        this.token = await this.options.fetchToken();
+        if (this.isClosed || this.token === null)
+            return;
+        const socket = SocketClientService.connect({
+            path: this.options.path,
+            token: () => this.token,
+        });
+        this.socket = socket;
+        this.options.events.forEach((name) => socket.on(name, (payload) => this.options.onEvent(name, payload)));
+        socket.on(SocketLiveConfig.connectEvent, () => this.connected());
+        socket.on(SocketLiveConfig.connectErrorEvent, () => this.retryLater());
+        if (typeof document !== 'undefined')
+            document.addEventListener(SocketLiveConfig.visibilityEvent, this.visibility);
+    }
+    close() {
+        this.isClosed = true;
+        this.clearTimers();
+        if (typeof document !== 'undefined')
+            document.removeEventListener(SocketLiveConfig.visibilityEvent, this.visibility);
+        if (this.socket !== null)
+            this.socket.disconnect();
+    }
+    connected() {
+        this.failures = 0;
+        if (this.hasConnected && this.options.onResume !== undefined)
+            this.options.onResume();
+        this.hasConnected = true;
+    }
+    retryLater() {
+        if (this.isClosed || this.retryTimer !== null)
+            return;
+        const delay = Math.min(SocketLiveConfig.retryBaseMilliseconds * 2 ** this.failures, SocketLiveConfig.maxRetryMilliseconds);
+        this.failures += 1;
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = null;
+            void this.reconnect();
+        }, delay);
+    }
+    async reconnect() {
+        const token = await this.options.fetchToken();
+        if (this.isClosed || this.socket === null)
+            return;
+        if (token === null)
+            return this.retryLater();
+        this.token = token;
+        this.socket.connect();
+    }
+    clearTimers() {
+        if (this.retryTimer !== null)
+            clearTimeout(this.retryTimer);
+        if (this.hiddenTimer !== null)
+            clearTimeout(this.hiddenTimer);
+        this.retryTimer = null;
+        this.hiddenTimer = null;
+    }
+}

package/dist/models/edge-log-attribute-value.d.ts

@@ -0,0 +1,6 @@
+export interface EdgeLogAttributeValue {
+    stringValue?: string;
+    intValue?: string;
+    doubleValue?: number;
+    boolValue?: boolean;
+}

package/dist/models/edge-log-attribute-value.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-attribute.d.ts

@@ -0,0 +1,5 @@
+import { EdgeLogAttributeValue } from './edge-log-attribute-value';
+export interface EdgeLogAttribute {
+    key: string;
+    value: EdgeLogAttributeValue;
+}

package/dist/models/edge-log-attribute.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-entry.d.ts

@@ -0,0 +1,7 @@
+import { EdgeLogLevel } from '../edge-logs/edge-log-level';
+export interface EdgeLogEntry {
+    level: EdgeLogLevel;
+    event: string;
+    attributes?: Record<string, unknown>;
+    timestamp?: number;
+}

package/dist/models/edge-log-entry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-options.d.ts

@@ -0,0 +1,8 @@
+export interface EdgeLogOptions {
+    host: string | undefined;
+    token: string | undefined;
+    serviceName: string;
+    serviceNamespace: string;
+    serviceVersion: string;
+    environment: string | undefined;
+}

package/dist/models/edge-log-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-payload.d.ts

@@ -0,0 +1,4 @@
+import { EdgeLogResourceLogs } from './edge-log-resource-logs';
+export interface EdgeLogPayload {
+    resourceLogs: EdgeLogResourceLogs[];
+}

package/dist/models/edge-log-payload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-record.d.ts

@@ -0,0 +1,9 @@
+import { EdgeLogAttribute } from './edge-log-attribute';
+import { EdgeLogAttributeValue } from './edge-log-attribute-value';
+export interface EdgeLogRecord {
+    timeUnixNano: string;
+    severityNumber: number;
+    severityText: string;
+    body: EdgeLogAttributeValue;
+    attributes: EdgeLogAttribute[];
+}

package/dist/models/edge-log-record.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-resource-logs.d.ts

@@ -0,0 +1,8 @@
+import { EdgeLogAttribute } from './edge-log-attribute';
+import { EdgeLogScopeLogs } from './edge-log-scope-logs';
+export interface EdgeLogResourceLogs {
+    resource: {
+        attributes: EdgeLogAttribute[];
+    };
+    scopeLogs: EdgeLogScopeLogs[];
+}

package/dist/models/edge-log-resource-logs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/edge-log-scope-logs.d.ts

@@ -0,0 +1,7 @@
+import { EdgeLogRecord } from './edge-log-record';
+export interface EdgeLogScopeLogs {
+    scope: {
+        name: string;
+    };
+    logRecords: EdgeLogRecord[];
+}

package/dist/models/edge-log-scope-logs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/socket-live-options.d.ts

@@ -0,0 +1,8 @@
+export interface SocketLiveOptions {
+    events: string[];
+    fetchToken: () => Promise<string | null>;
+    hiddenDelayMilliseconds?: number;
+    onEvent: (name: string, payload: unknown) => void;
+    onResume?: () => void;
+    path: string;
+}

package/dist/models/socket-live-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sockets/index.d.ts

@@ -1,2 +1,4 @@
 export * from './socket-client-service';
+export * from './socket-live-service';
 export type { SocketClientOptions } from '../models/socket-client-options';
+export type { SocketLiveOptions } from '../models/socket-live-options';

package/dist/sockets/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./socket-client-service"), exports);
+__exportStar(require("./socket-live-service"), exports);

package/dist/sockets/socket-live-config.d.ts

@@ -0,0 +1,8 @@
+export declare const SocketLiveConfig: {
+    readonly connectErrorEvent: "connect_error";
+    readonly connectEvent: "connect";
+    readonly hiddenDelayMilliseconds: 60000;
+    readonly maxRetryMilliseconds: 30000;
+    readonly retryBaseMilliseconds: 1000;
+    readonly visibilityEvent: "visibilitychange";
+};

package/dist/sockets/socket-live-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketLiveConfig = void 0;
+exports.SocketLiveConfig = {
+    connectErrorEvent: 'connect_error',
+    connectEvent: 'connect',
+    hiddenDelayMilliseconds: 60000,
+    maxRetryMilliseconds: 30000,
+    retryBaseMilliseconds: 1000,
+    visibilityEvent: 'visibilitychange',
+};

package/dist/sockets/socket-live-service.d.ts

@@ -0,0 +1,20 @@
+import type { SocketLiveOptions } from '../models/socket-live-options';
+export declare class SocketLiveService {
+    private readonly options;
+    private socket;
+    private token;
+    private isClosed;
+    private hasConnected;
+    private failures;
+    private retryTimer;
+    private hiddenTimer;
+    constructor(options: SocketLiveOptions);
+    static open(options: SocketLiveOptions): Promise<SocketLiveService>;
+    start(): Promise<void>;
+    close(): void;
+    private connected;
+    private retryLater;
+    private reconnect;
+    private readonly visibility;
+    private clearTimers;
+}

package/dist/sockets/socket-live-service.js

@@ -0,0 +1,174 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketLiveService = void 0;
+var socket_client_service_1 = require("./socket-client-service");
+var socket_live_config_1 = require("./socket-live-config");
+var SocketLiveService = /** @class */ (function () {
+    function SocketLiveService(options) {
+        var _this = this;
+        this.options = options;
+        this.socket = null;
+        this.token = null;
+        this.isClosed = false;
+        this.hasConnected = false;
+        this.failures = 0;
+        this.retryTimer = null;
+        this.hiddenTimer = null;
+        this.visibility = function () {
+            if (_this.isClosed || _this.socket === null)
+                return;
+            if (document.visibilityState === 'hidden') {
+                var delay = _this.options.hiddenDelayMilliseconds === undefined
+                    ? socket_live_config_1.SocketLiveConfig.hiddenDelayMilliseconds
+                    : _this.options.hiddenDelayMilliseconds;
+                _this.hiddenTimer = setTimeout(function () {
+                    _this.hiddenTimer = null;
+                    if (_this.socket !== null)
+                        _this.socket.disconnect();
+                }, delay);
+                return;
+            }
+            if (_this.hiddenTimer !== null) {
+                clearTimeout(_this.hiddenTimer);
+                _this.hiddenTimer = null;
+            }
+            if (!_this.socket.connected)
+                void _this.reconnect();
+        };
+    }
+    SocketLiveService.open = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var live;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        live = new SocketLiveService(options);
+                        return [4 /*yield*/, live.start()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, live];
+                }
+            });
+        });
+    };
+    SocketLiveService.prototype.start = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, socket;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, this.options.fetchToken()];
+                    case 1:
+                        _a.token = _b.sent();
+                        if (this.isClosed || this.token === null)
+                            return [2 /*return*/];
+                        socket = socket_client_service_1.SocketClientService.connect({
+                            path: this.options.path,
+                            token: function () { return _this.token; },
+                        });
+                        this.socket = socket;
+                        this.options.events.forEach(function (name) {
+                            return socket.on(name, function (payload) { return _this.options.onEvent(name, payload); });
+                        });
+                        socket.on(socket_live_config_1.SocketLiveConfig.connectEvent, function () { return _this.connected(); });
+                        socket.on(socket_live_config_1.SocketLiveConfig.connectErrorEvent, function () { return _this.retryLater(); });
+                        if (typeof document !== 'undefined')
+                            document.addEventListener(socket_live_config_1.SocketLiveConfig.visibilityEvent, this.visibility);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SocketLiveService.prototype.close = function () {
+        this.isClosed = true;
+        this.clearTimers();
+        if (typeof document !== 'undefined')
+            document.removeEventListener(socket_live_config_1.SocketLiveConfig.visibilityEvent, this.visibility);
+        if (this.socket !== null)
+            this.socket.disconnect();
+    };
+    SocketLiveService.prototype.connected = function () {
+        this.failures = 0;
+        if (this.hasConnected && this.options.onResume !== undefined)
+            this.options.onResume();
+        this.hasConnected = true;
+    };
+    SocketLiveService.prototype.retryLater = function () {
+        var _this = this;
+        if (this.isClosed || this.retryTimer !== null)
+            return;
+        var delay = Math.min(socket_live_config_1.SocketLiveConfig.retryBaseMilliseconds * Math.pow(2, this.failures), socket_live_config_1.SocketLiveConfig.maxRetryMilliseconds);
+        this.failures += 1;
+        this.retryTimer = setTimeout(function () {
+            _this.retryTimer = null;
+            void _this.reconnect();
+        }, delay);
+    };
+    SocketLiveService.prototype.reconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var token;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.fetchToken()];
+                    case 1:
+                        token = _a.sent();
+                        if (this.isClosed || this.socket === null)
+                            return [2 /*return*/];
+                        if (token === null)
+                            return [2 /*return*/, this.retryLater()];
+                        this.token = token;
+                        this.socket.connect();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SocketLiveService.prototype.clearTimers = function () {
+        if (this.retryTimer !== null)
+            clearTimeout(this.retryTimer);
+        if (this.hiddenTimer !== null)
+            clearTimeout(this.hiddenTimer);
+        this.retryTimer = null;
+        this.hiddenTimer = null;
+    };
+    return SocketLiveService;
+}());
+exports.SocketLiveService = SocketLiveService;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pallasoft/ps-utilities",
-	"version": "2.19.1",
+	"version": "2.21.0",
 	"private": false,
 	"main": "./dist/index.js",
 	"module": "./dist/esm/index.js",
@@ -19,6 +19,12 @@
 			"require": "./dist/server/index.js",
 			"default": "./dist/server/index.js"
 		},
+		"./edge-logs": {
+			"types": "./dist/edge-logs/index.d.ts",
+			"module": "./dist/esm/edge-logs/index.js",
+			"require": "./dist/edge-logs/index.js",
+			"default": "./dist/edge-logs/index.js"
+		},
 		"./build": {
 			"types": "./dist/build/index.d.ts",
 			"require": "./dist/build/index.js",
@@ -109,6 +115,9 @@
 	},
 	"typesVersions": {
 		"*": {
+			"edge-logs": [
+				"dist/edge-logs/index.d.ts"
+			],
 			"server": [
 				"dist/server/index.d.ts"
 			],