@oneuptime/common 14.0.11 → 14.0.12

package/build/dist/UI/Components/Workflow/ComponentPicker/ComponentSearch.js

@@ -0,0 +1,864 @@
+import ComponentID from "../../../../Types/Workflow/ComponentID";
+import { DatabaseOperation } from "../../../../Types/Workflow/DatabaseOperation";
+import { getComponentOperation, getOperationRank, isResourceComponent, } from "./PickerCatalog";
+/*
+ * Search for the Add Component and Add Trigger pickers. Pure and React-free,
+ * so the ranking can be tested on its own and over the real catalog.
+ *
+ * What it has to get right, in the words of the people using it:
+ *
+ *   - Every word typed counts, in any order and any field. "create monitor"
+ *     finds "Create One Monitor" although that is not a substring of it.
+ *   - The resource you named comes first. "incident" lists Incident's steps
+ *     before Incident State's, and "create incident" puts Create One Incident
+ *     first. The old picker drew its results group by group in the order the
+ *     models are registered, which put Incident State above Incident whatever
+ *     the scores said.
+ *   - Plurals, a typo, and the words people actually use: "incidents",
+ *     "incidnet", "add note", "http request", "wait".
+ *   - It is fast. The index is built once per catalog; a search scans a few
+ *     thousand distinct words and then scores each step against them, a few
+ *     milliseconds over the full catalog of about two thousand steps.
+ */
+// How a typed word matched a word of the catalog, best first.
+export var WordMatchKind;
+(function (WordMatchKind) {
+    WordMatchKind["Exact"] = "Exact";
+    // The same word in another number: "incidents" and "incident".
+    WordMatchKind["Variant"] = "Variant";
+    // What has been typed so far of a longer word: "inc" and "incident".
+    WordMatchKind["Prefix"] = "Prefix";
+    // Inside a longer word: "script" in "javascript".
+    WordMatchKind["Substring"] = "Substring";
+    // A typo, tried only for a word that matches nothing otherwise.
+    WordMatchKind["Fuzzy"] = "Fuzzy";
+})(WordMatchKind || (WordMatchKind = {}));
+export const WORD_MATCH_QUALITY = {
+    [WordMatchKind.Exact]: 1,
+    [WordMatchKind.Variant]: 0.95,
+    [WordMatchKind.Prefix]: 0.8,
+    [WordMatchKind.Fuzzy]: 0.6,
+    [WordMatchKind.Substring]: 0.45,
+};
+// Where in a step a word was found, and how much a match there counts.
+export var SearchField;
+(function (SearchField) {
+    SearchField["Title"] = "Title";
+    SearchField["Resource"] = "Resource";
+    SearchField["Category"] = "Category";
+    SearchField["Keyword"] = "Keyword";
+    SearchField["Description"] = "Description";
+})(SearchField || (SearchField = {}));
+export const SEARCH_FIELD_WEIGHT = {
+    [SearchField.Title]: 1,
+    [SearchField.Resource]: 1,
+    [SearchField.Category]: 0.7,
+    [SearchField.Keyword]: 0.7,
+    [SearchField.Description]: 0.35,
+};
+/*
+ * How a step that matched every word ranks, best first. Within a tier the
+ * score decides.
+ */
+export var SearchTier;
+(function (SearchTier) {
+    // The search is the step's whole title: "log", "if else".
+    SearchTier[SearchTier["ExactTitle"] = 0] = "ExactTitle";
+    /*
+     * Every word landed in the step's name, resource, category or keywords,
+     * and the step is hand-written or the resource is the one named in full:
+     * "incident" for Incident's steps, not for Incident State's.
+     */
+    SearchTier[SearchTier["Named"] = 1] = "Named";
+    // Every word landed in the step's name, resource, category or keywords.
+    SearchTier[SearchTier["Related"] = 2] = "Related";
+    // Some word was found only in the description.
+    SearchTier[SearchTier["Mentioned"] = 3] = "Mentioned";
+})(SearchTier || (SearchTier = {}));
+const SCORE_PER_WORD = 100;
+const BUILT_IN_BONUS = 30;
+const POPULAR_BONUS = 20;
+const COMMON_RESOURCE_BONUS = 30;
+// For each word of a resource's name the search did not mention.
+const UNNAMED_RESOURCE_WORD_PENALTY = 25;
+const MIN_SUBSTRING_LENGTH = 3;
+const MIN_FUZZY_LENGTH = 4;
+// A pasted sentence is still a search, just a bounded one.
+const MAX_SEARCH_WORDS = 8;
+/*
+ * Words that say nothing about which step is meant: "send a message to
+ * slack", "when an incident is created". Dropped from a search unless they
+ * are all it holds. "on" is not one of them: it is half of "on-call", and
+ * every generated trigger starts with it.
+ */
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "for",
+    "from",
+    "in",
+    "into",
+    "is",
+    "it",
+    "my",
+    "of",
+    "the",
+    "then",
+    "to",
+    "when",
+    "with",
+]);
+/*
+ * The words people type for a step that are not in its name. Kept to words
+ * that mean that step and nothing else here: "create" on API Post would put
+ * it above every Create One step.
+ */
+const HTTP_KEYWORDS = [
+    "http",
+    "https",
+    "rest",
+    "request",
+    "call",
+    "url",
+    "endpoint",
+    "integration",
+];
+const MESSAGE_KEYWORDS = [
+    "message",
+    "chat",
+    "notify",
+    "notification",
+    "channel",
+];
+export const COMPONENT_KEYWORDS = {
+    [ComponentID.Log]: ["print", "console", "debug", "output", "write"],
+    [ComponentID.IfElse]: [
+        "condition",
+        "conditional",
+        "branch",
+        "compare",
+        "comparison",
+        "check",
+        "filter",
+        "switch",
+    ],
+    [ComponentID.ApiGet]: [...HTTP_KEYWORDS, "fetch", "read", "download"],
+    [ComponentID.ApiPost]: [...HTTP_KEYWORDS, "webhook", "send", "submit"],
+    [ComponentID.ApiPut]: [...HTTP_KEYWORDS, "replace"],
+    [ComponentID.ApiPatch]: [...HTTP_KEYWORDS, "modify"],
+    [ComponentID.ApiDelete]: [...HTTP_KEYWORDS, "remove"],
+    [ComponentID.SlackSendMessageToChannel]: [...MESSAGE_KEYWORDS, "post"],
+    [ComponentID.MicrosoftTeamsSendMessageToChannel]: [
+        ...MESSAGE_KEYWORDS,
+        "microsoft",
+        "msteams",
+    ],
+    [ComponentID.DiscordSendMessageToChannel]: [...MESSAGE_KEYWORDS],
+    [ComponentID.TelegramSendMessageToChat]: [...MESSAGE_KEYWORDS, "bot"],
+    [ComponentID.SendEmail]: [
+        "mail",
+        "smtp",
+        "inbox",
+        "notify",
+        "notification",
+        "message",
+    ],
+    [ComponentID.JavaScriptCode]: [
+        "code",
+        "script",
+        "js",
+        "javascript",
+        "function",
+        "transform",
+        "program",
+    ],
+    [ComponentID.JsonToText]: ["stringify", "serialize", "convert", "string"],
+    [ComponentID.TextToJson]: ["parse", "deserialize", "convert", "string"],
+    [ComponentID.MergeJson]: ["combine", "join", "object"],
+    [ComponentID.Sleep]: ["wait", "delay", "pause", "timer", "later"],
+    [ComponentID.WorkflowRun]: [
+        "run",
+        "call",
+        "start",
+        "trigger",
+        "invoke",
+        "subworkflow",
+        "another",
+        "chain",
+    ],
+    [ComponentID.AIGenerateText]: [
+        "llm",
+        "gpt",
+        "chatgpt",
+        "openai",
+        "anthropic",
+        "claude",
+        "prompt",
+        "summarize",
+        "summary",
+        "write",
+    ],
+    [ComponentID.Schedule]: [
+        "cron",
+        "interval",
+        "every",
+        "recurring",
+        "periodic",
+        "timer",
+        "hourly",
+        "daily",
+        "weekly",
+        "time",
+    ],
+    [ComponentID.Webhook]: [
+        "http",
+        "url",
+        "incoming",
+        "receive",
+        "callback",
+        "endpoint",
+        "request",
+        "api",
+    ],
+    [ComponentID.Manual]: ["button", "run", "now", "test", "hand", "demand"],
+    [ComponentID.IncomingEmail]: [
+        "mail",
+        "inbox",
+        "inbound",
+        "incoming",
+        "receive",
+        "forward",
+        "smtp",
+        "message",
+    ],
+};
+const MANY_KEYWORDS = [
+    "all",
+    "bulk",
+    "multiple",
+    "several",
+];
+export const OPERATION_KEYWORDS = {
+    [DatabaseOperation.CreateOne]: [
+        "add",
+        "new",
+        "insert",
+        "make",
+        "open",
+        "raise",
+        "declare",
+    ],
+    [DatabaseOperation.CreateMany]: [
+        "add",
+        "new",
+        "insert",
+        "make",
+        ...MANY_KEYWORDS,
+    ],
+    [DatabaseOperation.FindOne]: [
+        "get",
+        "read",
+        "fetch",
+        "search",
+        "query",
+        "lookup",
+        "load",
+        "retrieve",
+    ],
+    [DatabaseOperation.FindMany]: [
+        "get",
+        "read",
+        "fetch",
+        "list",
+        "search",
+        "query",
+        "lookup",
+        "load",
+        "retrieve",
+        ...MANY_KEYWORDS,
+    ],
+    [DatabaseOperation.UpdateOne]: [
+        "edit",
+        "change",
+        "modify",
+        "set",
+        "save",
+        "resolve",
+        "acknowledge",
+        "assign",
+        "close",
+    ],
+    [DatabaseOperation.UpdateMany]: [
+        "edit",
+        "change",
+        "modify",
+        "set",
+        "save",
+        ...MANY_KEYWORDS,
+    ],
+    [DatabaseOperation.DeleteOne]: ["remove", "destroy", "erase"],
+    [DatabaseOperation.DeleteMany]: [
+        "remove",
+        "destroy",
+        "erase",
+        "purge",
+        ...MANY_KEYWORDS,
+    ],
+    [DatabaseOperation.OnCreate]: [
+        "created",
+        "new",
+        "added",
+        "opened",
+        "raised",
+        "declared",
+    ],
+    [DatabaseOperation.OnUpdate]: [
+        "updated",
+        "changed",
+        "change",
+        "edited",
+        "modified",
+        "resolved",
+        "acknowledged",
+        "status",
+    ],
+    [DatabaseOperation.OnDelete]: ["deleted", "removed"],
+};
+/*
+ * The words of a piece of text, lower case, without accents or punctuation:
+ * "On-Call Policy" is "on", "call", "policy" and "If / Else" is "if", "else".
+ */
+export const getSearchWords = (text) => {
+    return text
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .split(/[^a-z0-9]+/)
+        .filter((word) => {
+        return word.length > 0;
+    });
+};
+/*
+ * The words a search is matched on: its words without the stop words (unless
+ * nothing else was typed), each once, and at most MAX_SEARCH_WORDS of them.
+ * Empty when nothing searchable was typed.
+ */
+export const getSearchTokens = (search) => {
+    const words = getSearchWords(search);
+    const meaningful = words.filter((word) => {
+        return !STOP_WORDS.has(word);
+    });
+    return Array.from(new Set(meaningful.length > 0 ? meaningful : words)).slice(0, MAX_SEARCH_WORDS);
+};
+/*
+ * A word and the singulars it could be the plural of: "policies" is
+ * "policy", "statuses" is "status", "incidents" is "incident". Comparing
+ * these on both sides is what makes the number not matter, without a
+ * dictionary.
+ */
+export const getWordVariants = (word) => {
+    const variants = new Set([word]);
+    if (word.length > 3) {
+        if (word.endsWith("ies")) {
+            variants.add(`${word.slice(0, -3)}y`);
+        }
+        if (word.endsWith("es")) {
+            variants.add(word.slice(0, -2));
+        }
+        if (word.endsWith("s") && !word.endsWith("ss")) {
+            variants.add(word.slice(0, -1));
+        }
+    }
+    return Array.from(variants);
+};
+/*
+ * Edits between two words - insert, delete, replace, or swap two letters
+ * side by side ("incidnet") - stopping early once it is past maxDistance,
+ * when it returns maxDistance + 1.
+ */
+export const getEditDistance = (a, b, maxDistance) => {
+    if (Math.abs(a.length - b.length) > maxDistance) {
+        return maxDistance + 1;
+    }
+    const columns = b.length + 1;
+    let previousPrevious = new Array(columns).fill(0);
+    let previous = new Array(columns);
+    let current = new Array(columns);
+    for (let j = 0; j < columns; j++) {
+        previous[j] = j;
+    }
+    for (let i = 1; i <= a.length; i++) {
+        current[0] = i;
+        let rowMinimum = current[0];
+        for (let j = 1; j < columns; j++) {
+            const cost = a.charAt(i - 1) === b.charAt(j - 1) ? 0 : 1;
+            let value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+            if (i > 1 &&
+                j > 1 &&
+                a.charAt(i - 1) === b.charAt(j - 2) &&
+                a.charAt(i - 2) === b.charAt(j - 1)) {
+                value = Math.min(value, previousPrevious[j - 2] + 1);
+            }
+            current[j] = value;
+            rowMinimum = Math.min(rowMinimum, value);
+        }
+        if (rowMinimum > maxDistance) {
+            return maxDistance + 1;
+        }
+        const recycled = previousPrevious;
+        previousPrevious = previous;
+        previous = current;
+        current = recycled;
+    }
+    return Math.min(previous[b.length], maxDistance + 1);
+};
+// How many typos a word of this length may carry and still be recognised.
+export const getMaxTypoDistance = (word) => {
+    if (word.length >= 8) {
+        return 2;
+    }
+    if (word.length >= MIN_FUZZY_LENGTH) {
+        return 1;
+    }
+    return 0;
+};
+/*
+ * How a typed word matches one word of the catalog, without typos: those are
+ * only looked for when nothing else matches (see searchComponents). The
+ * variants can be passed in when the caller has them already.
+ */
+export const matchWord = (token, word, tokenVariants = getWordVariants(token), wordVariants = getWordVariants(word)) => {
+    if (token === word) {
+        return WordMatchKind.Exact;
+    }
+    if (tokenVariants.some((variant) => {
+        return wordVariants.includes(variant);
+    })) {
+        return WordMatchKind.Variant;
+    }
+    if (word.startsWith(token)) {
+        return WordMatchKind.Prefix;
+    }
+    if (token.length >= MIN_SUBSTRING_LENGTH && word.includes(token)) {
+        return WordMatchKind.Substring;
+    }
+    return null;
+};
+/*
+ * A typo of the whole word ("incidnet"), or of what has been typed of it so
+ * far ("incidne" for "inciden...").
+ */
+export const matchWordWithTypo = (token, word) => {
+    const maxDistance = getMaxTypoDistance(token);
+    if (maxDistance === 0) {
+        return false;
+    }
+    if (getEditDistance(token, word, maxDistance) <= maxDistance) {
+        return true;
+    }
+    return (word.length > token.length &&
+        getEditDistance(token, word.slice(0, token.length), maxDistance) <=
+            maxDistance);
+};
+// Neighbouring words run together: "on call policy" -> "oncall", "callpolicy".
+const compoundsOf = (words) => {
+    const compounds = [];
+    for (let i = 0; i + 1 < words.length; i++) {
+        compounds.push(`${words[i]}${words[i + 1]}`);
+    }
+    return compounds;
+};
+/*
+ * A title's words in parentheses qualify it rather than name it: "API Post
+ * (JSON)" is an API step that speaks JSON, and a search for "json" means the
+ * JSON steps first.
+ */
+const splitTitle = (title) => {
+    const qualifiers = [];
+    const main = title.replace(/\(([^)]*)\)/g, (_match, inner) => {
+        qualifiers.push(inner);
+        return " ";
+    });
+    return { main: main, qualifier: qualifiers.join(" ") };
+};
+// "service level objective" -> "slo". Only for three words or more.
+const initialsOf = (words) => {
+    if (words.length < 3) {
+        return null;
+    }
+    return words
+        .map((word) => {
+        return word.charAt(0);
+    })
+        .join("");
+};
+export const buildComponentSearchIndex = (catalog) => {
+    const words = [];
+    const idsByWord = new Map();
+    const initialsIds = new Set();
+    const plainWordIds = new Set();
+    const wordId = (word) => {
+        let id = idsByWord.get(word);
+        if (id === undefined) {
+            id = words.length;
+            words.push(word);
+            idsByWord.set(word, id);
+        }
+        return id;
+    };
+    const resourceByKey = catalog.resourcesByKey;
+    /*
+     * A to Z by resource, then operation, then title, as one plain string
+     * compare: localeCompare over a few thousand steps costs a visible pause
+     * on a slow machine, every time the picker opens.
+     */
+    const sortKeys = catalog.components.map((componentMetadata) => {
+        const resource = componentMetadata.tableName
+            ? componentMetadata.category.toLowerCase()
+            : "";
+        const operationRank = String(getOperationRank(getComponentOperation(componentMetadata))).padStart(2, "0");
+        return {
+            key: [
+                resource,
+                operationRank,
+                componentMetadata.title.toLowerCase(),
+            ].join("\u0000"),
+            componentMetadata: componentMetadata,
+        };
+    });
+    sortKeys.sort((a, b) => {
+        if (a.key === b.key) {
+            return 0;
+        }
+        return a.key < b.key ? -1 : 1;
+    });
+    const alphabeticalRankByComponent = new Map();
+    sortKeys.forEach((item, rank) => {
+        alphabeticalRankByComponent.set(item.componentMetadata, rank);
+    });
+    const entries = catalog.components.map((componentMetadata) => {
+        const weightsByWordId = new Map();
+        const addWords = (list, field, isInitials) => {
+            const weight = SEARCH_FIELD_WEIGHT[field];
+            for (const word of list) {
+                const id = wordId(word);
+                weightsByWordId.set(id, Math.max(weightsByWordId.get(id) || 0, weight));
+                if (isInitials) {
+                    initialsIds.add(id);
+                }
+                else {
+                    plainWordIds.add(id);
+                }
+            }
+        };
+        const titleWords = getSearchWords(componentMetadata.title);
+        const titleParts = splitTitle(componentMetadata.title);
+        const mainTitleWords = getSearchWords(titleParts.main);
+        const isBuiltIn = !isResourceComponent(componentMetadata);
+        const operation = getComponentOperation(componentMetadata);
+        addWords(mainTitleWords, SearchField.Title);
+        addWords(getSearchWords(titleParts.qualifier), SearchField.Category);
+        addWords(getSearchWords(componentMetadata.description), SearchField.Description);
+        addWords([...(COMPONENT_KEYWORDS[componentMetadata.id] || [])], SearchField.Keyword);
+        if (operation) {
+            addWords([...OPERATION_KEYWORDS[operation]], SearchField.Keyword);
+        }
+        let resourceWords = null;
+        if (isBuiltIn) {
+            addWords(compoundsOf(mainTitleWords), SearchField.Title);
+            addWords(getSearchWords(componentMetadata.category), SearchField.Category);
+        }
+        else {
+            const nameWords = getSearchWords(componentMetadata.category);
+            const compounds = compoundsOf(nameWords);
+            const initials = initialsOf(nameWords);
+            addWords(nameWords, SearchField.Resource);
+            addWords(compounds, SearchField.Resource);
+            if (initials) {
+                addWords([initials], SearchField.Keyword, true);
+            }
+            resourceWords = nameWords.map((word, index) => {
+                const covering = [
+                    { wordId: wordId(word), minTokenLength: 0 },
+                ];
+                /*
+                 * Two letters into the second word, not one: "incidents" runs on
+                 * into "incidentseverity", "incidentsla" and "incidentstate",
+                 * and its plural "s" names none of them.
+                 */
+                if (index > 0) {
+                    covering.push({
+                        wordId: wordId(compounds[index - 1]),
+                        minTokenLength: nameWords[index - 1].length + 2,
+                    });
+                }
+                if (index < compounds.length) {
+                    covering.push({
+                        wordId: wordId(compounds[index]),
+                        minTokenLength: 0,
+                    });
+                }
+                if (initials) {
+                    covering.push({ wordId: wordId(initials), minTokenLength: 0 });
+                }
+                return covering;
+            });
+        }
+        const resource = componentMetadata.tableName
+            ? resourceByKey.get(componentMetadata.tableName)
+            : undefined;
+        const popularRank = catalog.popularRankById.get(componentMetadata.id);
+        return {
+            component: componentMetadata,
+            terms: Array.from(weightsByWordId.entries()).map(([id, weight]) => {
+                return { wordId: id, weight: weight };
+            }),
+            titleKey: titleWords.join(" "),
+            resourceWords: resourceWords,
+            isBuiltIn: isBuiltIn,
+            popularRank: popularRank === undefined ? Number.POSITIVE_INFINITY : popularRank,
+            commonRank: resource && resource.commonRank !== null
+                ? resource.commonRank
+                : Number.POSITIVE_INFINITY,
+            alphabeticalRank: alphabeticalRankByComponent.get(componentMetadata),
+        };
+    });
+    const exactOnly = new Uint8Array(words.length);
+    for (const id of initialsIds) {
+        if (!plainWordIds.has(id)) {
+            exactOnly[id] = 1;
+        }
+    }
+    return {
+        entries: entries,
+        words: words,
+        wordVariants: words.map((word) => {
+            return getWordVariants(word);
+        }),
+        exactOnly: exactOnly,
+    };
+};
+const matchToken = (token, index) => {
+    const words = index.words;
+    const quality = new Float32Array(words.length);
+    const names = new Uint8Array(words.length);
+    const tokenVariants = getWordVariants(token);
+    let found = false;
+    for (let id = 0; id < words.length; id++) {
+        if (index.exactOnly[id] === 1) {
+            if (words[id] === token) {
+                quality[id] = WORD_MATCH_QUALITY[WordMatchKind.Exact];
+                names[id] = 1;
+                found = true;
+            }
+            continue;
+        }
+        const kind = matchWord(token, words[id], tokenVariants, index.wordVariants[id]);
+        if (kind) {
+            quality[id] = WORD_MATCH_QUALITY[kind];
+            names[id] = kind === WordMatchKind.Substring ? 0 : 1;
+            found = true;
+        }
+    }
+    /*
+     * Typos only for a word that matches nothing as typed. Otherwise "host"
+     * would also find "post", and a search would widen as it was spelled out.
+     */
+    if (!found) {
+        for (let id = 0; id < words.length; id++) {
+            if (index.exactOnly[id] !== 1 && matchWordWithTypo(token, words[id])) {
+                quality[id] = WORD_MATCH_QUALITY[WordMatchKind.Fuzzy];
+                names[id] = 1;
+            }
+        }
+    }
+    return {
+        quality: quality,
+        names: names,
+        isTypo: !found,
+        tokenLength: token.length,
+    };
+};
+export const searchComponents = (index, search) => {
+    const tokens = getSearchTokens(search);
+    if (tokens.length === 0) {
+        return { tokens: tokens, typoTokens: [], results: [] };
+    }
+    const searchKey = getSearchWords(search).join(" ");
+    const matches = tokens.map((token) => {
+        return matchToken(token, index);
+    });
+    // A match anywhere but the description names the step.
+    const descriptionWeight = SEARCH_FIELD_WEIGHT[SearchField.Description];
+    const scored = [];
+    for (const entry of index.entries) {
+        let total = 0;
+        let everyWordNamed = true;
+        let matchedAll = true;
+        for (const tokenMatches of matches) {
+            let best = 0;
+            let named = false;
+            for (const term of entry.terms) {
+                const quality = tokenMatches.quality[term.wordId];
+                if (quality === 0) {
+                    continue;
+                }
+                const value = quality * term.weight;
+                if (value > best) {
+                    best = value;
+                }
+                if (term.weight > descriptionWeight) {
+                    named = true;
+                }
+            }
+            if (best === 0) {
+                matchedAll = false;
+                break;
+            }
+            total += best;
+            everyWordNamed = everyWordNamed && named;
+        }
+        if (!matchedAll) {
+            continue;
+        }
+        let score = total * SCORE_PER_WORD;
+        let resourceNamedInFull = false;
+        if (entry.resourceWords) {
+            let named = 0;
+            for (const covering of entry.resourceWords) {
+                const isNamed = matches.some((tokenMatches) => {
+                    return covering.some((word) => {
+                        return (tokenMatches.names[word.wordId] === 1 &&
+                            tokenMatches.tokenLength >= word.minTokenLength);
+                    });
+                });
+                if (isNamed) {
+                    named++;
+                }
+            }
+            const unnamed = entry.resourceWords.length - named;
+            resourceNamedInFull = named > 0 && unnamed === 0;
+            // Closer resources first: Incident Feed before Incident Episode Feed.
+            if (named > 0) {
+                score -= unnamed * UNNAMED_RESOURCE_WORD_PENALTY;
+            }
+        }
+        if (entry.isBuiltIn) {
+            score += BUILT_IN_BONUS;
+        }
+        if (Number.isFinite(entry.popularRank)) {
+            score += POPULAR_BONUS;
+        }
+        if (Number.isFinite(entry.commonRank)) {
+            score += COMMON_RESOURCE_BONUS;
+        }
+        let tier = SearchTier.Mentioned;
+        if (entry.titleKey === searchKey) {
+            tier = SearchTier.ExactTitle;
+        }
+        else if (everyWordNamed && (entry.isBuiltIn || resourceNamedInFull)) {
+            tier = SearchTier.Named;
+        }
+        else if (everyWordNamed) {
+            tier = SearchTier.Related;
+        }
+        scored.push({
+            entry: entry,
+            result: { component: entry.component, tier: tier, score: score },
+        });
+    }
+    scored.sort((a, b) => {
+        return (a.result.tier - b.result.tier ||
+            b.result.score - a.result.score ||
+            compareRanks(a.entry.popularRank, b.entry.popularRank) ||
+            Number(b.entry.isBuiltIn) - Number(a.entry.isBuiltIn) ||
+            compareRanks(a.entry.commonRank, b.entry.commonRank) ||
+            a.entry.alphabeticalRank - b.entry.alphabeticalRank);
+    });
+    return {
+        tokens: tokens,
+        typoTokens: tokens.filter((_token, i) => {
+            return matches[i].isTypo;
+        }),
+        results: scored.map((item) => {
+            return item.result;
+        }),
+    };
+};
+// Ranks that may be Infinity ("not ranked"), without Infinity - Infinity.
+const compareRanks = (a, b) => {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+};
+/*
+ * The parts of a title to mark for a search: a whole word it named, what has
+ * been typed of a longer word, the typed letters inside one, or the word a
+ * typo was read as (only for the typoTokens the search read that way).
+ * Punctuation is never marked, and no part of the search is ever read as a
+ * pattern.
+ */
+export const getHighlightSegments = (text, tokens, typoTokens = []) => {
+    if (tokens.length === 0) {
+        return [{ text: text, isMatch: false }];
+    }
+    const marked = new Array(text.length).fill(false);
+    const wordPattern = /[\p{L}\p{N}]+/gu;
+    let wordMatch = wordPattern.exec(text);
+    while (wordMatch) {
+        const start = wordMatch.index;
+        const original = wordMatch[0];
+        // Same length as the original, so offsets carry over.
+        const word = original.toLowerCase();
+        for (const token of tokens) {
+            const kind = matchWord(token, word);
+            let from = -1;
+            let to = -1;
+            if (kind === WordMatchKind.Exact || kind === WordMatchKind.Variant) {
+                from = 0;
+                to = word.length;
+            }
+            else if (kind === WordMatchKind.Prefix) {
+                from = 0;
+                to = token.length;
+            }
+            else if (kind === WordMatchKind.Substring) {
+                from = word.indexOf(token);
+                to = from + token.length;
+            }
+            else if (typoTokens.includes(token) && matchWordWithTypo(token, word)) {
+                from = 0;
+                to = word.length;
+            }
+            for (let i = Math.max(from, 0); i < to; i++) {
+                marked[start + i] = true;
+            }
+        }
+        wordMatch = wordPattern.exec(text);
+    }
+    const segments = [];
+    for (let i = 0; i < text.length; i++) {
+        const last = segments[segments.length - 1];
+        if (last && last.isMatch === marked[i]) {
+            last.text += text.charAt(i);
+        }
+        else {
+            segments.push({ text: text.charAt(i), isMatch: Boolean(marked[i]) });
+        }
+    }
+    return segments.length > 0 ? segments : [{ text: text, isMatch: false }];
+};
+const indexCache = new WeakMap();
+// buildComponentSearchIndex, once per catalog.
+export const getComponentSearchIndex = (catalog) => {
+    let index = indexCache.get(catalog);
+    if (!index) {
+        index = buildComponentSearchIndex(catalog);
+        indexCache.set(catalog, index);
+    }
+    return index;
+};
+//# sourceMappingURL=ComponentSearch.js.map