@pdfme/pdf-lib 0.0.0

package/src/core/PDFObjectCopier.ts

@@ -0,0 +1,142 @@
+import PDFArray from './objects/PDFArray';
+import PDFDict from './objects/PDFDict';
+import PDFName from './objects/PDFName';
+import PDFObject from './objects/PDFObject';
+import PDFRef from './objects/PDFRef';
+import PDFStream from './objects/PDFStream';
+import PDFContext from './PDFContext';
+import PDFPageLeaf from './structures/PDFPageLeaf';
+
+/**
+ * PDFObjectCopier copies PDFObjects from a src context to a dest context.
+ * The primary use case for this is to copy pages between PDFs.
+ *
+ * _Copying_ an object with a PDFObjectCopier is different from _cloning_ an
+ * object with its [[PDFObject.clone]] method:
+ *
+ * ```
+ *   const src: PDFContext = ...
+ *   const dest: PDFContext = ...
+ *   const originalObject: PDFObject = ...
+ *   const copiedObject = PDFObjectCopier.for(src, dest).copy(originalObject);
+ *   const clonedObject = originalObject.clone();
+ * ```
+ *
+ * Copying an object is equivalent to cloning it and then copying over any other
+ * objects that it references. Note that only dictionaries, arrays, and streams
+ * (or structures build from them) can contain indirect references to other
+ * objects. Copying a PDFObject that is not a dictionary, array, or stream is
+ * supported, but is equivalent to cloning it.
+ */
+class PDFObjectCopier {
+  static for = (src: PDFContext, dest: PDFContext) => new PDFObjectCopier(src, dest);
+
+  private readonly src: PDFContext;
+  private readonly dest: PDFContext;
+  private readonly traversedObjects = new Map<PDFObject, PDFObject>();
+
+  private constructor(src: PDFContext, dest: PDFContext) {
+    this.src = src;
+    this.dest = dest;
+  }
+
+  // prettier-ignore
+  copy = <T extends PDFObject>(object: T): T => (
+      object instanceof PDFPageLeaf ? this.copyPDFPage(object)
+    : object instanceof PDFDict     ? this.copyPDFDict(object)
+    : object instanceof PDFArray    ? this.copyPDFArray(object)
+    : object instanceof PDFStream   ? this.copyPDFStream(object)
+    : object instanceof PDFRef      ? this.copyPDFIndirectObject(object)
+    : object.clone()
+  ) as T;
+
+  private copyPDFPage = (originalPage: PDFPageLeaf): PDFPageLeaf => {
+    const clonedPage = originalPage.clone();
+
+    // Move any entries that the originalPage is inheriting from its parent
+    // tree nodes directly into originalPage so they are preserved during
+    // the copy.
+    const { InheritableEntries } = PDFPageLeaf;
+    for (let idx = 0, len = InheritableEntries.length; idx < len; idx++) {
+      const key = PDFName.of(InheritableEntries[idx]);
+      const value = clonedPage.getInheritableAttribute(key)!;
+      if (!clonedPage.get(key) && value) clonedPage.set(key, value);
+    }
+
+    // Remove the parent reference to prevent the whole donor document's page
+    // tree from being copied when we only need a single page.
+    clonedPage.delete(PDFName.of('Parent'));
+
+    return this.copyPDFDict(clonedPage) as PDFPageLeaf;
+  };
+
+  private copyPDFDict = (originalDict: PDFDict): PDFDict => {
+    if (this.traversedObjects.has(originalDict)) {
+      return this.traversedObjects.get(originalDict) as PDFDict;
+    }
+
+    const clonedDict = originalDict.clone(this.dest);
+    this.traversedObjects.set(originalDict, clonedDict);
+
+    const entries = originalDict.entries();
+
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [key, value] = entries[idx];
+      clonedDict.set(key, this.copy(value));
+    }
+
+    return clonedDict;
+  };
+
+  private copyPDFArray = (originalArray: PDFArray): PDFArray => {
+    if (this.traversedObjects.has(originalArray)) {
+      return this.traversedObjects.get(originalArray) as PDFArray;
+    }
+
+    const clonedArray = originalArray.clone(this.dest);
+    this.traversedObjects.set(originalArray, clonedArray);
+
+    for (let idx = 0, len = originalArray.size(); idx < len; idx++) {
+      const value = originalArray.get(idx);
+      clonedArray.set(idx, this.copy(value));
+    }
+
+    return clonedArray;
+  };
+
+  private copyPDFStream = (originalStream: PDFStream): PDFStream => {
+    if (this.traversedObjects.has(originalStream)) {
+      return this.traversedObjects.get(originalStream) as PDFStream;
+    }
+
+    const clonedStream = originalStream.clone(this.dest);
+    this.traversedObjects.set(originalStream, clonedStream);
+
+    const entries = originalStream.dict.entries();
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [key, value] = entries[idx];
+      clonedStream.dict.set(key, this.copy(value));
+    }
+
+    return clonedStream;
+  };
+
+  private copyPDFIndirectObject = (ref: PDFRef): PDFRef => {
+    const alreadyMapped = this.traversedObjects.has(ref);
+
+    if (!alreadyMapped) {
+      const newRef = this.dest.nextRef();
+      this.traversedObjects.set(ref, newRef);
+
+      const dereferencedValue = this.src.lookup(ref);
+      if (dereferencedValue) {
+        const cloned = this.copy(dereferencedValue);
+        this.dest.assign(newRef, cloned);
+      }
+    }
+
+    return this.traversedObjects.get(ref) as PDFRef;
+  };
+}
+
+export default PDFObjectCopier;

package/src/core/acroform/PDFAcroButton.ts

@@ -0,0 +1,104 @@
+import PDFObject from '../objects/PDFObject';
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFArray from '../objects/PDFArray';
+import PDFName from '../objects/PDFName';
+import PDFRef from '../objects/PDFRef';
+import PDFAcroTerminal from './PDFAcroTerminal';
+import { IndexOutOfBoundsError } from '../errors';
+
+class PDFAcroButton extends PDFAcroTerminal {
+  Opt(): PDFString | PDFHexString | PDFArray | undefined {
+    return this.dict.lookupMaybe(PDFName.of('Opt'), PDFString, PDFHexString, PDFArray);
+  }
+
+  setOpt(opt: PDFObject[]) {
+    this.dict.set(PDFName.of('Opt'), this.dict.context.obj(opt));
+  }
+
+  getExportValues(): (PDFString | PDFHexString)[] | undefined {
+    const opt = this.Opt();
+
+    if (!opt) return undefined;
+
+    if (opt instanceof PDFString || opt instanceof PDFHexString) {
+      return [opt];
+    }
+
+    const values: (PDFString | PDFHexString)[] = [];
+    for (let idx = 0, len = opt.size(); idx < len; idx++) {
+      const value = opt.lookup(idx);
+      if (value instanceof PDFString || value instanceof PDFHexString) {
+        values.push(value);
+      }
+    }
+
+    return values;
+  }
+
+  removeExportValue(idx: number) {
+    const opt = this.Opt();
+
+    if (!opt) return;
+
+    if (opt instanceof PDFString || opt instanceof PDFHexString) {
+      if (idx !== 0) throw new IndexOutOfBoundsError(idx, 0, 0);
+      this.setOpt([]);
+    } else {
+      if (idx < 0 || idx > opt.size()) {
+        throw new IndexOutOfBoundsError(idx, 0, opt.size());
+      }
+      opt.remove(idx);
+    }
+  }
+
+  // Enforce use use of /Opt even if it isn't strictly necessary
+  normalizeExportValues() {
+    const exportValues = this.getExportValues() ?? [];
+
+    const Opt: (PDFString | PDFHexString)[] = [];
+
+    const widgets = this.getWidgets();
+    for (let idx = 0, len = widgets.length; idx < len; idx++) {
+      const widget = widgets[idx];
+      const exportVal =
+        exportValues[idx] ?? PDFHexString.fromText(widget.getOnValue()?.decodeText() ?? '');
+      Opt.push(exportVal);
+    }
+
+    this.setOpt(Opt);
+  }
+
+  /**
+   * Reuses existing opt if one exists with the same value (assuming
+   * `useExistingIdx` is `true`). Returns index of existing (or new) opt.
+   */
+  addOpt(opt: PDFHexString | PDFString, useExistingOptIdx: boolean): number {
+    this.normalizeExportValues();
+
+    const optText = opt.decodeText();
+
+    let existingIdx: number | undefined;
+    if (useExistingOptIdx) {
+      const exportValues = this.getExportValues() ?? [];
+      for (let idx = 0, len = exportValues.length; idx < len; idx++) {
+        const exportVal = exportValues[idx];
+        if (exportVal.decodeText() === optText) existingIdx = idx;
+      }
+    }
+
+    const Opt = this.Opt() as PDFArray;
+    Opt.push(opt);
+
+    return existingIdx ?? Opt.size() - 1;
+  }
+
+  addWidgetWithOpt(widget: PDFRef, opt: PDFHexString | PDFString, useExistingOptIdx: boolean) {
+    const optIdx = this.addOpt(opt, useExistingOptIdx);
+    const apStateValue = PDFName.of(String(optIdx));
+    this.addWidget(widget);
+    return apStateValue;
+  }
+}
+
+export default PDFAcroButton;

package/src/core/acroform/PDFAcroCheckBox.ts

@@ -0,0 +1,48 @@
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFAcroButton from './PDFAcroButton';
+import { InvalidAcroFieldValueError } from '../errors';
+
+class PDFAcroCheckBox extends PDFAcroButton {
+  static fromDict = (dict: PDFDict, ref: PDFRef) => new PDFAcroCheckBox(dict, ref);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({
+      FT: 'Btn',
+      Kids: [],
+    });
+    const ref = context.register(dict);
+    return new PDFAcroCheckBox(dict, ref);
+  };
+
+  setValue(value: PDFName) {
+    const onValue = this.getOnValue() ?? PDFName.of('Yes');
+    if (value !== onValue && value !== PDFName.of('Off')) {
+      throw new InvalidAcroFieldValueError();
+    }
+
+    this.dict.set(PDFName.of('V'), value);
+
+    const widgets = this.getWidgets();
+    for (let idx = 0, len = widgets.length; idx < len; idx++) {
+      const widget = widgets[idx];
+      const state = widget.getOnValue() === value ? value : PDFName.of('Off');
+      widget.setAppearanceState(state);
+    }
+  }
+
+  getValue(): PDFName {
+    const v = this.V();
+    if (v instanceof PDFName) return v;
+    return PDFName.of('Off');
+  }
+
+  getOnValue(): PDFName | undefined {
+    const [widget] = this.getWidgets();
+    return widget?.getOnValue();
+  }
+}
+
+export default PDFAcroCheckBox;

package/src/core/acroform/PDFAcroChoice.ts

@@ -0,0 +1,143 @@
+import PDFAcroTerminal from './PDFAcroTerminal';
+import PDFHexString from '../objects/PDFHexString';
+import PDFString from '../objects/PDFString';
+import PDFArray from '../objects/PDFArray';
+import PDFName from '../objects/PDFName';
+import { AcroChoiceFlags } from './flags';
+import { InvalidAcroFieldValueError, MultiSelectValueError } from '../errors';
+
+class PDFAcroChoice extends PDFAcroTerminal {
+  setValues(values: (PDFString | PDFHexString)[]) {
+    if (
+      this.hasFlag(AcroChoiceFlags.Combo) &&
+      !this.hasFlag(AcroChoiceFlags.Edit) &&
+      !this.valuesAreValid(values)
+    ) {
+      throw new InvalidAcroFieldValueError();
+    }
+
+    if (values.length === 0) {
+      this.dict.delete(PDFName.of('V'));
+    }
+    if (values.length === 1) {
+      this.dict.set(PDFName.of('V'), values[0]);
+    }
+    if (values.length > 1) {
+      if (!this.hasFlag(AcroChoiceFlags.MultiSelect)) {
+        throw new MultiSelectValueError();
+      }
+      this.dict.set(PDFName.of('V'), this.dict.context.obj(values));
+    }
+
+    this.updateSelectedIndices(values);
+  }
+
+  valuesAreValid(values: (PDFString | PDFHexString)[]): boolean {
+    const options = this.getOptions();
+    for (let idx = 0, len = values.length; idx < len; idx++) {
+      const val = values[idx].decodeText();
+      if (!options.find((o) => val === (o.display || o.value).decodeText())) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  updateSelectedIndices(values: (PDFString | PDFHexString)[]) {
+    if (values.length > 1) {
+      const indices = new Array<number>(values.length);
+      const options = this.getOptions();
+      for (let idx = 0, len = values.length; idx < len; idx++) {
+        const val = values[idx].decodeText();
+        indices[idx] = options.findIndex((o) => val === (o.display || o.value).decodeText());
+      }
+      this.dict.set(PDFName.of('I'), this.dict.context.obj(indices.sort()));
+    } else {
+      this.dict.delete(PDFName.of('I'));
+    }
+  }
+
+  getValues(): (PDFString | PDFHexString)[] {
+    const v = this.V();
+
+    if (v instanceof PDFString || v instanceof PDFHexString) return [v];
+
+    if (v instanceof PDFArray) {
+      const values: (PDFString | PDFHexString)[] = [];
+
+      for (let idx = 0, len = v.size(); idx < len; idx++) {
+        const value = v.lookup(idx);
+        if (value instanceof PDFString || value instanceof PDFHexString) {
+          values.push(value);
+        }
+      }
+
+      return values;
+    }
+
+    return [];
+  }
+
+  Opt(): PDFArray | PDFString | PDFHexString | undefined {
+    return this.dict.lookupMaybe(PDFName.of('Opt'), PDFString, PDFHexString, PDFArray);
+  }
+
+  setOptions(
+    options: {
+      value: PDFString | PDFHexString;
+      display?: PDFString | PDFHexString;
+    }[],
+  ) {
+    const newOpt = new Array<PDFArray>(options.length);
+    for (let idx = 0, len = options.length; idx < len; idx++) {
+      const { value, display } = options[idx];
+      newOpt[idx] = this.dict.context.obj([value, display || value]);
+    }
+    this.dict.set(PDFName.of('Opt'), this.dict.context.obj(newOpt));
+  }
+
+  getOptions(): {
+    value: PDFString | PDFHexString;
+    display: PDFString | PDFHexString;
+  }[] {
+    const Opt = this.Opt();
+
+    // Not supposed to happen - Opt _should_ always be `PDFArray | undefined`
+    if (Opt instanceof PDFString || Opt instanceof PDFHexString) {
+      return [{ value: Opt, display: Opt }];
+    }
+
+    if (Opt instanceof PDFArray) {
+      const res: {
+        value: PDFString | PDFHexString;
+        display: PDFString | PDFHexString;
+      }[] = [];
+
+      for (let idx = 0, len = Opt.size(); idx < len; idx++) {
+        const item = Opt.lookup(idx);
+
+        // If `item` is a string, use that as both the export and text value
+        if (item instanceof PDFString || item instanceof PDFHexString) {
+          res.push({ value: item, display: item });
+        }
+
+        // If `item` is an array of one, treat it the same as just a string,
+        // if it's an array of two then `item[0]` is the export value and
+        // `item[1]` is the text value
+        if (item instanceof PDFArray) {
+          if (item.size() > 0) {
+            const first = item.lookup(0, PDFString, PDFHexString);
+            const second = item.lookupMaybe(1, PDFString, PDFHexString);
+            res.push({ value: first, display: second || first });
+          }
+        }
+      }
+
+      return res;
+    }
+
+    return [];
+  }
+}
+
+export default PDFAcroChoice;

package/src/core/acroform/PDFAcroComboBox.ts

@@ -0,0 +1,21 @@
+import PDFDict from '../objects/PDFDict';
+import PDFAcroChoice from './PDFAcroChoice';
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+import { AcroChoiceFlags } from './flags';
+
+class PDFAcroComboBox extends PDFAcroChoice {
+  static fromDict = (dict: PDFDict, ref: PDFRef) => new PDFAcroComboBox(dict, ref);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({
+      FT: 'Ch',
+      Ff: AcroChoiceFlags.Combo,
+      Kids: [],
+    });
+    const ref = context.register(dict);
+    return new PDFAcroComboBox(dict, ref);
+  };
+}
+
+export default PDFAcroComboBox;

package/src/core/acroform/PDFAcroField.ts

@@ -0,0 +1,167 @@
+import PDFDict from '../objects/PDFDict';
+import PDFString from '../objects/PDFString';
+import PDFHexString from '../objects/PDFHexString';
+import PDFName from '../objects/PDFName';
+import PDFObject from '../objects/PDFObject';
+import PDFNumber from '../objects/PDFNumber';
+import PDFArray from '../objects/PDFArray';
+import PDFRef from '../objects/PDFRef';
+import { findLastMatch } from '../../utils';
+import { MissingDAEntryError, MissingTfOperatorError } from '../errors';
+
+// Examples:
+//   `/Helv 12 Tf` -> ['Helv', '12']
+//   `/HeBo 8.00 Tf` -> ['HeBo', '8.00']
+//   `/HeBo Tf` -> ['HeBo', undefined]
+const tfRegex = /\/([^\0\t\n\f\r\ ]+)[\0\t\n\f\r\ ]*(\d*\.\d+|\d+)?[\0\t\n\f\r\ ]+Tf/;
+
+class PDFAcroField {
+  readonly dict: PDFDict;
+  readonly ref: PDFRef;
+
+  protected constructor(dict: PDFDict, ref: PDFRef) {
+    this.dict = dict;
+    this.ref = ref;
+  }
+
+  T(): PDFString | PDFHexString | undefined {
+    return this.dict.lookupMaybe(PDFName.of('T'), PDFString, PDFHexString);
+  }
+
+  Ff(): PDFNumber | undefined {
+    const numberOrRef = this.getInheritableAttribute(PDFName.of('Ff'));
+    return this.dict.context.lookupMaybe(numberOrRef, PDFNumber);
+  }
+
+  V(): PDFObject | undefined {
+    const valueOrRef = this.getInheritableAttribute(PDFName.of('V'));
+    return this.dict.context.lookup(valueOrRef);
+  }
+
+  Kids(): PDFArray | undefined {
+    return this.dict.lookupMaybe(PDFName.of('Kids'), PDFArray);
+  }
+
+  // Parent(): PDFDict | undefined {
+  //   return this.dict.lookupMaybe(PDFName.of('Parent'), PDFDict);
+  // }
+
+  DA(): PDFString | PDFHexString | undefined {
+    const da = this.dict.lookup(PDFName.of('DA'));
+    if (da instanceof PDFString || da instanceof PDFHexString) return da;
+    return undefined;
+  }
+
+  setKids(kids: PDFObject[]) {
+    this.dict.set(PDFName.of('Kids'), this.dict.context.obj(kids));
+  }
+
+  getParent(): PDFAcroField | undefined {
+    // const parent = this.Parent();
+    // if (!parent) return undefined;
+    // return new PDFAcroField(parent);
+
+    const parentRef = this.dict.get(PDFName.of('Parent'));
+    if (parentRef instanceof PDFRef) {
+      const parent = this.dict.lookup(PDFName.of('Parent'), PDFDict);
+      return new PDFAcroField(parent, parentRef);
+    }
+
+    return undefined;
+  }
+
+  setParent(parent: PDFRef | undefined) {
+    if (!parent) this.dict.delete(PDFName.of('Parent'));
+    else this.dict.set(PDFName.of('Parent'), parent);
+  }
+
+  getFullyQualifiedName(): string | undefined {
+    const parent = this.getParent();
+    if (!parent) return this.getPartialName();
+    return `${parent.getFullyQualifiedName()}.${this.getPartialName()}`;
+  }
+
+  getPartialName(): string | undefined {
+    return this.T()?.decodeText();
+  }
+
+  setPartialName(partialName: string | undefined) {
+    if (!partialName) this.dict.delete(PDFName.of('T'));
+    else this.dict.set(PDFName.of('T'), PDFHexString.fromText(partialName));
+  }
+
+  setDefaultAppearance(appearance: string) {
+    this.dict.set(PDFName.of('DA'), PDFString.of(appearance));
+  }
+
+  getDefaultAppearance(): string | undefined {
+    const DA = this.DA();
+
+    if (DA instanceof PDFHexString) {
+      return DA.decodeText();
+    }
+
+    return DA?.asString();
+  }
+
+  setFontSize(fontSize: number) {
+    const name = this.getFullyQualifiedName() ?? '';
+
+    const da = this.getDefaultAppearance();
+    if (!da) throw new MissingDAEntryError(name);
+
+    const daMatch = findLastMatch(da, tfRegex);
+    if (!daMatch.match) throw new MissingTfOperatorError(name);
+
+    const daStart = da.slice(0, daMatch.pos - daMatch.match[0].length);
+    const daEnd = daMatch.pos <= da.length ? da.slice(daMatch.pos) : '';
+    const fontName = daMatch.match[1];
+    const modifiedDa = `${daStart} /${fontName} ${fontSize} Tf ${daEnd}`;
+
+    this.setDefaultAppearance(modifiedDa);
+  }
+
+  getFlags(): number {
+    return this.Ff()?.asNumber() ?? 0;
+  }
+
+  setFlags(flags: number) {
+    this.dict.set(PDFName.of('Ff'), PDFNumber.of(flags));
+  }
+
+  hasFlag(flag: number): boolean {
+    const flags = this.getFlags();
+    return (flags & flag) !== 0;
+  }
+
+  setFlag(flag: number) {
+    const flags = this.getFlags();
+    this.setFlags(flags | flag);
+  }
+
+  clearFlag(flag: number) {
+    const flags = this.getFlags();
+    this.setFlags(flags & ~flag);
+  }
+
+  setFlagTo(flag: number, enable: boolean) {
+    if (enable) this.setFlag(flag);
+    else this.clearFlag(flag);
+  }
+
+  getInheritableAttribute(name: PDFName): PDFObject | undefined {
+    let attribute: PDFObject | undefined;
+    this.ascend((node) => {
+      if (!attribute) attribute = node.dict.get(name);
+    });
+    return attribute;
+  }
+
+  ascend(visitor: (node: PDFAcroField) => any): void {
+    visitor(this);
+    const parent = this.getParent();
+    if (parent) parent.ascend(visitor);
+  }
+}
+
+export default PDFAcroField;