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

package/src/utils/arrays.ts

@@ -1,153 +0,0 @@
-import { decodeFromBase64DataUri } from './base64';
-import { charFromCode } from './strings';
-
-export const last = <T>(array: T[]): T => array[array.length - 1];
-
-// export const dropLast = <T>(array: T[]): T[] =>
-// array.slice(0, array.length - 1);
-
-export const typedArrayFor = (value: string | Uint8Array): Uint8Array => {
-  if (value instanceof Uint8Array) return value;
-  const length = value.length;
-  const typedArray = new Uint8Array(length);
-  for (let idx = 0; idx < length; idx++) {
-    typedArray[idx] = value.charCodeAt(idx);
-  }
-  return typedArray;
-};
-
-export const mergeIntoTypedArray = (...arrays: (string | Uint8Array)[]) => {
-  const arrayCount = arrays.length;
-
-  const typedArrays: Uint8Array[] = [];
-  for (let idx = 0; idx < arrayCount; idx++) {
-    const element = arrays[idx];
-    typedArrays[idx] = element instanceof Uint8Array ? element : typedArrayFor(element);
-  }
-
-  let totalSize = 0;
-  for (let idx = 0; idx < arrayCount; idx++) {
-    totalSize += arrays[idx].length;
-  }
-
-  const merged = new Uint8Array(totalSize);
-  let offset = 0;
-  for (let arrIdx = 0; arrIdx < arrayCount; arrIdx++) {
-    const arr = typedArrays[arrIdx];
-    for (let byteIdx = 0, arrLen = arr.length; byteIdx < arrLen; byteIdx++) {
-      merged[offset++] = arr[byteIdx];
-    }
-  }
-
-  return merged;
-};
-
-export const mergeUint8Arrays = (arrays: Uint8Array[]): Uint8Array => {
-  let totalSize = 0;
-  for (let idx = 0, len = arrays.length; idx < len; idx++) {
-    totalSize += arrays[idx].length;
-  }
-
-  const mergedBuffer = new Uint8Array(totalSize);
-  let offset = 0;
-  for (let idx = 0, len = arrays.length; idx < len; idx++) {
-    const array = arrays[idx];
-    mergedBuffer.set(array, offset);
-    offset += array.length;
-  }
-
-  return mergedBuffer;
-};
-
-export const arrayAsString = (array: Uint8Array | number[]): string => {
-  let str = '';
-  for (let idx = 0, len = array.length; idx < len; idx++) {
-    str += charFromCode(array[idx]);
-  }
-  return str;
-};
-
-export const byAscendingId = <T extends { id: any }>(a: T, b: T) => a.id - b.id;
-
-export const sortedUniq = <T>(array: T[], indexer: (elem: T) => any): T[] => {
-  const uniq: T[] = [];
-
-  for (let idx = 0, len = array.length; idx < len; idx++) {
-    const curr = array[idx];
-    const prev = array[idx - 1];
-    if (idx === 0 || indexer(curr) !== indexer(prev)) {
-      uniq.push(curr);
-    }
-  }
-
-  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.
-export const reverseArray = (array: Uint8Array) => {
-  const arrayLen = array.length;
-  for (let idx = 0, len = Math.floor(arrayLen / 2); idx < len; idx++) {
-    const leftIdx = idx;
-    const rightIdx = arrayLen - idx - 1;
-    const temp = array[idx];
-
-    array[leftIdx] = array[rightIdx];
-    array[rightIdx] = temp;
-  }
-  return array;
-};
-
-export const sum = (array: number[] | Uint8Array): number => {
-  let total = 0;
-  for (let idx = 0, len = array.length; idx < len; idx++) {
-    total += array[idx];
-  }
-  return total;
-};
-
-export const range = (start: number, end: number): number[] => {
-  const arr = Array<number>(end - start);
-  for (let idx = 0, len = arr.length; idx < len; idx++) {
-    arr[idx] = start + idx;
-  }
-  return arr;
-};
-
-export const pluckIndices = <T>(arr: T[], indices: number[]) => {
-  const plucked = Array<T>(indices.length);
-  for (let idx = 0, len = indices.length; idx < len; idx++) {
-    plucked[idx] = arr[indices[idx]];
-  }
-  return plucked;
-};
-
-export const canBeConvertedToUint8Array = (
-  input: any,
-): input is string | ArrayBuffer | Uint8Array =>
-  input instanceof Uint8Array || input instanceof ArrayBuffer || typeof input === 'string';
-
-export const toUint8Array = (input: string | ArrayBuffer | Uint8Array) => {
-  if (typeof input === 'string') {
-    return decodeFromBase64DataUri(input);
-  } else if (input instanceof ArrayBuffer) {
-    return new Uint8Array(input);
-  } else if (input instanceof Uint8Array) {
-    return input;
-  } else {
-    throw new TypeError('`input` must be one of `string | ArrayBuffer | Uint8Array`');
-  }
-};

package/src/utils/async.ts

@@ -1,8 +0,0 @@
-/**
- * Returns a Promise that resolves after at least one tick of the
- * Macro Task Queue occurs.
- */
-export const waitForTick = (): Promise<void> =>
-  new Promise((resolve) => {
-    setTimeout(() => resolve(), 0);
-  });

package/src/utils/base64.ts

@@ -1,98 +0,0 @@
-/*
- * The `chars`, `lookup`, `encode`, and `decode` members of this file are
- * licensed under the following:
- *
- *     base64-arraybuffer
- *     https://github.com/niklasvh/base64-arraybuffer
- *
- *     Copyright (c) 2012 Niklas von Hertzen
- *     Licensed under the MIT license.
- *
- */
-
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-// Use a lookup table to find the index.
-const lookup = new Uint8Array(256);
-for (let i = 0; i < chars.length; i++) {
-  lookup[chars.charCodeAt(i)] = i;
-}
-
-export const encodeToBase64 = (bytes: Uint8Array): string => {
-  let base64 = '';
-  const len = bytes.length;
-  for (let i = 0; i < len; i += 3) {
-    base64 += chars[bytes[i] >> 2];
-    base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
-    base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
-    base64 += chars[bytes[i + 2] & 63];
-  }
-
-  if (len % 3 === 2) {
-    base64 = base64.substring(0, base64.length - 1) + '=';
-  } else if (len % 3 === 1) {
-    base64 = base64.substring(0, base64.length - 2) + '==';
-  }
-
-  return base64;
-};
-
-export const decodeFromBase64 = (base64: string): Uint8Array => {
-  let bufferLength = base64.length * 0.75;
-  const len = base64.length;
-  let i;
-  let p = 0;
-  let encoded1;
-  let encoded2;
-  let encoded3;
-  let encoded4;
-
-  if (base64[base64.length - 1] === '=') {
-    bufferLength--;
-    if (base64[base64.length - 2] === '=') {
-      bufferLength--;
-    }
-  }
-
-  const bytes = new Uint8Array(bufferLength);
-
-  for (i = 0; i < len; i += 4) {
-    encoded1 = lookup[base64.charCodeAt(i)];
-    encoded2 = lookup[base64.charCodeAt(i + 1)];
-    encoded3 = lookup[base64.charCodeAt(i + 2)];
-    encoded4 = lookup[base64.charCodeAt(i + 3)];
-
-    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
-    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
-    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
-  }
-
-  return bytes;
-};
-
-// 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;
-
-/**
- * If the `dataUri` input is a data URI, then the data URI prefix must not be
- * longer than 100 characters, or this function will fail to decode it.
- *
- * @param dataUri a base64 data URI or plain base64 string
- * @returns a Uint8Array containing the decoded input
- */
-export const decodeFromBase64DataUri = (dataUri: string): Uint8Array => {
-  const trimmedUri = dataUri.trim();
-
-  const prefix = trimmedUri.substring(0, 100);
-  const res = prefix.match(DATA_URI_PREFIX_REGEX);
-
-  // Assume it's not a data URI - just a plain base64 string
-  if (!res) return decodeFromBase64(trimmedUri);
-
-  // Remove the data URI prefix and parse the remainder as a base64 string
-  const [fullMatch] = res;
-  const data = trimmedUri.substring(fullMatch.length);
-
-  return decodeFromBase64(data);
-};

package/src/utils/elements/Arc.ts

@@ -1,97 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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);
-  }
-}

package/src/utils/elements/Line.ts

@@ -1,83 +0,0 @@
-import { Coordinates } from '../../types';
-import { intersectionLine } from '../intersections';
-import { isColinear, isEqual, orthogonal, vector } from '../maths';
-
-import GraphElement from './GraphElement';
-import Point from './Point';
-
-export default class Line extends GraphElement {
-  origin(): Point {
-    return this.A;
-  }
-
-  dirVect(): Coordinates {
-    return vector(this.A, this.B);
-  }
-
-  A: Point;
-  B: Point;
-
-  constructor(A: Point = new Point(), B: Point = new Point()) {
-    super();
-    this.A = A;
-    this.B = B;
-  }
-
-  /** Line equation */
-  y(x: number) {
-    const a = this.a();
-    const b = this.b();
-    return a * x + b;
-  }
-
-  /** The slope */
-  a() {
-    const dirVect = this.dirVect();
-    return dirVect.y / dirVect.x;
-  }
-
-  /** Origin y coordinate */
-  b() {
-    const O = this.origin().toCoords();
-    const a = this.a();
-    return O.y - a * O.x;
-  }
-
-  isEqual(element: GraphElement): boolean {
-    const vect = this.dirVect();
-    return (
-      element instanceof Line &&
-      isColinear(vect, element.dirVect()) &&
-      (isEqual(vect.x, 0)
-        ? // We need to take care of the case of the vertical line
-          isEqual(this.origin().toCoords().x, element.origin().toCoords().x)
-        : isEqual(this.b(), element.b()))
-    );
-  }
-
-  /** Reversed line equation */
-  x(y: number) {
-    const dirVect = this.dirVect();
-    return ((y - this.b()) * dirVect.x) / dirVect.y;
-  }
-
-  includes(P: Point) {
-    const { x, y } = P.toCoords();
-    const vect = this.dirVect();
-    return isEqual(vect.x, 0) ? isEqual(this.origin().toCoords().x, x) : isEqual(this.y(x), y);
-  }
-
-  /** This is used to standarsize type Segment | HalfLine | Line */
-  getLine() {
-    const line = new Line(this.origin(), this.B);
-    return line;
-  }
-
-  orthoProjection(P: Point): Point {
-    const vectOrtho = orthogonal(this.dirVect());
-    const A = new Point(P.toCoords());
-    const ortho = new Line(A, A.plus(vectOrtho));
-    const H = intersectionLine(this, ortho)[0];
-    return new Point(H);
-  }
-}

package/src/utils/elements/Plot.ts

@@ -1,50 +0,0 @@
-import { Coordinates } from '../../types';
-import { plus } from '../maths';
-
-import GraphElement from './GraphElement';
-import Point from './Point';
-import Segment from './Segment';
-export default class Plot extends GraphElement {
-  points: Coordinates[];
-
-  constructor(points: Coordinates[] = []) {
-    super();
-    this.points = points;
-  }
-
-  getPoints() {
-    return [...this.points];
-  }
-
-  translate(translationVector: Coordinates) {
-    this.points = this.points.map((point) => plus(point, translationVector));
-  }
-
-  isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Plot)) return false;
-    const points = this.getPoints().map((coord) => new Point(coord));
-    const points2 = element.getPoints().map((coord) => new Point(coord));
-    return (
-      points.every((point, i) => point.isEqual(points2[i])) ||
-      points.reverse().every((point, i) => point.isEqual(points2[i]))
-    );
-  }
-
-  orthoProjection(P: Point) {
-    const points = this.getPoints();
-    const orthos = points
-      .slice(0, -1)
-      .map((pt, i) => new Segment(new Point(pt), new Point(points[i + 1])))
-      .map((seg) => seg.orthoProjection(P));
-    let min = Number.POSITIVE_INFINITY;
-    let closest: Point = new Point(points[0]);
-    orthos.forEach((ortho) => {
-      const d = ortho.distance(P);
-      if (d < min) {
-        min = d;
-        closest = ortho;
-      }
-    });
-    return closest;
-  }
-}

package/src/utils/elements/Point.ts

@@ -1,37 +0,0 @@
-import type { Coordinates } from '../../types';
-
-import { isEqual, plus } from '../maths';
-import GraphElement from './GraphElement';
-
-export default class Point extends GraphElement {
-  static type = 'PointFixed';
-
-  x: number;
-  y: number;
-
-  constructor(coords = { x: 0, y: 0 }) {
-    super();
-    this.x = coords.x;
-    this.y = coords.y;
-  }
-
-  toCoords() {
-    return { x: this.x, y: this.y };
-  }
-
-  isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Point)) return false;
-    const A = this.toCoords();
-    const B = element.toCoords();
-    return isEqual(A.x, B.x) && isEqual(A.y, B.y);
-  }
-
-  orthoProjection() {
-    return new Point(this.toCoords());
-  }
-
-  plus(vect: Coordinates) {
-    const P = new Point(plus(this.toCoords(), vect));
-    return P;
-  }
-}