A free, open source, and extensible speech-to-text application that works completely offline.
import React, { useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { isComposingKeyEvent } from "@/lib/utils/keyboard";
import {
getLanguage,
languageList,
languageName,
searchLanguages,
type Language,
} from "@/lib/constants/languages";
import { cjkSubsetFont } from "@/lib/utils/cjkFont";
/** Spoken-language picker pieces shared by onboarding's Welcome and the Preferred Languages setting. */
const RemoveIcon = () => (
<svg
width="10"
height="10"
viewBox="0 0 10 10"
fill="none"
stroke="currentColor"
strokeWidth="1.6"
strokeLinecap="round"
aria-hidden="true"
>
<path d="M2 2l6 6M8 2L2 8" />
</svg>
);
interface LanguageChipProps {
code: string;
/** What the button does, for screen readers ("Remove English"). */
removeLabel: string;
onRemove: () => void;
/** The last language can't go: the chip stays, without its ×. */
locked?: boolean;
/** `soft`: Settings' small borderless tag, beside its Dropdowns. */
variant?: "pill" | "soft";
}
/** A picked language by its endonym, with a remove button that keeps focus in the search. */
export const LanguageChip: React.FC<LanguageChipProps> = ({
code,
removeLabel,
onRemove,
locked = false,
variant = "pill",
}) => {
const { native } = getLanguage(code);
const name = (
<bdi lang={code} className={cjkSubsetFont(native)}>
{native}
</bdi>
);
if (variant === "soft") {
const soft =
"inline-flex h-[26px] shrink-0 items-center gap-1 whitespace-nowrap rounded-md bg-wash text-xs font-medium text-text";
if (locked) return <span className={`${soft} px-2.5`}>{name}</span>;
return (
<button
type="button"
aria-label={removeLabel}
onMouseDown={(e) => e.preventDefault()}
onClick={onRemove}
className={`group ${soft} cursor-pointer ps-2.5 pe-1.5 transition-colors hover:bg-line`}
>
{name}
<span className="grid size-[14px] place-items-center text-ink-3 transition-colors group-hover:text-text">
<RemoveIcon />
</span>
</button>
);
}
if (locked)
return (
<span className="inline-flex h-[28px] items-center rounded-full border-[1.5px] border-line-strong bg-background px-[12px] text-small font-semibold text-text">
{name}
</span>
);
return (
<button
type="button"
aria-label={removeLabel}
onMouseDown={(e) => e.preventDefault()}
onClick={(e) => {
e.preventDefault();
onRemove();
}}
className="group inline-flex h-[28px] cursor-pointer items-center gap-[6px] rounded-full border-[1.5px] border-line-strong bg-background ps-[12px] pe-[6px] text-small font-semibold text-text hover:border-ink-3"
>
{name}
<span className="grid size-[18px] place-items-center rounded-full leading-none text-ink-2 group-hover:bg-line">
<RemoveIcon />
</span>
</button>
);
};
interface LanguageOptionProps {
language: Language;
/** Its name in the UI language. */
name: string;
/** What Enter in the search adds. */
highlighted?: boolean;
onPick: () => void;
}
/** A language to add: endonym over its UI-language name (blank when equal, so cells align). */
export const LanguageOption: React.FC<LanguageOptionProps> = ({
language,
name,
highlighted = false,
onPick,
}) => (
<button
type="button"
onClick={onPick}
className={`flex h-[46px] cursor-pointer flex-col justify-center rounded-[9px] px-[12px] text-start leading-[1.25] hover:bg-wash ${
highlighted
? "border-[1.5px] border-line-strong bg-wash"
: "border border-transparent"
}`}
>
<b
lang={language.code}
className={`font-semibold ${cjkSubsetFont(language.native) ?? ""}`}
>
{language.native}
</b>
<small className="text-label text-ink-3">
{language.native !== name ? name : "\u00a0"}
</small>
</button>
);
/** Search keys: Enter adds, Backspace on empty removes the last, Escape clears. Returns true if handled. */
export const languageSearchKeys = (
e: React.KeyboardEvent<HTMLInputElement>,
{
query,
first,
last,
toggle,
clear,
}: {
query: string;
/** The language Enter adds. */
first: string | undefined;
/** The language Backspace removes (none when it can't). */
last: string | undefined;
toggle: (code: string) => void;
clear: () => void;
},
): boolean => {
if (isComposingKeyEvent(e.nativeEvent)) return false;
if (e.key === "Enter" && query) {
e.preventDefault();
if (first) toggle(first);
return true;
}
if (e.key === "Backspace" && !query && last) {
e.preventDefault();
toggle(last);
return true;
}
if (e.key === "Escape" && query) {
clear();
return true;
}
return false;
};
/**
* The picker's search: what matches, what's left to add, and toggling. With
* `keepOne` the last language can't be removed; a `suggestion` leads the list
* until something is typed.
*/
export const useLanguagePicker = ({
languages,
onChange,
keepOne = false,
suggestion = null,
}: {
languages: string[];
onChange: (next: string[]) => void;
keepOne?: boolean;
suggestion?: string | null;
}) => {
const { i18n } = useTranslation();
const ui = i18n.language;
const [query, setQuery] = useState("");
const inputRef = useRef<HTMLInputElement>(null);
const matches = useMemo(() => {
const found = searchLanguages(query, ui);
if (!suggestion || query) return found;
return [
...found.filter((l) => l.code === suggestion),
...found.filter((l) => l.code !== suggestion),
];
}, [query, ui, suggestion]);
const available = matches.filter((l) => !languages.includes(l.code));
const removable = !keepOne || languages.length > 1;
const toggle = (code: string) => {
const next = languages.includes(code)
? languages.filter((c) => c !== code)
: [...languages, code];
if (!next.length && keepOne) return;
onChange(next);
setQuery("");
inputRef.current?.focus({ preventScroll: true });
};
const onKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) =>
languageSearchKeys(e, {
query,
first: available[0]?.code,
last: removable ? languages[languages.length - 1] : undefined,
toggle,
clear: () => setQuery(""),
});
return {
languages,
query,
setQuery,
inputRef,
matches,
available,
removable,
toggle,
onKeyDown,
nameOf: (code: string) => languageName(code, ui),
};
};
type Picker = ReturnType<typeof useLanguagePicker>;
/** The picked languages as chips, then the search. Clicks around the chips go to the search. */
export const LanguageSearchField: React.FC<{
picker: Picker;
className?: string;
inputClassName?: string;
onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
"aria-expanded"?: boolean;
}> = ({
picker,
className = "",
inputClassName = "",
onKeyDown = picker.onKeyDown,
"aria-expanded": expanded,
}) => {
const { t } = useTranslation();
const { languages, inputRef } = picker;
return (
// Not a <label>: it would hand clicks to the first chip, which removes it.
<div
onClick={() => inputRef.current?.focus({ preventScroll: true })}
className={`flex min-h-[46px] cursor-text flex-wrap items-center gap-[4px] px-[8px] py-[7px] text-start ${className}`}
>
{languages.map((code) => (
<LanguageChip
key={code}
code={code}
removeLabel={t("languagePicker.remove", {
language: picker.nameOf(code),
})}
onRemove={() => picker.toggle(code)}
locked={!picker.removable}
/>
))}
<input
ref={inputRef}
type="text"
autoComplete="off"
spellCheck={false}
aria-label={t("languagePicker.search")}
aria-expanded={expanded}
placeholder={
languages.length
? t("languagePicker.addAnother")
: t("languagePicker.search")
}
value={picker.query}
onChange={(e) => picker.setQuery(e.target.value)}
onKeyDown={onKeyDown}
className={`h-[30px] flex-1 border-0 bg-transparent px-[8px] text-text outline-none placeholder:text-ink-3 ${inputClassName}`}
/>
</div>
);
};
/** The languages left to add, the first highlighted while it's what Enter adds; when none, why. */
export const LanguageOptions: React.FC<{
picker: Picker;
/** Highlight the first even with nothing typed (it's the suggestion). */
highlightFirst?: boolean;
/** Nothing matches the query. */
noMatch: string;
emptyClassName?: string;
}> = ({ picker, highlightFirst = false, noMatch, emptyClassName = "" }) => {
const { t, i18n } = useTranslation();
const { available, matches, query } = picker;
return (
<>
{available.map((l, i) => (
<LanguageOption
key={l.code}
language={l}
name={picker.nameOf(l.code)}
highlighted={(!!query || highlightFirst) && i === 0}
onPick={() => picker.toggle(l.code)}
/>
))}
{!available.length && (
<div
className={`col-span-full text-center text-small text-ink-3 ${emptyClassName}`}
>
{matches.length
? t("languagePicker.alreadyAdded", {
count: matches.length,
languages: languageList(
matches.map((l) => l.code),
i18n.language,
),
})
: noMatch}
</div>
)}
</>
);
};