2153 lines
74 KiB
JavaScript
2153 lines
74 KiB
JavaScript
/* Copyright 2017 Mozilla Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import {
|
|
Annotation, AnnotationBorderStyle, AnnotationFactory, getQuadPoints,
|
|
MarkupAnnotation
|
|
} from '../../src/core/annotation';
|
|
import {
|
|
AnnotationBorderStyleType, AnnotationFieldFlag, AnnotationFlag,
|
|
AnnotationType, stringToBytes, stringToUTF8String
|
|
} from '../../src/shared/util';
|
|
import { createIdFactory, XRefMock } from './test_utils';
|
|
import { Dict, Name, Ref } from '../../src/core/primitives';
|
|
import { Lexer, Parser } from '../../src/core/parser';
|
|
import { StringStream } from '../../src/core/stream';
|
|
|
|
describe('annotation', function() {
|
|
class PDFManagerMock {
|
|
constructor(params) {
|
|
this.docBaseUrl = params.docBaseUrl || null;
|
|
}
|
|
|
|
ensure(obj, prop, args) {
|
|
return new Promise(function(resolve) {
|
|
const value = obj[prop];
|
|
if (typeof value === 'function') {
|
|
resolve(value.apply(obj, args));
|
|
} else {
|
|
resolve(value);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
let pdfManagerMock, idFactoryMock;
|
|
|
|
beforeAll(function(done) {
|
|
pdfManagerMock = new PDFManagerMock({
|
|
docBaseUrl: null,
|
|
});
|
|
idFactoryMock = createIdFactory(/* pageIndex = */ 0);
|
|
done();
|
|
});
|
|
|
|
afterAll(function() {
|
|
pdfManagerMock = null;
|
|
idFactoryMock = null;
|
|
});
|
|
|
|
describe('AnnotationFactory', function() {
|
|
it('should get id for annotation', function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
|
|
const annotationRef = Ref.get(10, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.id).toEqual('10R');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle, and get fallback IDs for, annotations that are not ' +
|
|
'indirect objects (issue 7569)', function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
|
|
const xref = new XRefMock();
|
|
const idFactory = createIdFactory(/* pageIndex = */ 0);
|
|
|
|
const annotation1 = AnnotationFactory.create(xref, annotationDict,
|
|
pdfManagerMock, idFactory).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.id).toEqual('annot_p0_1');
|
|
});
|
|
|
|
const annotation2 = AnnotationFactory.create(xref, annotationDict,
|
|
pdfManagerMock, idFactory).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.id).toEqual('annot_p0_2');
|
|
});
|
|
|
|
Promise.all([annotation1, annotation2]).then(done, done.fail);
|
|
});
|
|
|
|
it('should handle missing /Subtype', function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
|
|
const annotationRef = Ref.get(1, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('getQuadPoints', function() {
|
|
let dict, rect;
|
|
|
|
beforeEach(function(done) {
|
|
dict = new Dict();
|
|
rect = [];
|
|
done();
|
|
});
|
|
|
|
afterEach(function() {
|
|
dict = null;
|
|
rect = null;
|
|
});
|
|
|
|
it('should ignore missing quadpoints', function() {
|
|
expect(getQuadPoints(dict, rect)).toEqual(null);
|
|
});
|
|
|
|
it('should ignore non-array values', function() {
|
|
dict.set('QuadPoints', 'foo');
|
|
expect(getQuadPoints(dict, rect)).toEqual(null);
|
|
});
|
|
|
|
it('should ignore arrays where the length is not a multiple of eight',
|
|
function() {
|
|
dict.set('QuadPoints', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
|
|
expect(getQuadPoints(dict, rect)).toEqual(null);
|
|
});
|
|
|
|
it('should ignore quadpoints if one coordinate lies outside the rectangle',
|
|
function() {
|
|
rect = [10, 10, 20, 20];
|
|
const inputs = [
|
|
[11, 11, 12, 12, 9, 13, 14, 14], // Smaller than lower x coordinate.
|
|
[11, 11, 12, 12, 13, 9, 14, 14], // Smaller than lower y coordinate.
|
|
[11, 11, 12, 12, 21, 13, 14, 14], // Larger than upper x coordinate.
|
|
[11, 11, 12, 12, 13, 21, 14, 14], // Larger than upper y coordinate.
|
|
];
|
|
for (const input of inputs) {
|
|
dict.set('QuadPoints', input);
|
|
expect(getQuadPoints(dict, rect)).toEqual(null);
|
|
}
|
|
});
|
|
|
|
it('should process valid quadpoints arrays', function() {
|
|
rect = [10, 10, 20, 20];
|
|
dict.set('QuadPoints', [
|
|
11, 11, 12, 12, 13, 13, 14, 14,
|
|
15, 15, 16, 16, 17, 17, 18, 18,
|
|
]);
|
|
expect(getQuadPoints(dict, rect)).toEqual([
|
|
[
|
|
{ x: 11, y: 11, }, { x: 12, y: 12, },
|
|
{ x: 13, y: 13, }, { x: 14, y: 14, },
|
|
],
|
|
[
|
|
{ x: 15, y: 15, }, { x: 16, y: 16, },
|
|
{ x: 17, y: 17, }, { x: 18, y: 18, },
|
|
],
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('Annotation', function() {
|
|
let dict, ref;
|
|
|
|
beforeAll(function(done) {
|
|
dict = new Dict();
|
|
ref = Ref.get(1, 0);
|
|
done();
|
|
});
|
|
|
|
afterAll(function() {
|
|
dict = ref = null;
|
|
});
|
|
|
|
it('should set and get valid contents', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setContents('Foo bar baz');
|
|
|
|
expect(annotation.contents).toEqual('Foo bar baz');
|
|
});
|
|
|
|
it('should not set and get invalid contents', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setContents(undefined);
|
|
|
|
expect(annotation.contents).toEqual('');
|
|
});
|
|
|
|
it('should set and get a valid modification date', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setModificationDate('D:20190422');
|
|
|
|
expect(annotation.modificationDate).toEqual('D:20190422');
|
|
});
|
|
|
|
it('should not set and get an invalid modification date', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setModificationDate(undefined);
|
|
|
|
expect(annotation.modificationDate).toEqual(null);
|
|
});
|
|
|
|
it('should set and get flags', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setFlags(13);
|
|
|
|
expect(annotation.hasFlag(AnnotationFlag.INVISIBLE)).toEqual(true);
|
|
expect(annotation.hasFlag(AnnotationFlag.NOZOOM)).toEqual(true);
|
|
expect(annotation.hasFlag(AnnotationFlag.PRINT)).toEqual(true);
|
|
expect(annotation.hasFlag(AnnotationFlag.READONLY)).toEqual(false);
|
|
});
|
|
|
|
it('should be viewable and not printable by default', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
|
|
expect(annotation.viewable).toEqual(true);
|
|
expect(annotation.printable).toEqual(false);
|
|
});
|
|
|
|
it('should set and get a valid rectangle', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setRectangle([117, 694, 164.298, 720]);
|
|
|
|
expect(annotation.rectangle).toEqual([117, 694, 164.298, 720]);
|
|
});
|
|
|
|
it('should not set and get an invalid rectangle', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setRectangle([117, 694, 164.298]);
|
|
|
|
expect(annotation.rectangle).toEqual([0, 0, 0, 0]);
|
|
});
|
|
|
|
it('should reject a color if it is not an array', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setColor('red');
|
|
|
|
expect(annotation.color).toEqual(new Uint8ClampedArray([0, 0, 0]));
|
|
});
|
|
|
|
it('should set and get a transparent color', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setColor([]);
|
|
|
|
expect(annotation.color).toEqual(null);
|
|
});
|
|
|
|
it('should set and get a grayscale color', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setColor([0.4]);
|
|
|
|
expect(annotation.color).toEqual(new Uint8ClampedArray([102, 102, 102]));
|
|
});
|
|
|
|
it('should set and get an RGB color', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setColor([0, 0, 1]);
|
|
|
|
expect(annotation.color).toEqual(new Uint8ClampedArray([0, 0, 255]));
|
|
});
|
|
|
|
it('should set and get a CMYK color', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setColor([0.1, 0.92, 0.84, 0.02]);
|
|
|
|
expect(annotation.color).toEqual(new Uint8ClampedArray([234, 59, 48]));
|
|
});
|
|
|
|
it('should not set and get an invalid color', function() {
|
|
const annotation = new Annotation({ dict, ref, });
|
|
annotation.setColor([0.4, 0.6]);
|
|
|
|
expect(annotation.color).toEqual(new Uint8ClampedArray([0, 0, 0]));
|
|
});
|
|
});
|
|
|
|
describe('AnnotationBorderStyle', function() {
|
|
it('should set and get a valid width', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setWidth(3);
|
|
|
|
expect(borderStyle.width).toEqual(3);
|
|
});
|
|
|
|
it('should not set and get an invalid width', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setWidth('three');
|
|
|
|
expect(borderStyle.width).toEqual(1);
|
|
});
|
|
|
|
it('should set the width to zero, when the input is a `Name` (issue 10385)',
|
|
function() {
|
|
const borderStyleZero = new AnnotationBorderStyle();
|
|
borderStyleZero.setWidth(Name.get('0'));
|
|
const borderStyleFive = new AnnotationBorderStyle();
|
|
borderStyleFive.setWidth(Name.get('5'));
|
|
|
|
expect(borderStyleZero.width).toEqual(0);
|
|
expect(borderStyleFive.width).toEqual(0);
|
|
});
|
|
|
|
it('should set and get a valid style', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setStyle(Name.get('D'));
|
|
|
|
expect(borderStyle.style).toEqual(AnnotationBorderStyleType.DASHED);
|
|
});
|
|
|
|
it('should not set and get an invalid style', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setStyle('Dashed');
|
|
|
|
expect(borderStyle.style).toEqual(AnnotationBorderStyleType.SOLID);
|
|
});
|
|
|
|
it('should set and get a valid dash array', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setDashArray([1, 2, 3]);
|
|
|
|
expect(borderStyle.dashArray).toEqual([1, 2, 3]);
|
|
});
|
|
|
|
it('should not set and get an invalid dash array', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setDashArray([0, 0]);
|
|
|
|
expect(borderStyle.dashArray).toEqual([3]);
|
|
});
|
|
|
|
it('should set and get a valid horizontal corner radius', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setHorizontalCornerRadius(3);
|
|
|
|
expect(borderStyle.horizontalCornerRadius).toEqual(3);
|
|
});
|
|
|
|
it('should not set and get an invalid horizontal corner radius',
|
|
function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setHorizontalCornerRadius('three');
|
|
|
|
expect(borderStyle.horizontalCornerRadius).toEqual(0);
|
|
});
|
|
|
|
it('should set and get a valid vertical corner radius', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setVerticalCornerRadius(3);
|
|
|
|
expect(borderStyle.verticalCornerRadius).toEqual(3);
|
|
});
|
|
|
|
it('should not set and get an invalid vertical corner radius', function() {
|
|
const borderStyle = new AnnotationBorderStyle();
|
|
borderStyle.setVerticalCornerRadius('three');
|
|
|
|
expect(borderStyle.verticalCornerRadius).toEqual(0);
|
|
});
|
|
});
|
|
|
|
describe('MarkupAnnotation', function() {
|
|
let dict, ref;
|
|
|
|
beforeAll(function(done) {
|
|
dict = new Dict();
|
|
ref = Ref.get(1, 0);
|
|
done();
|
|
});
|
|
|
|
afterAll(function() {
|
|
dict = ref = null;
|
|
});
|
|
|
|
it('should set and get a valid creation date', function() {
|
|
const markupAnnotation = new MarkupAnnotation({ dict, ref, });
|
|
markupAnnotation.setCreationDate('D:20190422');
|
|
|
|
expect(markupAnnotation.creationDate).toEqual('D:20190422');
|
|
});
|
|
|
|
it('should not set and get an invalid creation date', function() {
|
|
const markupAnnotation = new MarkupAnnotation({ dict, ref, });
|
|
markupAnnotation.setCreationDate(undefined);
|
|
|
|
expect(markupAnnotation.creationDate).toEqual(null);
|
|
});
|
|
|
|
it('should not parse IRT/RT when not defined', function (done) {
|
|
dict.set('Type', Name.get('Annot'));
|
|
dict.set('Subtype', Name.get('Text'));
|
|
|
|
const xref = new XRefMock([
|
|
{ ref, data: dict, },
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, ref, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.inReplyTo).toBeUndefined();
|
|
expect(data.replyType).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should parse IRT and set default RT when not defined.',
|
|
function (done) {
|
|
const annotationRef = new Ref(819, 0);
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Text'));
|
|
|
|
const replyRef = new Ref(820, 0);
|
|
const replyDict = new Dict();
|
|
replyDict.set('Type', Name.get('Annot'));
|
|
replyDict.set('Subtype', Name.get('Text'));
|
|
replyDict.set('IRT', annotationRef);
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, },
|
|
{ ref: replyRef, data: replyDict, }
|
|
]);
|
|
annotationDict.assignXref(xref);
|
|
replyDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, replyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.inReplyTo).toEqual(annotationRef.toString());
|
|
expect(data.replyType).toEqual('R');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should parse IRT/RT for a group type', function (done) {
|
|
const annotationRef = new Ref(819, 0);
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Text'));
|
|
annotationDict.set('T', 'ParentTitle');
|
|
annotationDict.set('Contents', 'ParentText');
|
|
annotationDict.set('CreationDate', 'D:20180423');
|
|
annotationDict.set('M', 'D:20190423');
|
|
annotationDict.set('C', [0, 0, 1]);
|
|
|
|
const popupRef = new Ref(820, 0);
|
|
const popupDict = new Dict();
|
|
popupDict.set('Type', Name.get('Annot'));
|
|
popupDict.set('Subtype', Name.get('Popup'));
|
|
popupDict.set('Parent', annotationRef);
|
|
annotationDict.set('Popup', popupRef);
|
|
|
|
const replyRef = new Ref(821, 0);
|
|
const replyDict = new Dict();
|
|
replyDict.set('Type', Name.get('Annot'));
|
|
replyDict.set('Subtype', Name.get('Text'));
|
|
replyDict.set('IRT', annotationRef);
|
|
replyDict.set('RT', Name.get('Group'));
|
|
replyDict.set('T', 'ReplyTitle');
|
|
replyDict.set('Contents', 'ReplyText');
|
|
replyDict.set('CreationDate', 'D:20180523');
|
|
replyDict.set('M', 'D:20190523');
|
|
replyDict.set('C', [0.4]);
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, },
|
|
{ ref: popupRef, data: popupDict, },
|
|
{ ref: replyRef, data: replyDict, }
|
|
]);
|
|
annotationDict.assignXref(xref);
|
|
popupDict.assignXref(xref);
|
|
replyDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, replyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.inReplyTo).toEqual(annotationRef.toString());
|
|
expect(data.replyType).toEqual('Group');
|
|
expect(data.title).toEqual('ParentTitle');
|
|
expect(data.contents).toEqual('ParentText');
|
|
expect(data.creationDate).toEqual('D:20180423');
|
|
expect(data.modificationDate).toEqual('D:20190423');
|
|
expect(data.color).toEqual(new Uint8ClampedArray([0, 0, 255]));
|
|
expect(data.hasPopup).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should parse IRT/RT for a reply type', function (done) {
|
|
const annotationRef = new Ref(819, 0);
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Text'));
|
|
annotationDict.set('T', 'ParentTitle');
|
|
annotationDict.set('Contents', 'ParentText');
|
|
annotationDict.set('CreationDate', 'D:20180423');
|
|
annotationDict.set('M', 'D:20190423');
|
|
annotationDict.set('C', [0, 0, 1]);
|
|
|
|
const popupRef = new Ref(820, 0);
|
|
const popupDict = new Dict();
|
|
popupDict.set('Type', Name.get('Annot'));
|
|
popupDict.set('Subtype', Name.get('Popup'));
|
|
popupDict.set('Parent', annotationRef);
|
|
annotationDict.set('Popup', popupRef);
|
|
|
|
const replyRef = new Ref(821, 0);
|
|
const replyDict = new Dict();
|
|
replyDict.set('Type', Name.get('Annot'));
|
|
replyDict.set('Subtype', Name.get('Text'));
|
|
replyDict.set('IRT', annotationRef);
|
|
replyDict.set('RT', Name.get('R'));
|
|
replyDict.set('T', 'ReplyTitle');
|
|
replyDict.set('Contents', 'ReplyText');
|
|
replyDict.set('CreationDate', 'D:20180523');
|
|
replyDict.set('M', 'D:20190523');
|
|
replyDict.set('C', [0.4]);
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, },
|
|
{ ref: popupRef, data: popupDict, },
|
|
{ ref: replyRef, data: replyDict, }
|
|
]);
|
|
annotationDict.assignXref(xref);
|
|
popupDict.assignXref(xref);
|
|
replyDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, replyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.inReplyTo).toEqual(annotationRef.toString());
|
|
expect(data.replyType).toEqual('R');
|
|
expect(data.title).toEqual('ReplyTitle');
|
|
expect(data.contents).toEqual('ReplyText');
|
|
expect(data.creationDate).toEqual('D:20180523');
|
|
expect(data.modificationDate).toEqual('D:20190523');
|
|
expect(data.color).toEqual(new Uint8ClampedArray([102, 102, 102]));
|
|
expect(data.hasPopup).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('TextAnnotation', function() {
|
|
it('should not parse state model and state when not defined',
|
|
function (done) {
|
|
const annotationRef = new Ref(819, 0);
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Text'));
|
|
annotationDict.set('Contents', 'TestText');
|
|
|
|
const replyRef = new Ref(820, 0);
|
|
const replyDict = new Dict();
|
|
replyDict.set('Type', Name.get('Annot'));
|
|
replyDict.set('Subtype', Name.get('Text'));
|
|
replyDict.set('IRT', annotationRef);
|
|
replyDict.set('RT', Name.get('R'));
|
|
replyDict.set('Contents', 'ReplyText');
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, },
|
|
{ ref: replyRef, data: replyDict, }
|
|
]);
|
|
annotationDict.assignXref(xref);
|
|
replyDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, replyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.stateModel).toBeNull();
|
|
expect(data.state).toBeNull();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse state model and state when defined',
|
|
function (done) {
|
|
const annotationRef = new Ref(819, 0);
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Text'));
|
|
|
|
const replyRef = new Ref(820, 0);
|
|
const replyDict = new Dict();
|
|
replyDict.set('Type', Name.get('Annot'));
|
|
replyDict.set('Subtype', Name.get('Text'));
|
|
replyDict.set('IRT', annotationRef);
|
|
replyDict.set('RT', Name.get('R'));
|
|
replyDict.set('StateModel', 'Review');
|
|
replyDict.set('State', 'Rejected');
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, },
|
|
{ ref: replyRef, data: replyDict, }
|
|
]);
|
|
annotationDict.assignXref(xref);
|
|
replyDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, replyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.stateModel).toEqual('Review');
|
|
expect(data.state).toEqual('Rejected');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('LinkAnnotation', function() {
|
|
it('should correctly parse a URI action', function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('URI'));
|
|
actionDict.set('URI', 'http://www.ctan.org/tex-archive/info/lshort');
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(820, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual('http://www.ctan.org/tex-archive/info/lshort');
|
|
expect(data.unsafeUrl).toEqual(
|
|
'http://www.ctan.org/tex-archive/info/lshort');
|
|
expect(data.dest).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a URI action, where the URI entry ' +
|
|
'is missing a protocol', function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('URI'));
|
|
actionDict.set('URI', 'www.hmrc.gov.uk');
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(353, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual('http://www.hmrc.gov.uk/');
|
|
expect(data.unsafeUrl).toEqual('http://www.hmrc.gov.uk');
|
|
expect(data.dest).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a URI action, where the URI entry ' +
|
|
'has an incorrect encoding (bug 1122280)', function(done) {
|
|
const actionStream = new StringStream(
|
|
'<<\n' +
|
|
'/Type /Action\n' +
|
|
'/S /URI\n' +
|
|
'/URI (http://www.example.com/\\303\\274\\303\\266\\303\\244)\n' +
|
|
'>>\n'
|
|
);
|
|
const parser = new Parser({
|
|
lexer: new Lexer(actionStream),
|
|
xref: null,
|
|
});
|
|
const actionDict = parser.getObj();
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(8, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual(
|
|
new URL(stringToUTF8String(
|
|
'http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4')).href);
|
|
expect(data.unsafeUrl).toEqual(
|
|
stringToUTF8String(
|
|
'http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4'));
|
|
expect(data.dest).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a GoTo action', function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('GoTo'));
|
|
actionDict.set('D', 'page.157');
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(798, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toBeUndefined();
|
|
expect(data.unsafeUrl).toBeUndefined();
|
|
expect(data.dest).toEqual('page.157');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a GoToR action, where the FileSpec entry ' +
|
|
'is a string containing a relative URL', function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('GoToR'));
|
|
actionDict.set('F', '../../0013/001346/134685E.pdf');
|
|
actionDict.set('D', '4.3');
|
|
actionDict.set('NewWindow', true);
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(489, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toBeUndefined();
|
|
expect(data.unsafeUrl).toEqual('../../0013/001346/134685E.pdf#4.3');
|
|
expect(data.dest).toBeUndefined();
|
|
expect(data.newWindow).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a GoToR action, containing a relative URL, ' +
|
|
'with the "docBaseUrl" parameter specified', function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('GoToR'));
|
|
actionDict.set('F', '../../0013/001346/134685E.pdf');
|
|
actionDict.set('D', '4.3');
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(489, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
const pdfManager = new PDFManagerMock({
|
|
docBaseUrl: 'http://www.example.com/test/pdfs/qwerty.pdf',
|
|
});
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManager,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual(
|
|
'http://www.example.com/0013/001346/134685E.pdf#4.3');
|
|
expect(data.unsafeUrl).toEqual('../../0013/001346/134685E.pdf#4.3');
|
|
expect(data.dest).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a GoToR action, with named destination',
|
|
function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('GoToR'));
|
|
actionDict.set('F', 'http://www.example.com/test.pdf');
|
|
actionDict.set('D', '15');
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(495, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual('http://www.example.com/test.pdf#15');
|
|
expect(data.unsafeUrl).toEqual('http://www.example.com/test.pdf#15');
|
|
expect(data.dest).toBeUndefined();
|
|
expect(data.newWindow).toBeFalsy();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a GoToR action, with explicit destination array',
|
|
function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('GoToR'));
|
|
actionDict.set('F', 'http://www.example.com/test.pdf');
|
|
actionDict.set('D', [14, Name.get('XYZ'), null, 298.043, null]);
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(489, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual(new URL('http://www.example.com/test.pdf#' +
|
|
'[14,{"name":"XYZ"},null,298.043,null]').href);
|
|
expect(data.unsafeUrl).toEqual('http://www.example.com/test.pdf#' +
|
|
'[14,{"name":"XYZ"},null,298.043,null]');
|
|
expect(data.dest).toBeUndefined();
|
|
expect(data.newWindow).toBeFalsy();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a Launch action, where the FileSpec dict ' +
|
|
'contains a relative URL, with the "docBaseUrl" parameter specified',
|
|
function(done) {
|
|
const fileSpecDict = new Dict();
|
|
fileSpecDict.set('Type', Name.get('FileSpec'));
|
|
fileSpecDict.set('F', 'Part II/Part II.pdf');
|
|
fileSpecDict.set('UF', 'Part II/Part II.pdf');
|
|
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('Launch'));
|
|
actionDict.set('F', fileSpecDict);
|
|
actionDict.set('NewWindow', true);
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(88, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
const pdfManager = new PDFManagerMock({
|
|
docBaseUrl: 'http://www.example.com/test/pdfs/qwerty.pdf',
|
|
});
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManager,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual(
|
|
new URL('http://www.example.com/test/pdfs/Part II/Part II.pdf').href);
|
|
expect(data.unsafeUrl).toEqual('Part II/Part II.pdf');
|
|
expect(data.dest).toBeUndefined();
|
|
expect(data.newWindow).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should recover valid URLs from JavaScript actions having certain ' +
|
|
'white-listed formats', function(done) {
|
|
function checkJsAction(params) {
|
|
const jsEntry = params.jsEntry;
|
|
const expectedUrl = params.expectedUrl;
|
|
const expectedUnsafeUrl = params.expectedUnsafeUrl;
|
|
const expectedNewWindow = params.expectedNewWindow;
|
|
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('JavaScript'));
|
|
actionDict.set('JS', jsEntry);
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(46, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
return AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toEqual(expectedUrl);
|
|
expect(data.unsafeUrl).toEqual(expectedUnsafeUrl);
|
|
expect(data.dest).toBeUndefined();
|
|
expect(data.newWindow).toEqual(expectedNewWindow);
|
|
});
|
|
}
|
|
|
|
// Check that we reject a 'JS' entry containing arbitrary JavaScript.
|
|
const annotation1 = checkJsAction({
|
|
jsEntry: 'function someFun() { return "qwerty"; } someFun();',
|
|
expectedUrl: undefined,
|
|
expectedUnsafeUrl: undefined,
|
|
expectedNewWindow: undefined,
|
|
});
|
|
|
|
// Check that we accept a white-listed {string} 'JS' entry.
|
|
const annotation2 = checkJsAction({
|
|
jsEntry: 'window.open(\'http://www.example.com/test.pdf\')',
|
|
expectedUrl: new URL('http://www.example.com/test.pdf').href,
|
|
expectedUnsafeUrl: 'http://www.example.com/test.pdf',
|
|
expectedNewWindow: undefined,
|
|
});
|
|
|
|
// Check that we accept a white-listed {Stream} 'JS' entry.
|
|
const annotation3 = checkJsAction({
|
|
jsEntry: new StringStream(
|
|
'app.launchURL("http://www.example.com/test.pdf", true)'),
|
|
expectedUrl: new URL('http://www.example.com/test.pdf').href,
|
|
expectedUnsafeUrl: 'http://www.example.com/test.pdf',
|
|
expectedNewWindow: true,
|
|
});
|
|
|
|
Promise.all([annotation1, annotation2, annotation3]).then(done,
|
|
done.fail);
|
|
});
|
|
|
|
it('should correctly parse a Named action', function(done) {
|
|
const actionDict = new Dict();
|
|
actionDict.set('Type', Name.get('Action'));
|
|
actionDict.set('S', Name.get('Named'));
|
|
actionDict.set('N', Name.get('GoToPage'));
|
|
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('A', actionDict);
|
|
|
|
const annotationRef = Ref.get(12, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toBeUndefined();
|
|
expect(data.unsafeUrl).toBeUndefined();
|
|
expect(data.action).toEqual('GoToPage');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a simple Dest', function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('Dest', Name.get('LI0'));
|
|
|
|
const annotationRef = Ref.get(583, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toBeUndefined();
|
|
expect(data.unsafeUrl).toBeUndefined();
|
|
expect(data.dest).toEqual('LI0');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a simple Dest, with explicit destination array',
|
|
function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('Dest', [Ref.get(17, 0), Name.get('XYZ'),
|
|
0, 841.89, null]);
|
|
|
|
const annotationRef = Ref.get(10, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toBeUndefined();
|
|
expect(data.unsafeUrl).toBeUndefined();
|
|
expect(data.dest).toEqual([{ num: 17, gen: 0, }, { name: 'XYZ', },
|
|
0, 841.89, null]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly parse a Dest, which violates the specification ' +
|
|
'by containing a dictionary', function(done) {
|
|
let destDict = new Dict();
|
|
destDict.set('Type', Name.get('Action'));
|
|
destDict.set('S', Name.get('GoTo'));
|
|
destDict.set('D', 'page.157');
|
|
|
|
let annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
// The /Dest must be a Name or an Array, refer to ISO 32000-1:2008
|
|
// section 12.3.3, but there are PDF files where it's a dictionary.
|
|
annotationDict.set('Dest', destDict);
|
|
|
|
let annotationRef = Ref.get(798, 0);
|
|
let xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.url).toBeUndefined();
|
|
expect(data.unsafeUrl).toBeUndefined();
|
|
expect(data.dest).toEqual('page.157');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should not set quadpoints if not defined', function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
|
|
const annotationRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.quadPoints).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set quadpoints if defined', function(done) {
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Link'));
|
|
annotationDict.set('Rect', [10, 10, 20, 20]);
|
|
annotationDict.set('QuadPoints', [11, 11, 12, 12, 13, 13, 14, 14]);
|
|
|
|
const annotationRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, annotationRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINK);
|
|
expect(data.quadPoints).toEqual([
|
|
[
|
|
{ x: 11, y: 11, }, { x: 12, y: 12, },
|
|
{ x: 13, y: 13, }, { x: 14, y: 14, },
|
|
],
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('WidgetAnnotation', function() {
|
|
let widgetDict;
|
|
|
|
beforeEach(function(done) {
|
|
widgetDict = new Dict();
|
|
widgetDict.set('Type', Name.get('Annot'));
|
|
widgetDict.set('Subtype', Name.get('Widget'));
|
|
done();
|
|
});
|
|
|
|
afterEach(function() {
|
|
widgetDict = null;
|
|
});
|
|
|
|
it('should handle unknown field names', function(done) {
|
|
const widgetRef = Ref.get(20, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: widgetRef, data: widgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, widgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.fieldName).toEqual('');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should construct the field name when there are no ancestors',
|
|
function(done) {
|
|
widgetDict.set('T', 'foo');
|
|
|
|
const widgetRef = Ref.get(21, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: widgetRef, data: widgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, widgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.fieldName).toEqual('foo');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should construct the field name when there are ancestors',
|
|
function(done) {
|
|
const firstParent = new Dict();
|
|
firstParent.set('T', 'foo');
|
|
|
|
const secondParent = new Dict();
|
|
secondParent.set('Parent', firstParent);
|
|
secondParent.set('T', 'bar');
|
|
|
|
widgetDict.set('Parent', secondParent);
|
|
widgetDict.set('T', 'baz');
|
|
|
|
const widgetRef = Ref.get(22, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: widgetRef, data: widgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, widgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.fieldName).toEqual('foo.bar.baz');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should construct the field name if a parent is not a dictionary ' +
|
|
'(issue 8143)', function(done) {
|
|
const parentDict = new Dict();
|
|
parentDict.set('Parent', null);
|
|
parentDict.set('T', 'foo');
|
|
|
|
widgetDict.set('Parent', parentDict);
|
|
widgetDict.set('T', 'bar');
|
|
|
|
const widgetRef = Ref.get(22, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: widgetRef, data: widgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, widgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.fieldName).toEqual('foo.bar');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('TextWidgetAnnotation', function() {
|
|
let textWidgetDict;
|
|
|
|
beforeEach(function(done) {
|
|
textWidgetDict = new Dict();
|
|
textWidgetDict.set('Type', Name.get('Annot'));
|
|
textWidgetDict.set('Subtype', Name.get('Widget'));
|
|
textWidgetDict.set('FT', Name.get('Tx'));
|
|
done();
|
|
});
|
|
|
|
afterEach(function() {
|
|
textWidgetDict = null;
|
|
});
|
|
|
|
it('should handle unknown text alignment, maximum length and flags',
|
|
function(done) {
|
|
const textWidgetRef = Ref.get(124, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: textWidgetRef, data: textWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, textWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.textAlignment).toEqual(null);
|
|
expect(data.maxLen).toEqual(null);
|
|
expect(data.readOnly).toEqual(false);
|
|
expect(data.multiLine).toEqual(false);
|
|
expect(data.comb).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should not set invalid text alignment, maximum length and flags',
|
|
function(done) {
|
|
textWidgetDict.set('Q', 'center');
|
|
textWidgetDict.set('MaxLen', 'five');
|
|
textWidgetDict.set('Ff', 'readonly');
|
|
|
|
const textWidgetRef = Ref.get(43, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: textWidgetRef, data: textWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, textWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.textAlignment).toEqual(null);
|
|
expect(data.maxLen).toEqual(null);
|
|
expect(data.readOnly).toEqual(false);
|
|
expect(data.multiLine).toEqual(false);
|
|
expect(data.comb).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set valid text alignment, maximum length and flags',
|
|
function(done) {
|
|
textWidgetDict.set('Q', 1);
|
|
textWidgetDict.set('MaxLen', 20);
|
|
textWidgetDict.set('Ff', AnnotationFieldFlag.READONLY +
|
|
AnnotationFieldFlag.MULTILINE);
|
|
|
|
const textWidgetRef = Ref.get(84, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: textWidgetRef, data: textWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, textWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.textAlignment).toEqual(1);
|
|
expect(data.maxLen).toEqual(20);
|
|
expect(data.readOnly).toEqual(true);
|
|
expect(data.multiLine).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should reject comb fields without a maximum length', function(done) {
|
|
textWidgetDict.set('Ff', AnnotationFieldFlag.COMB);
|
|
|
|
const textWidgetRef = Ref.get(46, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: textWidgetRef, data: textWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, textWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.comb).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should accept comb fields with a maximum length', function(done) {
|
|
textWidgetDict.set('MaxLen', 20);
|
|
textWidgetDict.set('Ff', AnnotationFieldFlag.COMB);
|
|
|
|
const textWidgetRef = Ref.get(46, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: textWidgetRef, data: textWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, textWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.comb).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should only accept comb fields when the flags are valid',
|
|
function(done) {
|
|
let invalidFieldFlags = [
|
|
AnnotationFieldFlag.MULTILINE,
|
|
AnnotationFieldFlag.PASSWORD,
|
|
AnnotationFieldFlag.FILESELECT,
|
|
];
|
|
|
|
// Start with all invalid flags set and remove them one by one.
|
|
// The field may only use combs when all invalid flags are unset.
|
|
let flags = AnnotationFieldFlag.COMB + AnnotationFieldFlag.MULTILINE +
|
|
AnnotationFieldFlag.PASSWORD + AnnotationFieldFlag.FILESELECT;
|
|
|
|
let promise = Promise.resolve();
|
|
for (let i = 0, ii = invalidFieldFlags.length; i <= ii; i++) {
|
|
promise = promise.then(() => {
|
|
textWidgetDict.set('MaxLen', 20);
|
|
textWidgetDict.set('Ff', flags);
|
|
|
|
const textWidgetRef = Ref.get(93, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: textWidgetRef, data: textWidgetDict, }
|
|
]);
|
|
|
|
return AnnotationFactory.create(xref, textWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
|
|
const valid = (invalidFieldFlags.length === 0);
|
|
expect(data.comb).toEqual(valid);
|
|
|
|
// Remove the last invalid flag for the next iteration.
|
|
if (!valid) {
|
|
flags -= invalidFieldFlags.pop();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
promise.then(done, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('ButtonWidgetAnnotation', function() {
|
|
let buttonWidgetDict;
|
|
|
|
beforeEach(function(done) {
|
|
buttonWidgetDict = new Dict();
|
|
buttonWidgetDict.set('Type', Name.get('Annot'));
|
|
buttonWidgetDict.set('Subtype', Name.get('Widget'));
|
|
buttonWidgetDict.set('FT', Name.get('Btn'));
|
|
done();
|
|
});
|
|
|
|
afterEach(function() {
|
|
buttonWidgetDict = null;
|
|
});
|
|
|
|
it('should handle checkboxes with export value', function(done) {
|
|
buttonWidgetDict.set('V', Name.get('1'));
|
|
|
|
const appearanceStatesDict = new Dict();
|
|
const exportValueOptionsDict = new Dict();
|
|
|
|
exportValueOptionsDict.set('Off', 0);
|
|
exportValueOptionsDict.set('Checked', 1);
|
|
appearanceStatesDict.set('D', exportValueOptionsDict);
|
|
buttonWidgetDict.set('AP', appearanceStatesDict);
|
|
|
|
const buttonWidgetRef = Ref.get(124, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: buttonWidgetRef, data: buttonWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, buttonWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.checkBox).toEqual(true);
|
|
expect(data.fieldValue).toEqual('1');
|
|
expect(data.radioButton).toEqual(false);
|
|
expect(data.exportValue).toEqual('Checked');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle checkboxes without export value', function(done) {
|
|
buttonWidgetDict.set('V', Name.get('1'));
|
|
|
|
const buttonWidgetRef = Ref.get(124, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: buttonWidgetRef, data: buttonWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, buttonWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.checkBox).toEqual(true);
|
|
expect(data.fieldValue).toEqual('1');
|
|
expect(data.radioButton).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle radio buttons with a field value', function(done) {
|
|
const parentDict = new Dict();
|
|
parentDict.set('V', Name.get('1'));
|
|
|
|
const normalAppearanceStateDict = new Dict();
|
|
normalAppearanceStateDict.set('2', null);
|
|
|
|
const appearanceStatesDict = new Dict();
|
|
appearanceStatesDict.set('N', normalAppearanceStateDict);
|
|
|
|
buttonWidgetDict.set('Ff', AnnotationFieldFlag.RADIO);
|
|
buttonWidgetDict.set('Parent', parentDict);
|
|
buttonWidgetDict.set('AP', appearanceStatesDict);
|
|
|
|
const buttonWidgetRef = Ref.get(124, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: buttonWidgetRef, data: buttonWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, buttonWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.checkBox).toEqual(false);
|
|
expect(data.radioButton).toEqual(true);
|
|
expect(data.fieldValue).toEqual('1');
|
|
expect(data.buttonValue).toEqual('2');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle radio buttons without a field value', function(done) {
|
|
const normalAppearanceStateDict = new Dict();
|
|
normalAppearanceStateDict.set('2', null);
|
|
|
|
const appearanceStatesDict = new Dict();
|
|
appearanceStatesDict.set('N', normalAppearanceStateDict);
|
|
|
|
buttonWidgetDict.set('Ff', AnnotationFieldFlag.RADIO);
|
|
buttonWidgetDict.set('AP', appearanceStatesDict);
|
|
|
|
const buttonWidgetRef = Ref.get(124, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: buttonWidgetRef, data: buttonWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, buttonWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.checkBox).toEqual(false);
|
|
expect(data.radioButton).toEqual(true);
|
|
expect(data.fieldValue).toEqual(null);
|
|
expect(data.buttonValue).toEqual('2');
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('ChoiceWidgetAnnotation', function() {
|
|
let choiceWidgetDict;
|
|
|
|
beforeEach(function(done) {
|
|
choiceWidgetDict = new Dict();
|
|
choiceWidgetDict.set('Type', Name.get('Annot'));
|
|
choiceWidgetDict.set('Subtype', Name.get('Widget'));
|
|
choiceWidgetDict.set('FT', Name.get('Ch'));
|
|
done();
|
|
});
|
|
|
|
afterEach(function() {
|
|
choiceWidgetDict = null;
|
|
});
|
|
|
|
it('should handle missing option arrays', function(done) {
|
|
const choiceWidgetRef = Ref.get(122, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.options).toEqual([]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle option arrays with array elements', function(done) {
|
|
const optionBarRef = Ref.get(20, 0);
|
|
const optionBarStr = 'Bar';
|
|
const optionOneRef = Ref.get(10, 0);
|
|
const optionOneArr = ['bar_export', optionBarRef];
|
|
|
|
const options = [['foo_export', 'Foo'], optionOneRef];
|
|
const expected = [
|
|
{ exportValue: 'foo_export', displayValue: 'Foo', },
|
|
{ exportValue: 'bar_export', displayValue: 'Bar', },
|
|
];
|
|
|
|
choiceWidgetDict.set('Opt', options);
|
|
|
|
const choiceWidgetRef = Ref.get(123, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, },
|
|
{ ref: optionBarRef, data: optionBarStr, },
|
|
{ ref: optionOneRef, data: optionOneArr, },
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.options).toEqual(expected);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle option arrays with string elements', function(done) {
|
|
const optionBarRef = Ref.get(10, 0);
|
|
const optionBarStr = 'Bar';
|
|
|
|
const options = ['Foo', optionBarRef];
|
|
const expected = [
|
|
{ exportValue: 'Foo', displayValue: 'Foo', },
|
|
{ exportValue: 'Bar', displayValue: 'Bar', },
|
|
];
|
|
|
|
choiceWidgetDict.set('Opt', options);
|
|
|
|
const choiceWidgetRef = Ref.get(981, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, },
|
|
{ ref: optionBarRef, data: optionBarStr, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.options).toEqual(expected);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle inherited option arrays (issue 8094)', function(done) {
|
|
const options = [
|
|
['Value1', 'Description1'],
|
|
['Value2', 'Description2'],
|
|
];
|
|
const expected = [
|
|
{ exportValue: 'Value1', displayValue: 'Description1', },
|
|
{ exportValue: 'Value2', displayValue: 'Description2', },
|
|
];
|
|
|
|
const parentDict = new Dict();
|
|
parentDict.set('Opt', options);
|
|
|
|
choiceWidgetDict.set('Parent', parentDict);
|
|
|
|
const choiceWidgetRef = Ref.get(123, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, },
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.options).toEqual(expected);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should sanitize display values in option arrays (issue 8947)',
|
|
function(done) {
|
|
// The option value is a UTF-16BE string. The display value should be
|
|
// sanitized, but the export value should remain the same since that
|
|
// may be used as a unique identifier when exporting form values.
|
|
const options = ['\xFE\xFF\x00F\x00o\x00o'];
|
|
const expected = [
|
|
{ exportValue: '\xFE\xFF\x00F\x00o\x00o', displayValue: 'Foo', },
|
|
];
|
|
|
|
choiceWidgetDict.set('Opt', options);
|
|
|
|
const choiceWidgetRef = Ref.get(984, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, },
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.options).toEqual(expected);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle array field values', function(done) {
|
|
const fieldValue = ['Foo', 'Bar'];
|
|
|
|
choiceWidgetDict.set('V', fieldValue);
|
|
|
|
const choiceWidgetRef = Ref.get(968, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.fieldValue).toEqual(fieldValue);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle string field values', function(done) {
|
|
const fieldValue = 'Foo';
|
|
|
|
choiceWidgetDict.set('V', fieldValue);
|
|
|
|
const choiceWidgetRef = Ref.get(978, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.fieldValue).toEqual([fieldValue]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle unknown flags', function(done) {
|
|
const choiceWidgetRef = Ref.get(166, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.readOnly).toEqual(false);
|
|
expect(data.combo).toEqual(false);
|
|
expect(data.multiSelect).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should not set invalid flags', function(done) {
|
|
choiceWidgetDict.set('Ff', 'readonly');
|
|
|
|
const choiceWidgetRef = Ref.get(165, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.readOnly).toEqual(false);
|
|
expect(data.combo).toEqual(false);
|
|
expect(data.multiSelect).toEqual(false);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set valid flags', function(done) {
|
|
choiceWidgetDict.set('Ff', AnnotationFieldFlag.READONLY +
|
|
AnnotationFieldFlag.COMBO +
|
|
AnnotationFieldFlag.MULTISELECT);
|
|
|
|
const choiceWidgetRef = Ref.get(512, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: choiceWidgetRef, data: choiceWidgetDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, choiceWidgetRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.WIDGET);
|
|
expect(data.readOnly).toEqual(true);
|
|
expect(data.combo).toEqual(true);
|
|
expect(data.multiSelect).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('LineAnnotation', function() {
|
|
it('should set the line coordinates', function(done) {
|
|
const lineDict = new Dict();
|
|
lineDict.set('Type', Name.get('Annot'));
|
|
lineDict.set('Subtype', Name.get('Line'));
|
|
lineDict.set('L', [1, 2, 3, 4]);
|
|
|
|
const lineRef = Ref.get(122, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: lineRef, data: lineDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, lineRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.LINE);
|
|
expect(data.lineCoordinates).toEqual([1, 2, 3, 4]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('FileAttachmentAnnotation', function() {
|
|
it('should correctly parse a file attachment', function(done) {
|
|
const fileStream = new StringStream(
|
|
'<<\n' +
|
|
'/Type /EmbeddedFile\n' +
|
|
'/Subtype /text#2Fplain\n' +
|
|
'>>\n' +
|
|
'stream\n' +
|
|
'Test attachment' +
|
|
'endstream\n'
|
|
);
|
|
const parser = new Parser({
|
|
lexer: new Lexer(fileStream),
|
|
xref: null,
|
|
allowStreams: true,
|
|
});
|
|
|
|
const fileStreamRef = Ref.get(18, 0);
|
|
const fileStreamDict = parser.getObj();
|
|
|
|
const embeddedFileDict = new Dict();
|
|
embeddedFileDict.set('F', fileStreamRef);
|
|
|
|
const fileSpecRef = Ref.get(19, 0);
|
|
const fileSpecDict = new Dict();
|
|
fileSpecDict.set('Type', Name.get('Filespec'));
|
|
fileSpecDict.set('Desc', '');
|
|
fileSpecDict.set('EF', embeddedFileDict);
|
|
fileSpecDict.set('UF', 'Test.txt');
|
|
|
|
const fileAttachmentRef = Ref.get(20, 0);
|
|
const fileAttachmentDict = new Dict();
|
|
fileAttachmentDict.set('Type', Name.get('Annot'));
|
|
fileAttachmentDict.set('Subtype', Name.get('FileAttachment'));
|
|
fileAttachmentDict.set('FS', fileSpecRef);
|
|
fileAttachmentDict.set('T', 'Topic');
|
|
fileAttachmentDict.set('Contents', 'Test.txt');
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: fileStreamRef, data: fileStreamDict, },
|
|
{ ref: fileSpecRef, data: fileSpecDict, },
|
|
{ ref: fileAttachmentRef, data: fileAttachmentDict, }
|
|
]);
|
|
embeddedFileDict.assignXref(xref);
|
|
fileSpecDict.assignXref(xref);
|
|
fileAttachmentDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, fileAttachmentRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.FILEATTACHMENT);
|
|
expect(data.file.filename).toEqual('Test.txt');
|
|
expect(data.file.content).toEqual(stringToBytes('Test attachment'));
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('PopupAnnotation', function() {
|
|
it('should inherit properties from its parent', function(done) {
|
|
const parentDict = new Dict();
|
|
parentDict.set('Type', Name.get('Annot'));
|
|
parentDict.set('Subtype', Name.get('Text'));
|
|
parentDict.set('M', 'D:20190423');
|
|
parentDict.set('C', [0, 0, 1]);
|
|
|
|
const popupDict = new Dict();
|
|
popupDict.set('Type', Name.get('Annot'));
|
|
popupDict.set('Subtype', Name.get('Popup'));
|
|
popupDict.set('Parent', parentDict);
|
|
|
|
const popupRef = Ref.get(13, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: popupRef, data: popupDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, popupRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, viewable, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.POPUP);
|
|
expect(data.modificationDate).toEqual('D:20190423');
|
|
expect(data.color).toEqual(new Uint8ClampedArray([0, 0, 255]));
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle missing parent properties', function(done) {
|
|
const parentDict = new Dict();
|
|
parentDict.set('Type', Name.get('Annot'));
|
|
parentDict.set('Subtype', Name.get('Text'));
|
|
|
|
const popupDict = new Dict();
|
|
popupDict.set('Type', Name.get('Annot'));
|
|
popupDict.set('Subtype', Name.get('Popup'));
|
|
popupDict.set('Parent', parentDict);
|
|
|
|
const popupRef = Ref.get(13, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: popupRef, data: popupDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, popupRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, viewable, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.POPUP);
|
|
expect(data.modificationDate).toEqual(null);
|
|
expect(data.color).toEqual(null);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should inherit the parent flags when the Popup is not viewable, ' +
|
|
'but the parent is (PR 7352)', function(done) {
|
|
const parentDict = new Dict();
|
|
parentDict.set('Type', Name.get('Annot'));
|
|
parentDict.set('Subtype', Name.get('Text'));
|
|
parentDict.set('F', 28); // viewable
|
|
|
|
const popupDict = new Dict();
|
|
popupDict.set('Type', Name.get('Annot'));
|
|
popupDict.set('Subtype', Name.get('Popup'));
|
|
popupDict.set('F', 25); // not viewable
|
|
popupDict.set('Parent', parentDict);
|
|
|
|
const popupRef = Ref.get(13, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: popupRef, data: popupDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, popupRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, viewable, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.POPUP);
|
|
// We should not modify the `annotationFlags` returned through
|
|
// e.g., the API.
|
|
expect(data.annotationFlags).toEqual(25);
|
|
// The popup should inherit the `viewable` property of the parent.
|
|
expect(viewable).toEqual(true);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should correctly inherit Contents from group-master annotation ' +
|
|
'if parent has ReplyType == Group', function (done) {
|
|
const annotationRef = new Ref(819, 0);
|
|
const annotationDict = new Dict();
|
|
annotationDict.set('Type', Name.get('Annot'));
|
|
annotationDict.set('Subtype', Name.get('Text'));
|
|
annotationDict.set('T', 'Correct Title');
|
|
annotationDict.set('Contents', 'Correct Text');
|
|
annotationDict.set('M', 'D:20190423');
|
|
annotationDict.set('C', [0, 0, 1]);
|
|
|
|
const replyRef = new Ref(820, 0);
|
|
const replyDict = new Dict();
|
|
replyDict.set('Type', Name.get('Annot'));
|
|
replyDict.set('Subtype', Name.get('Text'));
|
|
replyDict.set('IRT', annotationRef);
|
|
replyDict.set('RT', Name.get('Group'));
|
|
replyDict.set('T', 'Reply Title');
|
|
replyDict.set('Contents', 'Reply Text');
|
|
replyDict.set('M', 'D:20190523');
|
|
replyDict.set('C', [0.4]);
|
|
|
|
const popupRef = new Ref(821, 0);
|
|
const popupDict = new Dict();
|
|
popupDict.set('Type', Name.get('Annot'));
|
|
popupDict.set('Subtype', Name.get('Popup'));
|
|
popupDict.set('T', 'Wrong Title');
|
|
popupDict.set('Contents', 'Wrong Text');
|
|
popupDict.set('Parent', replyRef);
|
|
popupDict.set('M', 'D:20190623');
|
|
popupDict.set('C', [0.8]);
|
|
replyDict.set('Popup', popupRef);
|
|
|
|
const xref = new XRefMock([
|
|
{ ref: annotationRef, data: annotationDict, },
|
|
{ ref: replyRef, data: replyDict, },
|
|
{ ref: popupRef, data: popupDict, }
|
|
]);
|
|
annotationDict.assignXref(xref);
|
|
popupDict.assignXref(xref);
|
|
replyDict.assignXref(xref);
|
|
|
|
AnnotationFactory.create(xref, popupRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.title).toEqual('Correct Title');
|
|
expect(data.contents).toEqual('Correct Text');
|
|
expect(data.modificationDate).toEqual('D:20190423');
|
|
expect(data.color).toEqual(new Uint8ClampedArray([0, 0, 255]));
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('InkAnnotation', function() {
|
|
it('should handle a single ink list', function(done) {
|
|
const inkDict = new Dict();
|
|
inkDict.set('Type', Name.get('Annot'));
|
|
inkDict.set('Subtype', Name.get('Ink'));
|
|
inkDict.set('InkList', [[1, 1, 1, 2, 2, 2, 3, 3]]);
|
|
|
|
const inkRef = Ref.get(142, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: inkRef, data: inkDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, inkRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.INK);
|
|
expect(data.inkLists.length).toEqual(1);
|
|
expect(data.inkLists[0]).toEqual([
|
|
{ x: 1, y: 1, },
|
|
{ x: 1, y: 2, },
|
|
{ x: 2, y: 2, },
|
|
{ x: 3, y: 3, },
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should handle multiple ink lists', function(done) {
|
|
const inkDict = new Dict();
|
|
inkDict.set('Type', Name.get('Annot'));
|
|
inkDict.set('Subtype', Name.get('Ink'));
|
|
inkDict.set('InkList', [
|
|
[1, 1, 1, 2],
|
|
[3, 3, 4, 5],
|
|
]);
|
|
|
|
const inkRef = Ref.get(143, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: inkRef, data: inkDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, inkRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.INK);
|
|
expect(data.inkLists.length).toEqual(2);
|
|
expect(data.inkLists[0]).toEqual([
|
|
{ x: 1, y: 1, }, { x: 1, y: 2, }
|
|
]);
|
|
expect(data.inkLists[1]).toEqual([
|
|
{ x: 3, y: 3, }, { x: 4, y: 5, }
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('HightlightAnnotation', function() {
|
|
it('should not set quadpoints if not defined', function(done) {
|
|
const highlightDict = new Dict();
|
|
highlightDict.set('Type', Name.get('Annot'));
|
|
highlightDict.set('Subtype', Name.get('Highlight'));
|
|
|
|
const highlightRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: highlightRef, data: highlightDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, highlightRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.HIGHLIGHT);
|
|
expect(data.quadPoints).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set quadpoints if defined', function(done) {
|
|
const highlightDict = new Dict();
|
|
highlightDict.set('Type', Name.get('Annot'));
|
|
highlightDict.set('Subtype', Name.get('Highlight'));
|
|
highlightDict.set('Rect', [10, 10, 20, 20]);
|
|
highlightDict.set('QuadPoints', [11, 11, 12, 12, 13, 13, 14, 14]);
|
|
|
|
const highlightRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: highlightRef, data: highlightDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, highlightRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.HIGHLIGHT);
|
|
expect(data.quadPoints).toEqual([
|
|
[
|
|
{ x: 11, y: 11, }, { x: 12, y: 12, },
|
|
{ x: 13, y: 13, }, { x: 14, y: 14, },
|
|
],
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('UnderlineAnnotation', function() {
|
|
it('should not set quadpoints if not defined', function(done) {
|
|
const underlineDict = new Dict();
|
|
underlineDict.set('Type', Name.get('Annot'));
|
|
underlineDict.set('Subtype', Name.get('Underline'));
|
|
|
|
const underlineRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: underlineRef, data: underlineDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, underlineRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.UNDERLINE);
|
|
expect(data.quadPoints).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set quadpoints if defined', function(done) {
|
|
const underlineDict = new Dict();
|
|
underlineDict.set('Type', Name.get('Annot'));
|
|
underlineDict.set('Subtype', Name.get('Underline'));
|
|
underlineDict.set('Rect', [10, 10, 20, 20]);
|
|
underlineDict.set('QuadPoints', [11, 11, 12, 12, 13, 13, 14, 14]);
|
|
|
|
const underlineRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: underlineRef, data: underlineDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, underlineRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.UNDERLINE);
|
|
expect(data.quadPoints).toEqual([
|
|
[
|
|
{ x: 11, y: 11, }, { x: 12, y: 12, },
|
|
{ x: 13, y: 13, }, { x: 14, y: 14, },
|
|
],
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('SquigglyAnnotation', function() {
|
|
it('should not set quadpoints if not defined', function(done) {
|
|
const squigglyDict = new Dict();
|
|
squigglyDict.set('Type', Name.get('Annot'));
|
|
squigglyDict.set('Subtype', Name.get('Squiggly'));
|
|
|
|
const squigglyRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: squigglyRef, data: squigglyDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, squigglyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.SQUIGGLY);
|
|
expect(data.quadPoints).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set quadpoints if defined', function(done) {
|
|
const squigglyDict = new Dict();
|
|
squigglyDict.set('Type', Name.get('Annot'));
|
|
squigglyDict.set('Subtype', Name.get('Squiggly'));
|
|
squigglyDict.set('Rect', [10, 10, 20, 20]);
|
|
squigglyDict.set('QuadPoints', [11, 11, 12, 12, 13, 13, 14, 14]);
|
|
|
|
const squigglyRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: squigglyRef, data: squigglyDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, squigglyRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.SQUIGGLY);
|
|
expect(data.quadPoints).toEqual([
|
|
[
|
|
{ x: 11, y: 11, }, { x: 12, y: 12, },
|
|
{ x: 13, y: 13, }, { x: 14, y: 14, },
|
|
],
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
|
|
describe('StrikeOutAnnotation', function() {
|
|
it('should not set quadpoints if not defined', function(done) {
|
|
const strikeOutDict = new Dict();
|
|
strikeOutDict.set('Type', Name.get('Annot'));
|
|
strikeOutDict.set('Subtype', Name.get('StrikeOut'));
|
|
|
|
const strikeOutRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: strikeOutRef, data: strikeOutDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, strikeOutRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.STRIKEOUT);
|
|
expect(data.quadPoints).toBeUndefined();
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
|
|
it('should set quadpoints if defined', function(done) {
|
|
const strikeOutDict = new Dict();
|
|
strikeOutDict.set('Type', Name.get('Annot'));
|
|
strikeOutDict.set('Subtype', Name.get('StrikeOut'));
|
|
strikeOutDict.set('Rect', [10, 10, 20, 20]);
|
|
strikeOutDict.set('QuadPoints', [11, 11, 12, 12, 13, 13, 14, 14]);
|
|
|
|
const strikeOutRef = Ref.get(121, 0);
|
|
const xref = new XRefMock([
|
|
{ ref: strikeOutRef, data: strikeOutDict, }
|
|
]);
|
|
|
|
AnnotationFactory.create(xref, strikeOutRef, pdfManagerMock,
|
|
idFactoryMock).then(({ data, }) => {
|
|
expect(data.annotationType).toEqual(AnnotationType.STRIKEOUT);
|
|
expect(data.quadPoints).toEqual([
|
|
[
|
|
{ x: 11, y: 11, }, { x: 12, y: 12, },
|
|
{ x: 13, y: 13, }, { x: 14, y: 14, },
|
|
],
|
|
]);
|
|
done();
|
|
}, done.fail);
|
|
});
|
|
});
|
|
});
|