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

package/src/core/PDFObjectCopier.ts

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

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

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

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

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

@@ -1,168 +0,0 @@
-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]
-// oxlint-disable-next-line no-control-regex -- Default appearance strings can contain NUL delimiters.
-const tfRegex = /\/([^\u0000\t\n\f\r ]+)[\u0000\t\n\f\r ]*(\d*\.\d+|\d+)?[\u0000\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;