mirror of
https://github.com/zen-browser/pdf.js.git
synced 2025-07-07 17:05:38 +02:00
f051597e23
This patch allows embedders of PDF.js to provide custom match
logic for seaching in PDFs. This is done by subclassing the
PDFFindController class and overriding the `match` method.
`match` is called once per PDF page, receives as parameters the
search query, the page contents, and the page index, and returns
an array of { index, length } objects representing the search
results.
1140 lines
29 KiB
JavaScript
1140 lines
29 KiB
JavaScript
/* Copyright 2018 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 { FindState, PDFFindController } from "../../web/pdf_find_controller.js";
|
|
import { buildGetDocumentParams } from "./test_utils.js";
|
|
import { EventBus } from "../../web/event_utils.js";
|
|
import { getDocument } from "../../src/display/api.js";
|
|
import { isNodeJS } from "../../src/shared/util.js";
|
|
import { SimpleLinkService } from "../../web/pdf_link_service.js";
|
|
|
|
const tracemonkeyFileName = "tracemonkey.pdf";
|
|
|
|
const CMAP_URL = isNodeJS ? "./external/bcmaps/" : "../../../external/bcmaps/";
|
|
|
|
class MockLinkService extends SimpleLinkService {
|
|
constructor() {
|
|
super();
|
|
|
|
this._page = 1;
|
|
this._pdfDocument = null;
|
|
}
|
|
|
|
setDocument(pdfDocument) {
|
|
this._pdfDocument = pdfDocument;
|
|
}
|
|
|
|
get pagesCount() {
|
|
return this._pdfDocument.numPages;
|
|
}
|
|
|
|
get page() {
|
|
return this._page;
|
|
}
|
|
|
|
set page(value) {
|
|
this._page = value;
|
|
}
|
|
}
|
|
|
|
async function initPdfFindController(
|
|
filename,
|
|
updateMatchesCountOnProgress = true,
|
|
matcher = undefined
|
|
) {
|
|
const loadingTask = getDocument(
|
|
buildGetDocumentParams(filename || tracemonkeyFileName, {
|
|
cMapUrl: CMAP_URL,
|
|
})
|
|
);
|
|
const pdfDocument = await loadingTask.promise;
|
|
|
|
const eventBus = new EventBus();
|
|
|
|
const linkService = new MockLinkService();
|
|
linkService.setDocument(pdfDocument);
|
|
|
|
let FindControllerClass = PDFFindController;
|
|
if (matcher !== undefined) {
|
|
FindControllerClass = class extends PDFFindController {};
|
|
FindControllerClass.prototype.match = matcher;
|
|
}
|
|
|
|
const pdfFindController = new FindControllerClass({
|
|
linkService,
|
|
eventBus,
|
|
updateMatchesCountOnProgress,
|
|
});
|
|
pdfFindController.setDocument(pdfDocument); // Enable searching.
|
|
|
|
return { eventBus, pdfFindController };
|
|
}
|
|
|
|
function testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state,
|
|
matchesPerPage,
|
|
selectedMatch,
|
|
pageMatches = null,
|
|
pageMatchesLength = null,
|
|
updateFindMatchesCount = null,
|
|
updateFindControlState = null,
|
|
}) {
|
|
return new Promise(function (resolve) {
|
|
const eventState = Object.assign(
|
|
Object.create(null),
|
|
{
|
|
source: this,
|
|
type: "",
|
|
query: null,
|
|
caseSensitive: false,
|
|
entireWord: false,
|
|
findPrevious: false,
|
|
matchDiacritics: false,
|
|
},
|
|
state
|
|
);
|
|
eventBus.dispatch("find", eventState);
|
|
|
|
// The `updatefindmatchescount` event is only emitted if the page contains
|
|
// at least one match for the query, so the last non-zero item in the
|
|
// matches per page array corresponds to the page for which the final
|
|
// `updatefindmatchescount` event is emitted. If this happens, we know
|
|
// that any subsequent pages won't trigger the event anymore and we
|
|
// can start comparing the matches per page. This logic is necessary
|
|
// because we call the `pdfFindController.pageMatches` getter directly
|
|
// after receiving the event and the underlying `_pageMatches` array
|
|
// is only extended when a page is processed, so it will only contain
|
|
// entries for the pages processed until the time when the final event
|
|
// was emitted.
|
|
let totalPages = matchesPerPage.length;
|
|
for (let i = totalPages - 1; i >= 0; i--) {
|
|
if (matchesPerPage[i] > 0) {
|
|
totalPages = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const totalMatches = matchesPerPage.reduce((a, b) => a + b);
|
|
|
|
if (updateFindControlState) {
|
|
eventBus.on(
|
|
"updatefindcontrolstate",
|
|
function onUpdateFindControlState(evt) {
|
|
updateFindControlState[0] += 1;
|
|
}
|
|
);
|
|
}
|
|
|
|
eventBus.on(
|
|
"updatefindmatchescount",
|
|
function onUpdateFindMatchesCount(evt) {
|
|
if (updateFindMatchesCount) {
|
|
updateFindMatchesCount[0] += 1;
|
|
}
|
|
if (pdfFindController.pageMatches.length !== totalPages) {
|
|
return;
|
|
}
|
|
eventBus.off("updatefindmatchescount", onUpdateFindMatchesCount);
|
|
|
|
expect(evt.matchesCount.total).toBe(totalMatches);
|
|
for (let i = 0; i < totalPages; i++) {
|
|
expect(pdfFindController.pageMatches[i].length).toEqual(
|
|
matchesPerPage[i]
|
|
);
|
|
}
|
|
expect(pdfFindController.selected.pageIdx).toEqual(
|
|
selectedMatch.pageIndex
|
|
);
|
|
expect(pdfFindController.selected.matchIdx).toEqual(
|
|
selectedMatch.matchIndex
|
|
);
|
|
|
|
if (pageMatches) {
|
|
expect(pdfFindController.pageMatches).toEqual(pageMatches);
|
|
expect(pdfFindController.pageMatchesLength).toEqual(
|
|
pageMatchesLength
|
|
);
|
|
}
|
|
|
|
resolve();
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
function testEmptySearch({ eventBus, pdfFindController, state }) {
|
|
return new Promise(function (resolve) {
|
|
const eventState = Object.assign(
|
|
Object.create(null),
|
|
{
|
|
source: this,
|
|
type: "",
|
|
query: null,
|
|
caseSensitive: false,
|
|
entireWord: false,
|
|
findPrevious: false,
|
|
matchDiacritics: false,
|
|
},
|
|
state
|
|
);
|
|
eventBus.dispatch("find", eventState);
|
|
|
|
eventBus.on(
|
|
"updatefindcontrolstate",
|
|
function onUpdatefindcontrolstate(evt) {
|
|
if (evt.state !== FindState.NOT_FOUND) {
|
|
return;
|
|
}
|
|
eventBus.off("updatefindcontrolstate", onUpdatefindcontrolstate);
|
|
expect(evt.matchesCount.total).toBe(0);
|
|
resolve();
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
describe("pdf_find_controller", function () {
|
|
it("performs a normal search", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
const updateFindMatchesCount = [0];
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Dynamic",
|
|
},
|
|
matchesPerPage: [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
updateFindMatchesCount,
|
|
});
|
|
|
|
expect(updateFindMatchesCount[0]).toBe(9);
|
|
});
|
|
|
|
it("performs a normal search but the total counts is only updated one time", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
null,
|
|
false
|
|
);
|
|
const updateFindMatchesCount = [0];
|
|
const updateFindControlState = [0];
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Dynamic",
|
|
},
|
|
matchesPerPage: [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
updateFindMatchesCount,
|
|
updateFindControlState,
|
|
});
|
|
|
|
expect(updateFindMatchesCount[0]).toBe(1);
|
|
expect(updateFindControlState[0]).toBe(0);
|
|
});
|
|
|
|
it("performs a normal search and finds the previous result", async function () {
|
|
// Page 14 (with page index 13) contains five results. By default, the
|
|
// first result (match index 0) is selected, so the previous result
|
|
// should be the fifth result (match index 4).
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "conference",
|
|
findPrevious: true,
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],
|
|
selectedMatch: {
|
|
pageIndex: 13,
|
|
matchIndex: 4,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a case sensitive search", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Dynamic",
|
|
caseSensitive: true,
|
|
},
|
|
matchesPerPage: [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs an entire word search", async function () {
|
|
// Page 13 contains both 'Government' and 'Governmental', so the latter
|
|
// should not be found with entire word search.
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "Government",
|
|
entireWord: true,
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
|
|
selectedMatch: {
|
|
pageIndex: 12,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a multiple term (no phrase) search", async function () {
|
|
// Page 9 contains 'alternate' and pages 6 and 9 contain 'solution'.
|
|
// Both should be found for multiple term (no phrase) search.
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: ["alternate", "solution"],
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 5,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a multiple term (phrase) search", async function () {
|
|
// Page 9 contains 'alternate solution' and pages 6 and 9 contain
|
|
// 'solution'. Both should be found for multiple term (phrase) search.
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: ["alternate solution", "solution"],
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 5,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a normal search, where the text is normalized", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
"fraction-highlight.pdf"
|
|
);
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "fraction",
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[19, 46, 62]],
|
|
pageMatchesLength: [[8, 8, 8]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1/2",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "½",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1",
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54, 55]],
|
|
pageMatchesLength: [[1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "2",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1/",
|
|
},
|
|
matchesPerPage: [3],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[27, 54, 55]],
|
|
pageMatchesLength: [[1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "1/21",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[54]],
|
|
pageMatchesLength: [[2]],
|
|
});
|
|
});
|
|
|
|
it("performs a normal search, where the text with diacritics is normalized", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
"french_diacritics.pdf"
|
|
);
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "a",
|
|
},
|
|
matchesPerPage: [6],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[0, 2, 4, 6, 8, 10]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "u",
|
|
},
|
|
matchesPerPage: [6],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[44, 46, 48, 50, 52, 54]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "ë",
|
|
matchDiacritics: true,
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[28, 30]],
|
|
pageMatchesLength: [[1, 1]],
|
|
});
|
|
});
|
|
|
|
it("performs a search where one of the results contains an hyphen", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "optimiz",
|
|
},
|
|
matchesPerPage: [1, 4, 2, 3, 3, 0, 2, 9, 1, 0, 0, 6, 3, 4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a search where the result is on two lines", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "user experience",
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[2734]],
|
|
pageMatchesLength: [[14]],
|
|
});
|
|
});
|
|
|
|
it("performs a search where the result is on two lines with a punctuation at eol", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "version.the",
|
|
},
|
|
matchesPerPage: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 1,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[], [1486]],
|
|
pageMatchesLength: [[], [11]],
|
|
});
|
|
});
|
|
|
|
it("performs a search with a minus sign in the query", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "trace-based just-in-time",
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [
|
|
[0],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[2081],
|
|
],
|
|
pageMatchesLength: [
|
|
[24],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[24],
|
|
],
|
|
});
|
|
});
|
|
|
|
it("performs a search with square brackets in the query", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "[Programming Languages]",
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1497]],
|
|
pageMatchesLength: [[25]],
|
|
});
|
|
});
|
|
|
|
it("performs a search with parenthesis in the query", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\t (checks)",
|
|
},
|
|
matchesPerPage: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 1,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[], [201]],
|
|
pageMatchesLength: [[], [9]],
|
|
});
|
|
});
|
|
|
|
it("performs a search with a final dot in the query", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
// The whitespace after the dot mustn't be matched.
|
|
const query = "complex applications.";
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1941]],
|
|
pageMatchesLength: [[21]],
|
|
});
|
|
});
|
|
|
|
it("performs a search with a dot in the query and a missing whitespace", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
// The whitespace after the dot must be matched.
|
|
const query = "complex applications.J";
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1941]],
|
|
pageMatchesLength: [[23]],
|
|
});
|
|
});
|
|
|
|
it("performs a search with a dot followed by a whitespace in the query", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
const query = "complex applications. j";
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query,
|
|
},
|
|
matchesPerPage: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[1941]],
|
|
pageMatchesLength: [[23]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text containing diacritics before -\\n", async function () {
|
|
if (isNodeJS) {
|
|
pending("Linked test-cases are not supported in Node.js.");
|
|
}
|
|
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("issue14562.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "ä",
|
|
matchDiacritics: true,
|
|
},
|
|
matchesPerPage: [80],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [
|
|
[
|
|
302, 340, 418, 481, 628, 802, 983, 989, 1015, 1063, 1084, 1149, 1157,
|
|
1278, 1346, 1394, 1402, 1424, 1500, 1524, 1530, 1686, 1776, 1788,
|
|
1859, 1881, 1911, 1948, 2066, 2076, 2163, 2180, 2215, 2229, 2274,
|
|
2324, 2360, 2402, 2413, 2424, 2463, 2532, 2538, 2553, 2562, 2576,
|
|
2602, 2613, 2638, 2668, 2792, 2805, 2836, 2847, 2858, 2895, 2901,
|
|
2915, 2939, 2959, 3089, 3236, 3246, 3336, 3384, 3391, 3465, 3474,
|
|
3482, 3499, 3687, 3693, 3708, 3755, 3786, 3862, 3974, 4049, 4055,
|
|
4068,
|
|
],
|
|
],
|
|
pageMatchesLength: [
|
|
[
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
],
|
|
],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text containing some Hangul syllables", async function () {
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("bug1771477.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "안녕하세요 세계",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[139]],
|
|
pageMatchesLength: [[8]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text containing an ideographic at the end of a line", async function () {
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("issue15340.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "検知機構",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[29]],
|
|
pageMatchesLength: [[4]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text containing fullwidth chars", async function () {
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("issue15690.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "o",
|
|
},
|
|
matchesPerPage: [13],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[0, 10, 13, 30, 39, 41, 55, 60, 66, 84, 102, 117, 134]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text with some Katakana at the end of a line", async function () {
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("issue15759.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "ソレノイド",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6]],
|
|
pageMatchesLength: [[5]],
|
|
});
|
|
});
|
|
|
|
it("performs a search with a single diacritic", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController();
|
|
|
|
await testEmptySearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\u064E",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text containing combining diacritics", async function () {
|
|
if (isNodeJS) {
|
|
pending("Linked test-cases are not supported in Node.js.");
|
|
}
|
|
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("issue12909.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "הספר",
|
|
matchDiacritics: true,
|
|
},
|
|
matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 8,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "הספר",
|
|
matchDiacritics: false,
|
|
},
|
|
matchesPerPage: [0, 1, 0, 0, 0, 0, 0, 0, 1],
|
|
selectedMatch: {
|
|
pageIndex: 8,
|
|
matchIndex: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text with some Hiragana diacritics at the end of a line", async function () {
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("issue16063.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "行うことができる速結端子",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[63]],
|
|
pageMatchesLength: [[12]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "デュプレックス",
|
|
},
|
|
matchesPerPage: [1],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[205]],
|
|
pageMatchesLength: [[7]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text with some UTF-32 chars", async function () {
|
|
if (isNodeJS) {
|
|
pending("Linked test-cases are not supported in Node.js.");
|
|
}
|
|
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("bug1820909.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "31350",
|
|
},
|
|
matchesPerPage: [1, 2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[41], [131, 1359]],
|
|
pageMatchesLength: [[5], [5, 5]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text with some UTF-32 chars followed by a dash at the end of a line", async function () {
|
|
const { eventBus, pdfFindController } =
|
|
await initPdfFindController("bug1820909.1.pdf");
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "abcde",
|
|
},
|
|
matchesPerPage: [2],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[42, 95]],
|
|
pageMatchesLength: [[5, 5]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text with some arabic chars in different unicode ranges but with same normalized form", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
"ArabicCIDTrueType.pdf"
|
|
);
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\u0629",
|
|
},
|
|
matchesPerPage: [4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6, 25, 44, 63]],
|
|
pageMatchesLength: [[1, 1, 1, 1]],
|
|
});
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "\ufe94",
|
|
},
|
|
matchesPerPage: [4],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[6, 25, 44, 63]],
|
|
pageMatchesLength: [[1, 1, 1, 1]],
|
|
});
|
|
});
|
|
|
|
it("performs a search in a text with some f ligatures", async function () {
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
"copy_paste_ligatures.pdf"
|
|
);
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: {
|
|
query: "f",
|
|
},
|
|
matchesPerPage: [9],
|
|
selectedMatch: {
|
|
pageIndex: 0,
|
|
matchIndex: 0,
|
|
},
|
|
pageMatches: [[5, 6, 6, 7, 8, 9, 9, 10, 10]],
|
|
pageMatchesLength: [[1, 1, 1, 1, 1, 1, 1, 1, 1]],
|
|
});
|
|
});
|
|
|
|
it("dispatches updatefindcontrolstate with correct properties", async function () {
|
|
const testOnFind = ({ eventBus }) =>
|
|
new Promise(function (resolve) {
|
|
const eventState = {
|
|
source: this,
|
|
type: "",
|
|
query: "Foo",
|
|
caseSensitive: true,
|
|
entireWord: true,
|
|
findPrevious: false,
|
|
matchDiacritics: false,
|
|
};
|
|
eventBus.dispatch("find", eventState);
|
|
|
|
eventBus.on("updatefindcontrolstate", function (evt) {
|
|
expect(evt).toEqual(
|
|
jasmine.objectContaining({
|
|
state: FindState.NOT_FOUND,
|
|
previous: false,
|
|
entireWord: true,
|
|
matchesCount: { current: 0, total: 0 },
|
|
rawQuery: "Foo",
|
|
})
|
|
);
|
|
resolve();
|
|
});
|
|
});
|
|
|
|
const { eventBus } = await initPdfFindController();
|
|
await testOnFind({ eventBus });
|
|
});
|
|
|
|
describe("custom matcher", () => {
|
|
it("calls to the matcher with the right arguments", async () => {
|
|
const QUERY = "Foo bar";
|
|
|
|
const spy = jasmine
|
|
.createSpy("custom find matcher")
|
|
.and.callFake(() => [{ index: 0, length: 1 }]);
|
|
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
null,
|
|
false,
|
|
spy
|
|
);
|
|
|
|
const PAGES_COUNT = 14;
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: { query: QUERY },
|
|
selectedMatch: { pageIndex: 0, matchIndex: 0 },
|
|
matchesPerPage: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
|
|
});
|
|
|
|
expect(spy).toHaveBeenCalledTimes(PAGES_COUNT);
|
|
|
|
for (let i = 0; i < PAGES_COUNT; i++) {
|
|
const args = spy.calls.argsFor(i);
|
|
expect(args[0]).withContext(`page ${i}`).toBe(QUERY);
|
|
expect(args[2]).withContext(`page ${i}`).toBe(i);
|
|
}
|
|
|
|
expect(spy.calls.argsFor(0)[1]).toMatch(/^Trace-based /);
|
|
expect(spy.calls.argsFor(1)[1]).toMatch(/^Hence, recording and /);
|
|
expect(spy.calls.argsFor(12)[1]).toMatch(/Figure 12. Fraction of time /);
|
|
expect(spy.calls.argsFor(13)[1]).toMatch(/^not be interpreted as /);
|
|
});
|
|
|
|
it("uses the results returned by the custom matcher", async () => {
|
|
const QUERY = "Foo bar";
|
|
|
|
// prettier-ignore
|
|
const spy = jasmine.createSpy("custom find matcher")
|
|
.and.returnValue(undefined)
|
|
.withArgs(QUERY, jasmine.anything(), 0)
|
|
.and.returnValue([
|
|
{ index: 20, length: 3 },
|
|
{ index: 50, length: 8 },
|
|
])
|
|
.withArgs(QUERY, jasmine.anything(), 2)
|
|
.and.returnValue([
|
|
{ index: 7, length: 19 }
|
|
])
|
|
.withArgs(QUERY, jasmine.anything(), 13)
|
|
.and.returnValue([
|
|
{ index: 50, length: 2 },
|
|
{ index: 54, length: 9 },
|
|
{ index: 80, length: 4 },
|
|
]);
|
|
|
|
const { eventBus, pdfFindController } = await initPdfFindController(
|
|
null,
|
|
false,
|
|
spy
|
|
);
|
|
|
|
await testSearch({
|
|
eventBus,
|
|
pdfFindController,
|
|
state: { query: QUERY },
|
|
selectedMatch: { pageIndex: 0, matchIndex: 0 },
|
|
matchesPerPage: [2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3],
|
|
});
|
|
});
|
|
});
|
|
});
|