Spaces:
Running
Running
Download 731ai/node_modules/pdf-lib/src/api/form/PDFField.ts from u11310019/interactive-multi-web: direct link, hf CLI and curl.
- Browser
- Download file 16.3 kB
-
https://huggingface.co/spaces/u11310019/interactive-multi-web/resolve/main/731ai/node_modules/pdf-lib/src/api/form/PDFField.ts
- Command line
-
hf download hf://spaces/u11310019/interactive-multi-web/731ai/node_modules/pdf-lib/src/api/form/PDFField.ts
-
curl -L -o PDFField.ts https://huggingface.co/spaces/u11310019/interactive-multi-web/resolve/main/731ai/node_modules/pdf-lib/src/api/form/PDFField.ts
16.3 kB
| import PDFDocument from 'src/api/PDFDocument'; | |
| import PDFFont from 'src/api/PDFFont'; | |
| import { AppearanceMapping } from 'src/api/form/appearances'; | |
| import { Color, colorToComponents, setFillingColor } from 'src/api/colors'; | |
| import { | |
| Rotation, | |
| toDegrees, | |
| rotateRectangle, | |
| reduceRotation, | |
| adjustDimsForRotation, | |
| degrees, | |
| } from 'src/api/rotations'; | |
| import { | |
| PDFRef, | |
| PDFWidgetAnnotation, | |
| PDFOperator, | |
| PDFName, | |
| PDFDict, | |
| MethodNotImplementedError, | |
| AcroFieldFlags, | |
| PDFAcroTerminal, | |
| AnnotationFlags, | |
| } from 'src/core'; | |
| import { assertIs, assertMultiple, assertOrUndefined } from 'src/utils'; | |
| import { ImageAlignment } from '../image'; | |
| import PDFImage from '../PDFImage'; | |
| import { drawImage, rotateInPlace } from '../operations'; | |
| export interface FieldAppearanceOptions { | |
| x?: number; | |
| y?: number; | |
| width?: number; | |
| height?: number; | |
| textColor?: Color; | |
| backgroundColor?: Color; | |
| borderColor?: Color; | |
| borderWidth?: number; | |
| rotate?: Rotation; | |
| font?: PDFFont; | |
| hidden?: boolean; | |
| } | |
| export const assertFieldAppearanceOptions = ( | |
| options?: FieldAppearanceOptions, | |
| ) => { | |
| assertOrUndefined(options?.x, 'options.x', ['number']); | |
| assertOrUndefined(options?.y, 'options.y', ['number']); | |
| assertOrUndefined(options?.width, 'options.width', ['number']); | |
| assertOrUndefined(options?.height, 'options.height', ['number']); | |
| assertOrUndefined(options?.textColor, 'options.textColor', [ | |
| [Object, 'Color'], | |
| ]); | |
| assertOrUndefined(options?.backgroundColor, 'options.backgroundColor', [ | |
| [Object, 'Color'], | |
| ]); | |
| assertOrUndefined(options?.borderColor, 'options.borderColor', [ | |
| [Object, 'Color'], | |
| ]); | |
| assertOrUndefined(options?.borderWidth, 'options.borderWidth', ['number']); | |
| assertOrUndefined(options?.rotate, 'options.rotate', [[Object, 'Rotation']]); | |
| }; | |
| /** | |
| * Represents a field of a [[PDFForm]]. | |
| * | |
| * This class is effectively abstract. All fields in a [[PDFForm]] will | |
| * actually be an instance of a subclass of this class. | |
| * | |
| * Note that each field in a PDF is represented by a single field object. | |
| * However, a given field object may be rendered at multiple locations within | |
| * the document (across one or more pages). The rendering of a field is | |
| * controlled by its widgets. Each widget causes its field to be displayed at a | |
| * particular location in the document. | |
| * | |
| * Most of the time each field in a PDF has only a single widget, and thus is | |
| * only rendered once. However, if a field is rendered multiple times, it will | |
| * have multiple widgets - one for each location it is rendered. | |
| * | |
| * This abstraction of field objects and widgets is defined in the PDF | |
| * specification and dictates how PDF files store fields and where they are | |
| * to be rendered. | |
| */ | |
| export default class PDFField { | |
| /** The low-level PDFAcroTerminal wrapped by this field. */ | |
| readonly acroField: PDFAcroTerminal; | |
| /** The unique reference assigned to this field within the document. */ | |
| readonly ref: PDFRef; | |
| /** The document to which this field belongs. */ | |
| readonly doc: PDFDocument; | |
| protected constructor( | |
| acroField: PDFAcroTerminal, | |
| ref: PDFRef, | |
| doc: PDFDocument, | |
| ) { | |
| assertIs(acroField, 'acroField', [[PDFAcroTerminal, 'PDFAcroTerminal']]); | |
| assertIs(ref, 'ref', [[PDFRef, 'PDFRef']]); | |
| assertIs(doc, 'doc', [[PDFDocument, 'PDFDocument']]); | |
| this.acroField = acroField; | |
| this.ref = ref; | |
| this.doc = doc; | |
| } | |
| /** | |
| * Get the fully qualified name of this field. For example: | |
| * ```js | |
| * const fields = form.getFields() | |
| * fields.forEach(field => { | |
| * const name = field.getName() | |
| * console.log('Field name:', name) | |
| * }) | |
| * ``` | |
| * Note that PDF fields are structured as a tree. Each field is the | |
| * descendent of a series of ancestor nodes all the way up to the form node, | |
| * which is always the root of the tree. Each node in the tree (except for | |
| * the form node) has a partial name. Partial names can be composed of any | |
| * unicode characters except a period (`.`). The fully qualified name of a | |
| * field is composed of the partial names of all its ancestors joined | |
| * with periods. This means that splitting the fully qualified name on | |
| * periods and taking the last element of the resulting array will give you | |
| * the partial name of a specific field. | |
| * @returns The fully qualified name of this field. | |
| */ | |
| getName(): string { | |
| return this.acroField.getFullyQualifiedName() ?? ''; | |
| } | |
| /** | |
| * Returns `true` if this field is read only. This means that PDF readers | |
| * will not allow users to interact with the field or change its value. See | |
| * [[PDFField.enableReadOnly]] and [[PDFField.disableReadOnly]]. | |
| * For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * if (field.isReadOnly()) console.log('Read only is enabled') | |
| * ``` | |
| * @returns Whether or not this is a read only field. | |
| */ | |
| isReadOnly(): boolean { | |
| return this.acroField.hasFlag(AcroFieldFlags.ReadOnly); | |
| } | |
| /** | |
| * Prevent PDF readers from allowing users to interact with this field or | |
| * change its value. The field will not respond to mouse or keyboard input. | |
| * For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * field.enableReadOnly() | |
| * ``` | |
| * Useful for fields whose values are computed, imported from a database, or | |
| * prefilled by software before being displayed to the user. | |
| */ | |
| enableReadOnly() { | |
| this.acroField.setFlagTo(AcroFieldFlags.ReadOnly, true); | |
| } | |
| /** | |
| * Allow users to interact with this field and change its value in PDF | |
| * readers via mouse and keyboard input. For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * field.disableReadOnly() | |
| * ``` | |
| */ | |
| disableReadOnly() { | |
| this.acroField.setFlagTo(AcroFieldFlags.ReadOnly, false); | |
| } | |
| /** | |
| * Returns `true` if this field must have a value when the form is submitted. | |
| * See [[PDFField.enableRequired]] and [[PDFField.disableRequired]]. | |
| * For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * if (field.isRequired()) console.log('Field is required') | |
| * ``` | |
| * @returns Whether or not this field is required. | |
| */ | |
| isRequired(): boolean { | |
| return this.acroField.hasFlag(AcroFieldFlags.Required); | |
| } | |
| /** | |
| * Require this field to have a value when the form is submitted. | |
| * For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * field.enableRequired() | |
| * ``` | |
| */ | |
| enableRequired() { | |
| this.acroField.setFlagTo(AcroFieldFlags.Required, true); | |
| } | |
| /** | |
| * Do not require this field to have a value when the form is submitted. | |
| * For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * field.disableRequired() | |
| * ``` | |
| */ | |
| disableRequired() { | |
| this.acroField.setFlagTo(AcroFieldFlags.Required, false); | |
| } | |
| /** | |
| * Returns `true` if this field's value should be exported when the form is | |
| * submitted. See [[PDFField.enableExporting]] and | |
| * [[PDFField.disableExporting]]. | |
| * For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * if (field.isExported()) console.log('Exporting is enabled') | |
| * ``` | |
| * @returns Whether or not this field's value should be exported. | |
| */ | |
| isExported(): boolean { | |
| return !this.acroField.hasFlag(AcroFieldFlags.NoExport); | |
| } | |
| /** | |
| * Indicate that this field's value should be exported when the form is | |
| * submitted in a PDF reader. For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * field.enableExporting() | |
| * ``` | |
| */ | |
| enableExporting() { | |
| this.acroField.setFlagTo(AcroFieldFlags.NoExport, false); | |
| } | |
| /** | |
| * Indicate that this field's value should **not** be exported when the form | |
| * is submitted in a PDF reader. For example: | |
| * ```js | |
| * const field = form.getField('some.field') | |
| * field.disableExporting() | |
| * ``` | |
| */ | |
| disableExporting() { | |
| this.acroField.setFlagTo(AcroFieldFlags.NoExport, true); | |
| } | |
| /** @ignore */ | |
| needsAppearancesUpdate(): boolean { | |
| throw new MethodNotImplementedError( | |
| this.constructor.name, | |
| 'needsAppearancesUpdate', | |
| ); | |
| } | |
| /** @ignore */ | |
| defaultUpdateAppearances(_font: PDFFont) { | |
| throw new MethodNotImplementedError( | |
| this.constructor.name, | |
| 'defaultUpdateAppearances', | |
| ); | |
| } | |
| protected markAsDirty() { | |
| this.doc.getForm().markFieldAsDirty(this.ref); | |
| } | |
| protected markAsClean() { | |
| this.doc.getForm().markFieldAsClean(this.ref); | |
| } | |
| protected isDirty(): boolean { | |
| return this.doc.getForm().fieldIsDirty(this.ref); | |
| } | |
| protected createWidget(options: { | |
| x: number; | |
| y: number; | |
| width: number; | |
| height: number; | |
| textColor?: Color; | |
| backgroundColor?: Color; | |
| borderColor?: Color; | |
| borderWidth: number; | |
| rotate: Rotation; | |
| caption?: string; | |
| hidden?: boolean; | |
| page?: PDFRef; | |
| }): PDFWidgetAnnotation { | |
| const textColor = options.textColor; | |
| const backgroundColor = options.backgroundColor; | |
| const borderColor = options.borderColor; | |
| const borderWidth = options.borderWidth; | |
| const degreesAngle = toDegrees(options.rotate); | |
| const caption = options.caption; | |
| const x = options.x; | |
| const y = options.y; | |
| const width = options.width + borderWidth; | |
| const height = options.height + borderWidth; | |
| const hidden = Boolean(options.hidden); | |
| const pageRef = options.page; | |
| assertMultiple(degreesAngle, 'degreesAngle', 90); | |
| // Create a widget for this field | |
| const widget = PDFWidgetAnnotation.create(this.doc.context, this.ref); | |
| // Set widget properties | |
| const rect = rotateRectangle( | |
| { x, y, width, height }, | |
| borderWidth, | |
| degreesAngle, | |
| ); | |
| widget.setRectangle(rect); | |
| if (pageRef) widget.setP(pageRef); | |
| const ac = widget.getOrCreateAppearanceCharacteristics(); | |
| if (backgroundColor) { | |
| ac.setBackgroundColor(colorToComponents(backgroundColor)); | |
| } | |
| ac.setRotation(degreesAngle); | |
| if (caption) ac.setCaptions({ normal: caption }); | |
| if (borderColor) ac.setBorderColor(colorToComponents(borderColor)); | |
| const bs = widget.getOrCreateBorderStyle(); | |
| if (borderWidth !== undefined) bs.setWidth(borderWidth); | |
| widget.setFlagTo(AnnotationFlags.Print, true); | |
| widget.setFlagTo(AnnotationFlags.Hidden, hidden); | |
| widget.setFlagTo(AnnotationFlags.Invisible, false); | |
| // Set acrofield properties | |
| if (textColor) { | |
| const da = this.acroField.getDefaultAppearance() ?? ''; | |
| const newDa = da + '\n' + setFillingColor(textColor).toString(); | |
| this.acroField.setDefaultAppearance(newDa); | |
| } | |
| return widget; | |
| } | |
| protected updateWidgetAppearanceWithFont( | |
| widget: PDFWidgetAnnotation, | |
| font: PDFFont, | |
| { normal, rollover, down }: AppearanceMapping<PDFOperator[]>, | |
| ) { | |
| this.updateWidgetAppearances(widget, { | |
| normal: this.createAppearanceStream(widget, normal, font), | |
| rollover: rollover && this.createAppearanceStream(widget, rollover, font), | |
| down: down && this.createAppearanceStream(widget, down, font), | |
| }); | |
| } | |
| protected updateOnOffWidgetAppearance( | |
| widget: PDFWidgetAnnotation, | |
| onValue: PDFName, | |
| { | |
| normal, | |
| rollover, | |
| down, | |
| }: AppearanceMapping<{ on: PDFOperator[]; off: PDFOperator[] }>, | |
| ) { | |
| this.updateWidgetAppearances(widget, { | |
| normal: this.createAppearanceDict(widget, normal, onValue), | |
| rollover: | |
| rollover && this.createAppearanceDict(widget, rollover, onValue), | |
| down: down && this.createAppearanceDict(widget, down, onValue), | |
| }); | |
| } | |
| protected updateWidgetAppearances( | |
| widget: PDFWidgetAnnotation, | |
| { normal, rollover, down }: AppearanceMapping<PDFRef | PDFDict>, | |
| ) { | |
| widget.setNormalAppearance(normal); | |
| if (rollover) { | |
| widget.setRolloverAppearance(rollover); | |
| } else { | |
| widget.removeRolloverAppearance(); | |
| } | |
| if (down) { | |
| widget.setDownAppearance(down); | |
| } else { | |
| widget.removeDownAppearance(); | |
| } | |
| } | |
| // // TODO: Do we need to do this...? | |
| // private foo(font: PDFFont, dict: PDFDict) { | |
| // if (!dict.lookup(PDFName.of('DR'))) { | |
| // dict.set(PDFName.of('DR'), dict.context.obj({})); | |
| // } | |
| // const DR = dict.lookup(PDFName.of('DR'), PDFDict); | |
| // if (!DR.lookup(PDFName.of('Font'))) { | |
| // DR.set(PDFName.of('Font'), dict.context.obj({})); | |
| // } | |
| // const Font = DR.lookup(PDFName.of('Font'), PDFDict); | |
| // Font.set(PDFName.of(font.name), font.ref); | |
| // } | |
| private createAppearanceStream( | |
| widget: PDFWidgetAnnotation, | |
| appearance: PDFOperator[], | |
| font?: PDFFont, | |
| ): PDFRef { | |
| const { context } = this.acroField.dict; | |
| const { width, height } = widget.getRectangle(); | |
| // TODO: Do we need to do this...? | |
| // if (font) { | |
| // this.foo(font, widget.dict); | |
| // this.foo(font, this.doc.getForm().acroForm.dict); | |
| // } | |
| // END TODO | |
| const Resources = font && { Font: { [font.name]: font.ref } }; | |
| const stream = context.formXObject(appearance, { | |
| Resources, | |
| BBox: context.obj([0, 0, width, height]), | |
| Matrix: context.obj([1, 0, 0, 1, 0, 0]), | |
| }); | |
| const streamRef = context.register(stream); | |
| return streamRef; | |
| } | |
| /** | |
| * Create a FormXObject of the supplied image and add it to context. | |
| * The FormXObject size is calculated based on the widget (including | |
| * the alignment). | |
| * @param widget The widget that should display the image. | |
| * @param alignment The alignment of the image. | |
| * @param image The image that should be displayed. | |
| * @returns The ref for the FormXObject that was added to the context. | |
| */ | |
| protected createImageAppearanceStream( | |
| widget: PDFWidgetAnnotation, | |
| image: PDFImage, | |
| alignment: ImageAlignment, | |
| ): PDFRef { | |
| // NOTE: This implementation doesn't handle image borders. | |
| // NOTE: Acrobat seems to resize the image (maybe even skewing its aspect | |
| // ratio) to fit perfectly within the widget's rectangle. This method | |
| // does not currently do that. Should there be an option for that? | |
| const { context } = this.acroField.dict; | |
| const rectangle = widget.getRectangle(); | |
| const ap = widget.getAppearanceCharacteristics(); | |
| const bs = widget.getBorderStyle(); | |
| const borderWidth = bs?.getWidth() ?? 0; | |
| const rotation = reduceRotation(ap?.getRotation()); | |
| const rotate = rotateInPlace({ ...rectangle, rotation }); | |
| const adj = adjustDimsForRotation(rectangle, rotation); | |
| const imageDims = image.scaleToFit( | |
| adj.width - borderWidth * 2, | |
| adj.height - borderWidth * 2, | |
| ); | |
| // Support borders on images and maybe other properties | |
| const options = { | |
| x: borderWidth, | |
| y: borderWidth, | |
| width: imageDims.width, | |
| height: imageDims.height, | |
| // | |
| rotate: degrees(0), | |
| xSkew: degrees(0), | |
| ySkew: degrees(0), | |
| }; | |
| if (alignment === ImageAlignment.Center) { | |
| options.x += (adj.width - borderWidth * 2) / 2 - imageDims.width / 2; | |
| options.y += (adj.height - borderWidth * 2) / 2 - imageDims.height / 2; | |
| } else if (alignment === ImageAlignment.Right) { | |
| options.x = adj.width - borderWidth - imageDims.width; | |
| options.y = adj.height - borderWidth - imageDims.height; | |
| } | |
| const imageName = this.doc.context.addRandomSuffix('Image', 10); | |
| const appearance = [...rotate, ...drawImage(imageName, options)]; | |
| //////////// | |
| const Resources = { XObject: { [imageName]: image.ref } }; | |
| const stream = context.formXObject(appearance, { | |
| Resources, | |
| BBox: context.obj([0, 0, rectangle.width, rectangle.height]), | |
| Matrix: context.obj([1, 0, 0, 1, 0, 0]), | |
| }); | |
| return context.register(stream); | |
| } | |
| private createAppearanceDict( | |
| widget: PDFWidgetAnnotation, | |
| appearance: { on: PDFOperator[]; off: PDFOperator[] }, | |
| onValue: PDFName, | |
| ): PDFDict { | |
| const { context } = this.acroField.dict; | |
| const onStreamRef = this.createAppearanceStream(widget, appearance.on); | |
| const offStreamRef = this.createAppearanceStream(widget, appearance.off); | |
| const appearanceDict = context.obj({}); | |
| appearanceDict.set(onValue, onStreamRef); | |
| appearanceDict.set(PDFName.of('Off'), offStreamRef); | |
| return appearanceDict; | |
| } | |
| } | |