@adnsistemas/pdf-lib 1.18.0

package/src/core/acroform/PDFAcroForm.ts

@@ -0,0 +1,102 @@
+import PDFContext from 'src/core/PDFContext';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFArray from 'src/core/objects/PDFArray';
+import PDFName from 'src/core/objects/PDFName';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFAcroField from 'src/core/acroform/PDFAcroField';
+import PDFAcroNonTerminal from 'src/core/acroform/PDFAcroNonTerminal';
+import {
+  createPDFAcroField,
+  createPDFAcroFields,
+} from 'src/core/acroform/utils';
+
+class PDFAcroForm {
+  readonly dict: PDFDict;
+
+  static fromDict = (dict: PDFDict) => new PDFAcroForm(dict);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({ Fields: [] });
+    return new PDFAcroForm(dict);
+  };
+
+  private constructor(dict: PDFDict) {
+    this.dict = dict;
+  }
+
+  Fields(): PDFArray | undefined {
+    const fields = this.dict.lookup(PDFName.of('Fields'));
+    if (fields instanceof PDFArray) return fields;
+    return undefined;
+  }
+
+  getFields(): [PDFAcroField, PDFRef][] {
+    const { Fields } = this.normalizedEntries();
+
+    const fields = new Array(Fields.size());
+    for (let idx = 0, len = Fields.size(); idx < len; idx++) {
+      const ref = Fields.get(idx) as PDFRef;
+      const dict = Fields.lookup(idx, PDFDict);
+      fields[idx] = [createPDFAcroField(dict, ref), ref];
+    }
+
+    return fields;
+  }
+
+  getAllFields(): [PDFAcroField, PDFRef][] {
+    const allFields: [PDFAcroField, PDFRef][] = [];
+
+    const pushFields = (fields?: [PDFAcroField, PDFRef][]) => {
+      if (!fields) return;
+      for (let idx = 0, len = fields.length; idx < len; idx++) {
+        const field = fields[idx];
+        allFields.push(field);
+        const [fieldModel] = field;
+        if (fieldModel instanceof PDFAcroNonTerminal) {
+          pushFields(createPDFAcroFields(fieldModel.Kids()));
+        }
+      }
+    };
+
+    pushFields(this.getFields());
+
+    return allFields;
+  }
+
+  addField(field: PDFRef) {
+    const { Fields } = this.normalizedEntries();
+    Fields?.push(field);
+  }
+
+  removeField(field: PDFAcroField): void {
+    const parent = field.getParent();
+    const fields =
+      parent === undefined ? this.normalizedEntries().Fields : parent.Kids();
+
+    const index = fields?.indexOf(field.ref);
+    if (fields === undefined || index === undefined) {
+      throw new Error(
+        `Tried to remove inexistent field ${field.getFullyQualifiedName()}`,
+      );
+    }
+
+    fields.remove(index);
+
+    if (parent !== undefined && fields.size() === 0) {
+      this.removeField(parent);
+    }
+  }
+
+  normalizedEntries() {
+    let Fields = this.Fields();
+
+    if (!Fields) {
+      Fields = this.dict.context.obj([]);
+      this.dict.set(PDFName.of('Fields'), Fields);
+    }
+
+    return { Fields };
+  }
+}
+
+export default PDFAcroForm;

package/src/core/acroform/PDFAcroListBox.ts

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

package/src/core/acroform/PDFAcroNonTerminal.ts

@@ -0,0 +1,34 @@
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFName from 'src/core/objects/PDFName';
+import PDFContext from 'src/core/PDFContext';
+import PDFAcroField from 'src/core/acroform/PDFAcroField';
+
+class PDFAcroNonTerminal extends PDFAcroField {
+  static fromDict = (dict: PDFDict, ref: PDFRef) =>
+    new PDFAcroNonTerminal(dict, ref);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({});
+    const ref = context.register(dict);
+    return new PDFAcroNonTerminal(dict, ref);
+  };
+
+  addField(field: PDFRef) {
+    const { Kids } = this.normalizedEntries();
+    Kids?.push(field);
+  }
+
+  normalizedEntries() {
+    let Kids = this.Kids();
+
+    if (!Kids) {
+      Kids = this.dict.context.obj([]);
+      this.dict.set(PDFName.of('Kids'), Kids);
+    }
+
+    return { Kids };
+  }
+}
+
+export default PDFAcroNonTerminal;

package/src/core/acroform/PDFAcroPushButton.ts

@@ -0,0 +1,22 @@
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFAcroButton from 'src/core/acroform/PDFAcroButton';
+import PDFContext from 'src/core/PDFContext';
+import PDFRef from 'src/core/objects/PDFRef';
+import { AcroButtonFlags } from 'src/core/acroform/flags';
+
+class PDFAcroPushButton extends PDFAcroButton {
+  static fromDict = (dict: PDFDict, ref: PDFRef) =>
+    new PDFAcroPushButton(dict, ref);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({
+      FT: 'Btn',
+      Ff: AcroButtonFlags.PushButton,
+      Kids: [],
+    });
+    const ref = context.register(dict);
+    return new PDFAcroPushButton(dict, ref);
+  };
+}
+
+export default PDFAcroPushButton;

package/src/core/acroform/PDFAcroRadioButton.ts

@@ -0,0 +1,58 @@
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFName from 'src/core/objects/PDFName';
+import PDFAcroButton from 'src/core/acroform/PDFAcroButton';
+import PDFContext from 'src/core/PDFContext';
+import { AcroButtonFlags } from 'src/core/acroform/flags';
+import { InvalidAcroFieldValueError } from 'src/core/errors';
+
+class PDFAcroRadioButton extends PDFAcroButton {
+  static fromDict = (dict: PDFDict, ref: PDFRef) =>
+    new PDFAcroRadioButton(dict, ref);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({
+      FT: 'Btn',
+      Ff: AcroButtonFlags.Radio,
+      Kids: [],
+    });
+    const ref = context.register(dict);
+    return new PDFAcroRadioButton(dict, ref);
+  };
+
+  setValue(value: PDFName) {
+    const onValues = this.getOnValues();
+    if (!onValues.includes(value) && 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');
+  }
+
+  getOnValues(): PDFName[] {
+    const widgets = this.getWidgets();
+
+    const onValues: PDFName[] = [];
+    for (let idx = 0, len = widgets.length; idx < len; idx++) {
+      const onValue = widgets[idx].getOnValue();
+      if (onValue) onValues.push(onValue);
+    }
+
+    return onValues;
+  }
+}
+
+export default PDFAcroRadioButton;

package/src/core/acroform/PDFAcroSignature.ts

@@ -0,0 +1,10 @@
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFAcroTerminal from 'src/core/acroform/PDFAcroTerminal';
+
+class PDFAcroSignature extends PDFAcroTerminal {
+  static fromDict = (dict: PDFDict, ref: PDFRef) =>
+    new PDFAcroSignature(dict, ref);
+}
+
+export default PDFAcroSignature;

package/src/core/acroform/PDFAcroTerminal.ts

@@ -0,0 +1,71 @@
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFName from 'src/core/objects/PDFName';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFAcroField from 'src/core/acroform/PDFAcroField';
+import PDFWidgetAnnotation from 'src/core/annotation/PDFWidgetAnnotation';
+import { IndexOutOfBoundsError } from 'src/core/errors';
+
+class PDFAcroTerminal extends PDFAcroField {
+  static fromDict = (dict: PDFDict, ref: PDFRef) =>
+    new PDFAcroTerminal(dict, ref);
+
+  FT(): PDFName {
+    const nameOrRef = this.getInheritableAttribute(PDFName.of('FT'));
+    return this.dict.context.lookup(nameOrRef, PDFName);
+  }
+
+  getWidgets(): PDFWidgetAnnotation[] {
+    const kidDicts = this.Kids();
+
+    // This field is itself a widget
+    if (!kidDicts) return [PDFWidgetAnnotation.fromDict(this.dict)];
+
+    // This field's kids are its widgets
+    const widgets = new Array<PDFWidgetAnnotation>(kidDicts.size());
+    for (let idx = 0, len = kidDicts.size(); idx < len; idx++) {
+      const dict = kidDicts.lookup(idx, PDFDict);
+      widgets[idx] = PDFWidgetAnnotation.fromDict(dict);
+    }
+
+    return widgets;
+  }
+
+  addWidget(ref: PDFRef) {
+    const { Kids } = this.normalizedEntries();
+    Kids.push(ref);
+  }
+
+  removeWidget(idx: number) {
+    const kidDicts = this.Kids();
+
+    if (!kidDicts) {
+      // This field is itself a widget
+      if (idx !== 0) throw new IndexOutOfBoundsError(idx, 0, 0);
+      this.setKids([]);
+    } else {
+      // This field's kids are its widgets
+      if (idx < 0 || idx > kidDicts.size()) {
+        throw new IndexOutOfBoundsError(idx, 0, kidDicts.size());
+      }
+      kidDicts.remove(idx);
+    }
+  }
+
+  normalizedEntries() {
+    let Kids = this.Kids();
+
+    // If this field is itself a widget (because it was only rendered once in
+    // the document, so the field and widget properties were merged) then we
+    // add itself to the `Kids` array. The alternative would be to try
+    // splitting apart the widget properties and creating a separate object
+    // for them.
+    if (!Kids) {
+      Kids = this.dict.context.obj([this.ref]);
+      this.dict.set(PDFName.of('Kids'), Kids);
+    }
+
+    return { Kids };
+  }
+}
+
+export default PDFAcroTerminal;

package/src/core/acroform/PDFAcroText.ts

@@ -0,0 +1,76 @@
+import PDFContext from 'src/core/PDFContext';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFString from 'src/core/objects/PDFString';
+import PDFHexString from 'src/core/objects/PDFHexString';
+import PDFName from 'src/core/objects/PDFName';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFAcroTerminal from 'src/core/acroform/PDFAcroTerminal';
+
+class PDFAcroText extends PDFAcroTerminal {
+  static fromDict = (dict: PDFDict, ref: PDFRef) => new PDFAcroText(dict, ref);
+
+  static create = (context: PDFContext) => {
+    const dict = context.obj({
+      FT: 'Tx',
+      Kids: [],
+    });
+    const ref = context.register(dict);
+    return new PDFAcroText(dict, ref);
+  };
+
+  MaxLen(): PDFNumber | undefined {
+    const maxLen = this.dict.lookup(PDFName.of('MaxLen'));
+    if (maxLen instanceof PDFNumber) return maxLen;
+    return undefined;
+  }
+
+  Q(): PDFNumber | undefined {
+    const q = this.dict.lookup(PDFName.of('Q'));
+    if (q instanceof PDFNumber) return q;
+    return undefined;
+  }
+
+  setMaxLength(maxLength: number) {
+    this.dict.set(PDFName.of('MaxLen'), PDFNumber.of(maxLength));
+  }
+
+  removeMaxLength() {
+    this.dict.delete(PDFName.of('MaxLen'));
+  }
+
+  getMaxLength(): number | undefined {
+    return this.MaxLen()?.asNumber();
+  }
+
+  setQuadding(quadding: 0 | 1 | 2) {
+    this.dict.set(PDFName.of('Q'), PDFNumber.of(quadding));
+  }
+
+  getQuadding(): number | undefined {
+    return this.Q()?.asNumber();
+  }
+
+  setValue(value: PDFHexString | PDFString) {
+    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);
+    // }
+  }
+
+  removeValue() {
+    this.dict.delete(PDFName.of('V'));
+  }
+
+  getValue(): PDFString | PDFHexString | undefined {
+    const v = this.V();
+    if (v instanceof PDFString || v instanceof PDFHexString) return v;
+    return undefined;
+  }
+}
+
+export default PDFAcroText;

package/src/core/acroform/flags.ts

@@ -0,0 +1,162 @@
+const flag = (bitIndex: number) => 1 << bitIndex;
+
+/** From PDF spec table 221 */
+export enum AcroFieldFlags {
+  /**
+   * If set, the user may not change the value of the field. Any associated
+   * widget annotations will not interact with the user; that is, they will not
+   * respond to mouse clicks or change their appearance in response to mouse
+   * motions. This flag is useful for fields whose values are computed or
+   * imported from a database.
+   */
+  ReadOnly = flag(1 - 1),
+
+  /**
+   * If set, the field shall have a value at the time it is exported by a
+   * submit-form action (see 12.7.5.2, "Submit-Form Action").
+   */
+  Required = flag(2 - 1),
+
+  /**
+   * If set, the field shall not be exported by a submit-form action
+   * (see 12.7.5.2, "Submit-Form Action").
+   */
+  NoExport = flag(3 - 1),
+}
+
+/** From PDF spec table 226 */
+export enum AcroButtonFlags {
+  /**
+   * (Radio buttons only) If set, exactly one radio button shall be selected at
+   * all times; selecting the currently selected button has no effect. If clear,
+   * clicking the selected button deselects it, leaving no button selected.
+   */
+  NoToggleToOff = flag(15 - 1),
+
+  /**
+   * If set, the field is a set of radio buttons; if clear, the field is a check
+   * box. This flag may be set only if the Pushbutton flag is clear.
+   */
+  Radio = flag(16 - 1),
+
+  /**
+   * If set, the field is a pushbutton that does not retain a permanent value.
+   */
+  PushButton = flag(17 - 1),
+
+  /**
+   * If set, a group of radio buttons within a radio button field that use the
+   * same value for the on state will turn on and off in unison; that is if one
+   * is checked, they are all checked. If clear, the buttons are mutually
+   * exclusive (the same behavior as HTML radio buttons).
+   */
+  RadiosInUnison = flag(26 - 1),
+}
+
+/** From PDF spec table 228 */
+export enum AcroTextFlags {
+  /**
+   * If set, the field may contain multiple lines of text; if clear, the field's
+   * text shall be restricted to a single line.
+   */
+  Multiline = flag(13 - 1),
+
+  /**
+   * If set, the field is intended for entering a secure password that should
+   * not be echoed visibly to the screen. Characters typed from the keyboard
+   * shall instead be echoed in some unreadable form, such as asterisks or
+   * bullet characters.
+   * > NOTE   To protect password confidentiality, readers should never store
+   * >        the value of the text field in the PDF file if this flag is set.
+   */
+  Password = flag(14 - 1),
+
+  /**
+   * If set, the text entered in the field represents the pathname of a file
+   * whose contents shall be submitted as the value of the field.
+   */
+  FileSelect = flag(21 - 1),
+
+  /**
+   * If set, text entered in the field shall not be spell-checked.
+   */
+  DoNotSpellCheck = flag(23 - 1),
+
+  /**
+   * If set, the field shall not scroll (horizontally for single-line fields,
+   * vertically for multiple-line fields) to accommodate more text than fits
+   * within its annotation rectangle. Once the field is full, no further text
+   * shall be accepted for interactive form filling; for non-interactive form
+   * filling, the filler should take care not to add more character than will
+   * visibly fit in the defined area.
+   */
+  DoNotScroll = flag(24 - 1),
+
+  /**
+   * May be set only if the MaxLen entry is present in the text field dictionary
+   * (see Table 229) and if the Multiline, Password, and FileSelect flags are
+   * clear. If set, the field shall be automatically divided into as many
+   * equally spaced positions, or combs, as the value of MaxLen, and the text
+   * is laid out into those combs.
+   */
+  Comb = flag(25 - 1),
+
+  /**
+   * If set, the value of this field shall be a rich text string
+   * (see 12.7.3.4, "Rich Text Strings"). If the field has a value, the RV
+   * entry of the field dictionary (Table 222) shall specify the rich text
+   * string.
+   */
+  RichText = flag(26 - 1),
+}
+
+/** From PDF spec table 230 */
+export enum AcroChoiceFlags {
+  /**
+   * If set, the field is a combo box; if clear, the field is a list box.
+   */
+  Combo = flag(18 - 1),
+
+  /**
+   * If set, the combo box shall include an editable text box as well as a
+   * drop-down list; if clear, it shall include only a drop-down list. This
+   * flag shall be used only if the Combo flag is set.
+   */
+  Edit = flag(19 - 1),
+
+  /**
+   * If set, the field's option items shall be sorted alphabetically. This flag
+   * is intended for use by writers, not by readers. Conforming readers shall
+   * display the options in the order in which they occur in the Opt array
+   * (see Table 231).
+   */
+  Sort = flag(20 - 1),
+
+  /**
+   * If set, more than one of the field's option items may be selected
+   * simultaneously; if clear, at most one item shall be selected.
+   */
+  MultiSelect = flag(22 - 1),
+
+  /**
+   * If set, text entered in the field shall not be spell-checked. This flag
+   * shall not be used unless the Combo and Edit flags are both set.
+   */
+  DoNotSpellCheck = flag(23 - 1),
+
+  /**
+   * If set, the new value shall be committed as soon as a selection is made
+   * (commonly with the pointing device). In this case, supplying a value for
+   * a field involves three actions: selecting the field for fill-in,
+   * selecting a choice for the fill-in value, and leaving that field, which
+   * finalizes or "commits" the data choice and triggers any actions associated
+   * with the entry or changing of this data. If this flag is on, then
+   * processing does not wait for leaving the field action to occur, but
+   * immediately proceeds to the third step.
+   *
+   * This option enables applications to perform an action once a selection is
+   * made, without requiring the user to exit the field. If clear, the new
+   * value is not committed until the user exits the field.
+   */
+  CommitOnSelChange = flag(27 - 1),
+}

package/src/core/acroform/index.ts

@@ -0,0 +1,15 @@
+export { default as PDFAcroButton } from 'src/core/acroform/PDFAcroButton';
+export { default as PDFAcroCheckBox } from 'src/core/acroform/PDFAcroCheckBox';
+export { default as PDFAcroChoice } from 'src/core/acroform/PDFAcroChoice';
+export { default as PDFAcroComboBox } from 'src/core/acroform/PDFAcroComboBox';
+export { default as PDFAcroField } from 'src/core/acroform/PDFAcroField';
+export { default as PDFAcroForm } from 'src/core/acroform/PDFAcroForm';
+export { default as PDFAcroListBox } from 'src/core/acroform/PDFAcroListBox';
+export { default as PDFAcroNonTerminal } from 'src/core/acroform/PDFAcroNonTerminal';
+export { default as PDFAcroPushButton } from 'src/core/acroform/PDFAcroPushButton';
+export { default as PDFAcroRadioButton } from 'src/core/acroform/PDFAcroRadioButton';
+export { default as PDFAcroSignature } from 'src/core/acroform/PDFAcroSignature';
+export { default as PDFAcroTerminal } from 'src/core/acroform/PDFAcroTerminal';
+export { default as PDFAcroText } from 'src/core/acroform/PDFAcroText';
+export * from 'src/core/acroform/flags';
+export * from 'src/core/acroform/utils';