@pdfme/pdf-lib 1.17.3 → 1.18.3

package/src/core/structures/PDFFlateStream.ts

@@ -1,10 +1,10 @@
 import pako from 'pako';
 
-import { MethodNotImplementedError } from 'src/core/errors';
-import PDFDict from 'src/core/objects/PDFDict';
-import PDFName from 'src/core/objects/PDFName';
-import PDFStream from 'src/core/objects/PDFStream';
-import { Cache } from 'src/utils';
+import { MethodNotImplementedError } from '../errors';
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFStream from '../objects/PDFStream';
+import { Cache } from '../../utils';
 
 class PDFFlateStream extends PDFStream {
   protected readonly contentsCache: Cache<Uint8Array>;

package/src/core/structures/PDFObjectStream.ts

@@ -1,11 +1,11 @@
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFRef from 'src/core/objects/PDFRef';
-import PDFContext from 'src/core/PDFContext';
-import PDFFlateStream from 'src/core/structures/PDFFlateStream';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { copyStringIntoBuffer, last } from 'src/utils';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
+import CharCodes from '../syntax/CharCodes';
+import { copyStringIntoBuffer, last } from '../../utils';
 
 export type IndirectObject = [PDFRef, PDFObject];
 

package/src/core/structures/PDFPageLeaf.ts

@@ -1,12 +1,12 @@
-import PDFArray from 'src/core/objects/PDFArray';
-import PDFDict, { DictMap } from 'src/core/objects/PDFDict';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFRef from 'src/core/objects/PDFRef';
-import PDFStream from 'src/core/objects/PDFStream';
-import PDFContext from 'src/core/PDFContext';
-import PDFPageTree from 'src/core/structures/PDFPageTree';
+import PDFArray from '../objects/PDFArray';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFStream from '../objects/PDFStream';
+import PDFContext from '../PDFContext';
+import PDFPageTree from './PDFPageTree';
 
 class PDFPageLeaf extends PDFDict {
   static readonly InheritableEntries = [

package/src/core/structures/PDFPageTree.ts

@@ -1,11 +1,11 @@
-import PDFArray from 'src/core/objects/PDFArray';
-import PDFDict, { DictMap } from 'src/core/objects/PDFDict';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFRef from 'src/core/objects/PDFRef';
-import PDFContext from 'src/core/PDFContext';
-import PDFPageLeaf from 'src/core/structures/PDFPageLeaf';
-import { InvalidTargetIndexError, CorruptPageTreeError } from 'src/core/errors';
+import PDFArray from '../objects/PDFArray';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFPageLeaf from './PDFPageLeaf';
+import { InvalidTargetIndexError, CorruptPageTreeError } from '../errors';
 
 export type TreeNode = PDFPageTree | PDFPageLeaf;
 

package/src/core/syntax/Delimiters.ts

@@ -1,4 +1,4 @@
-import CharCodes from 'src/core/syntax/CharCodes';
+import CharCodes from './CharCodes';
 
 export const IsDelimiter = new Uint8Array(256);
 

package/src/core/syntax/Irregular.ts

@@ -1,6 +1,6 @@
-import CharCodes from 'src/core/syntax/CharCodes';
-import { IsDelimiter } from 'src/core/syntax/Delimiters';
-import { IsWhitespace } from 'src/core/syntax/Whitespace';
+import CharCodes from './CharCodes';
+import { IsDelimiter } from './Delimiters';
+import { IsWhitespace } from './Whitespace';
 
 export const IsIrregular = new Uint8Array(256);
 

package/src/core/syntax/Keywords.ts

@@ -1,4 +1,4 @@
-import CharCodes from 'src/core/syntax/CharCodes';
+import CharCodes from './CharCodes';
 
 const { Space, CarriageReturn, Newline } = CharCodes;
 

package/src/core/syntax/Numeric.ts

@@ -1,4 +1,4 @@
-import CharCodes from 'src/core/syntax/CharCodes';
+import CharCodes from './CharCodes';
 
 export const IsDigit = new Uint8Array(256);
 

package/src/core/syntax/Whitespace.ts

@@ -1,4 +1,4 @@
-import CharCodes from 'src/core/syntax/CharCodes';
+import CharCodes from './CharCodes';
 
 export const IsWhitespace = new Uint8Array(256);
 

package/src/core/writers/PDFStreamWriter.ts

@@ -1,16 +1,16 @@
-import PDFHeader from 'src/core/document/PDFHeader';
-import PDFTrailer from 'src/core/document/PDFTrailer';
-import PDFInvalidObject from 'src/core/objects/PDFInvalidObject';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFRef from 'src/core/objects/PDFRef';
-import PDFStream from 'src/core/objects/PDFStream';
-import PDFContext from 'src/core/PDFContext';
-import PDFCrossRefStream from 'src/core/structures/PDFCrossRefStream';
-import PDFObjectStream from 'src/core/structures/PDFObjectStream';
-import PDFWriter from 'src/core/writers/PDFWriter';
-import { last, waitForTick } from 'src/utils';
+import PDFHeader from '../document/PDFHeader';
+import PDFTrailer from '../document/PDFTrailer';
+import PDFInvalidObject from '../objects/PDFInvalidObject';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFStream from '../objects/PDFStream';
+import PDFContext from '../PDFContext';
+import PDFCrossRefStream from '../structures/PDFCrossRefStream';
+import PDFObjectStream from '../structures/PDFObjectStream';
+import PDFWriter from './PDFWriter';
+import { last, waitForTick } from '../../utils';
 
 class PDFStreamWriter extends PDFWriter {
   static forContext = (

package/src/core/writers/PDFWriter.ts

@@ -1,14 +1,14 @@
-import PDFCrossRefSection from 'src/core/document/PDFCrossRefSection';
-import PDFHeader from 'src/core/document/PDFHeader';
-import PDFTrailer from 'src/core/document/PDFTrailer';
-import PDFTrailerDict from 'src/core/document/PDFTrailerDict';
-import PDFDict from 'src/core/objects/PDFDict';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFRef from 'src/core/objects/PDFRef';
-import PDFContext from 'src/core/PDFContext';
-import PDFObjectStream from 'src/core/structures/PDFObjectStream';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { copyStringIntoBuffer, waitForTick } from 'src/utils';
+import PDFCrossRefSection from '../document/PDFCrossRefSection';
+import PDFHeader from '../document/PDFHeader';
+import PDFTrailer from '../document/PDFTrailer';
+import PDFTrailerDict from '../document/PDFTrailerDict';
+import PDFDict from '../objects/PDFDict';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFObjectStream from '../structures/PDFObjectStream';
+import CharCodes from '../syntax/CharCodes';
+import { copyStringIntoBuffer, waitForTick } from '../../utils';
 
 export interface SerializationInfo {
   size: number;
@@ -34,14 +34,8 @@ class PDFWriter {
   }
 
   async serializeToBuffer(): Promise<Uint8Array> {
-    const {
-      size,
-      header,
-      indirectObjects,
-      xref,
-      trailerDict,
-      trailer,
-    } = await this.computeBufferSize();
+    const { size, header, indirectObjects, xref, trailerDict, trailer } =
+      await this.computeBufferSize();
 
     let offset = 0;
     const buffer = new Uint8Array(size);

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from 'src/api/index';
-export * from 'src/core/index';
-export * from 'src/types/index';
-export * from 'src/utils/index';
+export * from './api';
+export * from './core';
+export * from './types';
+export * from './utils';

package/src/types/index.ts

@@ -1 +1,38 @@
-export { TransformationMatrix } from 'src/types/matrix';
+import Arc from '../utils/elements/Arc';
+import Circle from '../utils/elements/Circle';
+import Ellipse from '../utils/elements/Ellipse';
+import Line from '../utils/elements/Line';
+import Plot from '../utils/elements/Plot';
+import Point from '../utils/elements/Point';
+import Rectangle from '../utils/elements/Rectangle';
+import Segment from '../utils/elements/Segment';
+export { TransformationMatrix } from './matrix';
+
+export type Size = {
+  width: number;
+  height: number;
+};
+
+export type Coordinates = {
+  x: number;
+  y: number;
+};
+
+export type GraphicElement =
+  | Arc
+  | Circle
+  | Ellipse
+  | Line
+  | Plot
+  | Point
+  | Rectangle
+  | Segment;
+
+export type Space = {
+  topLeft: Coordinates
+  topRight: Coordinates
+  bottomRight: Coordinates
+  bottomLeft: Coordinates
+ };
+
+export type LinkElement = Rectangle | Ellipse;

package/src/utils/arrays.ts

@@ -1,5 +1,5 @@
-import { decodeFromBase64DataUri } from 'src/utils/base64';
-import { charFromCode } from 'src/utils/strings';
+import { decodeFromBase64DataUri } from './base64';
+import { charFromCode } from './strings';
 
 export const last = <T>(array: T[]): T => array[array.length - 1];
 
@@ -84,6 +84,18 @@ export const sortedUniq = <T>(array: T[], indexer: (elem: T) => any): T[] => {
   return uniq;
 };
 
+export const isArrayEqual = <T>(arr1: ArrayLike<T>, arr2: ArrayLike<T>) => {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  for (let i = 0, ii = arr1.length; i < ii; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
 // Arrays and TypedArrays in JS both have .reverse() methods, which would seem
 // to negate the need for this function. However, not all runtimes support this
 // method (e.g. React Native). This function compensates for that fact.

package/src/utils/base64.ts

@@ -73,7 +73,8 @@ export const decodeFromBase64 = (base64: string): Uint8Array => {
 
 // This regex is designed to be as flexible as possible. It will parse certain
 // invalid data URIs.
-const DATA_URI_PREFIX_REGEX = /^(data)?:?([\w\/\+]+)?;?(charset=[\w-]+|base64)?.*,/i;
+const DATA_URI_PREFIX_REGEX =
+  /^(data)?:?([\w\/\+]+)?;?(charset=[\w-]+|base64)?.*,/i;
 
 /**
  * If the `dataUri` input is a data URI, then the data URI prefix must not be

package/src/utils/elements/Arc.ts

@@ -0,0 +1,107 @@
+import { angleABC, distance, distanceCoords, rotate, vector } from '../maths';
+
+import Circle from './Circle';
+import GraphElement from './GraphElement';
+import Point from './Point';
+
+export default class Arc extends GraphElement {
+  O: Point;
+  A: Point;
+  B: Point;
+  /** Last sweep. Used to deduce the angle orientation */
+  lastSweep: number;
+
+  constructor(
+    O: Point = new Point(),
+    A: Point = new Point(),
+    B: Point = new Point(),
+    lastSweep = 0,
+  ) {
+    super();
+    this.O = O;
+    this.A = A;
+    this.B = B;
+    this.lastSweep = lastSweep;
+  }
+
+  center() {
+    return this.O;
+  }
+
+  origin() {
+    return this.A;
+  }
+
+  destination() {
+    return this.getCircle().orthoProjection(this.B);
+  }
+
+  sweep() {
+    this.lastSweep = angleABC(
+      this.origin(),
+      this.center(),
+      this.destination(),
+      this.lastSweep,
+    );
+    return this.lastSweep;
+  }
+
+  ray() {
+    return distance(this.center(), this.origin());
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Arc)) return false;
+    const dest = this.destination();
+    const o = this.origin();
+    const eDest = element.destination();
+    const eO = element.origin();
+    return (
+      this.getCircle().isEqual(element.getCircle()) &&
+      ((dest.isEqual(eDest) && o.isEqual(eO)) ||
+        (dest.isEqual(eO) && o.isEqual(eDest)))
+    );
+  }
+
+  getCircle() {
+    const circle = new Circle(this.center(), this.ray());
+    return circle;
+  }
+
+  originVect() {
+    return vector(this.center(), this.origin());
+  }
+
+  middle() {
+    const halfSweep = this.sweep() / 2;
+    const mid = this.center().plus(
+      rotate(vector(this.center(), this.origin()), halfSweep),
+    );
+    return mid;
+  }
+
+  includes(P: Point) {
+    // As angles are returned between -π and π, we need the middle of the arc
+    return (
+      this.getCircle().includes(P) &&
+      Math.abs(angleABC(this.middle(), this.center(), P)) <=
+        Math.abs(this.sweep() / 2)
+    );
+  }
+
+  orthoProjection(P: Point) {
+    const H = this.getCircle().orthoProjection(P);
+    if (this.includes(H)) return H;
+    else {
+      const origin = this.origin().toCoords();
+      const destination = this.destination().toCoords();
+      // Returns the closest between origin and destination
+      const coords =
+        distanceCoords(H.toCoords(), origin) <
+        distanceCoords(H.toCoords(), destination)
+          ? origin
+          : destination;
+      return new Point(coords);
+    }
+  }
+}

package/src/utils/elements/Circle.ts

@@ -0,0 +1,55 @@
+import {
+  distance,
+  distanceCoords,
+  isEqual,
+  minus,
+  plus,
+  times,
+  unitVector,
+} from '../maths';
+
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Circle extends GraphElement {
+  O: Point;
+  r: number;
+
+  constructor(O: Point = new Point(), r = 1) {
+    super();
+    this.O = O;
+    this.r = r;
+  }
+
+  ray() {
+    return this.r;
+  }
+
+  center() {
+    return this.O;
+  }
+
+  /** This is used to standardize type Circle | Arc */
+  getCircle() {
+    return this;
+  }
+
+  isEqual(element: GraphElement): boolean {
+    return (
+      element instanceof Circle &&
+      this.center().isEqual(element.center()) &&
+      isEqual(this.ray(), element.ray())
+    );
+  }
+
+  includes(P: Point) {
+    return isEqual(distance(this.center(), P), this.ray());
+  }
+
+  orthoProjection(P: Point) {
+    const center = this.center().toCoords();
+    const coords = P.toCoords();
+    if (distanceCoords(coords, center) < this.ray()) return P;
+    const vect = times(unitVector(minus(coords, center)), this.ray());
+    return new Point(plus(center, vect));
+  }
+}

package/src/utils/elements/Ellipse.ts

@@ -0,0 +1,135 @@
+import { Size } from '../../types';
+import {
+  angle,
+  distance,
+  isEqual,
+  orientation,
+  orthogonal,
+  times,
+  unitVector,
+  vector,
+} from '../maths';
+
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+
+export default class Ellipse extends GraphElement {
+  A: Point;
+  B: Point;
+  C: Point;
+
+  constructor(
+    A: Point = new Point(),
+    B: Point = new Point(),
+    C: Point = new Point(),
+  ) {
+    super();
+    this.A = A;
+    this.B = B;
+    this.C = C;
+  }
+
+  center(): Point {
+    const center = this.axis().middle();
+    return center;
+  }
+
+  axis(): Segment {
+    const axis = new Segment(this.A, this.B);
+    return axis;
+  }
+
+  a(): number {
+    const axis = this.axis();
+    return Math.max(axis.length() / 2, axis.distance(this.C));
+  }
+
+  b(): number {
+    const axis = this.axis();
+    return Math.min(axis.length() / 2, axis.distance(this.C));
+  }
+
+  rotation(): number {
+    const axis = this.axis();
+    return axis.length() / 2 > axis.distance(this.C)
+      ? orientation(axis.dirVect())
+      : orientation(orthogonal(axis.dirVect()));
+  }
+
+  getSize(): Size {
+    return { width: 2 * this.a(), height: 2 * this.b() };
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Ellipse)) return false;
+    const a = this.a();
+    const b = this.b();
+    const rotation = this.rotation();
+    const eltA = element.a();
+    const eltB = element.b();
+    const eltRotation = element.rotation();
+    // If the main axis is the same on both ellipse
+    if (eltA < eltB === a < b) {
+      // The rotation is equivalent module PI as the element is symetrical
+      return (
+        isEqual(eltA, a) &&
+        isEqual(eltB, b) &&
+        isEqual(
+          rotation + (Math.PI % Math.PI),
+          eltRotation + (Math.PI % Math.PI),
+        )
+      );
+    }
+    // If the small axis is different
+    else {
+      // We add a rotation of PI / 2 to emulate the fact that the main axis are actually orthogonal
+      return (
+        isEqual(eltA, b) &&
+        isEqual(eltB, a) &&
+        isEqual(
+          rotation + (Math.PI % Math.PI),
+          eltRotation + (((3 * Math.PI) / 2) % Math.PI),
+        )
+      );
+    }
+  }
+
+  includes(P: Point) {
+    const { x, y } = P.toCoords();
+    const { x: cx, y: cy } = this.center().toCoords();
+    const teta = this.rotation();
+    return isEqual(
+      Math.pow(
+        ((x - cx) * Math.cos(teta) + (y - cy) * Math.sin(teta)) / this.a(),
+        2,
+      ) +
+        Math.pow(
+          ((x - cx) * Math.sin(teta) - (y - cy) * Math.cos(teta)) / this.b(),
+          2,
+        ),
+      1,
+    );
+  }
+
+  orthoProjection(P: Point) {
+    // We will consider that the parametric projection is a correct approximation of the distance for the current case, even if it is not orthogonal
+    const C = this.center();
+    const axis = this.axis();
+    const CP = vector(C, P);
+    const teta = angle(axis.dirVect(), vector(C, P));
+    const ray = this.polarRay(teta);
+    if (distance(P, this.center()) < ray) return P;
+    const vect = times(unitVector(CP), ray);
+    return new Point(this.center().plus(vect).toCoords());
+  }
+
+  polarRay(teta: number) {
+    const a = this.a();
+    const b = this.b();
+    const excentricity = Math.sqrt(Math.abs(a * a - b * b)) / Math.max(a, b);
+    return (
+      Math.min(a, b) / Math.sqrt(1 - Math.pow(excentricity * Math.cos(teta), 2))
+    );
+  }
+}

package/src/utils/elements/GraphElement.ts

@@ -0,0 +1,14 @@
+import { distance } from '../maths';
+
+import Point from './Point';
+
+export default abstract class GraphElement {
+  abstract isEqual(element: GraphElement): boolean;
+
+  abstract orthoProjection(P: Point): Point;
+
+  distance(P: Point) {
+    const H = this.orthoProjection(P);
+    return distance(H, P);
+  }
+}