MapComplete/src/Logic/Search/LayerSearch.ts

import SearchUtils from "./SearchUtils"
import ThemeSearch from "./ThemeSearch"
import LayerConfig from "../../Models/ThemeConfig/LayerConfig"
import ThemeConfig from "../../Models/ThemeConfig/ThemeConfig"
import { Utils } from "../../Utils"

export default class LayerSearch {
    private readonly _theme: ThemeConfig
    private readonly _layerWhitelist: Set<string>

    constructor(theme: ThemeConfig) {
        this._theme = theme
        this._layerWhitelist = new Set(theme.layers.filter((l) => l.isNormal()).map((l) => l.id))
    }

    static scoreLayers(
        query: string,
        options: {
            whitelist?: Set<string>
            blacklist?: Set<string>
        }
    ): Record<string, number> {
        const result: Record<string, number> = {}
        const queryParts = query
            .trim()
            .split(" ")
            .map((q) => Utils.simplifyStringForSearch(q))
        for (const id in ThemeSearch.officialThemes.layers) {
            if (options?.whitelist && !options?.whitelist.has(id)) {
                continue
            }
            if (options?.blacklist?.has(id)) {
                continue
            }
            const keywords = ThemeSearch.officialThemes.layers[id]
            result[id] = Math.min(...queryParts.map((q) => SearchUtils.scoreKeywords(q, keywords)))
        }
        return result
    }

    public search(query: string, limit: number, scoreThreshold: number = 2): LayerConfig[] {
        if (query.length < 1) {
            return []
        }
        const scores = LayerSearch.scoreLayers(query, { whitelist: this._layerWhitelist })
        const asList: { layer: LayerConfig; score: number }[] = []
        for (const layer in scores) {
            asList.push({
                layer: this._theme.getLayer(layer),
                score: scores[layer],
            })
        }
        asList.sort((a, b) => a.score - b.score)

        return asList
            .filter((sorted) => sorted.score < scoreThreshold)
            .slice(0, limit)
            .map((l) => l.layer)
    }
}