@pallasoft/ps-utilities 2.21.0 → 2.23.0

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

@@ -0,0 +1,133 @@
+export const HtmlTextConfig = {
+    skipTags: [
+        'head',
+        'script',
+        'style',
+        'title',
+        'noscript',
+        'template',
+        'svg',
+        'iframe',
+        'object',
+        'embed',
+        'video',
+        'audio',
+        'canvas',
+        'select',
+        'textarea',
+    ],
+    rawTextTags: ['script', 'style', 'title', 'textarea'],
+    voidTags: [
+        'area',
+        'base',
+        'br',
+        'col',
+        'embed',
+        'hr',
+        'img',
+        'input',
+        'link',
+        'meta',
+        'param',
+        'source',
+        'track',
+        'wbr',
+    ],
+    blockTags: [
+        'address',
+        'article',
+        'aside',
+        'body',
+        'center',
+        'dd',
+        'details',
+        'div',
+        'dl',
+        'dt',
+        'fieldset',
+        'figcaption',
+        'figure',
+        'footer',
+        'form',
+        'header',
+        'html',
+        'main',
+        'nav',
+        'p',
+        'pre',
+        'section',
+        'summary',
+        'table',
+        'tbody',
+        'td',
+        'tfoot',
+        'th',
+        'thead',
+        'tr',
+    ],
+    strongTags: ['b', 'strong'],
+    emTags: ['i', 'em', 'cite', 'dfn'],
+    underlineTags: ['u', 'ins'],
+    codeTags: ['code', 'kbd', 'samp', 'tt'],
+    linkTag: 'a',
+    imageTag: 'img',
+    breakTag: 'br',
+    ruleTag: 'hr',
+    preTag: 'pre',
+    quoteTag: 'blockquote',
+    listItemTag: 'li',
+    orderedListTag: 'ol',
+    unorderedListTag: 'ul',
+    hiddenClassPattern: /(^|[\s_-])(preheader|pre-header|preview-text|previewtext)([\s_-]|$)/i,
+    hiddenDisplay: 'none',
+    hiddenVisibility: 'hidden',
+    hiddenMso: 'all',
+    hiddenAttribute: 'hidden',
+    hiddenAria: 'true',
+    tinyImageSize: 2,
+    importantPattern: /!important/i,
+    zeroPattern: /^0(\.0+)?(px|pt|em|rem|%)?$/,
+    pixelPattern: /^([0-9.]+)(px)?$/,
+    boldWeight: 600,
+    largeText: { heading3: 20, heading2: 24, heading1: 30, maxLength: 100 },
+    boldHeadingMaxLength: 80,
+    headingEndPattern: /[.,;:!?]$/,
+    pixelsPerPoint: 1.333,
+    pixelsPerEm: 16,
+    fontSizePattern: /^([0-9.]+)(px|pt|em|rem)$/,
+    commentStart: '<!--',
+    commentEnd: '-->',
+    declarationSeparator: ';',
+    propertySeparator: ':',
+    tagSource: '<(\\/?)([a-zA-Z][a-zA-Z0-9:-]*)((?:"[^"]*"|\'[^\']*\'|[^\'">])*)>',
+    tagFlags: 'y',
+    attributePattern: /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g,
+    selfClosingPattern: /\/\s*$/,
+    whitespacePattern: /[ \t\r\n\f\u00A0\u2007\u202F]+/g,
+    preLineBreakPattern: /\r\n?/g,
+    invisiblePattern: /\u00AD|\u034F|[\u200B-\u200F\u2028\u2029\u2060\uFEFF]/g,
+    entityPattern: /&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g,
+    maxCodePoint: 0x10ffff,
+    numericEntityPrefix: '#',
+    hexEntityPrefix: '#x',
+    rootName: 'root',
+    bodyListLevel: 1,
+    trailingBreakPattern: /[ \n]+$/,
+    leadingBreakPattern: /^[ \n]+/,
+    trailingSpacePattern: / +$/,
+    leadingSpacePattern: /^ +/,
+    nonBreakingPattern: /[\u00A0\u2007\u202F]/g,
+    srcAttribute: 'src',
+    altAttribute: 'alt',
+    hrefAttribute: 'href',
+    styleAttribute: 'style',
+    classAttribute: 'class',
+    widthAttribute: 'width',
+    heightAttribute: 'height',
+    aria: 'aria-hidden',
+    space: ' ',
+    newline: '\n',
+    trackingLinePattern: /^\[\s*(?:<)?(https?:\/\/[^\s\]>]+?)(?:>)?\s*\]$/i,
+    trackingEllipsis: '...',
+    trackingEllipsisCharacter: '\u2026',
+};

package/dist/esm/common/constants/html-token-kind.js

@@ -0,0 +1,5 @@
+export const HtmlTokenKind = {
+    Text: 'text',
+    Open: 'open',
+    Close: 'close',
+};

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

@@ -9,7 +9,21 @@ export const PortableTextConfig = {
     bulletPrefix: '- ',
     quotePrefix: '> ',
     numberSuffix: '. ',
-    keyPrefix: { block: 'b', span: 's' },
+    keyPrefix: { block: 'b', span: 's', link: 'l', image: 'i' },
+    blockType: Common.PortableTextConfig.blockType,
+    spanType: Common.PortableTextConfig.spanType,
+    linkType: Common.PortableTextConfig.linkType,
+    imageType: Common.PortableTextConfig.imageType,
+    decorators: Common.PortableTextConfig.decorators,
+    headingStyles: Common.PortableTextConfig.headingStyles,
+    messageStyles: Common.PortableTextConfig.messageStyles,
+    linkProtocols: Common.PortableTextConfig.linkProtocols,
+    maxListLevel: Common.PortableTextConfig.maxListLevel,
+    maxImageSrcLength: Common.PortableTextConfig.maxImageSrcLength,
+    maxImageAltLength: Common.PortableTextConfig.maxImageAltLength,
+    imageProtocolPattern: Common.PortableTextConfig.imageProtocolPattern,
+    maxControlCode: 31,
+    deleteCode: 127,
     normalStyle: Common.PortableTextConfig.styles[0],
     quoteStyle: Common.PortableTextConfig.styles[1],
     bulletItem: Common.PortableTextConfig.listItems[0],

package/dist/esm/common/html-entity-service.js

@@ -0,0 +1,25 @@
+import { HtmlEntityNames } from './constants/html-entity-names.js';
+import { HtmlTextConfig } from './constants/html-text-config.js';
+export class HtmlEntityService {
+    static decode(value) {
+        return value.replace(HtmlTextConfig.entityPattern, (match, body) => HtmlEntityService.resolve(match, body));
+    }
+    static resolve(match, body) {
+        if (body.startsWith(HtmlTextConfig.hexEntityPrefix))
+            return HtmlEntityService.fromCode(match, Number.parseInt(body.slice(2), 16));
+        if (body.startsWith(HtmlTextConfig.numericEntityPrefix))
+            return HtmlEntityService.fromCode(match, Number.parseInt(body.slice(1), 10));
+        if (HtmlEntityService.isNamed(body))
+            return HtmlEntityNames[body];
+        const lower = body.toLowerCase();
+        return HtmlEntityService.isNamed(lower) ? HtmlEntityNames[lower] : match;
+    }
+    static fromCode(match, code) {
+        return Number.isInteger(code) && code > 0 && code <= HtmlTextConfig.maxCodePoint
+            ? String.fromCodePoint(code)
+            : match;
+    }
+    static isNamed(name) {
+        return Object.prototype.hasOwnProperty.call(HtmlEntityNames, name);
+    }
+}

package/dist/esm/common/html-style-service.js

@@ -0,0 +1,85 @@
+import { HtmlTextConfig } from './constants/html-text-config.js';
+export class HtmlStyleService {
+    static parse(style) {
+        const declarations = {};
+        if (typeof style !== 'string')
+            return declarations;
+        style.split(HtmlTextConfig.declarationSeparator).forEach((entry) => {
+            const index = entry.indexOf(HtmlTextConfig.propertySeparator);
+            if (index === -1)
+                return;
+            const property = entry.slice(0, index).trim().toLowerCase();
+            const value = entry
+                .slice(index + 1)
+                .replace(HtmlTextConfig.importantPattern, '')
+                .trim()
+                .toLowerCase();
+            if (property !== '' && value !== '')
+                declarations[property] = value;
+        });
+        return declarations;
+    }
+    static isHidden(declarations) {
+        return (declarations['display'] === HtmlTextConfig.hiddenDisplay ||
+            declarations['visibility'] === HtmlTextConfig.hiddenVisibility ||
+            declarations['mso-hide'] === HtmlTextConfig.hiddenMso ||
+            HtmlStyleService.isZero(declarations['max-height']) ||
+            HtmlStyleService.isZero(declarations['max-width']) ||
+            HtmlStyleService.isZero(declarations['font-size']) ||
+            HtmlStyleService.isZero(declarations['opacity']));
+    }
+    static isTiny(declarations) {
+        return (HtmlStyleService.pixels(declarations['width']) <= HtmlTextConfig.tinyImageSize ||
+            HtmlStyleService.pixels(declarations['height']) <= HtmlTextConfig.tinyImageSize);
+    }
+    static fontSize(declarations) {
+        const value = declarations['font-size'];
+        if (typeof value !== 'string')
+            return null;
+        const match = HtmlTextConfig.fontSizePattern.exec(value);
+        if (match === null)
+            return null;
+        const amount = Number.parseFloat(match[1]);
+        if (match[2] === 'pt')
+            return amount * HtmlTextConfig.pixelsPerPoint;
+        if (match[2] === 'em' || match[2] === 'rem')
+            return amount * HtmlTextConfig.pixelsPerEm;
+        return amount;
+    }
+    static bold(declarations) {
+        const value = declarations['font-weight'];
+        if (typeof value !== 'string')
+            return null;
+        if (value === 'bold' || value === 'bolder')
+            return true;
+        if (value === 'normal' || value === 'lighter')
+            return false;
+        const weight = Number.parseInt(value, 10);
+        return Number.isNaN(weight) ? null : weight >= HtmlTextConfig.boldWeight;
+    }
+    static italic(declarations) {
+        const value = declarations['font-style'];
+        if (typeof value !== 'string')
+            return null;
+        if (value === 'italic' || value === 'oblique')
+            return true;
+        return value === 'normal' ? false : null;
+    }
+    static underline(declarations) {
+        const value = declarations['text-decoration'];
+        if (typeof value !== 'string')
+            return null;
+        if (value.includes('underline'))
+            return true;
+        return value.includes('none') ? false : null;
+    }
+    static isZero(value) {
+        return typeof value === 'string' && HtmlTextConfig.zeroPattern.test(value);
+    }
+    static pixels(value) {
+        if (typeof value !== 'string')
+            return Number.POSITIVE_INFINITY;
+        const match = HtmlTextConfig.pixelPattern.exec(value);
+        return match === null ? Number.POSITIVE_INFINITY : Number.parseFloat(match[1]);
+    }
+}

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

@@ -0,0 +1,83 @@
+import { HtmlTextConfig } from './constants/html-text-config.js';
+import { HtmlTokenKind } from './constants/html-token-kind.js';
+import { HtmlEntityService } from './html-entity-service.js';
+export class HtmlTokenService {
+    static tokenize(html) {
+        const tokens = [];
+        let cursor = 0;
+        while (cursor < html.length) {
+            const start = html.indexOf('<', cursor);
+            if (start === -1) {
+                HtmlTokenService.pushText(tokens, html.slice(cursor));
+                break;
+            }
+            HtmlTokenService.pushText(tokens, html.slice(cursor, start));
+            cursor = HtmlTokenService.consume(html, start, tokens);
+        }
+        return tokens;
+    }
+    static consume(html, start, tokens) {
+        if (html.startsWith(HtmlTextConfig.commentStart, start)) {
+            const end = html.indexOf(HtmlTextConfig.commentEnd, start + HtmlTextConfig.commentStart.length);
+            return end === -1 ? html.length : end + HtmlTextConfig.commentEnd.length;
+        }
+        const next = html.charAt(start + 1);
+        if (next === '!' || next === '?') {
+            const end = html.indexOf('>', start);
+            return end === -1 ? html.length : end + 1;
+        }
+        const pattern = new RegExp(HtmlTextConfig.tagSource, HtmlTextConfig.tagFlags);
+        pattern.lastIndex = start;
+        const match = pattern.exec(html);
+        if (match === null) {
+            HtmlTokenService.pushText(tokens, '<');
+            return start + 1;
+        }
+        const name = match[2].toLowerCase();
+        const end = start + match[0].length;
+        if (match[1] === '/') {
+            tokens.push({ kind: HtmlTokenKind.Close, name });
+            return end;
+        }
+        tokens.push({
+            attributes: HtmlTokenService.attributes(match[3]),
+            kind: HtmlTokenKind.Open,
+            name,
+            selfClosing: HtmlTextConfig.selfClosingPattern.test(match[3]),
+        });
+        return HtmlTextConfig.rawTextTags.includes(name)
+            ? HtmlTokenService.skipRawText(html, name, end, tokens)
+            : end;
+    }
+    static skipRawText(html, name, from, tokens) {
+        const closing = new RegExp(`</${name}\\s*>`, 'gi');
+        closing.lastIndex = from;
+        const match = closing.exec(html);
+        if (match === null)
+            return html.length;
+        tokens.push({ kind: HtmlTokenKind.Close, name });
+        return match.index + match[0].length;
+    }
+    static attributes(source) {
+        const attributes = {};
+        const pattern = new RegExp(HtmlTextConfig.attributePattern.source, HtmlTextConfig.attributePattern.flags);
+        let match = pattern.exec(source);
+        while (match !== null) {
+            const raw = [match[2], match[3], match[4]].find((value) => typeof value === 'string');
+            const key = match[1].toLowerCase();
+            if (!Object.prototype.hasOwnProperty.call(attributes, key))
+                attributes[key] = HtmlEntityService.decode(typeof raw === 'string' ? raw : '');
+            match = pattern.exec(source);
+        }
+        return attributes;
+    }
+    static pushText(tokens, text) {
+        if (text === '')
+            return;
+        const last = tokens[tokens.length - 1];
+        if (last !== undefined && last.kind === HtmlTokenKind.Text)
+            last.text += text;
+        else
+            tokens.push({ kind: HtmlTokenKind.Text, text });
+    }
+}

package/dist/esm/common/index.js

@@ -24,5 +24,6 @@ export * from './error-response-service.js';
 export * from './relative-time-service.js';
 export * from './request-client-service.js';
 export * from './json-service.js';
+export * from './portable-text-link-service.js';
 export * from './portable-text-service.js';
 export * from './text-tidy-service.js';