chore: allow different partial keywords for multiple searches

src/data/search/index.ts

@@ -41,28 +41,6 @@ export function search(
 		return;
 	}
 
-	// Check for partial
-	const partial = keywords.partial;
-	let partialKeywords: string[] | undefined;
-	let isFirstKeywordExact = true;
-
-	if (partial) {
-		// Get all partial keyword matches
-		const cache = getPartialKeywords(partial, true, data);
-		const exists = data.keywords[partial];
-		if (!cache || !cache.length) {
-			// No partial matches: check if keyword exists
-			if (!exists) {
-				return;
-			}
-			partialKeywords = [partial];
-		} else {
-			// Partial keywords exist
-			isFirstKeywordExact = !!exists;
-			partialKeywords = exists ? [partial].concat(cache) : cache.slice(0);
-		}
-	}
-
 	// Get prefixes
 	const basePrefixes = filterSearchPrefixes(data, iconSets, fullParams);
 
@@ -92,35 +70,27 @@ export function search(
 	};
 	const limit = params.limit;
 
-	// Run all searches
-	const check = (isExact: boolean, partial?: string) => {
-		for (let searchIndex = 0; searchIndex < keywords.searches.length; searchIndex++) {
-			// Add prefixes cache to avoid re-calculating it for every partial keyword
 	interface ExtendedSearchKeywordsEntry extends SearchKeywordsEntry {
+		// Add prefixes cache to avoid re-calculating it for every partial keyword
 		filteredPrefixes?: Readonly<string[]>;
 	}
-			const search = keywords.searches[searchIndex] as ExtendedSearchKeywordsEntry;
+	const runSearch = (search: ExtendedSearchKeywordsEntry, isExact: boolean, partial?: string) => {
-
 		// Filter prefixes (or get it from cache)
 		let filteredPrefixes: Readonly<string[]>;
 		if (search.filteredPrefixes) {
 			filteredPrefixes = search.filteredPrefixes;
 		} else {
-				filteredPrefixes = search.prefixes
+			filteredPrefixes = search.prefixes ? filterSearchPrefixesList(basePrefixes, search.prefixes) : basePrefixes;
-					? filterSearchPrefixesList(basePrefixes, search.prefixes)
-					: basePrefixes;
 
 			// Filter by required keywords
 			for (let i = 0; i < search.keywords.length; i++) {
-					filteredPrefixes = filteredPrefixes.filter((prefix) =>
+				filteredPrefixes = filteredPrefixes.filter((prefix) => data.keywords[search.keywords[i]]?.has(prefix));
-						data.keywords[search.keywords[i]].has(prefix)
-					);
 			}
 
 			search.filteredPrefixes = filteredPrefixes;
 		}
 		if (!filteredPrefixes.length) {
-				continue;
+			return;
 		}
 
 		// Get keywords
@@ -129,7 +99,7 @@ export function search(
 
 		// Check for partial keyword if testing for exact match
 		if (partial) {
-				filteredPrefixes = filteredPrefixes.filter((prefix) => data.keywords[partial].has(prefix));
+			filteredPrefixes = filteredPrefixes.filter((prefix) => data.keywords[partial]?.has(prefix));
 		}
 
 		// Check icons
@@ -229,23 +199,53 @@ export function search(
 				}
 			}
 		}
+	};
+
+	const runAllSearches = (isExact: boolean) => {
+		for (let searchIndex = 0; searchIndex < keywords.searches.length; searchIndex++) {
+			const search = keywords.searches[searchIndex];
+			const partial = search.partial;
+			if (partial) {
+				// Has partial
+				if (isExact) {
+					if (data.keywords[partial]) {
+						runSearch(search, true, partial);
+					}
+				} else {
+					// Get all partial matches
+					const keywords = getPartialKeywords(partial, true, data);
+					if (keywords) {
+						for (let keywordIndex = 0; keywordIndex < keywords.length; keywordIndex++) {
+							runSearch(search, false, keywords[keywordIndex]);
+						}
+					}
+				}
+			} else {
+				// No partial for this search
+				if (!isExact) {
+					continue;
+				}
+
+				// Exact match
+				runSearch(search, true);
+			}
+
+			// Check limit
+			if (!isExact && allMatchesLength >= limit) {
+				return;
+			}
 		}
 	};
 
 	// Check all keywords
-	if (!partialKeywords) {
+	try {
-		check(true);
+		runAllSearches(true);
-	} else {
+		if (allMatchesLength < limit) {
-		let partial: string | undefined;
+			runAllSearches(false);
-		while ((partial = partialKeywords.shift())) {
-			check(isFirstKeywordExact, partial);
-			if (allMatchesLength >= limit) {
-				break;
-			}
-
-			// Next check will be for partial keyword
-			isFirstKeywordExact = false;
 		}
+	} catch (err) {
+		console.warn('Got exception when searching for:', params);
+		console.error(err);
 	}
 
 	// Generate results

src/data/search/split.ts

@@ -21,20 +21,15 @@ interface SplitResultItem {
 
 	// Strings to test icon name
 	test?: string[];
-}
 
-interface SplitResult {
+	// Partial keyword. It is last chunk of last keyword, which cannot be treated as prefix
-	searches: SplitResultItem[];
-
-	// Partial keyword. It is last chunk of last keyword, which cannot be treated
-	// as prefix, so it is identical to all searches
 	partial?: string;
 }
 
+type SplitResult = SplitResultItem[];
+
 export function splitKeywordEntries(values: string[], options: SplitOptions): SplitResult | undefined {
-	const results: SplitResult = {
+	const results: SplitResult = [];
-		searches: [],
-	};
 	let invalid = false;
 
 	// Split each entry into arrays
@@ -83,8 +78,14 @@ export function splitKeywordEntries(values: string[], options: SplitOptions): Sp
 		return (items[0].empty ? '-' : '') + items.map((item) => item.value).join('-');
 	}
 
+	interface ResultsSet {
+		keywords: Set<string>;
+		test: Set<string>;
+		partial?: string;
+	}
+
 	// Function to add item
-	function add(items: Entry[], keywords: Set<string>, test: Set<string>, checkPartial: boolean) {
+	function addToSet(items: Entry[], set: ResultsSet, allowPartial: boolean) {
 		let partial: string | undefined;
 
 		// Add keywords
@@ -92,10 +93,10 @@ export function splitKeywordEntries(values: string[], options: SplitOptions): Sp
 		for (let i = 0; i <= max; i++) {
 			const value = items[i];
 			if (!value.empty) {
-				if (i === max && checkPartial && value.value.length >= minPartialKeywordLength) {
+				if (i === max && allowPartial && value.value.length >= minPartialKeywordLength) {
 					partial = value.value;
 				} else {
-					keywords.add(value.value);
+					set.keywords.add(value.value);
 				}
 			}
 		}
@@ -103,21 +104,31 @@ export function splitKeywordEntries(values: string[], options: SplitOptions): Sp
 		// Get test value
 		const testValue = valuesToString(items);
 		if (testValue) {
-			test.add(testValue);
+			set.test.add(testValue);
 		}
 
-		// Validate partial
+		// Add partial
-		if (checkPartial) {
+		if (allowPartial && partial) {
-			if (results.searches.length) {
+			if (set.partial && set.partial !== partial) {
-				if (results.partial !== partial) {
+				console.error('Different partial keywords. This should not be happening!');
-					// Partial should be identical for all searches. Something went wrong !!!
-					console.error('Mismatches partials when splitting keywords:', values);
-					delete results.partial;
 			}
-			} else {
+			set.partial = partial;
-				results.partial = partial;
 		}
 	}
+
+	// Add results set to result
+	function addToResult(set: ResultsSet, prefix?: string) {
+		if (set.keywords.size || set.partial) {
+			const item: SplitResultItem = {
+				keywords: Array.from(set.keywords),
+				prefix,
+				partial: set.partial,
+			};
+			if (set.test.size) {
+				item.test = Array.from(set.test);
+			}
+			results.push(item);
+		}
 	}
 
 	// Add items
@@ -134,22 +145,14 @@ export function splitKeywordEntries(values: string[], options: SplitOptions): Sp
 				const prefix = firstItem.length > 1 ? valuesToString(firstItem) : firstItem[0].value;
 				if (prefix) {
 					// Valid prefix
-					const keywords: Set<string> = new Set();
+					const set: ResultsSet = {
-					const test: Set<string> = new Set();
+						keywords: new Set(),
-					for (let i = 1; i <= lastIndex; i++) {
+						test: new Set(),
-						add(splitValues[i], keywords, test, options.partial && i === lastIndex);
-					}
-
-					if (keywords.size || results.partial) {
-						const item: SplitResultItem = {
-							keywords: Array.from(keywords),
-							prefix,
 					};
-						if (test.size) {
+					for (let i = 1; i <= lastIndex; i++) {
-							item.test = Array.from(test);
+						addToSet(splitValues[i], set, options.partial && i === lastIndex);
-						}
-						results.searches.push(item);
 					}
+					addToResult(set, prefix);
 				}
 			}
 		}
@@ -159,41 +162,26 @@ export function splitKeywordEntries(values: string[], options: SplitOptions): Sp
 		if (maxFirstItemIndex && !firstItem[0].empty && !firstItem[1].empty) {
 			const modifiedFirstItem = firstItem.slice(0);
 			const prefix = modifiedFirstItem.shift()!.value;
-			const keywords: Set<string> = new Set();
+			const set: ResultsSet = {
-			const test: Set<string> = new Set();
+				keywords: new Set(),
-			for (let i = 0; i <= lastIndex; i++) {
+				test: new Set(),
-				add(i ? splitValues[i] : modifiedFirstItem, keywords, test, options.partial && i === lastIndex);
-			}
-
-			if (keywords.size || results.partial) {
-				const item: SplitResultItem = {
-					keywords: Array.from(keywords),
-					prefix,
 			};
-				if (test.size) {
+			for (let i = 0; i <= lastIndex; i++) {
-					item.test = Array.from(test);
+				addToSet(i ? splitValues[i] : modifiedFirstItem, set, options.partial && i === lastIndex);
-				}
-				results.searches.push(item);
 			}
+			addToResult(set, prefix);
 		}
 	}
 
 	// Add as is
-	const keywords: Set<string> = new Set();
+	const set: ResultsSet = {
-	const test: Set<string> = new Set();
+		keywords: new Set(),
-	for (let i = 0; i <= lastIndex; i++) {
+		test: new Set(),
-		add(splitValues[i], keywords, test, options.partial && i === lastIndex);
-	}
-	if (keywords.size || results.partial) {
-		// Add item
-		const item: SplitResultItem = {
-			keywords: Array.from(keywords),
 	};
-		if (test.size) {
+	for (let i = 0; i <= lastIndex; i++) {
-			item.test = Array.from(test);
+		addToSet(splitValues[i], set, options.partial && i === lastIndex);
-		}
-		results.searches.push(item);
 	}
+	addToResult(set);
 
 	// Merge values
 	if (splitValues.length > 1) {
@@ -233,22 +221,14 @@ export function splitKeywordEntries(values: string[], options: SplitOptions): Sp
 						...splitValues.slice(endIndex + 1),
 					];
 					const newLastIndex = newSplitValues.length - 1;
-					const keywords: Set<string> = new Set();
+					const set: ResultsSet = {
-					const test: Set<string> = new Set();
+						keywords: new Set(),
-					for (let i = 0; i <= newLastIndex; i++) {
+						test: new Set(),
-						add(newSplitValues[i], keywords, test, false);
-					}
-
-					if (keywords.size || results.partial) {
-						// Add item
-						const item: SplitResultItem = {
-							keywords: Array.from(keywords),
 					};
-						if (test.size) {
+					for (let i = 0; i <= newLastIndex; i++) {
-							item.test = Array.from(test);
+						addToSet(newSplitValues[i], set, options.partial && i === newLastIndex);
-						}
-						results.searches.push(item);
 					}
+					addToResult(set);
 				}
 			}
 		}
@@ -484,7 +464,7 @@ export function splitKeyword(keyword: string, allowPartial = true): SearchKeywor
 		return;
 	}
 
-	const searches: SearchKeywordsEntry[] = entries.searches.map((item) => {
+	const searches: SearchKeywordsEntry[] = entries.map((item) => {
 		return {
 			...item,
 			prefixes: item.prefix
@@ -505,6 +485,5 @@ export function splitKeyword(keyword: string, allowPartial = true): SearchKeywor
 	return {
 		searches,
 		params,
-		partial: entries.partial,
 	};
 }

src/types/search.ts

@@ -67,6 +67,9 @@ export interface SearchKeywordsEntry {
 
 	// Strings to test icon value
 	test?: string[];
+
+	// Partial keyword
+	partial?: string;
 }
 
 /**
@@ -76,9 +79,6 @@ export interface SearchKeywords {
 	// List of searches
 	searches: SearchKeywordsEntry[];
 
-	// Partial keyword, used in all matches
-	partial?: string;
-
 	// Params extracted from keywords
 	params: Partial<SearchParams>;
 }

tests/search/split-keyword-entry-test.ts

@@ -37,40 +37,34 @@ describe('Splitting keywords', () => {
 				prefix: false,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['home'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['home'], {
 				prefix: true,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['home'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['home'], {
 				prefix: true,
 				partial: true,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: [],
-				},
-			],
 				partial: 'home',
-		});
+			},
+		]);
 	});
 
 	test('Multiple simple entries', () => {
@@ -79,24 +73,21 @@ describe('Splitting keywords', () => {
 				prefix: false,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['mdi', 'home'],
 			},
 			{
 				keywords: ['mdihome'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi', 'home', 'outline'], {
 				prefix: false,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['mdi', 'home', 'outline'],
 			},
@@ -109,16 +100,14 @@ describe('Splitting keywords', () => {
 			{
 				keywords: ['mdi', 'homeoutline'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi', 'home'], {
 				prefix: true,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi',
 				keywords: ['home'],
@@ -129,29 +118,28 @@ describe('Splitting keywords', () => {
 			{
 				keywords: ['mdihome'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi', 'home'], {
 				prefix: true,
 				partial: true,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi',
 				keywords: [],
+				partial: 'home',
 			},
 			{
 				keywords: ['mdi'],
+				partial: 'home',
 			},
 			{
-					keywords: ['mdihome'],
+				keywords: [],
+				partial: 'mdihome',
 			},
-			],
+		]);
-			partial: 'home',
-		});
 	});
 
 	test('Incomplete prefix', () => {
@@ -160,22 +148,19 @@ describe('Splitting keywords', () => {
 				prefix: false,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['mdi', 'home'],
 				test: ['mdi-'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-', 'home'], {
 				prefix: true,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi-',
 				keywords: ['home'],
@@ -184,27 +169,25 @@ describe('Splitting keywords', () => {
 				keywords: ['mdi', 'home'],
 				test: ['mdi-'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-', 'home'], {
 				prefix: true,
 				partial: true,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi-',
 				keywords: [],
+				partial: 'home',
 			},
 			{
 				keywords: ['mdi'],
+				partial: 'home',
 				test: ['mdi-'],
 			},
-			],
+		]);
-			partial: 'home',
-		});
 	});
 
 	test('Long entry', () => {
@@ -213,22 +196,19 @@ describe('Splitting keywords', () => {
 				prefix: false,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['mdi', 'home', 'outline'],
 				test: ['mdi-home-outline'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-home-outline'], {
 				prefix: true,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi',
 				keywords: ['home', 'outline'],
@@ -238,28 +218,26 @@ describe('Splitting keywords', () => {
 				keywords: ['mdi', 'home', 'outline'],
 				test: ['mdi-home-outline'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-home-outline'], {
 				prefix: true,
 				partial: true,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi',
 				keywords: ['home'],
+				partial: 'outline',
 				test: ['home-outline'],
 			},
 			{
 				keywords: ['mdi', 'home'],
+				partial: 'outline',
 				test: ['mdi-home-outline'],
 			},
-			],
+		]);
-			partial: 'outline',
-		});
 	});
 
 	test('Complex entries', () => {
@@ -268,22 +246,19 @@ describe('Splitting keywords', () => {
 				prefix: false,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['mdi', 'light', 'arrow', 'left'],
 				test: ['mdi-light', 'arrow-left'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-light', 'arrow-left'], {
 				prefix: true,
 				partial: false,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi-light',
 				keywords: ['arrow', 'left'],
@@ -298,47 +273,44 @@ describe('Splitting keywords', () => {
 				keywords: ['mdi', 'light', 'arrow', 'left'],
 				test: ['mdi-light', 'arrow-left'],
 			},
-			],
+		]);
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-light', 'arrow-left'], {
 				prefix: false,
 				partial: true,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				keywords: ['mdi', 'light', 'arrow'],
+				partial: 'left',
 				test: ['mdi-light', 'arrow-left'],
 			},
-			],
+		]);
-			partial: 'left',
-		});
 
 		expect(
 			splitKeywordEntries(['mdi-light', 'arrow-left'], {
 				prefix: true,
 				partial: true,
 			})
-		).toEqual({
+		).toEqual([
-			searches: [
 			{
 				prefix: 'mdi-light',
 				keywords: ['arrow'],
+				partial: 'left',
 				test: ['arrow-left'],
 			},
 			{
 				prefix: 'mdi',
 				keywords: ['light', 'arrow'],
+				partial: 'left',
 				test: ['arrow-left'],
 			},
 			{
 				keywords: ['mdi', 'light', 'arrow'],
+				partial: 'left',
 				test: ['mdi-light', 'arrow-left'],
 			},
-			],
+		]);
-			partial: 'left',
-		});
 	});
 });

tests/search/split-keyword-test.ts

@@ -20,13 +20,14 @@ describe('Splitting keywords', () => {
 					prefixes: ['mdi'],
 					prefix: 'mdi', // leftover from internal function
 					keywords: [],
+					partial: 'home',
 				},
 				{
 					keywords: ['mdi'],
+					partial: 'home',
 					test: ['mdi-home'],
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('mdi-home', false)).toEqual({
@@ -50,9 +51,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['mdi'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('mdi:home', false)).toEqual({
@@ -71,9 +72,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['mdi'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('prefix:mdi home', false)).toEqual({
@@ -92,9 +93,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['mdi'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('prefix=mdi home', false)).toEqual({
@@ -113,9 +114,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['mdi'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('prefixes:mdi home', false)).toEqual({
@@ -134,9 +135,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['fa6-', 'mdi-'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('prefixes:fa6-,mdi- home', false)).toEqual({
@@ -155,9 +156,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['mdi', 'mdi-'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('prefixes=mdi* home', false)).toEqual({
@@ -177,18 +178,20 @@ describe('Splitting keywords', () => {
 					prefixes: ['mdi-light'],
 					prefix: 'mdi-light',
 					keywords: [],
+					partial: 'home',
 				},
 				{
 					prefixes: ['mdi'],
 					prefix: 'mdi',
 					keywords: ['light'],
+					partial: 'home',
 				},
 				{
 					keywords: ['mdi', 'light'],
 					test: ['mdi-light'],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 		expect(splitKeyword('mdi-light home', false)).toEqual({
@@ -218,20 +221,22 @@ describe('Splitting keywords', () => {
 					prefixes: ['mdi-light'],
 					prefix: 'mdi-light',
 					keywords: ['home'],
+					partial: 'outline',
 					test: ['home-outline'],
 				},
 				{
 					prefixes: ['mdi'],
 					prefix: 'mdi',
 					keywords: ['light', 'home'],
+					partial: 'outline',
 					test: ['home-outline'],
 				},
 				{
 					keywords: ['mdi', 'light', 'home'],
+					partial: 'outline',
 					test: ['mdi-light', 'home-outline'],
 				},
 			],
-			partial: 'outline',
 			params: {},
 		});
 		expect(splitKeyword('mdi-light home-outline', false)).toEqual({
@@ -262,9 +267,9 @@ describe('Splitting keywords', () => {
 			searches: [
 				{
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {
 				palette: true,
 			},
@@ -274,9 +279,9 @@ describe('Splitting keywords', () => {
 			searches: [
 				{
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {
 				palette: false,
 			},
@@ -287,9 +292,9 @@ describe('Splitting keywords', () => {
 				{
 					prefixes: ['mdi', 'mdi-', 'fa6-'],
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {},
 		});
 
@@ -309,9 +314,9 @@ describe('Splitting keywords', () => {
 			searches: [
 				{
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {
 				style: 'fill',
 			},
@@ -321,9 +326,9 @@ describe('Splitting keywords', () => {
 			searches: [
 				{
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {
 				style: 'stroke',
 			},
@@ -333,9 +338,9 @@ describe('Splitting keywords', () => {
 			searches: [
 				{
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {
 				style: 'fill',
 			},
@@ -345,9 +350,9 @@ describe('Splitting keywords', () => {
 			searches: [
 				{
 					keywords: [],
+					partial: 'home',
 				},
 			],
-			partial: 'home',
 			params: {
 				style: 'stroke',
 			},