1
0
mirror of https://github.com/nextapps-de/flexsearch.git synced 2025-08-25 06:52:06 +02:00

support highlighting on resolver

This commit is contained in:
Thomas Wilkerling
2025-05-23 11:18:13 +02:00
parent 809119b492
commit db56fa1070
69 changed files with 5761 additions and 5038 deletions

View File

@@ -100,6 +100,289 @@ if(!build_light && !build_compact) describe("Worker", function(){
expect(await index.search("bar")).to.have.lengthOf(0);
expect(await index.search("foobar")).to.have.lengthOf(0);
});
it("Result Highlighting", async function(){
// some test data
const data = [{
"id": 1,
"title": "Carmencita"
},{
"id": 2,
"title": "Le clown et ses chiens"
}];
// create the document index
const document = await new Document({
worker: true,
document: {
store: true,
index: [{
field: "title",
tokenize: "forward",
encoder: Charset.LatinBalance
}]
}
});
// add test data
for(let i = 0; i < data.length; i++){
await document.add(data[i]);
}
// perform a query
let result = await document.searchCache({
query: "karmen or clown or not found",
suggest: true,
highlight: "<b>$1</b>"
});
expect(result[0].result).to.eql([{
id: 1,
doc: data[0],
highlight: '<b>Carmen</b>cita'
},{
id: 2,
doc: data[1],
highlight: 'Le <b>clown</b> et ses chiens'
}]);
// perform a query on cache
result = await document.searchCache({
query: "karmen or clown or not found",
suggest: true,
highlight: "<b>$1</b>"
});
expect(result[0].result).to.eql([{
id: 1,
doc: data[0],
highlight: '<b>Carmen</b>cita'
}, {
id: 2,
doc: data[1],
highlight: 'Le <b>clown</b> et ses chiens'
}]);
// perform a query using pluck
result = await document.search({
query: "karmen or clown or not found",
suggest: true,
field: "title",
highlight: "<b>$1</b>"
});
expect(result[0].result).to.eql([{
id: 1,
doc: data[0],
highlight: '<b>Carmen</b>cita'
},{
id: 2,
doc: data[1],
highlight: 'Le <b>clown</b> et ses chiens'
}]);
});
it("Should have been resolved a Resolver properly (Document Worker)", async function(){
const data = [{
"tconst": "tt0000001",
"titleType": "short",
"primaryTitle": "Carmencita",
"originalTitle": "Carmencita",
"isAdult": 0,
"startYear": "1894",
"endYear": "",
"runtimeMinutes": "1",
"genres": [
"Documentary",
"Short"
]
},{
"tconst": "tt0000002",
"titleType": "short",
"primaryTitle": "Le clown et ses chiens",
"originalTitle": "Le clown et ses chiens",
"isAdult": 0,
"startYear": "1892",
"endYear": "",
"runtimeMinutes": "5",
"genres": [
"Animation",
"Short"
]
}];
// create the document index
const document = await new Document({
worker: true,
encoder: Charset.LatinBalance,
document: {
id: "tconst",
store: true,
index: [{
field: "primaryTitle",
tokenize: "forward"
},{
field: "originalTitle",
tokenize: "forward"
}],
tag: [{
field: "startYear"
},{
field: "genres"
}]
}
});
// add test data
for(let i = 0; i < data.length; i++){
await document.addAsync(data[i]);
}
let resolver = new Resolver({
index: document,
query: "karmen or clown or nothing",
field: "primaryTitle",
suggest: true
});
expect(resolver).to.be.instanceof(Resolver);
expect(resolver.result).to.eql([]);
expect(resolver.await).to.be.instanceof(Promise);
let tmp = resolver.await;
resolver = resolver.resolve();
expect(resolver).to.be.instanceof(Promise);
expect(await resolver).to.have.members(["tt0000001", "tt0000002"]);
expect((await tmp)[0]).to.have.members(["tt0000001"]);
// -----------------------------------
resolver = new Resolver({
index: document,
async: true,
query: "karmen or clown or nothing",
field: "primaryTitle",
suggest: true
});
expect(resolver).to.be.instanceof(Resolver);
expect(resolver.result).to.eql([]);
expect(resolver.await).to.be.instanceof(Promise);
tmp = resolver.await;
resolver = resolver.resolve({ enrich: true });
expect(resolver).to.be.instanceof(Promise);
expect(await resolver).to.eql([{
id: data[0].tconst,
doc: data[0]
}, {
id: data[1].tconst,
doc: data[1]
}]);
expect((await tmp)[0]).to.have.members(["tt0000001"]);
// -----------------------------------
resolver = new Resolver({
index: document,
async: true,
query: "karmen or clown or nothing",
field: "primaryTitle",
suggest: true
}).or({
index: document,
queue: true,
query: "karmen or clown or nothing",
pluck: "primaryTitle",
suggest: true,
enrich: true,
resolve: true
});
expect(resolver).to.be.instanceof(Promise);
expect(await resolver).to.eql([{
id: data[0].tconst,
doc: data[0]
}, {
id: data[1].tconst,
doc: data[1]
}]);
// -----------------------------------
resolver = new Resolver({
index: document,
async: true,
query: "karmen or clown or nothing",
pluck: "primaryTitle",
suggest: true
});
expect(resolver).to.be.instanceof(Resolver);
expect(resolver.result).to.eql([]);
expect(resolver.await).to.be.instanceof(Promise);
resolver = resolver.resolve({
limit: 1,
offset: 1
});
expect(resolver).to.be.instanceof(Promise);
expect(await resolver).to.eql(["tt0000002"]);
// -----------------------------------
resolver = new Resolver({
index: document,
async: true,
query: "karmen",
pluck: "primaryTitle"
}).or({
queue: true,
cache: true,
query: "clown",
field: "originalTitle"
}).and({
async: true,
query: "not found",
pluck: "originalTitle",
suggest: true
});
expect(resolver).to.be.instanceof(Resolver);
resolver = resolver.resolve();
expect(resolver).to.be.instanceof(Promise);
expect(await resolver).to.eql(["tt0000001", "tt0000002"]);
// -----------------------------------
resolver = new Resolver({
index: document,
async: true,
cache: true,
query: "karmen",
pluck: "primaryTitle"
}).or({
and: [{
async: true,
cache: true,
query: "not found",
pluck: "originalTitle",
suggest: true
},{
queue: true,
cache: true,
query: "clown",
field: "originalTitle",
suggest: true
}]
}).resolve();
expect(resolver).to.be.instanceof(Promise);
expect(await resolver).to.eql(["tt0000001", "tt0000002"]);
});
});