@kyco-utils/search 0.0.0-stage → 0.0.0

package/README.md

@@ -1,3 +1,78 @@
-# Temporary Holding Version
+# @kyco-utils/search
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<!-- #region docs -->
+
+Dependency-free search that ignores case and accents, with highlighting.
+
+## Install
+
+```sh
+pnpm add @kyco-utils/search
+```
+
+## Usage
+
+### Filter a list
+
+```ts
+import { filterBySearch } from '@kyco-utils/search'
+
+const users = [
+  { name: 'Renée Smith', city: 'Paris' },
+  { name: 'John Smith', city: 'London' },
+  { name: 'Jane Doe', city: 'Paris' },
+]
+
+filterBySearch(users, 'smith paris', (user) => [user.name, user.city])
+// [{ name: 'Renée Smith', city: 'Paris' }]
+
+filterBySearch(users, 'renee', (user) => [user.name, user.city])
+// [{ name: 'Renée Smith', city: 'Paris' }]
+```
+
+Every query word must match one of the texts, in any order.
+
+### Match a single item
+
+```ts
+import { matchesSearch } from '@kyco-utils/search'
+
+matchesSearch(['John Doe', 'New York'], 'john') // true
+matchesSearch(['Jane Doe', 'Paris'], 'john') // false
+```
+
+### Highlight matches
+
+```ts
+import { getHighlightSegments } from '@kyco-utils/search'
+
+getHighlightSegments('Café Royal', 'caf')
+// [
+//   { text: 'Caf', isMatch: true, isInMatchedWord: true },
+//   { text: 'é', isMatch: false, isInMatchedWord: true },
+//   { text: ' Royal', isMatch: false, isInMatchedWord: false },
+// ]
+```
+
+Segments are plain text, so the query can't inject markup.
+
+## Options
+
+| Option                | Default | Description                                                                    |
+| --------------------- | ------- | ------------------------------------------------------------------------------ |
+| `ignoreDiacritics`    | `true`  | `é` matches `e`, `ü` matches `u`.                                              |
+| `matchFrom`           | `'any'` | `'any'` matches anywhere; `'wordStart'` only at the start of a word.           |
+| `germanNormalization` | `false` | Also match `ä`, `ö`, `ü` with `ae`, `oe`, `ue`, e.g. `mueller` finds `Müller`. |
+
+## Matching rules
+
+- Case is ignored, and `ß` matches `ss`.
+- The query is split into words on anything that isn't a letter or number.
+
+<!-- #endregion docs -->
+
+See the [API reference](https://kyco.github.io/kyco-utils/api/@kyco-utils/search) for all exports.
+
+## License
+
+[MIT](https://github.com/kyco/kyco-utils/blob/main/LICENSE)

package/dist/index.d.mts

@@ -0,0 +1,127 @@
+/** A text to search in. `null` and `undefined` never match. */
+export type SearchText = string | null | undefined;
+/** What to search for. A string is split into words; an array is treated as separate words. */
+export type SearchQuery = string | readonly string[];
+export type SearchOptions = {
+  /** Ignore diacritics, e.g. `é` ↔ `e`, `ä` ↔ `a`. Default `true`. */
+  ignoreDiacritics?: boolean;
+  /** Treat `ä`, `ö`, `ü` as `ae`, `oe`, `ue` (German spelling). Default `false`. */
+  germanNormalization?: boolean;
+  /** Where a query word may match: anywhere in the text (`'any'`), or only where a word starts (`'wordStart'`). Default `'any'`. */
+  matchFrom?: 'any' | 'wordStart';
+};
+/** A range in the original text. `end` is exclusive. */
+export type SearchMatchRange = {
+  start: number;
+  end: number;
+};
+/** A piece of text from {@link getHighlightSegments} or {@link splitByMatchRanges}. */
+export type HighlightSegment = {
+  text: string;
+  /** The exact matched letters. */
+  isMatch: boolean;
+  /** Inside a word that has a match, e.g. to highlight the whole word. */
+  isInMatchedWord: boolean;
+};
+/**
+ * Returns whether every word of the query matches in at least one of the texts, in any order. Case is always ignored.
+ * A query without words matches everything.
+ *
+ * @param texts - The texts to search in, e.g. several fields of one item.
+ * @param query - The search query.
+ * @param options - See {@link SearchOptions}.
+ * @returns `true` if every query word matches.
+ * @example
+ * ```ts
+ * import { matchesSearch } from '@kyco-utils/search'
+ *
+ * matchesSearch(['Renée Smith', 'Paris'], 'smith renee') // true
+ * matchesSearch(['Invoice'], 'voice', { matchFrom: 'wordStart' }) // false
+ * ```
+ */
+export declare const matchesSearch: (texts: readonly SearchText[], query: SearchQuery, options?: SearchOptions) => boolean;
+/**
+ * Returns the items where every word of the query matches in at least one of the item's texts (see
+ * {@link matchesSearch}), in their original order. For a query without words, returns `items` itself, not a copy.
+ *
+ * @param items - The items to filter.
+ * @param query - The search query.
+ * @param getTexts - Returns the texts to search in for an item.
+ * @param options - See {@link SearchOptions}.
+ * @returns The matching items.
+ * @example
+ * ```ts
+ * import { filterBySearch } from '@kyco-utils/search'
+ *
+ * const users = [
+ *   { name: 'Renée Smith', city: 'Paris' },
+ *   { name: 'John Smith', city: 'London' },
+ *   { name: 'Jane Doe', city: 'Paris' },
+ * ]
+ *
+ * filterBySearch(users, 'smith paris', (user) => [user.name, user.city])
+ * // [{ name: 'Renée Smith', city: 'Paris' }]
+ * ```
+ */
+export declare const filterBySearch: <T>(items: readonly T[], query: SearchQuery, getTexts: (item: T) => readonly SearchText[], options?: SearchOptions) => readonly T[];
+/**
+ * Returns the ranges of the original text matched by any query word, sorted and merged, for highlighting. Ranges always
+ * cover whole characters, e.g. the whole `ß` when only one `s` matched.
+ *
+ * @param text - The text to find matches in.
+ * @param query - The search query.
+ * @param options - See {@link SearchOptions}. Use the same options as for filtering.
+ * @returns The matched ranges, `end` exclusive. Empty for a query without words.
+ * @example
+ * ```ts
+ * import { findMatchRanges } from '@kyco-utils/search'
+ *
+ * findMatchRanges('Café Royal', 'cafe') // [{ start: 0, end: 4 }]
+ * findMatchRanges('Renée Smith', 'sm re') // [{ start: 0, end: 2 }, { start: 6, end: 8 }]
+ * ```
+ */
+export declare const findMatchRanges: (text: string, query: SearchQuery, options?: SearchOptions) => SearchMatchRange[];
+/**
+ * Splits a text into segments for highlighting: the matched letters (`isMatch`) and the words they're in
+ * (`isInMatchedWord`). Words are runs of letters, numbers and marks. The ranges are sorted and merged first, so any
+ * ranges work.
+ *
+ * @param text - The text to split.
+ * @param ranges - The ranges to mark, e.g. from {@link findMatchRanges}. For a query, use {@link getHighlightSegments}.
+ * @returns The segments, which joined give back `text`. Empty for an empty text.
+ * @example
+ * ```ts
+ * import { findMatchRanges, splitByMatchRanges } from '@kyco-utils/search'
+ *
+ * splitByMatchRanges('Invoice no', findMatchRanges('Invoice no', 'voi'))
+ * // [
+ * //   { text: 'In', isMatch: false, isInMatchedWord: true },
+ * //   { text: 'voi', isMatch: true, isInMatchedWord: true },
+ * //   { text: 'ce', isMatch: false, isInMatchedWord: true },
+ * //   { text: ' no', isMatch: false, isInMatchedWord: false },
+ * // ]
+ * ```
+ */
+export declare const splitByMatchRanges: (text: string, ranges: readonly SearchMatchRange[]) => HighlightSegment[];
+/**
+ * Splits a text into highlight segments for a query: shorthand for
+ * `splitByMatchRanges(text, findMatchRanges(text, query, options))`.
+ *
+ * @param text - The text to split.
+ * @param query - The search query.
+ * @param options - See {@link SearchOptions}. Use the same options as for filtering.
+ * @returns The segments, which joined give back `text`. Empty for an empty text.
+ * @example
+ * ```ts
+ * import { getHighlightSegments } from '@kyco-utils/search'
+ *
+ * getHighlightSegments('Café Royal', 'caf')
+ * // [
+ * //   { text: 'Caf', isMatch: true, isInMatchedWord: true },
+ * //   { text: 'é', isMatch: false, isInMatchedWord: true },
+ * //   { text: ' Royal', isMatch: false, isInMatchedWord: false },
+ * // ]
+ * ```
+ */
+export declare const getHighlightSegments: (text: string, query: SearchQuery, options?: SearchOptions) => HighlightSegment[];
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,306 @@
+// src/index.ts
+const NON_WORD_CHARS = /[^\p{L}\p{N}\p{M}]+/u;
+const WORD_CHAR_AT_END = /[\p{L}\p{N}\p{M}]$/u;
+const WORDS = /[\p{L}\p{N}\p{M}]+/gu;
+const UNITS = /\P{M}\p{M}*|\p{M}+/gu;
+const MARKS = /\p{M}/gu;
+const UMLAUTS = /[äöü]/g;
+const SPELL_OUT_TRIGGER = /[äöü]|ae|oe|ue/;
+const SPELLED_OUT = {
+	ä: "ae",
+	ö: "oe",
+	ü: "ue"
+};
+const MAX_TEXT_CACHE_SIZE = 1e5;
+const MAX_UNIT_CACHE_SIZE = 1e4;
+const modeIndex = ({ spellOut, stripMarks }) => (spellOut ? 2 : 0) + (stripMarks ? 1 : 0);
+const textCaches = [
+	/* @__PURE__ */ new Map(),
+	/* @__PURE__ */ new Map(),
+	/* @__PURE__ */ new Map(),
+	/* @__PURE__ */ new Map()
+];
+const unitCaches = [
+	/* @__PURE__ */ new Map(),
+	/* @__PURE__ */ new Map(),
+	/* @__PURE__ */ new Map(),
+	/* @__PURE__ */ new Map()
+];
+const isAscii = (text) => {
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) > 127) return false;
+	return true;
+};
+/** Folds one character with its combining marks: NFC, lowercase, `ß` → `ss`, optionally spell out umlauts and strip marks. */
+const foldUnit = (unit, mode) => {
+	const cache = unitCaches[modeIndex(mode)];
+	const cached = cache.get(unit);
+	if (cached !== void 0) return cached;
+	let folded = unit.normalize("NFC").toLowerCase().replaceAll("ß", "ss");
+	if (mode.spellOut) folded = folded.replace(UMLAUTS, (char) => SPELLED_OUT[char] ?? char);
+	if (mode.stripMarks) folded = folded.normalize("NFD").replace(MARKS, "");
+	if (cache.size >= MAX_UNIT_CACHE_SIZE) cache.clear();
+	cache.set(unit, folded);
+	return folded;
+};
+/**
+* Folds a text for matching. `starts[i]` and `ends[i]` are the range in the original text that folded char `i` came
+* from. A character with its combining marks is folded as one unit, so `a` + combining diaeresis folds like `ä`.
+*/
+const fold = (text, mode) => {
+	if (isAscii(text)) {
+		const starts = Array.from({ length: text.length }, (_, i) => i);
+		return {
+			folded: text.toLowerCase(),
+			starts,
+			ends: starts.map((i) => i + 1)
+		};
+	}
+	let folded = "";
+	const starts = [];
+	const ends = [];
+	for (const match of text.matchAll(UNITS)) {
+		const unit = match[0];
+		const foldedUnit = foldUnit(unit, mode);
+		folded += foldedUnit;
+		for (let i = 0; i < foldedUnit.length; i++) {
+			starts.push(match.index);
+			ends.push(match.index + unit.length);
+		}
+	}
+	return {
+		folded,
+		starts,
+		ends
+	};
+};
+/** The folded text only, cached per text and fold mode. */
+const foldCached = (text, mode) => {
+	if (isAscii(text)) return text.toLowerCase();
+	const cache = textCaches[modeIndex(mode)];
+	const cached = cache.get(text);
+	if (cached !== void 0) return cached;
+	const { folded } = fold(text, mode);
+	if (cache.size >= MAX_TEXT_CACHE_SIZE) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) cache.delete(oldest);
+	}
+	cache.set(text, folded);
+	return folded;
+};
+const getModes = (options) => {
+	const stripMarks = options?.ignoreDiacritics ?? true;
+	return {
+		plain: {
+			spellOut: false,
+			stripMarks
+		},
+		spelled: options?.germanNormalization ?? false ? {
+			spellOut: true,
+			stripMarks
+		} : null
+	};
+};
+const getQueryWords = (query, options) => {
+	const { plain, spelled } = getModes(options);
+	return (typeof query === "string" ? query : query.join(" ")).split(NON_WORD_CHARS).filter((word) => word !== "").map((word) => ({
+		plain: foldCached(word, plain),
+		spelled: spelled !== null && SPELL_OUT_TRIGGER.test(foldCached(word, {
+			spellOut: false,
+			stripMarks: false
+		})) ? foldCached(word, spelled) : null
+	}));
+};
+const isWordStartAt = (folded, index) => index === 0 || !WORD_CHAR_AT_END.test(folded.slice(Math.max(0, index - 2), index));
+/** Index of the next occurrence of `needle` at or after `from`, only at word starts if `wordStart`; `-1` if none. */
+const findFrom = (folded, needle, wordStart, from) => {
+	let index = folded.indexOf(needle, from);
+	while (index !== -1 && wordStart && !isWordStartAt(folded, index)) index = folded.indexOf(needle, index + 1);
+	return index;
+};
+const mergeRanges = (ranges, textLength) => {
+	const sorted = ranges.map(({ start, end }) => ({
+		start: Math.max(0, start),
+		end: Math.min(textLength, end)
+	})).filter(({ start, end }) => start < end).sort((a, b) => a.start - b.start || a.end - b.end);
+	const merged = [];
+	for (const range of sorted) {
+		const last = merged.at(-1);
+		if (last !== void 0 && range.start <= last.end) last.end = Math.max(last.end, range.end);
+		else merged.push(range);
+	}
+	return merged;
+};
+const matchesWords = (texts, words, options) => {
+	const { plain, spelled } = getModes(options);
+	const wordStart = options?.matchFrom === "wordStart";
+	return words.every((word) => texts.some((text) => {
+		if (text === null || text === void 0 || text === "") return false;
+		if (findFrom(foldCached(text, plain), word.plain, wordStart, 0) !== -1) return true;
+		return spelled !== null && word.spelled !== null && findFrom(foldCached(text, spelled), word.spelled, wordStart, 0) !== -1;
+	}));
+};
+/**
+* Returns whether every word of the query matches in at least one of the texts, in any order. Case is always ignored.
+* A query without words matches everything.
+*
+* @param texts - The texts to search in, e.g. several fields of one item.
+* @param query - The search query.
+* @param options - See {@link SearchOptions}.
+* @returns `true` if every query word matches.
+* @example
+* ```ts
+* import { matchesSearch } from '@kyco-utils/search'
+*
+* matchesSearch(['Renée Smith', 'Paris'], 'smith renee') // true
+* matchesSearch(['Invoice'], 'voice', { matchFrom: 'wordStart' }) // false
+* ```
+*/
+const matchesSearch = (texts, query, options) => matchesWords(texts, getQueryWords(query, options), options);
+/**
+* Returns the items where every word of the query matches in at least one of the item's texts (see
+* {@link matchesSearch}), in their original order. For a query without words, returns `items` itself, not a copy.
+*
+* @param items - The items to filter.
+* @param query - The search query.
+* @param getTexts - Returns the texts to search in for an item.
+* @param options - See {@link SearchOptions}.
+* @returns The matching items.
+* @example
+* ```ts
+* import { filterBySearch } from '@kyco-utils/search'
+*
+* const users = [
+*   { name: 'Renée Smith', city: 'Paris' },
+*   { name: 'John Smith', city: 'London' },
+*   { name: 'Jane Doe', city: 'Paris' },
+* ]
+*
+* filterBySearch(users, 'smith paris', (user) => [user.name, user.city])
+* // [{ name: 'Renée Smith', city: 'Paris' }]
+* ```
+*/
+const filterBySearch = (items, query, getTexts, options) => {
+	const words = getQueryWords(query, options);
+	if (words.length === 0) return items;
+	return items.filter((item) => matchesWords(getTexts(item), words, options));
+};
+/**
+* Returns the ranges of the original text matched by any query word, sorted and merged, for highlighting. Ranges always
+* cover whole characters, e.g. the whole `ß` when only one `s` matched.
+*
+* @param text - The text to find matches in.
+* @param query - The search query.
+* @param options - See {@link SearchOptions}. Use the same options as for filtering.
+* @returns The matched ranges, `end` exclusive. Empty for a query without words.
+* @example
+* ```ts
+* import { findMatchRanges } from '@kyco-utils/search'
+*
+* findMatchRanges('Café Royal', 'cafe') // [{ start: 0, end: 4 }]
+* findMatchRanges('Renée Smith', 'sm re') // [{ start: 0, end: 2 }, { start: 6, end: 8 }]
+* ```
+*/
+const findMatchRanges = (text, query, options) => {
+	const words = getQueryWords(query, options);
+	if (words.length === 0 || text === "") return [];
+	const { plain, spelled } = getModes(options);
+	const wordStart = options?.matchFrom === "wordStart";
+	const ranges = [];
+	let plainFolded;
+	let spelledFolded;
+	const collect = ({ folded, starts, ends }, needle) => {
+		if (needle === "") return;
+		for (let index = findFrom(folded, needle, wordStart, 0); index !== -1;) {
+			ranges.push({
+				start: starts[index] ?? 0,
+				end: ends[index + needle.length - 1] ?? text.length
+			});
+			index = findFrom(folded, needle, wordStart, index + 1);
+		}
+	};
+	for (const word of words) {
+		plainFolded ??= fold(text, plain);
+		collect(plainFolded, word.plain);
+		if (spelled !== null && word.spelled !== null) {
+			spelledFolded ??= fold(text, spelled);
+			collect(spelledFolded, word.spelled);
+		}
+	}
+	return mergeRanges(ranges, text.length);
+};
+/**
+* Splits a text into segments for highlighting: the matched letters (`isMatch`) and the words they're in
+* (`isInMatchedWord`). Words are runs of letters, numbers and marks. The ranges are sorted and merged first, so any
+* ranges work.
+*
+* @param text - The text to split.
+* @param ranges - The ranges to mark, e.g. from {@link findMatchRanges}. For a query, use {@link getHighlightSegments}.
+* @returns The segments, which joined give back `text`. Empty for an empty text.
+* @example
+* ```ts
+* import { findMatchRanges, splitByMatchRanges } from '@kyco-utils/search'
+*
+* splitByMatchRanges('Invoice no', findMatchRanges('Invoice no', 'voi'))
+* // [
+* //   { text: 'In', isMatch: false, isInMatchedWord: true },
+* //   { text: 'voi', isMatch: true, isInMatchedWord: true },
+* //   { text: 'ce', isMatch: false, isInMatchedWord: true },
+* //   { text: ' no', isMatch: false, isInMatchedWord: false },
+* // ]
+* ```
+*/
+const splitByMatchRanges = (text, ranges) => {
+	if (text === "") return [];
+	const matches = mergeRanges(ranges, text.length);
+	const overlaps = (a, b) => a.start < b.end && b.start < a.end;
+	const matchedWords = Array.from(text.matchAll(WORDS), (match) => ({
+		start: match.index,
+		end: match.index + match[0].length
+	})).filter((word) => matches.some((match) => overlaps(word, match)));
+	const boundaries = [.../* @__PURE__ */ new Set([
+		0,
+		text.length,
+		...[...matches, ...matchedWords].flatMap(({ start, end }) => [start, end])
+	])].sort((a, b) => a - b);
+	const segments = [];
+	for (let i = 0; i < boundaries.length - 1; i++) {
+		const piece = {
+			start: boundaries[i] ?? 0,
+			end: boundaries[i + 1] ?? text.length
+		};
+		const isMatch = matches.some((match) => overlaps(piece, match));
+		const isInMatchedWord = matchedWords.some((word) => overlaps(piece, word));
+		const last = segments.at(-1);
+		if (last !== void 0 && last.isMatch === isMatch && last.isInMatchedWord === isInMatchedWord) last.text += text.slice(piece.start, piece.end);
+		else segments.push({
+			text: text.slice(piece.start, piece.end),
+			isMatch,
+			isInMatchedWord
+		});
+	}
+	return segments;
+};
+/**
+* Splits a text into highlight segments for a query: shorthand for
+* `splitByMatchRanges(text, findMatchRanges(text, query, options))`.
+*
+* @param text - The text to split.
+* @param query - The search query.
+* @param options - See {@link SearchOptions}. Use the same options as for filtering.
+* @returns The segments, which joined give back `text`. Empty for an empty text.
+* @example
+* ```ts
+* import { getHighlightSegments } from '@kyco-utils/search'
+*
+* getHighlightSegments('Café Royal', 'caf')
+* // [
+* //   { text: 'Caf', isMatch: true, isInMatchedWord: true },
+* //   { text: 'é', isMatch: false, isInMatchedWord: true },
+* //   { text: ' Royal', isMatch: false, isInMatchedWord: false },
+* // ]
+* ```
+*/
+const getHighlightSegments = (text, query, options) => splitByMatchRanges(text, findMatchRanges(text, query, options));
+export { filterBySearch, findMatchRanges, getHighlightSegments, matchesSearch, splitByMatchRanges };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/** A text to search in. `null` and `undefined` never match. */\nexport type SearchText = string | null | undefined\n\n/** What to search for. A string is split into words; an array is treated as separate words. */\nexport type SearchQuery = string | readonly string[]\n\nexport type SearchOptions = {\n  /** Ignore diacritics, e.g. `é` ↔ `e`, `ä` ↔ `a`. Default `true`. */\n  ignoreDiacritics?: boolean\n  /** Treat `ä`, `ö`, `ü` as `ae`, `oe`, `ue` (German spelling). Default `false`. */\n  germanNormalization?: boolean\n  /** Where a query word may match: anywhere in the text (`'any'`), or only where a word starts (`'wordStart'`). Default `'any'`. */\n  matchFrom?: 'any' | 'wordStart'\n}\n\n/** A range in the original text. `end` is exclusive. */\nexport type SearchMatchRange = { start: number; end: number }\n\n/** A piece of text from {@link getHighlightSegments} or {@link splitByMatchRanges}. */\nexport type HighlightSegment = {\n  text: string\n  /** The exact matched letters. */\n  isMatch: boolean\n  /** Inside a word that has a match, e.g. to highlight the whole word. */\n  isInMatchedWord: boolean\n}\n\ntype FoldMode = { spellOut: boolean; stripMarks: boolean }\ntype Folded = { folded: string; starts: number[]; ends: number[] }\ntype QueryWord = { plain: string; spelled: string | null }\n\nconst NON_WORD_CHARS = /[^\\p{L}\\p{N}\\p{M}]+/u\nconst WORD_CHAR_AT_END = /[\\p{L}\\p{N}\\p{M}]$/u\nconst WORDS = /[\\p{L}\\p{N}\\p{M}]+/gu\nconst UNITS = /\\P{M}\\p{M}*|\\p{M}+/gu\nconst MARKS = /\\p{M}/gu\nconst UMLAUTS = /[äöü]/g\nconst SPELL_OUT_TRIGGER = /[äöü]|ae|oe|ue/\nconst SPELLED_OUT: Record<string, string> = { ä: 'ae', ö: 'oe', ü: 'ue' }\n\nconst MAX_TEXT_CACHE_SIZE = 100_000\nconst MAX_UNIT_CACHE_SIZE = 10_000\n\nconst modeIndex = ({ spellOut, stripMarks }: FoldMode): number => (spellOut ? 2 : 0) + (stripMarks ? 1 : 0)\nconst textCaches: Map<string, string>[] = [new Map(), new Map(), new Map(), new Map()]\nconst unitCaches: Map<string, string>[] = [new Map(), new Map(), new Map(), new Map()]\n\nconst isAscii = (text: string): boolean => {\n  for (let i = 0; i < text.length; i++) {\n    if (text.charCodeAt(i) > 127) return false\n  }\n  return true\n}\n\n/** Folds one character with its combining marks: NFC, lowercase, `ß` → `ss`, optionally spell out umlauts and strip marks. */\nconst foldUnit = (unit: string, mode: FoldMode): string => {\n  const cache = unitCaches[modeIndex(mode)] as Map<string, string>\n  const cached = cache.get(unit)\n  if (cached !== undefined) return cached\n\n  let folded = unit.normalize('NFC').toLowerCase().replaceAll('ß', 'ss')\n  if (mode.spellOut) folded = folded.replace(UMLAUTS, (char) => SPELLED_OUT[char] ?? char)\n  if (mode.stripMarks) folded = folded.normalize('NFD').replace(MARKS, '')\n\n  if (cache.size >= MAX_UNIT_CACHE_SIZE) cache.clear()\n  cache.set(unit, folded)\n  return folded\n}\n\n/**\n * Folds a text for matching. `starts[i]` and `ends[i]` are the range in the original text that folded char `i` came\n * from. A character with its combining marks is folded as one unit, so `a` + combining diaeresis folds like `ä`.\n */\nconst fold = (text: string, mode: FoldMode): Folded => {\n  if (isAscii(text)) {\n    const starts = Array.from({ length: text.length }, (_, i) => i)\n    return { folded: text.toLowerCase(), starts, ends: starts.map((i) => i + 1) }\n  }\n\n  let folded = ''\n  const starts: number[] = []\n  const ends: number[] = []\n  for (const match of text.matchAll(UNITS)) {\n    const unit = match[0]\n    const foldedUnit = foldUnit(unit, mode)\n    folded += foldedUnit\n    for (let i = 0; i < foldedUnit.length; i++) {\n      starts.push(match.index)\n      ends.push(match.index + unit.length)\n    }\n  }\n  return { folded, starts, ends }\n}\n\n/** The folded text only, cached per text and fold mode. */\nconst foldCached = (text: string, mode: FoldMode): string => {\n  if (isAscii(text)) return text.toLowerCase()\n\n  const cache = textCaches[modeIndex(mode)] as Map<string, string>\n  const cached = cache.get(text)\n  if (cached !== undefined) return cached\n\n  const { folded } = fold(text, mode)\n  if (cache.size >= MAX_TEXT_CACHE_SIZE) {\n    const oldest = cache.keys().next().value\n    if (oldest !== undefined) cache.delete(oldest)\n  }\n  cache.set(text, folded)\n  return folded\n}\n\nconst getModes = (options: SearchOptions | undefined): { plain: FoldMode; spelled: FoldMode | null } => {\n  const stripMarks = options?.ignoreDiacritics ?? true\n  return {\n    plain: { spellOut: false, stripMarks },\n    spelled: (options?.germanNormalization ?? false) ? { spellOut: true, stripMarks } : null,\n  }\n}\n\nconst getQueryWords = (query: SearchQuery, options: SearchOptions | undefined): QueryWord[] => {\n  const { plain, spelled } = getModes(options)\n  const joined = typeof query === 'string' ? query : query.join(' ')\n  return joined\n    .split(NON_WORD_CHARS)\n    .filter((word) => word !== '')\n    .map((word) => ({\n      plain: foldCached(word, plain),\n      // Spelling out can only add a meaningful match for words with an umlaut or its spelled-out form.\n      spelled:\n        spelled !== null && SPELL_OUT_TRIGGER.test(foldCached(word, { spellOut: false, stripMarks: false }))\n          ? foldCached(word, spelled)\n          : null,\n    }))\n}\n\nconst isWordStartAt = (folded: string, index: number): boolean =>\n  index === 0 || !WORD_CHAR_AT_END.test(folded.slice(Math.max(0, index - 2), index))\n\n/** Index of the next occurrence of `needle` at or after `from`, only at word starts if `wordStart`; `-1` if none. */\nconst findFrom = (folded: string, needle: string, wordStart: boolean, from: number): number => {\n  let index = folded.indexOf(needle, from)\n  while (index !== -1 && wordStart && !isWordStartAt(folded, index)) {\n    index = folded.indexOf(needle, index + 1)\n  }\n  return index\n}\n\nconst mergeRanges = (ranges: readonly SearchMatchRange[], textLength: number): SearchMatchRange[] => {\n  const sorted = ranges\n    .map(({ start, end }) => ({ start: Math.max(0, start), end: Math.min(textLength, end) }))\n    .filter(({ start, end }) => start < end)\n    .sort((a, b) => a.start - b.start || a.end - b.end)\n\n  const merged: SearchMatchRange[] = []\n  for (const range of sorted) {\n    const last = merged.at(-1)\n    if (last !== undefined && range.start <= last.end) {\n      last.end = Math.max(last.end, range.end)\n    } else {\n      merged.push(range)\n    }\n  }\n  return merged\n}\n\nconst matchesWords = (texts: readonly SearchText[], words: readonly QueryWord[], options?: SearchOptions): boolean => {\n  const { plain, spelled } = getModes(options)\n  const wordStart = options?.matchFrom === 'wordStart'\n\n  return words.every((word) =>\n    texts.some((text) => {\n      if (text === null || text === undefined || text === '') return false\n      if (findFrom(foldCached(text, plain), word.plain, wordStart, 0) !== -1) return true\n      return (\n        spelled !== null &&\n        word.spelled !== null &&\n        findFrom(foldCached(text, spelled), word.spelled, wordStart, 0) !== -1\n      )\n    }),\n  )\n}\n\n/**\n * Returns whether every word of the query matches in at least one of the texts, in any order. Case is always ignored.\n * A query without words matches everything.\n *\n * @param texts - The texts to search in, e.g. several fields of one item.\n * @param query - The search query.\n * @param options - See {@link SearchOptions}.\n * @returns `true` if every query word matches.\n * @example\n * ```ts\n * import { matchesSearch } from '@kyco-utils/search'\n *\n * matchesSearch(['Renée Smith', 'Paris'], 'smith renee') // true\n * matchesSearch(['Invoice'], 'voice', { matchFrom: 'wordStart' }) // false\n * ```\n */\nexport const matchesSearch = (texts: readonly SearchText[], query: SearchQuery, options?: SearchOptions): boolean =>\n  matchesWords(texts, getQueryWords(query, options), options)\n\n/**\n * Returns the items where every word of the query matches in at least one of the item's texts (see\n * {@link matchesSearch}), in their original order. For a query without words, returns `items` itself, not a copy.\n *\n * @param items - The items to filter.\n * @param query - The search query.\n * @param getTexts - Returns the texts to search in for an item.\n * @param options - See {@link SearchOptions}.\n * @returns The matching items.\n * @example\n * ```ts\n * import { filterBySearch } from '@kyco-utils/search'\n *\n * const users = [\n *   { name: 'Renée Smith', city: 'Paris' },\n *   { name: 'John Smith', city: 'London' },\n *   { name: 'Jane Doe', city: 'Paris' },\n * ]\n *\n * filterBySearch(users, 'smith paris', (user) => [user.name, user.city])\n * // [{ name: 'Renée Smith', city: 'Paris' }]\n * ```\n */\nexport const filterBySearch = <T>(\n  items: readonly T[],\n  query: SearchQuery,\n  getTexts: (item: T) => readonly SearchText[],\n  options?: SearchOptions,\n): readonly T[] => {\n  const words = getQueryWords(query, options)\n  if (words.length === 0) return items\n  return items.filter((item) => matchesWords(getTexts(item), words, options))\n}\n\n/**\n * Returns the ranges of the original text matched by any query word, sorted and merged, for highlighting. Ranges always\n * cover whole characters, e.g. the whole `ß` when only one `s` matched.\n *\n * @param text - The text to find matches in.\n * @param query - The search query.\n * @param options - See {@link SearchOptions}. Use the same options as for filtering.\n * @returns The matched ranges, `end` exclusive. Empty for a query without words.\n * @example\n * ```ts\n * import { findMatchRanges } from '@kyco-utils/search'\n *\n * findMatchRanges('Café Royal', 'cafe') // [{ start: 0, end: 4 }]\n * findMatchRanges('Renée Smith', 'sm re') // [{ start: 0, end: 2 }, { start: 6, end: 8 }]\n * ```\n */\nexport const findMatchRanges = (text: string, query: SearchQuery, options?: SearchOptions): SearchMatchRange[] => {\n  const words = getQueryWords(query, options)\n  if (words.length === 0 || text === '') return []\n\n  const { plain, spelled } = getModes(options)\n  const wordStart = options?.matchFrom === 'wordStart'\n  const ranges: SearchMatchRange[] = []\n  let plainFolded: Folded | undefined\n  let spelledFolded: Folded | undefined\n\n  const collect = ({ folded, starts, ends }: Folded, needle: string) => {\n    if (needle === '') return\n    for (let index = findFrom(folded, needle, wordStart, 0); index !== -1; ) {\n      ranges.push({ start: starts[index] ?? 0, end: ends[index + needle.length - 1] ?? text.length })\n      index = findFrom(folded, needle, wordStart, index + 1)\n    }\n  }\n\n  for (const word of words) {\n    plainFolded ??= fold(text, plain)\n    collect(plainFolded, word.plain)\n    if (spelled !== null && word.spelled !== null) {\n      spelledFolded ??= fold(text, spelled)\n      collect(spelledFolded, word.spelled)\n    }\n  }\n\n  return mergeRanges(ranges, text.length)\n}\n\n/**\n * Splits a text into segments for highlighting: the matched letters (`isMatch`) and the words they're in\n * (`isInMatchedWord`). Words are runs of letters, numbers and marks. The ranges are sorted and merged first, so any\n * ranges work.\n *\n * @param text - The text to split.\n * @param ranges - The ranges to mark, e.g. from {@link findMatchRanges}. For a query, use {@link getHighlightSegments}.\n * @returns The segments, which joined give back `text`. Empty for an empty text.\n * @example\n * ```ts\n * import { findMatchRanges, splitByMatchRanges } from '@kyco-utils/search'\n *\n * splitByMatchRanges('Invoice no', findMatchRanges('Invoice no', 'voi'))\n * // [\n * //   { text: 'In', isMatch: false, isInMatchedWord: true },\n * //   { text: 'voi', isMatch: true, isInMatchedWord: true },\n * //   { text: 'ce', isMatch: false, isInMatchedWord: true },\n * //   { text: ' no', isMatch: false, isInMatchedWord: false },\n * // ]\n * ```\n */\nexport const splitByMatchRanges = (text: string, ranges: readonly SearchMatchRange[]): HighlightSegment[] => {\n  if (text === '') return []\n\n  const matches = mergeRanges(ranges, text.length)\n  const overlaps = (a: SearchMatchRange, b: SearchMatchRange) => a.start < b.end && b.start < a.end\n  const matchedWords = Array.from(text.matchAll(WORDS), (match) => ({\n    start: match.index,\n    end: match.index + match[0].length,\n  })).filter((word) => matches.some((match) => overlaps(word, match)))\n\n  const boundaries = [\n    ...new Set([0, text.length, ...[...matches, ...matchedWords].flatMap(({ start, end }) => [start, end])]),\n  ].sort((a, b) => a - b)\n\n  const segments: HighlightSegment[] = []\n  for (let i = 0; i < boundaries.length - 1; i++) {\n    const piece = { start: boundaries[i] ?? 0, end: boundaries[i + 1] ?? text.length }\n    const isMatch = matches.some((match) => overlaps(piece, match))\n    const isInMatchedWord = matchedWords.some((word) => overlaps(piece, word))\n    const last = segments.at(-1)\n    if (last !== undefined && last.isMatch === isMatch && last.isInMatchedWord === isInMatchedWord) {\n      last.text += text.slice(piece.start, piece.end)\n    } else {\n      segments.push({ text: text.slice(piece.start, piece.end), isMatch, isInMatchedWord })\n    }\n  }\n  return segments\n}\n\n/**\n * Splits a text into highlight segments for a query: shorthand for\n * `splitByMatchRanges(text, findMatchRanges(text, query, options))`.\n *\n * @param text - The text to split.\n * @param query - The search query.\n * @param options - See {@link SearchOptions}. Use the same options as for filtering.\n * @returns The segments, which joined give back `text`. Empty for an empty text.\n * @example\n * ```ts\n * import { getHighlightSegments } from '@kyco-utils/search'\n *\n * getHighlightSegments('Café Royal', 'caf')\n * // [\n * //   { text: 'Caf', isMatch: true, isInMatchedWord: true },\n * //   { text: 'é', isMatch: false, isInMatchedWord: true },\n * //   { text: ' Royal', isMatch: false, isInMatchedWord: false },\n * // ]\n * ```\n */\nexport const getHighlightSegments = (text: string, query: SearchQuery, options?: SearchOptions): HighlightSegment[] =>\n  splitByMatchRanges(text, findMatchRanges(text, query, options))\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@kyco-utils/search",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.0",
+  "description": "Dependency-free word search with diacritic folding and highlight ranges.",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kyco/kyco-utils.git",
+    "directory": "packages/search"
+  },
+  "homepage": "https://github.com/kyco/kyco-utils/tree/main/packages/search",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "@kyco-utils/source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}