@pdfme/common 1.1.9 → 1.2.0

package/dist/types/src/type.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Lang, Size, Alignment, BarcodeSchemaType, SchemaType, CommonSchema as _CommonSchema, TextSchema, ImageSchema, BarcodeSchema, Schema, SchemaForUI, Font, BasePdf, Template, CommonProps, GeneratorOptions, GenerateProps, UIOptions, UIProps, PreviewProps, PreviewReactProps, DesignerProps, DesignerReactProps } from './schema.js';
+import { Lang, Size, Alignment, BarcodeSchemaType, SchemaType, CommonSchema as _CommonSchema, TextSchema, ImageSchema, BarcodeSchema, Schema, SchemaInputs, SchemaForUI, Font, BasePdf, Template, CommonProps, GeneratorOptions, GenerateProps, UIOptions, UIProps, PreviewProps, PreviewReactProps, DesignerProps, DesignerReactProps } from './schema.js';
 declare type CommonSchema = z.infer<typeof _CommonSchema>;
 export declare const schemaTypes: readonly ["text", "image", "qrcode", "japanpost", "ean13", "ean8", "code39", "code128", "nw7", "itf14", "upca", "upce"];
 export declare const isTextSchema: (arg: CommonSchema) => arg is {
@@ -11,6 +11,10 @@ export declare const isTextSchema: (arg: CommonSchema) => arg is {
     fontName?: string | undefined;
     fontColor?: string | undefined;
     characterSpacing?: number | undefined;
+    dynamicFontSize?: {
+        max: number;
+        min: number;
+    } | undefined;
     type: "text";
     height: number;
     width: number;
@@ -48,6 +52,7 @@ export declare type TextSchema = z.infer<typeof TextSchema>;
 export declare type ImageSchema = z.infer<typeof ImageSchema>;
 export declare type BarcodeSchema = z.infer<typeof BarcodeSchema>;
 export declare type Schema = z.infer<typeof Schema>;
+export declare type SchemaInputs = z.infer<typeof SchemaInputs>;
 export declare type SchemaForUI = z.infer<typeof SchemaForUI>;
 export declare type Font = z.infer<typeof Font>;
 export declare type BasePdf = z.infer<typeof BasePdf>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdfme/common",
-  "version": "1.1.9",
+  "version": "1.2.0",
   "sideEffects": false,
   "author": "hand-dot",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "node": ">=14"
   },
   "scripts": {
-    "develop": "tsc -w",
+    "develop": "tsc -p tsconfig.esm.json -w",
     "build": "npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:esm": "tsc -p tsconfig.esm.json",
@@ -46,6 +46,8 @@
     "prune": "ts-prune src"
   },
   "dependencies": {
+    "buffer": "^6.0.3",
+    "fontkit": "^2.0.2",
     "zod": "^3.20.2"
   },
   "jest": {
@@ -68,5 +70,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/fontkit": "^2.0.3"
   }
 }

package/src/calculateDynamicFontSize.ts

@@ -0,0 +1,101 @@
+import * as fontkit from 'fontkit';
+import { TextSchema, Font } from './type';
+import { Buffer } from 'buffer';
+import {
+  DEFAULT_FONT_VALUE,
+  DEFAULT_FONT_NAME,
+  DEFAULT_FONT_SIZE,
+  DEFAULT_CHARACTER_SPACING,
+  DEFAULT_TOLERANCE,
+  DEFAULT_FONT_SIZE_ADJUSTMENT,
+  DEFAULT_PT_TO_MM_RATIO
+} from './constants';
+import { b64toUint8Array } from "."
+
+const widthOfTextAtSize = (input: string, fontKitFont: fontkit.Font, fontSize: number) => {
+  const { glyphs } = fontKitFont.layout(input);
+  const scale = 1000 / fontKitFont.unitsPerEm;
+  return glyphs.reduce((totalWidth, glyph) => totalWidth + glyph.advanceWidth * scale, 0) * (fontSize / 1000);
+}
+
+const calculateCharacterSpacing = (
+  textContent: string,
+  textCharacterSpacing: number
+) => {
+  const numberOfCharacters = textContent.length;
+  return (numberOfCharacters - 1) * textCharacterSpacing;
+};
+
+const calculateTextWidthInMm = (textContent: string, textWidth: number, textCharacterSpacing: number) =>
+  (textWidth + calculateCharacterSpacing(textContent, textCharacterSpacing)) * DEFAULT_PT_TO_MM_RATIO;
+
+  const getLongestLine = (
+    textContentRows: string[],
+    fontKitFont: fontkit.Font,
+    fontSize: number,
+    characterSpacingCount: number
+  ) => {
+    let longestLine = '';
+    let maxLineWidth = 0;
+  
+    textContentRows.forEach((line) => {
+      const textWidth = widthOfTextAtSize(line, fontKitFont, fontSize);
+      const lineWidth = calculateTextWidthInMm(line, textWidth, characterSpacingCount);
+  
+      if (lineWidth > maxLineWidth) {
+        longestLine = line;
+        maxLineWidth = lineWidth;
+      }
+    });
+  
+    return longestLine;
+  };
+  
+
+const fontKitFontCache: { [fontName: string]: fontkit.Font } = {};
+const createFontKitFont = async (font: Font, fontName: string = DEFAULT_FONT_NAME) => {
+  if (fontKitFontCache[fontName]) {
+    return fontKitFontCache[fontName];
+  }
+
+  let fontData = font[fontName]?.data || DEFAULT_FONT_VALUE;
+  if (typeof fontData === 'string') {
+    fontData = fontData.startsWith('http') ? await fetch(fontData).then((res) => res.arrayBuffer()) : b64toUint8Array(fontData);
+  }
+
+  const fontKitFont = fontkit.create(fontData instanceof Buffer ? fontData : Buffer.from(fontData as string));
+  fontKitFontCache[fontName] = fontKitFont
+
+  return fontKitFont;
+}
+
+const getTextContent = (input: string, fontKitFont: fontkit.Font, fontSize: number, characterSpacingCount: number): string => {
+  const textContentRows = input.split('\n');
+  return textContentRows.length > 1 ? getLongestLine(textContentRows, fontKitFont, fontSize, characterSpacingCount) : input;
+}
+
+export const calculateDynamicFontSize = async ({ textSchema, font, input }: { textSchema: TextSchema, font: Font, input: string }) => {
+  const { fontName, fontSize: _fontSize, dynamicFontSize: dynamicFontSizeSetting, characterSpacing, width } = textSchema;
+  const fontSize = _fontSize || DEFAULT_FONT_SIZE;
+  if (!dynamicFontSizeSetting) return fontSize;
+
+  const characterSpacingCount = characterSpacing ?? DEFAULT_CHARACTER_SPACING;
+  const fontKitFont = await createFontKitFont(font, fontName);
+  const textContent = getTextContent(input, fontKitFont, fontSize, characterSpacingCount);
+  const textWidth = widthOfTextAtSize(textContent, fontKitFont, fontSize);
+
+  let dynamicFontSize = fontSize;
+  let textWidthInMm = calculateTextWidthInMm(textContent, textWidth, characterSpacingCount);
+
+  while (textWidthInMm > width - DEFAULT_TOLERANCE && dynamicFontSize > dynamicFontSizeSetting.min) {
+    dynamicFontSize -= DEFAULT_FONT_SIZE_ADJUSTMENT;
+    textWidthInMm = calculateTextWidthInMm(textContent, widthOfTextAtSize(textContent, fontKitFont, dynamicFontSize), characterSpacingCount);
+  }
+
+  while (textWidthInMm < width - DEFAULT_TOLERANCE && dynamicFontSize < dynamicFontSizeSetting.max) {
+    dynamicFontSize += DEFAULT_FONT_SIZE_ADJUSTMENT;
+    textWidthInMm = calculateTextWidthInMm(textContent, widthOfTextAtSize(textContent, fontKitFont, dynamicFontSize), characterSpacingCount);
+  }
+
+  return dynamicFontSize;
+};