@contrail/document-util 1.0.0 → 1.0.2

package/lib/document-style-util/document-style-util.service.d.ts

@@ -0,0 +1,10 @@
+export declare class DocumentStyleUtil {
+    static getFirstInlineStyleValue(text: string, pattern: string): string;
+    static getFirstFontSize(text: string, toPt?: boolean): string;
+    static getFirstFontFamily(text: string): string;
+    static getFirstFontColor(text: string): string;
+    static isPx(str: any): boolean;
+    static toPt(px: any, precision?: number): number;
+    static toPx(pt: any, precision?: number): number;
+    static convertToPt(fontSize: any, precision?: number): any;
+}

package/lib/document-style-util/document-style-util.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentStyleUtil = void 0;
+class DocumentStyleUtil {
+    static getFirstInlineStyleValue(text, pattern) {
+        if (!text)
+            return null;
+        const regex = new RegExp('(?:\\b' + pattern + ':)\\s*([^;]*)[;"](?=[^>]*>)');
+        const found = text === null || text === void 0 ? void 0 : text.match(regex);
+        return (found === null || found === void 0 ? void 0 : found.length) > 1 ? found[1] : null;
+    }
+    static getFirstFontSize(text, toPt = false) {
+        const fontSize = this.getFirstInlineStyleValue(text, 'font-size');
+        if (!toPt || !fontSize) {
+            return fontSize;
+        }
+        return this.convertToPt(fontSize)
+            .replace('pt', '')
+            .replace('px', '');
+    }
+    static getFirstFontFamily(text) {
+        return this.getFirstInlineStyleValue(text, 'font-family');
+    }
+    static getFirstFontColor(text) {
+        return this.getFirstInlineStyleValue(text, 'color');
+    }
+    static isPx(str) {
+        return /[0-9.]+px$/.test(str);
+    }
+    static toPt(px, precision = 0) {
+        const factor = Math.pow(10, precision);
+        return Math.round(((parseInt(px, 10) * 72) / 96) * factor) / factor;
+    }
+    static toPx(pt, precision = 0) {
+        const factor = Math.pow(10, precision);
+        return Math.round((parseInt(pt, 10) / 72) * 96 * factor) / factor;
+    }
+    static convertToPt(fontSize, precision = 0) {
+        if (this.isPx(fontSize)) {
+            return this.toPt(fontSize, precision) + 'pt';
+        }
+        return fontSize;
+    }
+}
+exports.DocumentStyleUtil = DocumentStyleUtil;

package/lib/{measure-text/measure-text.d.ts → document-text-util/document-text-util.d.ts}

@@ -6,10 +6,12 @@ export declare class MeasureTextSettings {
     scale?: number;
     italic?: boolean;
     bold?: boolean;
+    letterSpacing?: number;
     map?: any;
 }
-declare const measureText: (string: any, settings: MeasureTextSettings) => {
-    width: number;
-    height: number;
-};
-export default measureText;
+export declare class DocumentTextUtil {
+    static measureText(string: string, settings: MeasureTextSettings): {
+        width: number;
+        height: number;
+    };
+}

package/lib/document-text-util/document-text-util.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentTextUtil = exports.MeasureTextSettings = void 0;
+const widths_map_1 = require("./widths-map");
+const settingsDefaults = { fontFamily: 'Arial', fontSize: 14 };
+class MeasureTextSettings {
+}
+exports.MeasureTextSettings = MeasureTextSettings;
+class DocumentTextUtil {
+    static measureText(string, settings) {
+        if (string === null || string === undefined) {
+            return { width: 0, height: 0 };
+        }
+        const sett = Object.assign(Object.assign({}, settingsDefaults), settings);
+        let font = sett.fontFamily.toLowerCase();
+        const fontSize = sett.fontSize;
+        const variant = 0 + (sett.bold ? 1 : 0) + (sett.italic ? 2 : 0);
+        const map = sett.map || widths_map_1.WIDTHS_MAP;
+        const available = Object.keys(map);
+        if (available.indexOf(font) === -1) {
+            if (sett.fallbackFontFamily && available.indexOf(sett.fallbackFontFamily.toLowerCase()) !== -1) {
+                font = sett.fallbackFontFamily.toLowerCase();
+            }
+            else {
+                font = 'arial';
+            }
+        }
+        let totalWidth = 0;
+        let lines = 1;
+        let lineWidth = 0;
+        let charLength = 0;
+        const str = string.toString().normalize('NFD');
+        const words = str.split(/(\s|-)/);
+        const fixedWidth = settings.width ? (settings.width * 100) / fontSize : null;
+        words.forEach((word, index) => {
+            let wordWidth = 0;
+            word.split('').forEach(char => {
+                if (/[\x00-\x1F]/.test(char)) {
+                    return true;
+                }
+                const widths = map[font][char] || map[font].x;
+                const width = widths[variant];
+                totalWidth += width;
+                wordWidth += width;
+                charLength++;
+                return true;
+            });
+            if (fixedWidth != null) {
+                lineWidth = lineWidth + wordWidth;
+                if (lineWidth > fixedWidth) {
+                    lineWidth = wordWidth % fixedWidth;
+                    lines = (index === 0 ? 0 : lines) + Math.max(1, Math.ceil(wordWidth / fixedWidth));
+                }
+            }
+        });
+        let letterSpacingWidth = sett.letterSpacing ? charLength * sett.letterSpacing : 0;
+        let width = Math.ceil(totalWidth * (fontSize / 100) + letterSpacingWidth);
+        let height = Math.ceil(fontSize * 1.16);
+        if ((settings === null || settings === void 0 ? void 0 : settings.width) != null) {
+            width = settings.width;
+            height = height * lines;
+        }
+        height = height + 1 * ((settings === null || settings === void 0 ? void 0 : settings.scale) || 1);
+        return { width, height };
+    }
+}
+exports.DocumentTextUtil = DocumentTextUtil;