@adnsistemas/pdf-lib 2.8.0 → 2.9.0

package/src/api/form/PDFForm.ts

@@ -42,6 +42,7 @@ import {
   PDFWidgetAnnotation,
 } from '../../core';
 import { assertIs, Cache, assertOrUndefined } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../objects';
 
 export interface FlattenOptions {
   updateFieldAppearances: boolean;
@@ -202,7 +203,7 @@ export default class PDFForm {
   getButton(name: string): PDFButton {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFButton) return field;
+    if (isPDFInstance(field, PDFClasses.PDFButton)) return field as PDFButton;
     throw new UnexpectedFieldTypeError(name, PDFButton, field);
   }
 
@@ -222,7 +223,8 @@ export default class PDFForm {
   getCheckBox(name: string): PDFCheckBox {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFCheckBox) return field;
+    if (isPDFInstance(field, PDFClasses.PDFCheckBox))
+      return field as PDFCheckBox;
     throw new UnexpectedFieldTypeError(name, PDFCheckBox, field);
   }
 
@@ -243,7 +245,8 @@ export default class PDFForm {
   getDropdown(name: string): PDFDropdown {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFDropdown) return field;
+    if (isPDFInstance(field, PDFClasses.PDFDropdown))
+      return field as PDFDropdown;
     throw new UnexpectedFieldTypeError(name, PDFDropdown, field);
   }
 
@@ -264,7 +267,8 @@ export default class PDFForm {
   getOptionList(name: string): PDFOptionList {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFOptionList) return field;
+    if (isPDFInstance(field, PDFClasses.PDFOptionList))
+      return field as PDFOptionList;
     throw new UnexpectedFieldTypeError(name, PDFOptionList, field);
   }
 
@@ -285,7 +289,8 @@ export default class PDFForm {
   getRadioGroup(name: string): PDFRadioGroup {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFRadioGroup) return field;
+    if (isPDFInstance(field, PDFClasses.PDFRadioGroup))
+      return field as PDFRadioGroup;
     throw new UnexpectedFieldTypeError(name, PDFRadioGroup, field);
   }
 
@@ -304,7 +309,8 @@ export default class PDFForm {
   getSignature(name: string): PDFSignature {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFSignature) return field;
+    if (isPDFInstance(field, PDFClasses.PDFSignature))
+      return field as PDFSignature;
     throw new UnexpectedFieldTypeError(name, PDFSignature, field);
   }
 
@@ -324,7 +330,8 @@ export default class PDFForm {
   getTextField(name: string): PDFTextField {
     assertIs(name, 'name', ['string']);
     const field = this.getField(name);
-    if (field instanceof PDFTextField) return field;
+    if (isPDFInstance(field, PDFClasses.PDFTextField))
+      return field as PDFTextField;
     throw new UnexpectedFieldTypeError(name, PDFTextField, field);
   }
 
@@ -606,8 +613,8 @@ export default class PDFForm {
     const kidsCount = fieldKids.size();
     for (let childIndex = 0; childIndex < kidsCount; childIndex++) {
       const child = fieldKids.get(childIndex);
-      if (child instanceof PDFRef) {
-        this.doc.context.delete(child);
+      if (isPDFInstance(child, PDFClasses.PDFRef)) {
+        this.doc.context.delete(child as PDFRef);
       }
     }
     this.doc.context.delete(field.ref);
@@ -731,26 +738,33 @@ export default class PDFForm {
   ): PDFRef {
     let refOrDict = widget.getNormalAppearance();
 
-    if (field instanceof PDFCheckBox || field instanceof PDFRadioGroup) {
-      if (refOrDict instanceof PDFRef) {
+    if (
+      isPDFInstance(field, PDFClasses.PDFCheckBox) ||
+      isPDFInstance(field, PDFClasses.PDFRadioGroup)
+    ) {
+      if (isPDFInstance(refOrDict, PDFClasses.PDFRef)) {
         refOrDict = this.doc.context.lookup(refOrDict, PDFDict);
       }
-      if (refOrDict instanceof PDFDict) {
-        const value = field.acroField.getValue();
-        const ref = refOrDict.get(value) ?? refOrDict.get(PDFName.of('Off'));
-
-        if (ref instanceof PDFRef) {
-          refOrDict = ref;
+      if (isPDFInstance(refOrDict, PDFClasses.PDFDict)) {
+        const value = (
+          field as PDFCheckBox | PDFRadioGroup
+        ).acroField.getValue();
+        const ref =
+          (refOrDict as PDFDict).get(value) ??
+          (refOrDict as PDFDict).get(PDFName.of('Off'));
+
+        if (isPDFInstance(ref, PDFClasses.PDFRef)) {
+          refOrDict = ref as PDFRef;
         }
       }
     }
 
-    if (!(refOrDict instanceof PDFRef)) {
+    if (!isPDFInstance(refOrDict, PDFClasses.PDFRef)) {
       const name = field.getName();
       throw new Error(`Failed to extract appearance ref for: ${name}`);
     }
 
-    return refOrDict;
+    return refOrDict as PDFRef;
   }
 
   private findOrCreateNonTerminals(partialNames: string[]) {
@@ -781,15 +795,15 @@ export default class PDFForm {
     partialName: string,
     parent: PDFAcroForm | PDFAcroNonTerminal,
   ): [PDFAcroNonTerminal, PDFRef] | undefined {
-    const fields =
-      parent instanceof PDFAcroForm
-        ? this.acroForm.getFields()
-        : createPDFAcroFields(parent.Kids());
+    const fields = isPDFInstance(parent, PDFClasses.PDFAcroForm)
+      ? this.acroForm.getFields()
+      : createPDFAcroFields((parent as PDFAcroNonTerminal).Kids());
 
     for (let idx = 0, len = fields.length; idx < len; idx++) {
       const [field, ref] = fields[idx];
       if (field.getPartialName() === partialName) {
-        if (field instanceof PDFAcroNonTerminal) return [field, ref];
+        if (isPDFInstance(field, PDFClasses.PDFAcroNonTerminal))
+          return [field as PDFAcroNonTerminal, ref];
         throw new FieldAlreadyExistsError(partialName);
       }
     }
@@ -806,16 +820,21 @@ const convertToPDFField = (
   ref: PDFRef,
   doc: PDFDocument,
 ): PDFField | undefined => {
-  if (field instanceof PDFAcroPushButton) return PDFButton.of(field, ref, doc);
-  if (field instanceof PDFAcroCheckBox) return PDFCheckBox.of(field, ref, doc);
-  if (field instanceof PDFAcroComboBox) return PDFDropdown.of(field, ref, doc);
-  if (field instanceof PDFAcroListBox) return PDFOptionList.of(field, ref, doc);
-  if (field instanceof PDFAcroText) return PDFTextField.of(field, ref, doc);
-  if (field instanceof PDFAcroRadioButton) {
-    return PDFRadioGroup.of(field, ref, doc);
-  }
-  if (field instanceof PDFAcroSignature) {
-    return PDFSignature.of(field, ref, doc);
+  if (isPDFInstance(field, PDFClasses.PDFAcroPushButton))
+    return PDFButton.of(field as PDFAcroPushButton, ref, doc);
+  if (isPDFInstance(field, PDFClasses.PDFAcroCheckBox))
+    return PDFCheckBox.of(field as PDFAcroCheckBox, ref, doc);
+  if (isPDFInstance(field, PDFClasses.PDFAcroComboBox))
+    return PDFDropdown.of(field as PDFAcroComboBox, ref, doc);
+  if (isPDFInstance(field, PDFClasses.PDFAcroListBox))
+    return PDFOptionList.of(field as PDFAcroListBox, ref, doc);
+  if (isPDFInstance(field, PDFClasses.PDFAcroText))
+    return PDFTextField.of(field as PDFAcroText, ref, doc);
+  if (isPDFInstance(field, PDFClasses.PDFAcroRadioButton)) {
+    return PDFRadioGroup.of(field as PDFAcroRadioButton, ref, doc);
+  }
+  if (isPDFInstance(field, PDFClasses.PDFAcroSignature)) {
+    return PDFSignature.of(field as PDFAcroSignature, ref, doc);
   }
   return undefined;
 };

package/src/api/form/PDFOptionList.ts

@@ -17,7 +17,6 @@ import {
   PDFRef,
   PDFHexString,
   PDFString,
-  PDFStream,
   PDFAcroListBox,
   AcroChoiceFlags,
   PDFWidgetAnnotation,
@@ -28,6 +27,7 @@ import {
   assertOrUndefined,
   assertPositive,
 } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../objects';
 
 /**
  * Represents an option list field of a [[PDFForm]].
@@ -41,6 +41,10 @@ import {
  * more than one option (see [[PDFOptionList.isMultiselect]]).
  */
 export default class PDFOptionList extends PDFField {
+  static className = () => PDFClasses.PDFOptionList;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFOptionList;
+  }
   /**
    * > **NOTE:** You probably don't want to call this method directly. Instead,
    * > consider using the [[PDFForm.getOptionList]] method, which will create
@@ -498,8 +502,10 @@ export default class PDFOptionList extends PDFField {
     const widgets = this.acroField.getWidgets();
     for (let idx = 0, len = widgets.length; idx < len; idx++) {
       const widget = widgets[idx];
-      const hasAppearances =
-        widget.getAppearances()?.normal instanceof PDFStream;
+      const hasAppearances = isPDFInstance(
+        widget.getAppearances()?.normal,
+        PDFClasses.PDFStream,
+      );
       if (!hasAppearances) return true;
     }
 

package/src/api/form/PDFRadioGroup.ts

@@ -22,6 +22,7 @@ import {
   AcroButtonFlags,
 } from '../../core';
 import { assertIs, assertOrUndefined, assertIsOneOf } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../objects';
 
 /**
  * Represents a radio group field of a [[PDFForm]].
@@ -41,6 +42,10 @@ import { assertIs, assertOrUndefined, assertIsOneOf } from '../../utils';
  * [[PDFRadioGroup.isMutuallyExclusive]]).
  */
 export default class PDFRadioGroup extends PDFField {
+  static className = () => PDFClasses.PDFRadioGroup;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFRadioGroup;
+  }
   /**
    * > **NOTE:** You probably don't want to call this method directly. Instead,
    * > consider using the [[PDFForm.getOptionList]] method, which will create an
@@ -405,8 +410,8 @@ export default class PDFRadioGroup extends PDFField {
       const state = widget.getAppearanceState();
       const normal = widget.getAppearances()?.normal;
 
-      if (!(normal instanceof PDFDict)) return true;
-      if (state && !normal.has(state)) return true;
+      if (!isPDFInstance(normal, PDFClasses.PDFDict)) return true;
+      if (state && !(normal as PDFDict).has(state)) return true;
     }
 
     return false;
@@ -426,7 +431,7 @@ export default class PDFRadioGroup extends PDFField {
 
   // rg.updateAppearances((field: any, widget: any) => {
   //   assert(field === rg);
-  //   assert(widget instanceof PDFWidgetAnnotation);
+  //   assert(isPDFInstance(widget, PDFClasses.PDFWidgetAnnotation));
   //   return { on: [...rectangle, ...circle], off: [...rectangle, ...circle] };
   // });
 

package/src/api/form/PDFSignature.ts

@@ -3,6 +3,7 @@ import PDFField from './PDFField';
 
 import { PDFRef, PDFAcroSignature } from '../../core';
 import { assertIs } from '../../utils';
+import { PDFClasses } from '../objects';
 
 /**
  * Represents a signature field of a [[PDFForm]].
@@ -12,6 +13,10 @@ import { assertIs } from '../../utils';
  * reading the contents of existing digital signatures.
  */
 export default class PDFSignature extends PDFField {
+  static className = () => PDFClasses.PDFSignature;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFSignature;
+  }
   /**
    * > **NOTE:** You probably don't want to call this method directly. Instead,
    * > consider using the [[PDFForm.getSignature]] method, which will create an

package/src/api/form/PDFTextField.ts

@@ -24,7 +24,6 @@ import { TextAlignment } from '../text/alignment';
 import {
   PDFHexString,
   PDFRef,
-  PDFStream,
   PDFAcroText,
   AcroTextFlags,
   PDFWidgetAnnotation,
@@ -36,6 +35,7 @@ import {
   assertPositive,
   assertRangeOrUndefined,
 } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../objects';
 
 /**
  * Represents a text field of a [[PDFForm]].
@@ -47,6 +47,10 @@ import {
  * to be entered (see [[PDFTextField.isMultiline]]).
  */
 export default class PDFTextField extends PDFField {
+  static className = () => PDFClasses.PDFTextField;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFTextField;
+  }
   /**
    * > **NOTE:** You probably don't want to call this method directly. Instead,
    * > consider using the [[PDFForm.getTextField]] method, which will create an
@@ -760,8 +764,10 @@ export default class PDFTextField extends PDFField {
     const widgets = this.acroField.getWidgets();
     for (let idx = 0, len = widgets.length; idx < len; idx++) {
       const widget = widgets[idx];
-      const hasAppearances =
-        widget.getAppearances()?.normal instanceof PDFStream;
+      const hasAppearances = isPDFInstance(
+        widget.getAppearances()?.normal,
+        PDFClasses.PDFStream,
+      );
       if (!hasAppearances) return true;
     }
 

package/src/api/objects.ts

@@ -1,10 +1,97 @@
 import { PDFName, PDFNumber } from '../core';
 
 export const asPDFName = (name: string | PDFName) =>
-  name instanceof PDFName ? name : PDFName.of(name);
+  typeof name !== 'string' ? name : PDFName.of(name);
 
 export const asPDFNumber = (num: number | PDFNumber) =>
-  num instanceof PDFNumber ? num : PDFNumber.of(num);
+  typeof num !== 'number' ? num : PDFNumber.of(num);
 
 export const asNumber = (num: number | PDFNumber) =>
-  num instanceof PDFNumber ? num.asNumber() : num;
+  typeof num !== 'number' ? num.asNumber() : num;
+
+export enum PDFClasses {
+  PDFDict = 'PDFDict',
+  PDFObject = 'PDFObject',
+  PDFNumber = 'PDFNumber',
+  PDFName = 'PDFName',
+  PDFStream = 'PDFStream',
+  PDFWriter = 'PDFWriter',
+  PDFStreamWriter = 'PDFStreamWriter',
+  PDFString = 'PDFString',
+  PDFHexString = 'PDFHexString',
+  PDFDocument = 'PDFDocument',
+  PDFPageLeaf = 'PDFPageLeaf',
+  StandardFontEmbedder = 'StandardFontEmbedder',
+  PDFArray = 'PDFArray',
+  PDFButton = 'PDFButton',
+  PDFCheckBox = 'PDFCheckBox',
+  PDFDropdown = 'PDFDropdown',
+  PDFOptionList = 'PDFOptionList',
+  PDFRadioGroup = 'PDFRadioGroup',
+  PDFSignature = 'PDFSignature',
+  PDFTextField = 'PDFTextField',
+  PDFField = 'PDFField',
+  PDFRef = 'PDFRef',
+  PDFAcroForm = 'PDFAcroForm',
+  PDFAcroField = 'PDFAcroField',
+  PDFAcroNonTerminal = 'PDFAcroNonTerminal',
+  PDFAcroPushButton = 'PDFAcroPushButton',
+  PDFAcroCheckBox = 'PDFAcroCheckBox',
+  PDFAcroComboBox = 'PDFAcroComboBox',
+  PDFAcroListBox = 'PDFAcroListBox',
+  PDFAcroText = 'PDFAcroText',
+  PDFAcroRadioButton = 'PDFAcroRadioButton',
+  PDFAcroSignature = 'PDFAcroSignature',
+  AESBaseCipher = 'AESBaseCipher',
+  PDFBool = 'PDFBool',
+  PDFRawStream = 'PDFRawStream',
+  PDFContentStream = 'PDFContentStream',
+  Segment = 'Segment',
+  Rectangle = 'Rectangle',
+  Arc = 'Arc',
+  Circle = 'Circle',
+  Ellipse = 'Ellipse',
+  Line = 'Line',
+  Plot = 'Plot',
+  Point = 'Point',
+  PDFPageTree = 'PDFPageTree',
+  PDFInvalidObject = 'PDFInvalidObject',
+  PDFCatalog = 'PDFCatalog',
+  DefaultDocumentSnapshot = 'DefaultDocumentSnapshot',
+  PDFObjectStream = 'PDFObjectStream',
+  IncrementalDocumentSnapshot = 'IncrementalDocumentSnapshot',
+  PDFNull = 'PDFNull',
+}
+
+/**
+ * Replaces instanceof operator by a "secure function" that uses clases internal identification.
+ * This allows complex environments, where objects comes from different library instances, to work as expected.
+ * @param {any} object Object to which compare the classname.
+ * @param {PDFClasses | typeof PDFClass} className Class name object is expected to be an instanca (or subclass instance)
+ * @returns {boolean}
+ */
+export const isPDFInstance = (object: any, className: PDFClasses): boolean => {
+  if (!object) return false;
+  if (!object.myClass) return false; // it's not an object from this library
+  if (typeof className === 'function') {
+    // is a constructor (PDFnNumber, PDFDict, etc)
+    try {
+      return isPDFInstance(object, (className as any).className());
+    } catch (error) {
+      return false;
+    }
+  }
+  if (object.myClass() === className) return true;
+  // not a perfect match, check superclasses
+  let proto = Object.getPrototypeOf(object);
+  while (proto && proto.constructor.className) {
+    try {
+      if (proto.constructor.className() === className) return true;
+      proto = Object.getPrototypeOf(proto);
+    } catch (error) {
+      return false;
+    }
+  }
+  // not the class, nor a subclass
+  return false;
+};

package/src/api/operators.ts

@@ -1,3 +1,35 @@
+/** =============== There is a circular dependency ===============
+ * To avoid inclusion "undefined" elementos, enums are declared before
+ * imports.
+ */
+export enum LineCapStyle {
+  Butt = 0,
+  Round = 1,
+  Projecting = 2,
+}
+
+export enum LineJoinStyle {
+  Miter = 0,
+  Round = 1,
+  Bevel = 2,
+}
+
+export enum FillRule {
+  NonZero = 'f',
+  EvenOdd = 'f*',
+}
+
+export enum TextRenderingMode {
+  Fill = 0,
+  Outline = 1,
+  FillAndOutline = 2,
+  Invisible = 3,
+  FillAndClip = 4,
+  OutlineAndClip = 5,
+  FillAndOutlineAndClip = 6,
+  Clip = 7,
+}
+
 import { asNumber, asPDFName, asPDFNumber } from './objects';
 import { degreesToRadians } from './rotations';
 import {
@@ -86,21 +118,9 @@ export const setDashPattern = (
 
 export const restoreDashPattern = () => setDashPattern([], 0);
 
-export enum LineCapStyle {
-  Butt = 0,
-  Round = 1,
-  Projecting = 2,
-}
-
 export const setLineCap = (style: LineCapStyle) =>
   PDFOperator.of(Ops.SetLineCapStyle, [asPDFNumber(style)]);
 
-export enum LineJoinStyle {
-  Miter = 0,
-  Round = 1,
-  Bevel = 2,
-}
-
 export const setLineJoin = (style: LineJoinStyle) =>
   PDFOperator.of(Ops.SetLineJoinStyle, [asPDFNumber(style)]);
 
@@ -185,11 +205,6 @@ export const square = (xPos: number, yPos: number, size: number) =>
 
 export const stroke = () => PDFOperator.of(Ops.StrokePath);
 
-export enum FillRule {
-  NonZero = 'f',
-  EvenOdd = 'f*',
-}
-
 export const fill = () => PDFOperator.of(Ops.FillNonZero);
 
 export const fillEvenOdd = () => PDFOperator.of(Ops.FillEvenOdd);
@@ -236,17 +251,6 @@ export const setLineHeight = (lineHeight: number | PDFNumber) =>
 export const setTextRise = (rise: number | PDFNumber) =>
   PDFOperator.of(Ops.SetTextRise, [asPDFNumber(rise)]);
 
-export enum TextRenderingMode {
-  Fill = 0,
-  Outline = 1,
-  FillAndOutline = 2,
-  Invisible = 3,
-  FillAndClip = 4,
-  OutlineAndClip = 5,
-  FillAndOutlineAndClip = 6,
-  Clip = 7,
-}
-
 export const setTextRenderingMode = (mode: TextRenderingMode) =>
   PDFOperator.of(Ops.SetTextRenderingMode, [asPDFNumber(mode)]);
 

package/src/api/snapshot/DefaultDocumentSnapshot.ts

@@ -1,7 +1,13 @@
 import type { PDFObject, PDFRef } from '../../core';
+import { PDFClasses } from '../objects';
 import type { DocumentSnapshot } from './DocumentSnapshot';
 
 export class DefaultDocumentSnapshot implements DocumentSnapshot {
+  static className = () => PDFClasses.DefaultDocumentSnapshot;
+  myClass(): PDFClasses {
+    return PDFClasses.DefaultDocumentSnapshot;
+  }
+
   pdfSize = 0;
   prevStartXRef = 0;
   deletedCount = 0;

package/src/api/snapshot/DocumentSnapshot.ts

@@ -1,10 +1,13 @@
 import type { PDFObject, PDFRef } from '../../core';
+import { PDFClasses } from '../objects';
 
 export interface DocumentSnapshot {
   pdfSize: number;
   prevStartXRef: number;
   deletedCount: number;
 
+  myClass: () => PDFClasses;
+
   shouldSave: (objectNumber: number) => boolean;
 
   markRefForSave: (ref: PDFRef) => void;

package/src/api/snapshot/IncrementalDocumentSnapshot.ts

@@ -1,4 +1,5 @@
 import type { PDFContext, PDFObject, PDFRef } from '../../core';
+import { PDFClasses } from '../objects';
 import type { DocumentSnapshot } from './DocumentSnapshot';
 
 export class IncrementalDocumentSnapshot implements DocumentSnapshot {
@@ -26,6 +27,11 @@ export class IncrementalDocumentSnapshot implements DocumentSnapshot {
     this.context = context;
   }
 
+  static className = () => PDFClasses.IncrementalDocumentSnapshot;
+  myClass(): PDFClasses {
+    return PDFClasses.IncrementalDocumentSnapshot;
+  }
+
   shouldSave(objectNumber: number): boolean {
     if (objectNumber > this.lastObjectNumber) return true;
     return this.changedObjects.has(objectNumber);