@peculiar/pdf-form-json/build/peculiar.pdf.form.js

A PDF module enabling working with form elements through JSON.

'use strict';

var pdfDoc = require('@peculiar/pdf-doc');

function _interopNamespaceDefault(e) {
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var pdfDoc__namespace = /*#__PURE__*/_interopNamespaceDefault(pdfDoc);

class ComponentConverter {
    constructor(type) {
        this.type = type;
    }
}

class ComponentConverterFactory {
    constructor(...converters) {
        this.items = new Map();
        for (const converter of converters) {
            this.register(converter);
        }
    }
    register(converter) {
        this.items.set(converter.type, converter);
    }
    find(type) {
        const converter = this.items.get(type);
        return converter || null;
    }
    get(type) {
        const converter = this.find(type);
        if (!converter) {
            throw new Error(`Converter not found for type ${type.name}`);
        }
        return converter;
    }
}

class FieldConverter extends ComponentConverter {
    export(component) {
        const json = {
            type: this.typeJSON,
            id: component.id,
            name: component.name
        };
        this.onExport(component, json);
        return json;
    }
}

class WidgetConverter extends ComponentConverter {
    export(component) {
        const json = {
            type: this.typeJSON,
            id: component.id,
            name: component.name,
            position: {
                left: component.left,
                top: component.top,
                height: component.height,
                width: component.width
            },
            flags: {
                hidden: component.hidden,
                invisible: component.invisible,
                locked: component.locked,
                lockedContents: component.lockedContents,
                noExport: component.noExport,
                noRotate: component.noRotate,
                noView: component.noView,
                noZoom: component.noZoom,
                print: component.print,
                readOnly: component.readOnly,
                readOnlyAnnot: component.readOnlyAnnot,
                required: component.required,
                toggleNoView: component.toggleNoView
            }
        };
        this.onExport(component, json);
        return json;
    }
}

class CheckBoxConverter extends WidgetConverter {
    constructor() {
        super(pdfDoc__namespace.CheckBox);
        this.typeJSON = pdfDoc__namespace.FormComponentType.checkBox;
    }
    onExport(component, json) {
        json.checked = component.checked;
        json.value = component.value;
    }
    setValue(component, data) {
        component.checked = data.checked;
    }
}

class ComboBoxConverter extends WidgetConverter {
    constructor() {
        super(pdfDoc__namespace.ComboBox);
        this.typeJSON = pdfDoc__namespace.FormComponentType.comboBox;
    }
    onExport(component, json) {
        let flags = {};
        if (json.flags && typeof json.flags === "object") {
            flags = json.flags;
        }
        json.flags = {
            ...flags,
            combo: component.combo,
            edit: component.edit,
            sort: component.sort,
            multiSelect: component.multiSelect,
            doNotSpellCheck: component.doNotSpellCheck,
            commitOnSelChange: component.commitOnSelChange
        };
        json.options = component.options;
        json.selected = component.selected;
    }
    setValue(component, data) {
        component.selected = data.selected;
    }
}

class RadioButtonConverter extends WidgetConverter {
    constructor() {
        super(pdfDoc__namespace.RadioButton);
        this.typeJSON = pdfDoc__namespace.FormComponentType.radioButton;
    }
    onExport(component, json) {
        json.checked = component.checked;
        json.value = component.value;
    }
    setValue(component, data) {
        component.checked = data.checked;
    }
}

class RadioButtonGroupConverter extends FieldConverter {
    constructor() {
        super(pdfDoc__namespace.RadioButtonGroup);
        this.typeJSON = pdfDoc__namespace.FormComponentType.radioButtonGroup;
    }
    onExport(component, json) {
        json.selected = component.selected;
    }
    setValue(component, data) {
        const button = component.get(data.selected);
        button.checked = true;
    }
}

class TextEditorConverter extends WidgetConverter {
    constructor() {
        super(pdfDoc__namespace.TextEditor);
        this.typeJSON = pdfDoc__namespace.FormComponentType.textEditor;
    }
    onExport(component, json) {
        json.maxLen = component.maxLen;
        json.multiline = component.multiline;
        json.text = component.text;
    }
    setValue(component, data) {
        component.text = data.text;
    }
}

class FormConverter {
    constructor(registry) {
        this.registry = registry;
    }
    export(doc) {
        const res = {
            form: {}
        };
        const components = doc.getComponents();
        for (const component of components) {
            const obj = this.exportComponent(component);
            if (obj) {
                res.form[obj.name] = obj;
            }
        }
        return res;
    }
    exportComponent(component) {
        const converter = this.registry.find(component.constructor);
        if (converter) {
            return converter.export(component);
        }
        return null;
    }
    setValue(doc, data) {
        for (const item of data) {
            const component = doc.getComponentByName(item.name);
            if (!component) {
                continue;
            }
            const converter = this.registry.find(component.constructor);
            if (!converter || converter.typeJSON !== item.type) {
                continue;
            }
            converter.setValue(component, item);
        }
    }
}

const registry = new ComponentConverterFactory(new CheckBoxConverter(), new RadioButtonConverter(), new TextEditorConverter(), new ComboBoxConverter(), new ComboBoxConverter(), new RadioButtonGroupConverter());
const globalFormConverter = new FormConverter(registry);

exports.CheckBoxConverter = CheckBoxConverter;
exports.ComboBoxConverter = ComboBoxConverter;
exports.ComponentConverter = ComponentConverter;
exports.ComponentConverterFactory = ComponentConverterFactory;
exports.FieldConverter = FieldConverter;
exports.FormConverter = FormConverter;
exports.RadioButtonConverter = RadioButtonConverter;
exports.RadioButtonGroupConverter = RadioButtonGroupConverter;
exports.TextEditorConverter = TextEditorConverter;
exports.WidgetConverter = WidgetConverter;
exports.globalFormConverter = globalFormConverter;