@pdfme/pdf-lib 6.0.3-dev.0 → 6.0.4-dev.1

package/src/api/text/layout.ts

@@ -1,328 +0,0 @@
-import PDFFont from '../PDFFont';
-import { CombedTextLayoutError } from '../errors';
-import { TextAlignment } from './alignment';
-
-import { PDFHexString } from '../../core';
-import { cleanText, lineSplit, mergeLines, charAtIndex, charSplit } from '../../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

@@ -1,274 +0,0 @@
-import pako from 'pako';
-
-import PDFHeader from './document/PDFHeader';
-import { UnexpectedObjectTypeError } from './errors';
-import PDFArray from './objects/PDFArray';
-import PDFBool from './objects/PDFBool';
-import PDFDict from './objects/PDFDict';
-import PDFHexString from './objects/PDFHexString';
-import PDFName from './objects/PDFName';
-import PDFNull from './objects/PDFNull';
-import PDFNumber from './objects/PDFNumber';
-import PDFObject from './objects/PDFObject';
-import PDFRawStream from './objects/PDFRawStream';
-import PDFRef from './objects/PDFRef';
-import PDFStream from './objects/PDFStream';
-import PDFString from './objects/PDFString';
-import PDFOperator from './operators/PDFOperator';
-import Ops from './operators/PDFOperatorNames';
-import PDFContentStream from './structures/PDFContentStream';
-import { typedArrayFor } from '../utils';
-import { SimpleRNG } from '../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 {
-  isDecrypted = true;
-  static create = () => new PDFContext();
-
-  largestObjectNumber: number;
-  header: PDFHeader;
-  trailerInfo: {
-    Root?: PDFObject;
-    Encrypt?: PDFObject;
-    Info?: PDFObject;
-    ID?: PDFObject;
-  };
-  rng: SimpleRNG;
-
-  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);
-  }
-
-  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)}`;
-  }
-}
-
-export default PDFContext;