@pallasoft/ps-utilities 2.18.0 → 2.19.0

package/bin/ps-worker-bundle-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.exitCode = require('../dist/build/worker-bundle-cli').WorkerBundleCli.run(
+	process.argv.slice(2)
+);

package/dist/build/index.d.ts

@@ -0,0 +1,6 @@
+export type { WorkerBundleBudgetData } from '../models/worker-bundle-budget-data';
+export type { WorkerBundleFileData } from '../models/worker-bundle-file-data';
+export type { WorkerBundleOptionsData } from '../models/worker-bundle-options-data';
+export type { WorkerBundleReportData } from '../models/worker-bundle-report-data';
+export * from './worker-bundle-cli';
+export * from './worker-bundle-service';

package/dist/build/index.js

@@ -0,0 +1,18 @@
+"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("./worker-bundle-cli"), exports);
+__exportStar(require("./worker-bundle-service"), exports);

package/dist/build/worker-bundle-cli.d.ts

@@ -0,0 +1,5 @@
+import type { WorkerBundleOptionsData } from '../models/worker-bundle-options-data';
+export declare class WorkerBundleCli {
+    static options(argv: string[]): WorkerBundleOptionsData;
+    static run(argv: string[]): number;
+}

package/dist/build/worker-bundle-cli.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerBundleCli = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var worker_bundle_service_1 = require("./worker-bundle-service");
+var WorkerBundleCli = /** @class */ (function () {
+    function WorkerBundleCli() {
+    }
+    WorkerBundleCli.options = function (argv) {
+        var read = function (name, fallback) {
+            var index = argv.indexOf("--".concat(name));
+            return index === -1 || index + 1 >= argv.length ? fallback : argv[index + 1];
+        };
+        return {
+            budget: {
+                eagerKb: Number(read('eager-kb', '0')),
+                gzipKb: Number(read('gzip-kb', '0')),
+                totalKb: Number(read('total-kb', '0')),
+            },
+            directory: read('dir', 'build/server'),
+            entry: read('entry', 'index.js'),
+        };
+    };
+    WorkerBundleCli.run = function (argv) {
+        var options = WorkerBundleCli.options(argv);
+        if (!(0, fs_1.existsSync)((0, path_1.resolve)(options.directory, options.entry))) {
+            console.error("No Worker build at ".concat((0, path_1.resolve)(options.directory, options.entry), "; build first."));
+            return 1;
+        }
+        var report = worker_bundle_service_1.WorkerBundleService.report(options.directory, options.entry, options.budget);
+        worker_bundle_service_1.WorkerBundleService.summary(report, options.budget).forEach(function (line) { return console.log(line); });
+        if (report.failures.length === 0)
+            return 0;
+        console.error("Worker bundle over budget (".concat(report.failures.join(', '), "): keep browser-only and heavy libraries out of the server build."));
+        return 1;
+    };
+    return WorkerBundleCli;
+}());
+exports.WorkerBundleCli = WorkerBundleCli;

package/dist/build/worker-bundle-service.d.ts

@@ -0,0 +1,10 @@
+import type { WorkerBundleBudgetData } from '../models/worker-bundle-budget-data';
+import type { WorkerBundleReportData } from '../models/worker-bundle-report-data';
+export declare class WorkerBundleService {
+    static staticImports(source: string): string[];
+    static scriptFiles(directory: string): string[];
+    static eagerFiles(entry: string): string[];
+    static kilobytes(bytes: number): number;
+    static report(directory: string, entry: string, budget: WorkerBundleBudgetData): WorkerBundleReportData;
+    static summary(report: WorkerBundleReportData, budget: WorkerBundleBudgetData): string[];
+}

package/dist/build/worker-bundle-service.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerBundleService = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var zlib_1 = require("zlib");
+var WorkerBundleService = /** @class */ (function () {
+    function WorkerBundleService() {
+    }
+    WorkerBundleService.staticImports = function (source) {
+        var pattern = /\b(?:import|from)\s*["'](\.{1,2}\/[^"']+)["']/g;
+        var specifiers = [];
+        var match = pattern.exec(source);
+        while (match !== null) {
+            specifiers.push(match[1]);
+            match = pattern.exec(source);
+        }
+        return specifiers;
+    };
+    WorkerBundleService.scriptFiles = function (directory) {
+        return (0, fs_1.readdirSync)(directory).reduce(function (files, name) {
+            var path = (0, path_1.join)(directory, name);
+            if ((0, fs_1.statSync)(path).isDirectory())
+                return files.concat(WorkerBundleService.scriptFiles(path));
+            return /\.(m?js|wasm)$/.test(name) ? files.concat(path) : files;
+        }, []);
+    };
+    WorkerBundleService.eagerFiles = function (entry) {
+        var seen = [];
+        var queue = [entry];
+        var _loop_1 = function () {
+            var file = queue.pop();
+            if (seen.indexOf(file) === -1 && (0, fs_1.existsSync)(file)) {
+                seen.push(file);
+                WorkerBundleService.staticImports((0, fs_1.readFileSync)(file, 'utf8')).forEach(function (specifier) {
+                    return queue.push((0, path_1.resolve)((0, path_1.dirname)(file), specifier));
+                });
+            }
+        };
+        while (queue.length > 0) {
+            _loop_1();
+        }
+        return seen;
+    };
+    WorkerBundleService.kilobytes = function (bytes) {
+        return Math.round(bytes / 1024);
+    };
+    WorkerBundleService.report = function (directory, entry, budget) {
+        var eager = WorkerBundleService.eagerFiles((0, path_1.resolve)(directory, entry));
+        var files = WorkerBundleService.scriptFiles((0, path_1.resolve)(directory)).map(function (path) {
+            var content = (0, fs_1.readFileSync)(path);
+            return {
+                file: (0, path_1.relative)((0, path_1.resolve)(directory), path),
+                gzipBytes: (0, zlib_1.gzipSync)(content).length,
+                isEager: eager.indexOf(path) !== -1,
+                sizeBytes: content.length,
+            };
+        });
+        var eagerBytes = files
+            .filter(function (file) { return file.isEager; })
+            .reduce(function (sum, file) { return sum + file.sizeBytes; }, 0);
+        var totalBytes = files.reduce(function (sum, file) { return sum + file.sizeBytes; }, 0);
+        var gzipBytes = files.reduce(function (sum, file) { return sum + file.gzipBytes; }, 0);
+        var checks = [
+            ['eager', eagerBytes, budget.eagerKb],
+            ['total', totalBytes, budget.totalKb],
+            ['gzip', gzipBytes, budget.gzipKb],
+        ];
+        return {
+            eagerBytes: eagerBytes,
+            failures: checks
+                .filter(function (_a) {
+                var bytes = _a[1], limit = _a[2];
+                return limit > 0 && WorkerBundleService.kilobytes(bytes) > limit;
+            })
+                .map(function (_a) {
+                var label = _a[0];
+                return label;
+            }),
+            files: files.sort(function (a, b) { return b.sizeBytes - a.sizeBytes; }),
+            gzipBytes: gzipBytes,
+            totalBytes: totalBytes,
+        };
+    };
+    WorkerBundleService.summary = function (report, budget) {
+        var limit = function (value) { return (value > 0 ? " / budget ".concat(value, " KB") : ''); };
+        return report.files
+            .slice(0, 12)
+            .map(function (file) {
+            return "".concat(String(WorkerBundleService.kilobytes(file.sizeBytes)).padStart(7), " KB  ").concat(file.isEager ? 'eager' : 'lazy ', "  ").concat(file.file);
+        })
+            .concat([
+            "eager (evaluated at startup): ".concat(WorkerBundleService.kilobytes(report.eagerBytes), " KB").concat(limit(budget.eagerKb)),
+            "total server JS: ".concat(WorkerBundleService.kilobytes(report.totalBytes), " KB").concat(limit(budget.totalKb)),
+            "total gzip (upload size): ".concat(WorkerBundleService.kilobytes(report.gzipBytes), " KB").concat(limit(budget.gzipKb)),
+        ]);
+    };
+    return WorkerBundleService;
+}());
+exports.WorkerBundleService = WorkerBundleService;

package/dist/esm/build/index.js

@@ -0,0 +1,2 @@
+export * from './worker-bundle-cli';
+export * from './worker-bundle-service';

package/dist/esm/build/worker-bundle-cli.js

@@ -0,0 +1,33 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { WorkerBundleService } from './worker-bundle-service';
+export class WorkerBundleCli {
+    static options(argv) {
+        const read = (name, fallback) => {
+            const index = argv.indexOf(`--${name}`);
+            return index === -1 || index + 1 >= argv.length ? fallback : argv[index + 1];
+        };
+        return {
+            budget: {
+                eagerKb: Number(read('eager-kb', '0')),
+                gzipKb: Number(read('gzip-kb', '0')),
+                totalKb: Number(read('total-kb', '0')),
+            },
+            directory: read('dir', 'build/server'),
+            entry: read('entry', 'index.js'),
+        };
+    }
+    static run(argv) {
+        const options = WorkerBundleCli.options(argv);
+        if (!existsSync(resolve(options.directory, options.entry))) {
+            console.error(`No Worker build at ${resolve(options.directory, options.entry)}; build first.`);
+            return 1;
+        }
+        const report = WorkerBundleService.report(options.directory, options.entry, options.budget);
+        WorkerBundleService.summary(report, options.budget).forEach((line) => console.log(line));
+        if (report.failures.length === 0)
+            return 0;
+        console.error(`Worker bundle over budget (${report.failures.join(', ')}): keep browser-only and heavy libraries out of the server build.`);
+        return 1;
+    }
+}

package/dist/esm/build/worker-bundle-service.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { dirname, join, relative, resolve } from 'path';
+import { gzipSync } from 'zlib';
+export class WorkerBundleService {
+    static staticImports(source) {
+        const pattern = /\b(?:import|from)\s*["'](\.{1,2}\/[^"']+)["']/g;
+        const specifiers = [];
+        let match = pattern.exec(source);
+        while (match !== null) {
+            specifiers.push(match[1]);
+            match = pattern.exec(source);
+        }
+        return specifiers;
+    }
+    static scriptFiles(directory) {
+        return readdirSync(directory).reduce((files, name) => {
+            const path = join(directory, name);
+            if (statSync(path).isDirectory())
+                return files.concat(WorkerBundleService.scriptFiles(path));
+            return /\.(m?js|wasm)$/.test(name) ? files.concat(path) : files;
+        }, []);
+    }
+    static eagerFiles(entry) {
+        const seen = [];
+        const queue = [entry];
+        while (queue.length > 0) {
+            const file = queue.pop();
+            if (seen.indexOf(file) === -1 && existsSync(file)) {
+                seen.push(file);
+                WorkerBundleService.staticImports(readFileSync(file, 'utf8')).forEach((specifier) => queue.push(resolve(dirname(file), specifier)));
+            }
+        }
+        return seen;
+    }
+    static kilobytes(bytes) {
+        return Math.round(bytes / 1024);
+    }
+    static report(directory, entry, budget) {
+        const eager = WorkerBundleService.eagerFiles(resolve(directory, entry));
+        const files = WorkerBundleService.scriptFiles(resolve(directory)).map((path) => {
+            const content = readFileSync(path);
+            return {
+                file: relative(resolve(directory), path),
+                gzipBytes: gzipSync(content).length,
+                isEager: eager.indexOf(path) !== -1,
+                sizeBytes: content.length,
+            };
+        });
+        const eagerBytes = files
+            .filter((file) => file.isEager)
+            .reduce((sum, file) => sum + file.sizeBytes, 0);
+        const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0);
+        const gzipBytes = files.reduce((sum, file) => sum + file.gzipBytes, 0);
+        const checks = [
+            ['eager', eagerBytes, budget.eagerKb],
+            ['total', totalBytes, budget.totalKb],
+            ['gzip', gzipBytes, budget.gzipKb],
+        ];
+        return {
+            eagerBytes,
+            failures: checks
+                .filter(([, bytes, limit]) => limit > 0 && WorkerBundleService.kilobytes(bytes) > limit)
+                .map(([label]) => label),
+            files: files.sort((a, b) => b.sizeBytes - a.sizeBytes),
+            gzipBytes,
+            totalBytes,
+        };
+    }
+    static summary(report, budget) {
+        const limit = (value) => (value > 0 ? ` / budget ${value} KB` : '');
+        return report.files
+            .slice(0, 12)
+            .map((file) => `${String(WorkerBundleService.kilobytes(file.sizeBytes)).padStart(7)} KB  ${file.isEager ? 'eager' : 'lazy '}  ${file.file}`)
+            .concat([
+            `eager (evaluated at startup): ${WorkerBundleService.kilobytes(report.eagerBytes)} KB${limit(budget.eagerKb)}`,
+            `total server JS: ${WorkerBundleService.kilobytes(report.totalBytes)} KB${limit(budget.totalKb)}`,
+            `total gzip (upload size): ${WorkerBundleService.kilobytes(report.gzipBytes)} KB${limit(budget.gzipKb)}`,
+        ]);
+    }
+}

package/dist/esm/client/constants/device-config.js

@@ -0,0 +1,6 @@
+export const DeviceConfig = {
+    ios: /iPhone|iPad|iPod/i,
+    macintosh: /Macintosh/i,
+    mobile: /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile|Tablet|Silk|Kindle/i,
+    touchPointsForTablet: 1,
+};

package/dist/esm/client/debounce-service.js

@@ -0,0 +1,34 @@
+export class DebounceService {
+    static create(action, waitMs) {
+        let timer = null;
+        let pending = null;
+        const clear = () => {
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = null;
+        };
+        return {
+            cancel: () => {
+                clear();
+                pending = null;
+            },
+            flush: () => {
+                if (pending === null)
+                    return;
+                const args = pending;
+                clear();
+                pending = null;
+                action(...args);
+            },
+            run: (...args) => {
+                pending = args;
+                clear();
+                timer = setTimeout(() => {
+                    timer = null;
+                    pending = null;
+                    action(...args);
+                }, waitMs);
+            },
+        };
+    }
+}

package/dist/esm/client/device-service.js

@@ -0,0 +1,15 @@
+import { DeviceConfig } from './constants/device-config';
+export class DeviceService {
+    static fromUserAgent(userAgent, maxTouchPoints) {
+        const isIPadOS = DeviceConfig.macintosh.test(userAgent) && maxTouchPoints > DeviceConfig.touchPointsForTablet;
+        return {
+            isIOS: DeviceConfig.ios.test(userAgent) || isIPadOS,
+            isMobile: DeviceConfig.mobile.test(userAgent) || isIPadOS,
+        };
+    }
+    static current() {
+        if (typeof navigator === 'undefined')
+            return { isIOS: false, isMobile: false };
+        return DeviceService.fromUserAgent(navigator.userAgent, navigator.maxTouchPoints);
+    }
+}

package/dist/esm/client/http-service.js

@@ -0,0 +1,51 @@
+import { HttpContentType } from '../common/constants/http-content-type';
+import { HttpHeader } from '../common/constants/http-header';
+import { HttpMethod } from '../common/constants/http-method';
+const isBinaryBody = (data) => data instanceof FormData ||
+    data instanceof Blob ||
+    data instanceof ArrayBuffer ||
+    data instanceof URLSearchParams;
+export class HttpService {
+    static createApiClient(options = {}) {
+        const { apiKey, apiKeyHeader = HttpHeader.apiKey, baseURL, headers: defaultHeaders } = options;
+        const request = async (method, url, data, config) => {
+            const fullUrl = baseURL ? `${baseURL}${url}` : url;
+            const sendsBinaryBody = isBinaryBody(data);
+            const headers = sendsBinaryBody
+                ? {}
+                : { [HttpHeader.contentType]: HttpContentType.json };
+            if (defaultHeaders)
+                Object.assign(headers, defaultHeaders);
+            if (apiKey)
+                headers[apiKeyHeader] = apiKey;
+            if (config?.headers)
+                Object.assign(headers, config.headers);
+            const body = data === undefined ? undefined : sendsBinaryBody ? data : JSON.stringify(data);
+            const response = await fetch(fullUrl, { method, headers, body });
+            if (config?.responseType === 'stream' && response.ok)
+                return { data: response.body, headers: response.headers, status: response.status };
+            const responseData = await (config?.responseType === 'arraybuffer'
+                ? response.arrayBuffer()
+                : config?.responseType === 'text'
+                    ? response.text()
+                    : config?.responseType === 'json'
+                        ? response.json()
+                        : String(response.headers.get(HttpHeader.contentType)).includes(HttpContentType.json)
+                            ? response.json()
+                            : response.text());
+            if (!response.ok) {
+                const error = new Error(`Request failed with status ${response.status}`);
+                error.response = { data: responseData, status: response.status };
+                throw error;
+            }
+            return { data: responseData, headers: response.headers, status: response.status };
+        };
+        return {
+            get: (url, config) => request(HttpMethod.Get, url, undefined, config),
+            post: (url, data, config) => request(HttpMethod.Post, url, data, config),
+            put: (url, data, config) => request(HttpMethod.Put, url, data, config),
+            patch: (url, data, config) => request(HttpMethod.Patch, url, data, config),
+            delete: (url, config) => request(HttpMethod.Delete, url, undefined, config),
+        };
+    }
+}

package/dist/esm/client/index.js

@@ -0,0 +1,3 @@
+export * from './debounce-service';
+export * from './device-service';
+export * from './http-service';

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

@@ -0,0 +1,37 @@
+import { AmountConfig } from './constants/amount-config';
+import { AmountDirection } from './constants/amount-direction';
+export class AmountService {
+    static normalise(raw) {
+        const trimmed = raw.trim();
+        const isBracketed = trimmed.startsWith(AmountConfig.openBracket) && trimmed.endsWith(AmountConfig.closeBracket);
+        const isNegative = isBracketed || trimmed.startsWith(AmountConfig.minus);
+        const kept = trimmed.replace(AmountConfig.disallowed, '');
+        const pointIndex = kept.indexOf(AmountConfig.point);
+        const digits = pointIndex === -1
+            ? kept
+            : `${kept.slice(0, pointIndex + 1)}${kept
+                .slice(pointIndex + 1)
+                .split(AmountConfig.point)
+                .join('')}`;
+        if (digits === '')
+            return isNegative && !isBracketed ? AmountConfig.minus : '';
+        return isNegative ? `${AmountConfig.minus}${digits}` : digits;
+    }
+    static toNumber(raw) {
+        const normalised = AmountService.normalise(raw);
+        const parsed = Number(normalised);
+        return normalised === '' || !Number.isFinite(parsed) ? 0 : parsed;
+    }
+    static isAmount(raw) {
+        const normalised = AmountService.normalise(raw);
+        return (normalised !== '' && normalised !== AmountConfig.minus && Number.isFinite(Number(normalised)));
+    }
+    static direction(raw) {
+        if (!AmountService.isAmount(raw))
+            return AmountDirection.Neutral;
+        const normalised = AmountService.normalise(raw);
+        if (AmountConfig.zeroPattern.test(normalised))
+            return AmountDirection.Neutral;
+        return normalised.startsWith(AmountConfig.minus) ? AmountDirection.Out : AmountDirection.In;
+    }
+}

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

@@ -0,0 +1,17 @@
+export class Base64Service {
+    static encode(bytes) {
+        let binary = '';
+        for (let index = 0; index < bytes.length; index += 1) {
+            binary += String.fromCharCode(bytes[index]);
+        }
+        return btoa(binary);
+    }
+    static decode(value) {
+        const binary = atob(value.trim());
+        const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+        for (let index = 0; index < binary.length; index += 1) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+        return bytes;
+    }
+}

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

@@ -0,0 +1,8 @@
+export class ColorService {
+    static hexToRgb(hex) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result
+            ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)]
+            : [0, 0, 0];
+    }
+}

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

@@ -0,0 +1,8 @@
+export const AmountConfig = {
+    closeBracket: ')',
+    disallowed: /[^0-9.]/g,
+    minus: '-',
+    openBracket: '(',
+    point: '.',
+    zeroPattern: /^-?0*\.?0*$/,
+};

package/dist/esm/common/constants/amount-direction.js

@@ -0,0 +1,6 @@
+export var AmountDirection;
+(function (AmountDirection) {
+    AmountDirection["In"] = "in";
+    AmountDirection["Neutral"] = "neutral";
+    AmountDirection["Out"] = "out";
+})(AmountDirection || (AmountDirection = {}));

package/dist/esm/common/constants/email-preview-config.js

@@ -0,0 +1,30 @@
+export const EmailPreviewConfig = {
+    documentName: 'email.html',
+    documentContentType: 'text/html',
+    imageName: 'email.png',
+    imageContentType: 'image/png',
+    fallbackSubject: 'Email',
+    dateFormat: 'D MMM YYYY, h:mm A',
+    page: {
+        width: 860,
+        padding: 48,
+        headerGap: 28,
+        subjectSize: 22,
+        metaSize: 13,
+        bodySize: 15,
+        lineHeight: 24,
+        maxLines: 140,
+        minHeight: 320,
+        charWidth: 7.4,
+        subjectWidthRatio: 1.45,
+        metaWidthRatio: 0.9,
+        fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Helvetica, Arial, 'DejaVu Sans', 'Liberation Sans', sans-serif",
+        paperColour: '#ffffff',
+        bandColour: '#0f9d58',
+        bandHeight: 6,
+        ruleColour: '#e4e8ee',
+        subjectColour: '#101828',
+        metaColour: '#667085',
+        bodyColour: '#344054',
+    },
+};

package/dist/esm/common/constants/error-response-config.js

@@ -0,0 +1,4 @@
+export const ErrorResponseConfig = {
+    clientErrorStart: 400,
+    serverErrorStart: 500,
+};

package/dist/esm/common/constants/file-size-config.js

@@ -0,0 +1,5 @@
+export const FileSizeConfig = {
+    step: 1024,
+    units: ['B', 'KB', 'MB', 'GB', 'TB'],
+    wholeFrom: 10,
+};

package/dist/esm/common/constants/http-auth-scheme.js

@@ -0,0 +1,3 @@
+export const HttpAuthScheme = {
+    bearerPrefix: 'Bearer ',
+};

package/dist/esm/common/constants/http-content-type.js

@@ -0,0 +1,8 @@
+export const HttpContentType = {
+    formUrlEncoded: 'application/x-www-form-urlencoded',
+    html: 'text/html',
+    json: 'application/json',
+    multipartFormData: 'multipart/form-data',
+    octetStream: 'application/octet-stream',
+    plainText: 'text/plain',
+};

package/dist/esm/common/constants/http-header.js

@@ -0,0 +1,23 @@
+export const HttpHeader = {
+    accept: 'Accept',
+    apiKey: 'X-API-Key',
+    authorization: 'Authorization',
+    cacheControl: 'Cache-Control',
+    cfConnectingIp: 'CF-Connecting-IP',
+    contentDisposition: 'Content-Disposition',
+    contentSecurityPolicy: 'Content-Security-Policy',
+    contentType: 'Content-Type',
+    contentTypeOptions: 'X-Content-Type-Options',
+    cookie: 'Cookie',
+    forwardedFor: 'X-Forwarded-For',
+    frameOptions: 'X-Frame-Options',
+    idempotencyKey: 'Idempotency-Key',
+    location: 'Location',
+    prefer: 'Prefer',
+    realIp: 'X-Real-IP',
+    retryAfter: 'Retry-After',
+    robotsTag: 'X-Robots-Tag',
+    setCookie: 'Set-Cookie',
+    strictTransportSecurity: 'Strict-Transport-Security',
+    userAgent: 'User-Agent',
+};

package/dist/esm/common/constants/http-method.js

@@ -0,0 +1,10 @@
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["Delete"] = "DELETE";
+    HttpMethod["Get"] = "GET";
+    HttpMethod["Head"] = "HEAD";
+    HttpMethod["Options"] = "OPTIONS";
+    HttpMethod["Patch"] = "PATCH";
+    HttpMethod["Post"] = "POST";
+    HttpMethod["Put"] = "PUT";
+})(HttpMethod || (HttpMethod = {}));

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

@@ -0,0 +1,19 @@
+export * from './amount-config';
+export * from './email-preview-config';
+export * from './phone-config';
+export * from './postal-code-formats';
+export * from './signed-token-config';
+export * from './user-token-config';
+export * from './validation-config';
+export * from './file-size-config';
+export * from './socket-token-config';
+export * from './user-agent-config';
+export * from './amount-direction';
+export * from './error-response-config';
+export * from './http-auth-scheme';
+export * from './http-content-type';
+export * from './http-header';
+export * from './http-method';
+export * from './relative-time-config';
+export * from './request-client-config';
+export * from './portable-text-config';

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

@@ -0,0 +1,6 @@
+export const PhoneConfig = {
+    defaultCountry: 'CA',
+    displayNamesType: 'region',
+    locale: 'en',
+    plus: '+',
+};

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

@@ -0,0 +1,17 @@
+import { Common } from '@pallasoft/ps-models';
+export const PortableTextConfig = {
+    linkRel: 'noopener noreferrer',
+    linkTarget: '_blank',
+    paragraphSeparator: '\n\n',
+    lineSeparator: '\n',
+    paragraphSplitPattern: /\n[ \t]*\n/,
+    lineBreakPattern: /\r\n?/g,
+    bulletPrefix: '- ',
+    quotePrefix: '> ',
+    numberSuffix: '. ',
+    keyPrefix: { block: 'b', span: 's' },
+    normalStyle: Common.PortableTextConfig.styles[0],
+    quoteStyle: Common.PortableTextConfig.styles[1],
+    bulletItem: Common.PortableTextConfig.listItems[0],
+    numberItem: Common.PortableTextConfig.listItems[1],
+};