@pallasoft/ps-utilities 2.18.0 → 2.19.0

package/dist/esm/common/constants/postal-code-formats.js

@@ -0,0 +1,10 @@
+export const PostalCodeFormats = {
+    CA: { allowed: /[^A-Z0-9]/g, groups: [3, 3], separator: ' ' },
+    GB: { allowed: /[^A-Z0-9]/g, groups: [], separator: ' ' },
+    IN: { allowed: /[^0-9]/g, groups: [6], separator: '' },
+    NL: { allowed: /[^A-Z0-9]/g, groups: [4, 2], separator: ' ' },
+    US: { allowed: /[^0-9]/g, groups: [5, 4], separator: '-' },
+};
+export const PostalCodeConfig = {
+    fallbackAllowed: /[^A-Z0-9 -]/g,
+};

package/dist/esm/common/constants/relative-time-config.js

@@ -0,0 +1,11 @@
+export const RelativeTimeConfig = {
+    futureToleranceSeconds: 300,
+    justNowSeconds: 45,
+    millisecondsPerSecond: 1000,
+    format: { numeric: 'auto' },
+    units: [
+        { limitSeconds: 3600, seconds: 60, unit: 'minute' },
+        { limitSeconds: 86400, seconds: 3600, unit: 'hour' },
+        { limitSeconds: 604800, seconds: 86400, unit: 'day' },
+    ],
+};

package/dist/esm/common/constants/request-client-config.js

@@ -0,0 +1,6 @@
+import { HttpHeader } from './http-header';
+export const RequestClientConfig = {
+    addressHeaders: [HttpHeader.cfConnectingIp, HttpHeader.realIp, HttpHeader.forwardedFor],
+    agentHeader: HttpHeader.userAgent,
+    listSeparator: ',',
+};

package/dist/esm/common/constants/signed-token-config.js

@@ -0,0 +1,11 @@
+export const SignedTokenConfig = {
+    algorithm: 'ES256',
+    type: 'JWT',
+    keyAlgorithm: { name: 'ECDSA', namedCurve: 'P-256' },
+    signAlgorithm: { name: 'ECDSA', hash: 'SHA-256' },
+    privateKeyFormat: 'pkcs8',
+    publicKeyFormat: 'spki',
+    separator: '.',
+    partCount: 3,
+    keyCacheLimit: 20,
+};

package/dist/esm/common/constants/socket-token-config.js

@@ -0,0 +1,4 @@
+export const SocketTokenConfig = {
+    defaultSeconds: 43200,
+    millisecondsPerSecond: 1000,
+};

package/dist/esm/common/constants/user-agent-config.js

@@ -0,0 +1,18 @@
+export const UserAgentConfig = {
+    browsers: [
+        { name: 'Edge', pattern: /Edg\//i },
+        { name: 'Opera', pattern: /OPR\//i },
+        { name: 'Firefox', pattern: /Firefox\//i },
+        { name: 'Chrome', pattern: /(Chrome|CriOS)\//i },
+        { name: 'Safari', pattern: /Safari\//i },
+    ],
+    systems: [
+        { name: 'iOS', pattern: /iPhone|iPad|iPod/i },
+        { name: 'Android', pattern: /Android/i },
+        { name: 'Windows', pattern: /Windows/i },
+        { name: 'macOS', pattern: /Mac OS X|Macintosh/i },
+        { name: 'Linux', pattern: /Linux/i },
+    ],
+    unknown: 'Unknown device',
+    joiner: ' on ',
+};

package/dist/esm/common/constants/user-token-config.js

@@ -0,0 +1,5 @@
+export const UserTokenConfig = {
+    defaultLifetimeSeconds: 60,
+    maxLifetimeSeconds: 120,
+    clockSkewSeconds: 5,
+};

package/dist/esm/common/constants/validation-config.js

@@ -0,0 +1,8 @@
+export const ValidationConfig = {
+    email: /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+    webProtocols: ['http:', 'https:'],
+    hostSeparator: '.',
+    urlProtocol: 'https://',
+    urlProtocolPattern: /^[a-z][a-z0-9+.-]*:\/\//i,
+    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+};

package/dist/esm/common/crypto-service.js

@@ -0,0 +1,128 @@
+import { Base64Service } from './base64-service';
+export class CryptoService {
+    static requireKey(key, name) {
+        if (typeof key !== 'string' || key.trim().length === 0) {
+            throw new Error(`${name} is required and must not be empty`);
+        }
+        return key;
+    }
+    static _getAdditionalData() {
+        return this._textEncoder.encode(this._aad);
+    }
+    static _parsePayload(encryptedPayload) {
+        const payload = JSON.parse(encryptedPayload);
+        const isDerived = payload.v === this._payloadVersion && Boolean(payload.salt);
+        const isDataKey = payload.v === this._dataKeyPayloadVersion;
+        if (payload.alg !== this._payloadAlgorithm ||
+            !payload.iv ||
+            !payload.ciphertext ||
+            (!isDerived && !isDataKey)) {
+            throw new Error('Encrypted payload is malformed');
+        }
+        return payload;
+    }
+    static async _deriveKey(cryptoKey, salt) {
+        const baseKey = await crypto.subtle.importKey('raw', this._textEncoder.encode(cryptoKey), 'PBKDF2', false, ['deriveKey']);
+        return await crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            hash: 'SHA-256',
+            salt: salt,
+            iterations: this._iterations,
+        }, baseKey, {
+            name: this._algorithm,
+            length: this._keyLength,
+        }, false, ['encrypt', 'decrypt']);
+    }
+    static async encryptPayload(payload, cryptoKey) {
+        this.requireKey(cryptoKey, 'Encryption key');
+        const iv = crypto.getRandomValues(new Uint8Array(this._ivLength));
+        const salt = crypto.getRandomValues(new Uint8Array(this._saltLength));
+        const key = await this._deriveKey(cryptoKey, salt);
+        const encryptedBuffer = await crypto.subtle.encrypt({
+            name: this._algorithm,
+            iv,
+            additionalData: this._getAdditionalData(),
+        }, key, this._textEncoder.encode(JSON.stringify(payload)));
+        const serializedPayload = {
+            v: this._payloadVersion,
+            alg: this._payloadAlgorithm,
+            iv: Base64Service.encode(iv),
+            salt: Base64Service.encode(salt),
+            ciphertext: Base64Service.encode(new Uint8Array(encryptedBuffer)),
+        };
+        return JSON.stringify(serializedPayload);
+    }
+    static async _importDataKey(dataKey) {
+        return await crypto.subtle.importKey('raw', Base64Service.decode(dataKey), { name: this._algorithm, length: this._keyLength }, false, ['encrypt', 'decrypt']);
+    }
+    static generateDataKey() {
+        return Base64Service.encode(crypto.getRandomValues(new Uint8Array(this._dataKeyLength)));
+    }
+    static async encryptPayloadWithDataKey(payload, dataKey) {
+        this.requireKey(dataKey, 'Data key');
+        const iv = crypto.getRandomValues(new Uint8Array(this._ivLength));
+        const encryptedBuffer = await crypto.subtle.encrypt({ name: this._algorithm, iv, additionalData: this._getAdditionalData() }, await this._importDataKey(dataKey), this._textEncoder.encode(JSON.stringify(payload)));
+        return JSON.stringify({
+            v: this._dataKeyPayloadVersion,
+            alg: this._payloadAlgorithm,
+            iv: Base64Service.encode(iv),
+            ciphertext: Base64Service.encode(new Uint8Array(encryptedBuffer)),
+        });
+    }
+    static async decryptPayloadWithDataKey(encryptedPayload, dataKey) {
+        this.requireKey(dataKey, 'Data key');
+        const payload = this._parsePayload(encryptedPayload);
+        const decryptedBuffer = await crypto.subtle.decrypt({
+            name: this._algorithm,
+            iv: Base64Service.decode(payload.iv),
+            additionalData: this._getAdditionalData(),
+        }, await this._importDataKey(dataKey), Base64Service.decode(payload.ciphertext));
+        return JSON.parse(this._textDecoder.decode(decryptedBuffer));
+    }
+    static async encryptValueWithDataKey(value, dataKey) {
+        return await this.encryptPayloadWithDataKey({ value }, dataKey);
+    }
+    static async decryptValueWithDataKey(encryptedPayload, dataKey) {
+        const { value } = await this.decryptPayloadWithDataKey(encryptedPayload, dataKey);
+        return value;
+    }
+    static async encryptValue(value, cryptoKey) {
+        return await this.encryptPayload({ value }, cryptoKey);
+    }
+    static async decryptValue(encryptedPayload, cryptoKey) {
+        const { value } = await this.decryptPayload(encryptedPayload, cryptoKey);
+        return value;
+    }
+    static isEncryptedPayload(candidate) {
+        try {
+            this._parsePayload(candidate);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async decryptPayload(encryptedPayload, cryptoKey) {
+        this.requireKey(cryptoKey, 'Encryption key');
+        const payload = this._parsePayload(encryptedPayload);
+        const key = await this._deriveKey(cryptoKey, Base64Service.decode(payload.salt));
+        const decryptedBuffer = await crypto.subtle.decrypt({
+            name: this._algorithm,
+            iv: Base64Service.decode(payload.iv),
+            additionalData: this._getAdditionalData(),
+        }, key, Base64Service.decode(payload.ciphertext));
+        return JSON.parse(this._textDecoder.decode(decryptedBuffer));
+    }
+}
+CryptoService._algorithm = 'AES-GCM';
+CryptoService._keyLength = 256;
+CryptoService._iterations = 100000;
+CryptoService._ivLength = 12;
+CryptoService._saltLength = 16;
+CryptoService._textEncoder = new TextEncoder();
+CryptoService._textDecoder = new TextDecoder();
+CryptoService._payloadVersion = 1;
+CryptoService._dataKeyPayloadVersion = 2;
+CryptoService._dataKeyLength = 32;
+CryptoService._payloadAlgorithm = 'A256GCM';
+CryptoService._aad = 'encrypted-form:v1:a256gcm';

package/dist/esm/common/date-service.js

@@ -0,0 +1,101 @@
+import dayjs from 'dayjs';
+import timezone from 'dayjs/plugin/timezone.js';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+export class DateService {
+    static getDate(date) {
+        if (date)
+            return dayjs(date);
+        return dayjs();
+    }
+    static getToday() {
+        return dayjs().toISOString();
+    }
+    static getTomorrow() {
+        return dayjs().add(1, 'day').toISOString();
+    }
+    static formatSecondsToTime(seconds) {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const remainingSeconds = Math.floor(seconds % 60);
+        if (hours > 0) {
+            return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(remainingSeconds).padStart(2, '0')}`;
+        }
+        else if (minutes > 0) {
+            return `${String(minutes).padStart(2, '0')}:${String(remainingSeconds).padStart(2, '0')}`;
+        }
+        else {
+            return `00:${String(remainingSeconds).padStart(2, '0')}`;
+        }
+    }
+    static calculateTimeRemaining(date, placeholder) {
+        const currentDate = dayjs();
+        const targetDate = dayjs(date);
+        const diffSeconds = targetDate.diff(currentDate, 'second');
+        if (diffSeconds <= 0) {
+            return placeholder;
+        }
+        const hours = Math.floor(diffSeconds / 3600);
+        const minutes = Math.floor((diffSeconds % 3600) / 60);
+        const seconds = diffSeconds % 60;
+        if (hours)
+            return `${hours}h ${minutes}m ${seconds}s`;
+        if (minutes)
+            return `${minutes}m ${seconds}s`;
+        return `${seconds}s`;
+    }
+    static getNextWeek() {
+        return dayjs().add(1, 'week').toISOString();
+    }
+    static getNextMonth() {
+        return dayjs().add(1, 'month').toISOString();
+    }
+    static getNextYear() {
+        return dayjs().add(1, 'year').toISOString();
+    }
+    static formatDate(date, format) {
+        return dayjs(date).format(format);
+    }
+    static formatDateInTimezone(date, zone, format) {
+        return dayjs(date).tz(zone).format(format);
+    }
+    static calendarDateInTimezone(date, zone) {
+        return dayjs(date).tz(zone).format('YYYY-MM-DD');
+    }
+    static todayInTimezone(zone) {
+        return dayjs().tz(zone).format('YYYY-MM-DD');
+    }
+    static formatDateToString(date, short) {
+        return dayjs(date).format(short ? 'DD MMM, YYYY' : 'DD MMMM, YYYY');
+    }
+    static formatTimeToString(date, short) {
+        return dayjs(date).format(short ? 'DD MMM, YYYY @ hh:MM:ss A' : 'DD MMMM, YYYY @ hh:MM:ss A');
+    }
+    static diffInMins(startDate, endDate) {
+        const start = dayjs(startDate);
+        const end = dayjs(endDate);
+        return end.diff(start, 'minutes');
+    }
+    static nowMilliseconds() {
+        return dayjs().valueOf();
+    }
+    static nowUnixSeconds() {
+        return dayjs().unix();
+    }
+    static fromParts(year, monthIndex, day) {
+        return dayjs(`${String(year).padStart(4, '0')}-${String(monthIndex + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`);
+    }
+    static isValid(date) {
+        return dayjs(date).isValid();
+    }
+    static addDays(date, days) {
+        return dayjs.utc(date).add(days, 'day').format('YYYY-MM-DD');
+    }
+    static addDaysToInstant(instant, days) {
+        return dayjs.utc(instant).add(days, 'day').toDate();
+    }
+    static startOfUtcDay(instant) {
+        return dayjs.utc(instant).startOf('day').toDate();
+    }
+}

package/dist/esm/common/email-preview-service.js

@@ -0,0 +1,142 @@
+import { EmailPreviewConfig } from './constants/email-preview-config';
+import { DateService } from './date-service';
+export class EmailPreviewService {
+    static escape(value) {
+        return value
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+    }
+    static hasContent(input) {
+        return ((input.html !== null && input.html.trim() !== '') ||
+            (input.text !== null && input.text.trim() !== ''));
+    }
+    static receivedOf(input) {
+        return DateService.formatDateInTimezone(input.receivedAt, input.timezone, EmailPreviewConfig.dateFormat);
+    }
+    static subjectOf(input) {
+        return input.subject === null || input.subject.trim() === ''
+            ? EmailPreviewConfig.fallbackSubject
+            : input.subject.trim();
+    }
+    static toText(input) {
+        if (input.text !== null && input.text.trim() !== '')
+            return input.text.trim();
+        if (input.html === null)
+            return '';
+        return EmailPreviewService.fromHtml(input.html);
+    }
+    static toDocument(input) {
+        const subject = EmailPreviewService.subjectOf(input);
+        const body = input.html !== null && input.html.trim() !== ''
+            ? EmailPreviewService.body(input.html)
+            : `<pre style="white-space:pre-wrap;font-family:inherit;margin:0;">${EmailPreviewService.escape(input.text === null ? '' : input.text)}</pre>`;
+        return `<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>${EmailPreviewService.escape(subject)}</title>
+	</head>
+	<body style="margin:0;padding:24px;background:#f5f7fa;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif;color:#101828;">
+		<div style="max-width:760px;margin:0 auto;background:#ffffff;border:1px solid #e4e8ee;border-radius:12px;overflow:hidden;">
+			<div style="padding:16px 20px;border-bottom:1px solid #e4e8ee;background:#f9fafb;">
+				<div style="font-size:15px;font-weight:700;">${EmailPreviewService.escape(subject)}</div>
+				<div style="margin-top:4px;font-size:12px;color:#667085;">From ${EmailPreviewService.escape(input.from)} · ${EmailPreviewService.escape(EmailPreviewService.receivedOf(input))}</div>
+			</div>
+			<div style="padding:20px;">${body}</div>
+		</div>
+	</body>
+</html>`;
+    }
+    static toImageMarkup(input) {
+        const { page } = EmailPreviewConfig;
+        const width = page.width - page.padding * 2;
+        const subject = EmailPreviewService.clip(EmailPreviewService.subjectOf(input), Math.floor(width / (page.charWidth * page.subjectWidthRatio)));
+        const meta = EmailPreviewService.clip(`From ${input.from} · ${EmailPreviewService.receivedOf(input)}`, Math.floor(width / (page.charWidth * page.metaWidthRatio)));
+        const lines = EmailPreviewService.wrap(EmailPreviewService.toText(input), Math.floor(width / page.charWidth)).slice(0, page.maxLines);
+        const metaBaseline = page.padding + page.subjectSize + 10 + page.metaSize;
+        const bodyTop = metaBaseline + page.headerGap;
+        const height = Math.max(page.minHeight, bodyTop + lines.length * page.lineHeight + page.padding);
+        const body = lines
+            .map((line, index) => `<text x="${page.padding}" y="${bodyTop + index * page.lineHeight}" font-size="${page.bodySize}" fill="${page.bodyColour}">${EmailPreviewService.escape(line)}</text>`)
+            .join('');
+        return `<svg xmlns="http://www.w3.org/2000/svg" width="${page.width}" height="${height}" viewBox="0 0 ${page.width} ${height}" font-family="${page.fontFamily}">
+	<rect width="${page.width}" height="${height}" fill="${page.paperColour}" />
+	<rect x="0" y="0" width="${page.width}" height="${page.bandHeight}" fill="${page.bandColour}" />
+	<text x="${page.padding}" y="${page.padding + page.subjectSize}" font-size="${page.subjectSize}" font-weight="700" fill="${page.subjectColour}">${EmailPreviewService.escape(subject)}</text>
+	<text x="${page.padding}" y="${metaBaseline}" font-size="${page.metaSize}" fill="${page.metaColour}">${EmailPreviewService.escape(meta)}</text>
+	<line x1="${page.padding}" y1="${metaBaseline + 8}" x2="${page.width - page.padding}" y2="${metaBaseline + 8}" stroke="${page.ruleColour}" stroke-width="1" />
+	${body}
+</svg>`;
+    }
+    static clip(value, limit) {
+        return value.length <= limit ? value : `${value.slice(0, Math.max(limit - 1, 1))}…`;
+    }
+    static wrap(text, limit) {
+        const lines = [];
+        for (const paragraph of text.split('\n')) {
+            if (paragraph.trim() === '') {
+                lines.push('');
+                continue;
+            }
+            let current = '';
+            for (const word of paragraph.trim().split(/\s+/)) {
+                const candidate = current === '' ? word : `${current} ${word}`;
+                if (candidate.length <= limit) {
+                    current = candidate;
+                    continue;
+                }
+                if (current !== '')
+                    lines.push(current);
+                current = word.length <= limit ? word : EmailPreviewService.push(lines, word, limit);
+            }
+            lines.push(current);
+        }
+        return lines;
+    }
+    static push(lines, word, limit) {
+        let rest = word;
+        while (rest.length > limit) {
+            lines.push(rest.slice(0, limit));
+            rest = rest.slice(limit);
+        }
+        return rest;
+    }
+    static fromHtml(html) {
+        return EmailPreviewService.decode(html
+            .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '')
+            .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, '')
+            .replace(/<head\b[^>]*>[\s\S]*?<\/head>/gi, '')
+            .replace(/<br\s*\/?>/gi, '\n')
+            .replace(/<\/(p|div|tr|li|h[1-6]|table|section|header|footer)>/gi, '\n')
+            .replace(/<[^>]+>/g, ' '))
+            .replace(/[^\S\n]+/g, ' ')
+            .replace(/ *\n */g, '\n')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+    }
+    static decode(value) {
+        return value
+            .replace(/&nbsp;/gi, ' ')
+            .replace(/&amp;/gi, '&')
+            .replace(/&lt;/gi, '<')
+            .replace(/&gt;/gi, '>')
+            .replace(/&quot;/gi, '"')
+            .replace(/&#0?39;|&#x27;|&apos;/gi, "'")
+            .replace(/&#8217;|&rsquo;/gi, '’')
+            .replace(/&#8212;|&mdash;/gi, '—')
+            .replace(/&#8211;|&ndash;/gi, '–');
+    }
+    static body(html) {
+        const withoutScripts = html
+            .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '')
+            .replace(/<iframe\b[^>]*>[\s\S]*?<\/iframe>/gi, '')
+            .replace(/\son[a-z]+\s*=\s*"[^"]*"/gi, '')
+            .replace(/\son[a-z]+\s*=\s*'[^']*'/gi, '');
+        const inner = withoutScripts.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+        return inner === null ? withoutScripts : inner[1];
+    }
+}

package/dist/esm/common/encrypted-fields-service.js

@@ -0,0 +1,49 @@
+import { EnvelopeCryptoService } from './envelope-crypto-service';
+export class EncryptedFieldsService {
+    static _isBlank(value) {
+        return value === null || value === undefined || value === '';
+    }
+    static async encrypt(row, spec, wrappedDataKey, masterKey) {
+        const encrypted = { ...row };
+        for (const field of (spec.values !== null && spec.values !== undefined
+            ? spec.values
+            : [])) {
+            const value = encrypted[field];
+            if (this._isBlank(value))
+                continue;
+            encrypted[field] = await EnvelopeCryptoService.encryptValue(value, wrappedDataKey, masterKey);
+        }
+        for (const field of (spec.json !== null && spec.json !== undefined
+            ? spec.json
+            : [])) {
+            const value = encrypted[field];
+            if (this._isBlank(value))
+                continue;
+            encrypted[field] = await EnvelopeCryptoService.encryptPayload(value, wrappedDataKey, masterKey);
+        }
+        return encrypted;
+    }
+    static async decrypt(row, spec, wrappedDataKey, masterKey) {
+        const decrypted = { ...row };
+        for (const field of (spec.values !== null && spec.values !== undefined
+            ? spec.values
+            : [])) {
+            const value = decrypted[field];
+            if (this._isBlank(value))
+                continue;
+            decrypted[field] = await EnvelopeCryptoService.decryptValue(value, wrappedDataKey, masterKey);
+        }
+        for (const field of (spec.json !== null && spec.json !== undefined
+            ? spec.json
+            : [])) {
+            const value = decrypted[field];
+            if (this._isBlank(value))
+                continue;
+            decrypted[field] = await EnvelopeCryptoService.decryptPayload(value, wrappedDataKey, masterKey);
+        }
+        return decrypted;
+    }
+    static async decryptMany(rows, spec, wrappedDataKey, masterKey) {
+        return await Promise.all(rows.map(async (row) => await this.decrypt(row, spec, wrappedDataKey, masterKey)));
+    }
+}

package/dist/esm/common/envelope-crypto-service.js

@@ -0,0 +1,48 @@
+import { CryptoService } from './crypto-service';
+export class EnvelopeCryptoService {
+    static _remember(wrappedDataKey, dataKey) {
+        if (this._cache.size >= this._cacheLimit) {
+            const oldest = this._cache.keys().next().value;
+            if (oldest)
+                this._cache.delete(oldest);
+        }
+        this._cache.set(wrappedDataKey, dataKey);
+    }
+    static async createDataKey(masterKey) {
+        CryptoService.requireKey(masterKey, 'Master key');
+        const dataKey = CryptoService.generateDataKey();
+        const wrappedDataKey = await CryptoService.encryptValue(dataKey, masterKey);
+        this._remember(wrappedDataKey, dataKey);
+        return { dataKey, wrappedDataKey };
+    }
+    static async unwrapDataKey(wrappedDataKey, masterKey) {
+        CryptoService.requireKey(masterKey, 'Master key');
+        const cached = this._cache.get(wrappedDataKey);
+        if (cached)
+            return cached;
+        const dataKey = await CryptoService.decryptValue(wrappedDataKey, masterKey);
+        this._remember(wrappedDataKey, dataKey);
+        return dataKey;
+    }
+    static async rewrapDataKey(wrappedDataKey, currentMasterKey, nextMasterKey) {
+        const dataKey = await this.unwrapDataKey(wrappedDataKey, currentMasterKey);
+        return await CryptoService.encryptValue(dataKey, nextMasterKey);
+    }
+    static async encryptValue(value, wrappedDataKey, masterKey) {
+        return await CryptoService.encryptValueWithDataKey(value, await this.unwrapDataKey(wrappedDataKey, masterKey));
+    }
+    static async decryptValue(encryptedPayload, wrappedDataKey, masterKey) {
+        return await CryptoService.decryptValueWithDataKey(encryptedPayload, await this.unwrapDataKey(wrappedDataKey, masterKey));
+    }
+    static async encryptPayload(payload, wrappedDataKey, masterKey) {
+        return await CryptoService.encryptPayloadWithDataKey(payload, await this.unwrapDataKey(wrappedDataKey, masterKey));
+    }
+    static async decryptPayload(encryptedPayload, wrappedDataKey, masterKey) {
+        return await CryptoService.decryptPayloadWithDataKey(encryptedPayload, await this.unwrapDataKey(wrappedDataKey, masterKey));
+    }
+    static forget(wrappedDataKey) {
+        this._cache.delete(wrappedDataKey);
+    }
+}
+EnvelopeCryptoService._cache = new Map();
+EnvelopeCryptoService._cacheLimit = 500;

package/dist/esm/common/error-response-service.js

@@ -0,0 +1,20 @@
+import { ErrorResponseConfig } from './constants/error-response-config';
+export class ErrorResponseService {
+    static create(message, code) {
+        return Object.assign(new Error(message), { code });
+    }
+    static code(error) {
+        if (typeof error !== 'object' || error === null || !('code' in error))
+            return null;
+        return typeof error.code === 'number' ? error.code : null;
+    }
+    static isClientError(status) {
+        return (status >= ErrorResponseConfig.clientErrorStart &&
+            status < ErrorResponseConfig.serverErrorStart);
+    }
+    static pageContent(status, message, base) {
+        return ErrorResponseService.isClientError(status) && message !== undefined && message !== ''
+            ? { ...base, description: message }
+            : base;
+    }
+}

package/dist/esm/common/file-size-service.js

@@ -0,0 +1,15 @@
+import { FileSizeConfig } from './constants/file-size-config';
+export class FileSizeService {
+    static format(bytes) {
+        let value = Math.max(0, bytes);
+        let unit = 0;
+        while (value >= FileSizeConfig.step && unit < FileSizeConfig.units.length - 1) {
+            value /= FileSizeConfig.step;
+            unit += 1;
+        }
+        const shown = unit === 0 || value >= FileSizeConfig.wholeFrom
+            ? Math.round(value)
+            : Math.round(value * 10) / 10;
+        return `${shown} ${FileSizeConfig.units[unit]}`;
+    }
+}

package/dist/esm/common/index.js

@@ -0,0 +1,27 @@
+export * from './amount-service';
+export * from './base64-service';
+export * from './color-service';
+export * from './constants';
+export * from './crypto-service';
+export * from './date-service';
+export * from './email-preview-service';
+export * from './encrypted-fields-service';
+export * from './file-size-service';
+export * from './envelope-crypto-service';
+export * from './number-format-service';
+export * from './phone-service';
+export * from './postal-code-service';
+export * from './recaptcha-service';
+export * from './signed-token-service';
+export * from './socket-token-service';
+export * from './string-service';
+export * from './transform-service';
+export * from './url-service';
+export * from './user-agent-service';
+export * from './user-token-service';
+export * from './validation-service';
+export * from './error-response-service';
+export * from './relative-time-service';
+export * from './request-client-service';
+export * from './json-service';
+export * from './portable-text-service';

package/dist/esm/common/json-service.js

@@ -0,0 +1,16 @@
+export class JsonService {
+    static read(text) {
+        if (typeof text !== 'string')
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static parse(text, guard) {
+        const value = this.read(text);
+        return value !== undefined && guard(value) ? value : null;
+    }
+}

package/dist/esm/common/number-format-service.js

@@ -0,0 +1,22 @@
+export class NumberFormatService {
+    static formatCurrency(value, currencyCode, locale = 'en-US', minimumFractionDigits = 0, maximumFractionDigits = 2) {
+        return new Intl.NumberFormat(locale, {
+            currency: currencyCode,
+            maximumFractionDigits,
+            minimumFractionDigits,
+            style: 'currency',
+        }).format(value);
+    }
+    static formatCompact(value, locale = 'en-US') {
+        return new Intl.NumberFormat(locale, {
+            compactDisplay: 'short',
+            notation: 'compact',
+        }).format(value);
+    }
+    static formatPercent(value, locale = 'en-US') {
+        return new Intl.NumberFormat(locale, {
+            maximumFractionDigits: 1,
+            style: 'percent',
+        }).format(value);
+    }
+}