@pallasoft/ps-utilities 2.19.1 → 2.20.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/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/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/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.20.0",
 	"private": false,
 	"main": "./dist/index.js",
 	"module": "./dist/esm/index.js",