@pallasoft/ps-utilities 2.18.0 → 2.19.0

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

@@ -0,0 +1,70 @@
+import { AsYouType, getCountries, getCountryCallingCode, parsePhoneNumberFromString, } from 'libphonenumber-js';
+import { PhoneConfig } from './constants/phone-config';
+export class PhoneService {
+    static isCountry(code) {
+        return getCountries().includes(code);
+    }
+    static countries(preferred, locale = PhoneConfig.locale) {
+        const names = new Intl.DisplayNames([locale], { type: PhoneConfig.displayNamesType });
+        const options = getCountries().map((code) => {
+            const name = names.of(code);
+            return {
+                callingCode: getCountryCallingCode(code),
+                code,
+                label: name !== undefined ? name : code,
+            };
+        });
+        return options.sort((left, right) => {
+            if (left.code === preferred)
+                return -1;
+            if (right.code === preferred)
+                return 1;
+            return left.label.localeCompare(right.label);
+        });
+    }
+    static display(value, fallbackCountry) {
+        const parsed = value.startsWith(PhoneConfig.plus)
+            ? parsePhoneNumberFromString(value)
+            : undefined;
+        if (parsed !== undefined && parsed.country !== undefined)
+            return { country: parsed.country, national: parsed.formatNational() };
+        return { country: fallbackCountry, national: value };
+    }
+    static format(national, country) {
+        if (!PhoneService.isCountry(country))
+            return national;
+        return new AsYouType(country).input(national);
+    }
+    static formatForDisplay(value, country) {
+        const parsed = PhoneService.parse(value, country);
+        if (parsed === undefined || !parsed.isValid())
+            return value.trim();
+        return parsed.country === country ? parsed.formatNational() : parsed.formatInternational();
+    }
+    static toStored(national, country) {
+        const trimmed = national.trim();
+        if (trimmed === '' || !PhoneService.isCountry(country))
+            return trimmed;
+        const parsed = parsePhoneNumberFromString(trimmed, country);
+        return parsed !== undefined ? parsed.number : trimmed;
+    }
+    static isValid(national, country) {
+        if (national.trim() === '')
+            return true;
+        const parsed = PhoneService.parse(national, country);
+        return parsed !== undefined && parsed.isValid();
+    }
+    static callingCode(country) {
+        return PhoneService.isCountry(country) ? getCountryCallingCode(country) : '';
+    }
+    static parse(value, country) {
+        const trimmed = value.trim();
+        if (trimmed === '')
+            return undefined;
+        if (trimmed.startsWith(PhoneConfig.plus))
+            return parsePhoneNumberFromString(trimmed);
+        return PhoneService.isCountry(country)
+            ? parsePhoneNumberFromString(trimmed, country)
+            : undefined;
+    }
+}

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

@@ -0,0 +1,97 @@
+import { Common } from '@pallasoft/ps-models';
+import { escapeHTML, toHTML } from '@portabletext/to-html';
+import { PortableTextConfig } from './constants/portable-text-config';
+export class PortableTextService {
+    static toPlainText(blocks) {
+        const lines = [];
+        const counters = {};
+        let previousWasList = false;
+        blocks.forEach((block) => {
+            if (block._type !== Common.PortableTextConfig.blockType)
+                return;
+            const text = this.blockText(block);
+            const level = typeof block.level === 'number' ? block.level : 1;
+            const isNumber = block.listItem === PortableTextConfig.numberItem;
+            const isBullet = block.listItem === PortableTextConfig.bulletItem;
+            const isList = isNumber || isBullet;
+            if (!isList) {
+                counters[level] = 0;
+                if (lines.length > 0)
+                    lines.push(PortableTextConfig.paragraphSeparator);
+                lines.push(block.style === PortableTextConfig.quoteStyle
+                    ? PortableTextConfig.quotePrefix + text
+                    : text);
+                previousWasList = false;
+                return;
+            }
+            counters[level] = isNumber
+                ? (typeof counters[level] === 'number' ? counters[level] : 0) + 1
+                : 0;
+            const prefix = isNumber
+                ? `${counters[level]}${PortableTextConfig.numberSuffix}`
+                : PortableTextConfig.bulletPrefix;
+            const indent = '  '.repeat(level - 1);
+            if (lines.length > 0)
+                lines.push(previousWasList ? PortableTextConfig.lineSeparator : PortableTextConfig.paragraphSeparator);
+            lines.push(indent + prefix + text);
+            previousWasList = true;
+        });
+        return lines.join('');
+    }
+    static fromPlainText(text) {
+        return text
+            .replace(PortableTextConfig.lineBreakPattern, PortableTextConfig.lineSeparator)
+            .split(PortableTextConfig.paragraphSplitPattern)
+            .map((paragraph) => paragraph.trim())
+            .filter((paragraph) => paragraph.length > 0)
+            .map((paragraph, index) => ({
+            _type: Common.PortableTextConfig.blockType,
+            _key: `${PortableTextConfig.keyPrefix.block}${index}`,
+            style: PortableTextConfig.normalStyle,
+            markDefs: [],
+            children: [
+                {
+                    _type: Common.PortableTextConfig.spanType,
+                    _key: `${PortableTextConfig.keyPrefix.span}${index}`,
+                    text: paragraph,
+                    marks: [],
+                },
+            ],
+        }));
+    }
+    static isEmpty(blocks) {
+        return (!Array.isArray(blocks) || blocks.every((block) => this.blockText(block).trim().length === 0));
+    }
+    static toHtml(blocks) {
+        return toHTML(blocks, {
+            onMissingComponent: false,
+            components: {
+                marks: {
+                    link: ({ children, value }) => {
+                        const href = typeof value?.href === 'string' ? value.href : '';
+                        return this.isSafeLink(href)
+                            ? `<a href="${escapeHTML(href)}" rel="${PortableTextConfig.linkRel}" target="${PortableTextConfig.linkTarget}">${children}</a>`
+                            : children;
+                    },
+                },
+            },
+        });
+    }
+    static blockText(block) {
+        return Array.isArray(block.children)
+            ? block.children
+                .map((child) => child._type === Common.PortableTextConfig.spanType && typeof child.text === 'string'
+                ? child.text
+                : '')
+                .join('')
+            : '';
+    }
+    static isSafeLink(href) {
+        try {
+            return Common.PortableTextConfig.linkProtocols.includes(new URL(href).protocol);
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/esm/common/postal-code-service.js

@@ -0,0 +1,34 @@
+import { PostalCodeConfig, PostalCodeFormats } from './constants/postal-code-formats';
+export class PostalCodeService {
+    static format(raw, country) {
+        const upper = raw.toUpperCase();
+        const format = PostalCodeFormats[country];
+        if (format === undefined)
+            return upper.replace(PostalCodeConfig.fallbackAllowed, '');
+        const compact = upper.replace(format.allowed, '');
+        if (format.groups.length === 0)
+            return upper.replace(PostalCodeConfig.fallbackAllowed, '');
+        const parts = [];
+        let cursor = 0;
+        for (const size of format.groups) {
+            if (cursor >= compact.length)
+                break;
+            parts.push(compact.slice(cursor, cursor + size));
+            cursor += size;
+        }
+        return parts.join(format.separator);
+    }
+    static maxLength(country) {
+        const format = PostalCodeFormats[country];
+        if (format === undefined || format.groups.length === 0)
+            return undefined;
+        return (format.groups.reduce((sum, size) => sum + size, 0) +
+            format.separator.length * (format.groups.length - 1));
+    }
+    static isValid(raw, country) {
+        const format = PostalCodeFormats[country];
+        if (raw.trim() === '' || format === undefined || format.groups.length === 0)
+            return true;
+        return PostalCodeService.format(raw, country).length === PostalCodeService.maxLength(country);
+    }
+}

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

@@ -0,0 +1,23 @@
+export class RecaptchaService {
+    static async verify(token, secretKey, remoteIp) {
+        if (!process.env.RECAPTCHA_VERIFY_URL) {
+            throw new Error('No reCAPTCHA verify URL found');
+        }
+        const params = new URLSearchParams({ secret: secretKey, response: token });
+        if (remoteIp)
+            params.set('remoteip', remoteIp);
+        const response = await fetch(process.env.RECAPTCHA_VERIFY_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            return { success: false, errorCodes: ['verification-request-failed'] };
+        }
+        const data = (await response.json());
+        return {
+            success: !!data.success,
+            errorCodes: data['error-codes'] ? data['error-codes'] : [],
+        };
+    }
+}

package/dist/esm/common/relative-time-service.js

@@ -0,0 +1,18 @@
+import { RelativeTimeConfig } from './constants/relative-time-config';
+import { DateService } from './date-service';
+export class RelativeTimeService {
+    static format(value, now, options) {
+        if (!DateService.isValid(value))
+            return value;
+        const seconds = (now.getTime() - DateService.getDate(value).valueOf()) /
+            RelativeTimeConfig.millisecondsPerSecond;
+        if (seconds < -RelativeTimeConfig.futureToleranceSeconds)
+            return options.formatDate(value);
+        if (seconds < RelativeTimeConfig.justNowSeconds)
+            return options.justNow;
+        const step = RelativeTimeConfig.units.find((unit) => seconds < unit.limitSeconds);
+        return step === undefined
+            ? options.formatDate(value)
+            : new Intl.RelativeTimeFormat(options.locale, RelativeTimeConfig.format).format(-Math.max(1, Math.round(seconds / step.seconds)), step.unit);
+    }
+}

package/dist/esm/common/request-client-service.js

@@ -0,0 +1,20 @@
+import { RequestClientConfig } from './constants/request-client-config';
+export class RequestClientService {
+    static from(headers, options = {}) {
+        const address = RequestClientConfig.addressHeaders
+            .map((name) => headers.get(name))
+            .find((value) => value !== null && value.trim() !== '');
+        const agent = headers.get(RequestClientConfig.agentHeader);
+        return {
+            ipAddress: address === undefined
+                ? null
+                : this._limit(address.split(RequestClientConfig.listSeparator)[0].trim(), options.ipAddressMaxLength),
+            userAgent: agent === null || agent.trim() === ''
+                ? null
+                : this._limit(agent.trim(), options.userAgentMaxLength),
+        };
+    }
+    static _limit(value, maxLength) {
+        return typeof maxLength === 'number' ? value.slice(0, maxLength) : value;
+    }
+}

package/dist/esm/common/signed-token-service.js

@@ -0,0 +1,111 @@
+import { Base64Service } from './base64-service';
+import { SignedTokenConfig } from './constants/signed-token-config';
+export class SignedTokenService {
+    static async generateKeyPair() {
+        const pair = (await crypto.subtle.generateKey(SignedTokenConfig.keyAlgorithm, true, [
+            'sign',
+            'verify',
+        ]));
+        const privateKey = await crypto.subtle.exportKey(SignedTokenConfig.privateKeyFormat, pair.privateKey);
+        const publicKey = await crypto.subtle.exportKey(SignedTokenConfig.publicKeyFormat, pair.publicKey);
+        return {
+            privateKey: Base64Service.encode(new Uint8Array(privateKey)),
+            publicKey: Base64Service.encode(new Uint8Array(publicKey)),
+        };
+    }
+    static async sign(claims, privateKey) {
+        const header = {
+            alg: SignedTokenConfig.algorithm,
+            typ: SignedTokenConfig.type,
+        };
+        const signingInput = `${this._encodeJson(header)}${SignedTokenConfig.separator}${this._encodeJson(claims)}`;
+        const signature = await crypto.subtle.sign(SignedTokenConfig.signAlgorithm, await this._privateKey(privateKey), this._textEncoder.encode(signingInput));
+        return `${signingInput}${SignedTokenConfig.separator}${this._toBase64Url(new Uint8Array(signature))}`;
+    }
+    static async verify(token, publicKeys) {
+        const parts = token.split(SignedTokenConfig.separator);
+        if (parts.length !== SignedTokenConfig.partCount)
+            return null;
+        const [encodedHeader, encodedClaims, encodedSignature] = parts;
+        const header = this._decodeJson(encodedHeader);
+        if (header === null ||
+            header.alg !== SignedTokenConfig.algorithm ||
+            header.typ !== SignedTokenConfig.type)
+            return null;
+        const signature = this._fromBase64Url(encodedSignature);
+        if (signature === null)
+            return null;
+        const signingInput = this._textEncoder.encode(`${encodedHeader}${SignedTokenConfig.separator}${encodedClaims}`);
+        for (const publicKey of publicKeys) {
+            const key = await this._publicKey(publicKey).catch(() => null);
+            if (key === null)
+                continue;
+            const isValid = await crypto.subtle
+                .verify(SignedTokenConfig.signAlgorithm, key, signature, signingInput)
+                .catch(() => false);
+            if (isValid)
+                return this._decodeJson(encodedClaims);
+        }
+        return null;
+    }
+    static async _privateKey(privateKey) {
+        const cached = this._privateKeys.get(privateKey);
+        if (cached !== undefined)
+            return cached;
+        const key = await crypto.subtle.importKey(SignedTokenConfig.privateKeyFormat, Base64Service.decode(privateKey), SignedTokenConfig.keyAlgorithm, false, ['sign']);
+        this._remember(this._privateKeys, privateKey, key);
+        return key;
+    }
+    static async _publicKey(publicKey) {
+        const cached = this._publicKeys.get(publicKey);
+        if (cached !== undefined)
+            return cached;
+        const key = await crypto.subtle.importKey(SignedTokenConfig.publicKeyFormat, Base64Service.decode(publicKey), SignedTokenConfig.keyAlgorithm, false, ['verify']);
+        this._remember(this._publicKeys, publicKey, key);
+        return key;
+    }
+    static _remember(cache, source, key) {
+        if (cache.size >= SignedTokenConfig.keyCacheLimit) {
+            const oldest = cache.keys().next().value;
+            if (oldest !== undefined)
+                cache.delete(oldest);
+        }
+        cache.set(source, key);
+    }
+    static _encodeJson(value) {
+        return this._toBase64Url(this._textEncoder.encode(JSON.stringify(value)));
+    }
+    static _decodeJson(encoded) {
+        const bytes = this._fromBase64Url(encoded);
+        if (bytes === null)
+            return null;
+        try {
+            const value = JSON.parse(this._textDecoder.decode(bytes));
+            return typeof value === 'object' && value !== null && !Array.isArray(value)
+                ? value
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static _toBase64Url(bytes) {
+        return Base64Service.encode(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    }
+    static _fromBase64Url(value) {
+        if (!/^[A-Za-z0-9_-]*$/.test(value))
+            return null;
+        const base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+        const padding = base64.length % 4 === 0 ? '' : '='.repeat(4 - (base64.length % 4));
+        try {
+            return Base64Service.decode(`${base64}${padding}`);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+SignedTokenService._textEncoder = new TextEncoder();
+SignedTokenService._textDecoder = new TextDecoder();
+SignedTokenService._privateKeys = new Map();
+SignedTokenService._publicKeys = new Map();

package/dist/esm/common/socket-token-service.js

@@ -0,0 +1,22 @@
+import { SocketTokenConfig } from './constants/socket-token-config';
+import { DateService } from './date-service';
+import { SignedTokenService } from './signed-token-service';
+export class SocketTokenService {
+    static async issue(scope, privateKey, seconds = SocketTokenConfig.defaultSeconds) {
+        const claims = {
+            scope,
+            exp: DateService.nowUnixSeconds() + seconds,
+        };
+        return SignedTokenService.sign(claims, privateKey);
+    }
+    static async verify(token, publicKeys) {
+        const claims = await SignedTokenService.verify(token, publicKeys).catch(() => null);
+        if (claims === null ||
+            typeof claims.scope !== 'string' ||
+            claims.scope === '' ||
+            typeof claims.exp !== 'number' ||
+            claims.exp * SocketTokenConfig.millisecondsPerSecond < DateService.nowMilliseconds())
+            return null;
+        return claims.scope;
+    }
+}

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

@@ -0,0 +1,5 @@
+export class StringService {
+    static cleanString(value) {
+        return value.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+    }
+}

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

@@ -0,0 +1,12 @@
+export class TransformService {
+    static isArray(input) {
+        try {
+            const parsed = JSON.parse(input);
+            return Array.isArray(parsed);
+        }
+        catch (error) {
+            console.error(error);
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+export class URLService {
+    static saveToQueryParams(key, value) {
+        const url = this.updatePath(key, value.toString(), true);
+        window.history.replaceState({}, '', url);
+    }
+}
+URLService.updatePath = (key, value, doRemoveParams) => {
+    const queryParams = new URLSearchParams(location.search);
+    if (doRemoveParams && !value) {
+        queryParams.delete(key);
+    }
+    else
+        queryParams.set(key, value);
+    return `${location.pathname}?${queryParams.toString()}`;
+};

package/dist/esm/common/user-agent-service.js

@@ -0,0 +1,26 @@
+import { UserAgentConfig } from './constants/user-agent-config';
+export class UserAgentService {
+    static browser(userAgent) {
+        if (userAgent === null)
+            return null;
+        const match = UserAgentConfig.browsers.find((browser) => browser.pattern.test(userAgent));
+        return match === undefined ? null : match.name;
+    }
+    static system(userAgent) {
+        if (userAgent === null)
+            return null;
+        const match = UserAgentConfig.systems.find((system) => system.pattern.test(userAgent));
+        return match === undefined ? null : match.name;
+    }
+    static describe(userAgent) {
+        const browser = UserAgentService.browser(userAgent);
+        const system = UserAgentService.system(userAgent);
+        if (browser === null && system === null)
+            return UserAgentConfig.unknown;
+        if (browser === null)
+            return String(system);
+        if (system === null)
+            return browser;
+        return `${browser}${UserAgentConfig.joiner}${system}`;
+    }
+}

package/dist/esm/common/user-token-service.js

@@ -0,0 +1,59 @@
+import { UserTokenConfig } from './constants/user-token-config';
+import { DateService } from './date-service';
+import { SignedTokenService } from './signed-token-service';
+export class UserTokenService {
+    static async issue(subject, request, options) {
+        const issuedAt = this._now();
+        const lifetime = typeof options.lifetimeSeconds === 'number'
+            ? Math.min(options.lifetimeSeconds, UserTokenConfig.maxLifetimeSeconds)
+            : UserTokenConfig.defaultLifetimeSeconds;
+        const claims = {
+            iss: options.issuer,
+            aud: options.audience,
+            sub: subject.id,
+            email: subject.email.trim().toLowerCase(),
+            name: subject.displayName,
+            htm: request.method.toUpperCase(),
+            htu: request.path,
+            iat: issuedAt,
+            exp: issuedAt + lifetime,
+            jti: crypto.randomUUID(),
+        };
+        return SignedTokenService.sign(claims, options.privateKey);
+    }
+    static async verify(token, request, options) {
+        const claims = await SignedTokenService.verify(token, options.publicKeys);
+        if (claims === null || !this._isWellFormed(claims))
+            return null;
+        const now = this._now();
+        const maxLifetime = typeof options.maxLifetimeSeconds === 'number'
+            ? options.maxLifetimeSeconds
+            : UserTokenConfig.maxLifetimeSeconds;
+        if (claims.iss !== options.issuer ||
+            claims.aud !== options.audience ||
+            claims.htm !== request.method.toUpperCase() ||
+            claims.htu !== request.path ||
+            claims.iat > now + UserTokenConfig.clockSkewSeconds ||
+            claims.exp <= now - UserTokenConfig.clockSkewSeconds ||
+            claims.exp - claims.iat > maxLifetime)
+            return null;
+        return claims;
+    }
+    static _isWellFormed(claims) {
+        return (typeof claims.iss === 'string' &&
+            typeof claims.aud === 'string' &&
+            typeof claims.sub === 'string' &&
+            typeof claims.email === 'string' &&
+            claims.email !== '' &&
+            typeof claims.name === 'string' &&
+            typeof claims.htm === 'string' &&
+            typeof claims.htu === 'string' &&
+            typeof claims.iat === 'number' &&
+            typeof claims.exp === 'number' &&
+            typeof claims.jti === 'string' &&
+            claims.jti !== '');
+    }
+    static _now() {
+        return DateService.nowUnixSeconds();
+    }
+}

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

@@ -0,0 +1,29 @@
+import { ValidationConfig } from './constants/validation-config';
+import { PhoneService } from './phone-service';
+export class ValidationService {
+    static isEmail(value) {
+        return ValidationConfig.email.test(value.trim());
+    }
+    static withProtocol(value) {
+        const trimmed = value.trim();
+        if (trimmed === '' || ValidationConfig.urlProtocolPattern.test(trimmed))
+            return trimmed;
+        return `${ValidationConfig.urlProtocol}${trimmed}`;
+    }
+    static isWebUrl(value) {
+        try {
+            const url = new URL(ValidationService.withProtocol(value));
+            return (ValidationConfig.webProtocols.some((protocol) => protocol === url.protocol) &&
+                url.hostname.includes(ValidationConfig.hostSeparator));
+        }
+        catch {
+            return false;
+        }
+    }
+    static isPhone(value, country) {
+        return value.trim() !== '' && PhoneService.isValid(value, country);
+    }
+    static isUuid(value) {
+        return ValidationConfig.uuid.test(value.trim());
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * as Client from './client';
+export * as Common from './common';
+export { AmountDirection } from './common/constants/amount-direction';
+export { HttpMethod } from './common/constants/http-method';

package/dist/esm/models/coded-error-data.js

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

package/dist/esm/models/device-data.js

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

package/dist/esm/models/email-preview-input.js

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

package/dist/esm/models/encrypted-value-payload.js

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

package/dist/esm/models/json-value-guard.js

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

package/dist/esm/models/phone-country-data.js

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

package/dist/esm/models/phone-display-data.js

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

package/dist/esm/models/postal-code-format-data.js

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

package/dist/esm/models/relative-time-options.js

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

package/dist/esm/models/request-client-data.js

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

package/dist/esm/models/request-client-options.js

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

package/dist/esm/models/signed-token-header.js

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

package/dist/esm/models/signed-token-key-pair.js

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

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

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

package/dist/esm/models/socket-token-claims.js

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

package/dist/esm/models/user-token-claims.js

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

package/dist/esm/models/user-token-issue-options.js

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

package/dist/esm/models/user-token-request.js

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

package/dist/esm/models/user-token-subject.js

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

package/dist/esm/models/user-token-verify-options.js

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

package/dist/esm/models/worker-bundle-budget-data.js

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

package/dist/esm/models/worker-bundle-file-data.js

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

package/dist/esm/models/worker-bundle-options-data.js

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

package/dist/esm/models/worker-bundle-report-data.js

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

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}