mapcomplete/UI/Wikipedia/WikidataSearchBox.ts

import Combine from "../Base/Combine"
import { InputElement } from "../Input/InputElement"
import { TextField } from "../Input/TextField"
import Translations from "../i18n/Translations"
import { ImmutableStore, Store, Stores, UIEventSource } from "../../Logic/UIEventSource"
import Wikidata, { WikidataResponse } from "../../Logic/Web/Wikidata"
import Locale from "../i18n/Locale"
import { VariableUiElement } from "../Base/VariableUIElement"
import WikidataPreviewBox from "./WikidataPreviewBox"
import Title from "../Base/Title"
import WikipediaBox from "./WikipediaBox"
import Svg from "../../Svg"
import Loading from "../Base/Loading"

export default class WikidataSearchBox extends InputElement<string> {
    private static readonly _searchCache = new Map<string, Promise<WikidataResponse[]>>()
    IsSelected: UIEventSource<boolean> = new UIEventSource<boolean>(false)
    private readonly wikidataId: UIEventSource<string>
    private readonly searchText: UIEventSource<string>
    private readonly instanceOf?: number[]
    private readonly notInstanceOf?: number[]

    constructor(options?: {
        searchText?: UIEventSource<string>
        value?: UIEventSource<string>
        notInstanceOf?: number[]
        instanceOf?: number[]
    }) {
        super()
        this.searchText = options?.searchText
        this.wikidataId = options?.value ?? new UIEventSource<string>(undefined)
        this.instanceOf = options?.instanceOf
        this.notInstanceOf = options?.notInstanceOf
    }

    GetValue(): UIEventSource<string> {
        return this.wikidataId
    }

    IsValid(t: string): boolean {
        return t.startsWith("Q") && !isNaN(Number(t.substring(1)))
    }

    protected InnerConstructElement(): HTMLElement {
        const searchField = new TextField({
            placeholder: Translations.t.general.wikipedia.searchWikidata,
            value: this.searchText,
            inputStyle: "width: calc(100% - 0.5rem); border: 1px solid black",
        })
        const selectedWikidataId = this.wikidataId

        const tooShort = new ImmutableStore<{ success: WikidataResponse[] }>({ success: undefined })
        const searchResult: Store<{ success?: WikidataResponse[]; error?: any }> = searchField
            .GetValue()
            .bind((searchText) => {
                if (searchText.length < 3) {
                    return tooShort
                }
                const lang = Locale.language.data
                const key = lang + ":" + searchText
                let promise = WikidataSearchBox._searchCache.get(key)
                if (promise === undefined) {
                    promise = Wikidata.searchAndFetch(searchText, {
                        lang,
                        maxCount: 5,
                        notInstanceOf: this.notInstanceOf,
                        instanceOf: this.instanceOf,
                    })
                    WikidataSearchBox._searchCache.set(key, promise)
                }
                return Stores.FromPromiseWithErr(promise)
            })

        const previews = new VariableUiElement(
            searchResult.map(
                (searchResultsOrFail) => {
                    if (searchField.GetValue().data.length === 0) {
                        return Translations.t.general.wikipedia.doSearch
                    }

                    if (searchField.GetValue().data.length < 3) {
                        return Translations.t.general.wikipedia.searchToShort
                    }

                    if (searchResultsOrFail === undefined) {
                        return new Loading(Translations.t.general.loading)
                    }

                    if (searchResultsOrFail.error !== undefined) {
                        return new Combine([
                            Translations.t.general.wikipedia.failed.Clone().SetClass("alert"),
                            searchResultsOrFail.error,
                        ])
                    }

                    const searchResults = searchResultsOrFail.success
                    if (searchResults.length === 0) {
                        return Translations.t.general.wikipedia.noResults.Subs({
                            search: searchField.GetValue().data ?? "",
                        })
                    }

                    return new Combine(
                        searchResults.map((wikidataresponse) => {
                            const el = WikidataPreviewBox.WikidataResponsePreview(
                                wikidataresponse
                            ).SetClass(
                                "rounded-xl p-1 sm:p-2 md:p-3 m-px border-2 sm:border-4 transition-colors"
                            )
                            el.onClick(() => {
                                selectedWikidataId.setData(wikidataresponse.id)
                            })
                            selectedWikidataId.addCallbackAndRunD((selected) => {
                                if (selected === wikidataresponse.id) {
                                    el.SetClass("subtle-background border-attention")
                                } else {
                                    el.RemoveClass("subtle-background")
                                    el.RemoveClass("border-attention")
                                }
                            })
                            return el
                        })
                    ).SetClass("flex flex-col")
                },
                [searchField.GetValue()]
            )
        )

        const full = new Combine([
            new Title(Translations.t.general.wikipedia.searchWikidata, 3).SetClass("m-2"),
            new Combine([
                Svg.search_ui().SetStyle("width: 1.5rem"),
                searchField.SetClass("m-2 w-full"),
            ]).SetClass("flex"),
            previews,
        ]).SetClass("flex flex-col border-2 border-black rounded-xl m-2 p-2")

        return new Combine([
            new VariableUiElement(
                selectedWikidataId.map((wid) => {
                    if (wid === undefined) {
                        return undefined
                    }
                    return new WikipediaBox(wid.split(";"))
                })
            ).SetStyle("max-height:12.5rem"),
            full,
        ]).ConstructElement()
    }
}