@adnsistemas/pdf-lib 1.18.0

package/src/api/text/layout.ts

@@ -0,0 +1,343 @@
+import PDFFont from 'src/api/PDFFont';
+import { CombedTextLayoutError } from 'src/api/errors';
+import { TextAlignment } from 'src/api/text/alignment';
+
+import { PDFHexString } from 'src/core';
+import {
+  cleanText,
+  lineSplit,
+  mergeLines,
+  charAtIndex,
+  charSplit,
+} from 'src/utils';
+
+export interface TextPosition {
+  text: string;
+  encoded: PDFHexString;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface LayoutBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+const MIN_FONT_SIZE = 4;
+const MAX_FONT_SIZE = 500;
+
+const computeFontSize = (
+  lines: string[],
+  font: PDFFont,
+  bounds: LayoutBounds,
+  multiline: boolean = false,
+) => {
+  let fontSize = MIN_FONT_SIZE;
+
+  while (fontSize < MAX_FONT_SIZE) {
+    let linesUsed = 0;
+
+    for (
+      let lineIdx = 0, lineLen = lines.length;
+      lineIdx < lineLen;
+      lineIdx++
+    ) {
+      linesUsed += 1;
+
+      const line = lines[lineIdx];
+      const words = line.split(' ');
+
+      // Layout the words using the current `fontSize`, line wrapping
+      // whenever we reach the end of the current line.
+      let spaceInLineRemaining = bounds.width;
+      for (let idx = 0, len = words.length; idx < len; idx++) {
+        const isLastWord = idx === len - 1;
+        const word = isLastWord ? words[idx] : words[idx] + ' ';
+        const widthOfWord = font.widthOfTextAtSize(word, fontSize);
+        spaceInLineRemaining -= widthOfWord;
+        if (spaceInLineRemaining <= 0) {
+          linesUsed += 1;
+          spaceInLineRemaining = bounds.width - widthOfWord;
+        }
+      }
+    }
+
+    // Return if we exceeded the allowed width
+    if (!multiline && linesUsed > lines.length) return fontSize - 1;
+
+    const height = font.heightAtSize(fontSize);
+    const lineHeight = height + height * 0.2;
+    const totalHeight = lineHeight * linesUsed;
+
+    // Return if we exceeded the allowed height
+    if (totalHeight > Math.abs(bounds.height)) return fontSize - 1;
+
+    fontSize += 1;
+  }
+
+  return fontSize;
+};
+
+const computeCombedFontSize = (
+  line: string,
+  font: PDFFont,
+  bounds: LayoutBounds,
+  cellCount: number,
+) => {
+  const cellWidth = bounds.width / cellCount;
+  const cellHeight = bounds.height;
+
+  let fontSize = MIN_FONT_SIZE;
+
+  const chars = charSplit(line);
+  while (fontSize < MAX_FONT_SIZE) {
+    for (let idx = 0, len = chars.length; idx < len; idx++) {
+      const c = chars[idx];
+      const tooLong = font.widthOfTextAtSize(c, fontSize) > cellWidth * 0.75;
+      if (tooLong) return fontSize - 1;
+    }
+
+    const height = font.heightAtSize(fontSize, { descender: false });
+    if (height > cellHeight) return fontSize - 1;
+
+    fontSize += 1;
+  }
+
+  return fontSize;
+};
+
+export interface LayoutTextOptions {
+  alignment: TextAlignment;
+  fontSize?: number;
+  font: PDFFont;
+  bounds: LayoutBounds;
+}
+
+export interface MultilineTextLayout {
+  bounds: LayoutBounds;
+  lines: TextPosition[];
+  fontSize: number;
+  lineHeight: number;
+}
+
+const lastIndexOfWhitespace = (line: string) => {
+  for (let idx = line.length; idx > 0; idx--) {
+    if (/\s/.test(line[idx])) return idx;
+  }
+  return undefined;
+};
+
+const splitOutLines = (
+  input: string,
+  maxWidth: number,
+  font: PDFFont,
+  fontSize: number,
+) => {
+  let lastWhitespaceIdx = input.length;
+  while (lastWhitespaceIdx > 0) {
+    const line = input.substring(0, lastWhitespaceIdx);
+    const encoded = font.encodeText(line);
+    const width = font.widthOfTextAtSize(line, fontSize);
+    if (width < maxWidth) {
+      const remainder = input.substring(lastWhitespaceIdx) || undefined;
+      return { line, encoded, width, remainder };
+    }
+    lastWhitespaceIdx = lastIndexOfWhitespace(line) ?? 0;
+  }
+
+  // We were unable to split the input enough to get a chunk that would fit
+  // within the specified `maxWidth` so we'll just return everything
+  return {
+    line: input,
+    encoded: font.encodeText(input),
+    width: font.widthOfTextAtSize(input, fontSize),
+    remainder: undefined,
+  };
+};
+
+export const layoutMultilineText = (
+  text: string,
+  { alignment, fontSize, font, bounds }: LayoutTextOptions,
+): MultilineTextLayout => {
+  const lines = lineSplit(cleanText(text));
+
+  if (fontSize === undefined || fontSize === 0) {
+    fontSize = computeFontSize(lines, font, bounds, true);
+  }
+  const height = font.heightAtSize(fontSize);
+  const lineHeight = height + height * 0.2;
+
+  const textLines: TextPosition[] = [];
+
+  let minX = bounds.x;
+  let minY = bounds.y;
+  let maxX = bounds.x + bounds.width;
+  let maxY = bounds.y + bounds.height;
+
+  let y = bounds.y + bounds.height;
+  for (let idx = 0, len = lines.length; idx < len; idx++) {
+    let prevRemainder: string | undefined = lines[idx];
+    while (prevRemainder !== undefined) {
+      const { line, encoded, width, remainder } = splitOutLines(
+        prevRemainder,
+        bounds.width,
+        font,
+        fontSize,
+      );
+
+      // prettier-ignore
+      const x = (
+          alignment === TextAlignment.Left   ? bounds.x
+        : alignment === TextAlignment.Center ? bounds.x + (bounds.width / 2) - (width / 2)
+        : alignment === TextAlignment.Right  ? bounds.x + bounds.width - width
+        : bounds.x
+      );
+
+      y -= lineHeight;
+
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (x + width > maxX) maxX = x + width;
+      if (y + height > maxY) maxY = y + height;
+
+      textLines.push({ text: line, encoded, width, height, x, y });
+
+      // Only trim lines that we had to split ourselves. So we won't trim lines
+      // that the user provided themselves with whitespace.
+      prevRemainder = remainder?.trim();
+    }
+  }
+
+  return {
+    fontSize,
+    lineHeight,
+    lines: textLines,
+    bounds: {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY,
+    },
+  };
+};
+
+export interface LayoutCombedTextOptions {
+  fontSize?: number;
+  font: PDFFont;
+  bounds: LayoutBounds;
+  cellCount: number;
+}
+
+export interface CombedTextLayout {
+  bounds: LayoutBounds;
+  cells: TextPosition[];
+  fontSize: number;
+}
+
+export const layoutCombedText = (
+  text: string,
+  { fontSize, font, bounds, cellCount }: LayoutCombedTextOptions,
+): CombedTextLayout => {
+  const line = mergeLines(cleanText(text));
+
+  if (line.length > cellCount) {
+    throw new CombedTextLayoutError(line.length, cellCount);
+  }
+
+  if (fontSize === undefined || fontSize === 0) {
+    fontSize = computeCombedFontSize(line, font, bounds, cellCount);
+  }
+
+  const cellWidth = bounds.width / cellCount;
+
+  const height = font.heightAtSize(fontSize, { descender: false });
+  const y = bounds.y + (bounds.height / 2 - height / 2);
+
+  const cells: TextPosition[] = [];
+
+  let minX = bounds.x;
+  let minY = bounds.y;
+  let maxX = bounds.x + bounds.width;
+  let maxY = bounds.y + bounds.height;
+
+  let cellOffset = 0;
+  let charOffset = 0;
+  while (cellOffset < cellCount) {
+    const [char, charLength] = charAtIndex(line, charOffset);
+
+    const encoded = font.encodeText(char);
+    const width = font.widthOfTextAtSize(char, fontSize);
+
+    const cellCenter = bounds.x + (cellWidth * cellOffset + cellWidth / 2);
+    const x = cellCenter - width / 2;
+
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x + width > maxX) maxX = x + width;
+    if (y + height > maxY) maxY = y + height;
+
+    cells.push({ text: line, encoded, width, height, x, y });
+
+    cellOffset += 1;
+    charOffset += charLength;
+  }
+
+  return {
+    fontSize,
+    cells,
+    bounds: {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY,
+    },
+  };
+};
+
+export interface LayoutSinglelineTextOptions {
+  alignment: TextAlignment;
+  fontSize?: number;
+  font: PDFFont;
+  bounds: LayoutBounds;
+}
+
+export interface SinglelineTextLayout {
+  bounds: LayoutBounds;
+  line: TextPosition;
+  fontSize: number;
+}
+
+export const layoutSinglelineText = (
+  text: string,
+  { alignment, fontSize, font, bounds }: LayoutSinglelineTextOptions,
+): SinglelineTextLayout => {
+  const line = mergeLines(cleanText(text));
+
+  if (fontSize === undefined || fontSize === 0) {
+    fontSize = computeFontSize([line], font, bounds);
+  }
+
+  const encoded = font.encodeText(line);
+  const width = font.widthOfTextAtSize(line, fontSize);
+  const height = font.heightAtSize(fontSize, { descender: false });
+
+  // prettier-ignore
+  const x = (
+      alignment === TextAlignment.Left   ? bounds.x
+    : alignment === TextAlignment.Center ? bounds.x + (bounds.width / 2) - (width / 2)
+    : alignment === TextAlignment.Right  ? bounds.x + bounds.width - width
+    : bounds.x
+  );
+
+  const y = bounds.y + (bounds.height / 2 - height / 2);
+
+  return {
+    fontSize,
+    line: { text: line, encoded, width, height, x, y },
+    bounds: { x, y, width, height },
+  };
+};

package/src/core/PDFContext.ts

@@ -0,0 +1,316 @@
+import pako from 'pako';
+import { DocumentSnapshot } from 'src/api';
+
+import PDFHeader from 'src/core/document/PDFHeader';
+import { UnexpectedObjectTypeError } from 'src/core/errors';
+import PDFArray from 'src/core/objects/PDFArray';
+import PDFBool from 'src/core/objects/PDFBool';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFHexString from 'src/core/objects/PDFHexString';
+import PDFName from 'src/core/objects/PDFName';
+import PDFNull from 'src/core/objects/PDFNull';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFRawStream from 'src/core/objects/PDFRawStream';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFStream from 'src/core/objects/PDFStream';
+import PDFString from 'src/core/objects/PDFString';
+import PDFOperator from 'src/core/operators/PDFOperator';
+import Ops from 'src/core/operators/PDFOperatorNames';
+import PDFContentStream from 'src/core/structures/PDFContentStream';
+import { typedArrayFor } from 'src/utils';
+import { SimpleRNG } from 'src/utils/rng';
+
+type LookupKey = PDFRef | PDFObject | undefined;
+
+interface LiteralObject {
+  [name: string]: Literal | PDFObject;
+}
+
+interface LiteralArray {
+  [index: number]: Literal | PDFObject;
+}
+
+type Literal =
+  | LiteralObject
+  | LiteralArray
+  | string
+  | number
+  | boolean
+  | null
+  | undefined;
+
+const byAscendingObjectNumber = (
+  [a]: [PDFRef, PDFObject],
+  [b]: [PDFRef, PDFObject],
+) => a.objectNumber - b.objectNumber;
+
+class PDFContext {
+  static create = () => new PDFContext();
+
+  largestObjectNumber: number;
+  header: PDFHeader;
+  trailerInfo: {
+    Root?: PDFObject;
+    Encrypt?: PDFObject;
+    Info?: PDFObject;
+    ID?: PDFObject;
+  };
+  rng: SimpleRNG;
+  pdfFileDetails: {
+    pdfSize: number;
+    prevStartXRef: number;
+    useObjectStreams: boolean;
+    originalBytes?: Uint8Array;
+  };
+  snapshot?: DocumentSnapshot;
+
+  private readonly indirectObjects: Map<PDFRef, PDFObject>;
+
+  private pushGraphicsStateContentStreamRef?: PDFRef;
+  private popGraphicsStateContentStreamRef?: PDFRef;
+
+  private constructor() {
+    this.largestObjectNumber = 0;
+    this.header = PDFHeader.forVersion(1, 7);
+    this.trailerInfo = {};
+
+    this.indirectObjects = new Map();
+    this.rng = SimpleRNG.withSeed(1);
+    this.pdfFileDetails = {
+      pdfSize: 0,
+      prevStartXRef: 0,
+      useObjectStreams: false,
+    };
+  }
+
+  assign(ref: PDFRef, object: PDFObject): void {
+    this.indirectObjects.set(ref, object);
+    if (ref.objectNumber > this.largestObjectNumber) {
+      this.largestObjectNumber = ref.objectNumber;
+    }
+  }
+
+  nextRef(): PDFRef {
+    this.largestObjectNumber += 1;
+    return PDFRef.of(this.largestObjectNumber);
+  }
+
+  register(object: PDFObject): PDFRef {
+    const ref = this.nextRef();
+    this.assign(ref, object);
+    return ref;
+  }
+
+  delete(ref: PDFRef): boolean {
+    return this.indirectObjects.delete(ref);
+  }
+
+  lookupMaybe(ref: LookupKey, type: typeof PDFArray): PDFArray | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFBool): PDFBool | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFDict): PDFDict | undefined;
+  lookupMaybe(
+    ref: LookupKey,
+    type: typeof PDFHexString,
+  ): PDFHexString | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFName): PDFName | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFNull): typeof PDFNull | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFNumber): PDFNumber | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFStream): PDFStream | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFRef): PDFRef | undefined;
+  lookupMaybe(ref: LookupKey, type: typeof PDFString): PDFString | undefined;
+  lookupMaybe(
+    ref: LookupKey,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+  ): PDFString | PDFHexString | undefined;
+
+  lookupMaybe(ref: LookupKey, ...types: any[]) {
+    // TODO: `preservePDFNull` is for backwards compatibility. Should be
+    // removed in next breaking API change.
+    const preservePDFNull = types.includes(PDFNull);
+
+    const result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
+
+    if (!result || (result === PDFNull && !preservePDFNull)) return undefined;
+
+    for (let idx = 0, len = types.length; idx < len; idx++) {
+      const type = types[idx];
+      if (type === PDFNull) {
+        if (result === PDFNull) return result;
+      } else {
+        if (result instanceof type) return result;
+      }
+    }
+    throw new UnexpectedObjectTypeError(types, result);
+  }
+
+  lookup(ref: LookupKey): PDFObject | undefined;
+  lookup(ref: LookupKey, type: typeof PDFArray): PDFArray;
+  lookup(ref: LookupKey, type: typeof PDFBool): PDFBool;
+  lookup(ref: LookupKey, type: typeof PDFDict): PDFDict;
+  lookup(ref: LookupKey, type: typeof PDFHexString): PDFHexString;
+  lookup(ref: LookupKey, type: typeof PDFName): PDFName;
+  lookup(ref: LookupKey, type: typeof PDFNull): typeof PDFNull;
+  lookup(ref: LookupKey, type: typeof PDFNumber): PDFNumber;
+  lookup(ref: LookupKey, type: typeof PDFStream): PDFStream;
+  lookup(ref: LookupKey, type: typeof PDFRef): PDFRef;
+  lookup(ref: LookupKey, type: typeof PDFString): PDFString;
+  lookup(
+    ref: LookupKey,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+  ): PDFString | PDFHexString;
+
+  lookup(ref: LookupKey, ...types: any[]) {
+    const result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
+
+    if (types.length === 0) return result;
+
+    for (let idx = 0, len = types.length; idx < len; idx++) {
+      const type = types[idx];
+      if (type === PDFNull) {
+        if (result === PDFNull) return result;
+      } else {
+        if (result instanceof type) return result;
+      }
+    }
+
+    throw new UnexpectedObjectTypeError(types, result);
+  }
+
+  getObjectRef(pdfObject: PDFObject): PDFRef | undefined {
+    const entries = Array.from(this.indirectObjects.entries());
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [ref, object] = entries[idx];
+      if (object === pdfObject) {
+        return ref;
+      }
+    }
+
+    return undefined;
+  }
+
+  enumerateIndirectObjects(): [PDFRef, PDFObject][] {
+    return Array.from(this.indirectObjects.entries()).sort(
+      byAscendingObjectNumber,
+    );
+  }
+
+  obj(literal: null | undefined): typeof PDFNull;
+  obj(literal: string): PDFName;
+  obj(literal: number): PDFNumber;
+  obj(literal: boolean): PDFBool;
+  obj(literal: LiteralObject): PDFDict;
+  obj(literal: LiteralArray): PDFArray;
+
+  obj(literal: Literal) {
+    if (literal instanceof PDFObject) {
+      return literal;
+    } else if (literal === null || literal === undefined) {
+      return PDFNull;
+    } else if (typeof literal === 'string') {
+      return PDFName.of(literal);
+    } else if (typeof literal === 'number') {
+      return PDFNumber.of(literal);
+    } else if (typeof literal === 'boolean') {
+      return literal ? PDFBool.True : PDFBool.False;
+    } else if (Array.isArray(literal)) {
+      const array = PDFArray.withContext(this);
+      for (let idx = 0, len = literal.length; idx < len; idx++) {
+        array.push(this.obj(literal[idx]));
+      }
+      return array;
+    } else {
+      const dict = PDFDict.withContext(this);
+      const keys = Object.keys(literal);
+      for (let idx = 0, len = keys.length; idx < len; idx++) {
+        const key = keys[idx];
+        const value = (literal as LiteralObject)[key] as any;
+        if (value !== undefined) dict.set(PDFName.of(key), this.obj(value));
+      }
+      return dict;
+    }
+  }
+
+  stream(
+    contents: string | Uint8Array,
+    dict: LiteralObject = {},
+  ): PDFRawStream {
+    return PDFRawStream.of(this.obj(dict), typedArrayFor(contents));
+  }
+
+  flateStream(
+    contents: string | Uint8Array,
+    dict: LiteralObject = {},
+  ): PDFRawStream {
+    return this.stream(pako.deflate(typedArrayFor(contents)), {
+      ...dict,
+      Filter: 'FlateDecode',
+    });
+  }
+
+  contentStream(
+    operators: PDFOperator[],
+    dict: LiteralObject = {},
+  ): PDFContentStream {
+    return PDFContentStream.of(this.obj(dict), operators);
+  }
+
+  formXObject(
+    operators: PDFOperator[],
+    dict: LiteralObject = {},
+  ): PDFContentStream {
+    return this.contentStream(operators, {
+      BBox: this.obj([0, 0, 0, 0]),
+      Matrix: this.obj([1, 0, 0, 1, 0, 0]),
+      ...dict,
+      Type: 'XObject',
+      Subtype: 'Form',
+    });
+  }
+
+  /*
+   * Reference to PDFContentStream that contains a single PDFOperator: `q`.
+   * Used by [[PDFPageLeaf]] instances to ensure that when content streams are
+   * added to a modified PDF, they start in the default, unchanged graphics
+   * state.
+   */
+  getPushGraphicsStateContentStream(): PDFRef {
+    if (this.pushGraphicsStateContentStreamRef) {
+      return this.pushGraphicsStateContentStreamRef;
+    }
+    const dict = this.obj({});
+    const op = PDFOperator.of(Ops.PushGraphicsState);
+    const stream = PDFContentStream.of(dict, [op]);
+    this.pushGraphicsStateContentStreamRef = this.register(stream);
+    return this.pushGraphicsStateContentStreamRef;
+  }
+
+  /*
+   * Reference to PDFContentStream that contains a single PDFOperator: `Q`.
+   * Used by [[PDFPageLeaf]] instances to ensure that when content streams are
+   * added to a modified PDF, they start in the default, unchanged graphics
+   * state.
+   */
+  getPopGraphicsStateContentStream(): PDFRef {
+    if (this.popGraphicsStateContentStreamRef) {
+      return this.popGraphicsStateContentStreamRef;
+    }
+    const dict = this.obj({});
+    const op = PDFOperator.of(Ops.PopGraphicsState);
+    const stream = PDFContentStream.of(dict, [op]);
+    this.popGraphicsStateContentStreamRef = this.register(stream);
+    return this.popGraphicsStateContentStreamRef;
+  }
+
+  addRandomSuffix(prefix: string, suffixLength = 4): string {
+    return `${prefix}-${Math.floor(this.rng.nextInt() * 10 ** suffixLength)}`;
+  }
+
+  registerObjectChange(obj: PDFObject) {
+    if (this.snapshot) this.snapshot.markObjForSave(obj);
+  }
+}
+
+export default PDFContext;