feat: Support more sections in the dictionary adapters.

source/constants/dictionaries.ts

@@ -1,5 +1,23 @@
 import type { LearningLanguage } from "logos:constants/languages/learning";
 
+const sections = [
+	"partOfSpeech",
+	"definitions",
+	"translations",
+	"relations",
+	"syllables",
+	"pronunciation",
+	"rhymes",
+	"audio",
+	"expressions",
+	"examples",
+	"frequency",
+	"inflection",
+	"etymology",
+	"notes",
+] as const;
+type DictionarySection = (typeof sections)[number];
+
 type Dictionary = "dexonline" | "dicolink" | "wiktionary" | "wordnik" | "words-api";
 
 const dictionariesByLanguage = Object.freeze({
@@ -25,4 +43,4 @@ const dictionariesByLanguage = Object.freeze({
 } satisfies Record<LearningLanguage, Dictionary[]> as Record<LearningLanguage, Dictionary[]>);
 
 export default Object.freeze({ languages: dictionariesByLanguage });
-export type { Dictionary };
+export type { Dictionary, DictionarySection };

source/constants/emojis.ts

@@ -56,8 +56,13 @@ export default Object.freeze({
 	word: {
 		word: "📜",
 		definitions: "📚",
+		translations: "🌐",
+		relations: "🌳",
+		pronunciation: "🗣️",
 		expressions: "💐",
-		etymology: "🌐",
+		examples: "🏷️",
+		etymology: "🌱",
+		notes: "📝",
 	},
 	music: {
 		song: "🎵",

source/constants/parts-of-speech.ts

@@ -46,34 +46,35 @@ function isUnknownPartOfSpeech(partOfSpeech: PartOfSpeech): partOfSpeech is "unk
 	return partOfSpeech === "unknown";
 }
 
+interface PartOfSpeechDetection {
+	readonly detected: PartOfSpeech;
+	readonly original: string;
+}
 function getPartOfSpeech({
 	terms,
 	learningLanguage,
-}: { terms: { exact: string; approximate?: string }; learningLanguage: LearningLanguage }): [
-	detected: PartOfSpeech,
-	original: string,
-] {
+}: { terms: { exact: string; approximate?: string }; learningLanguage: LearningLanguage }): PartOfSpeechDetection {
 	if (isPartOfSpeech(terms.exact)) {
-		return [terms.exact, terms.exact];
+		return { detected: terms.exact, original: terms.exact };
 	}
 
 	if (!(learningLanguage in partsOfSpeechByLanguage)) {
-		return ["unknown", terms.exact];
+		return { detected: "unknown", original: terms.exact };
 	}
 
 	const partsOfSpeechLocalised = partsOfSpeechByLanguage[
 		learningLanguage as keyof typeof partsOfSpeechByLanguage
 	] as Record<string, PartOfSpeech>;
 
 	if (terms.exact in partsOfSpeechLocalised) {
-		return [partsOfSpeechLocalised[terms.exact]!, terms.exact];
+		return { detected: partsOfSpeechLocalised[terms.exact]!, original: terms.exact };
 	}
 
 	if (terms.approximate !== undefined && terms.approximate in partsOfSpeechLocalised) {
-		return [partsOfSpeechLocalised[terms.approximate]!, terms.approximate];
+		return { detected: partsOfSpeechLocalised[terms.approximate]!, original: terms.approximate };
 	}
 
-	return ["unknown", terms.exact];
+	return { detected: "unknown", original: terms.exact };
 }
 
 export { getPartOfSpeech, isUnknownPartOfSpeech };

source/library/adapters/dictionaries/adapter.ts

@@ -1,81 +1,14 @@
+import type { DictionarySection } from "logos:constants/dictionaries.ts";
 import type { LearningLanguage } from "logos:constants/languages/learning";
-import type { Licence } from "logos:constants/licences";
-import type { PartOfSpeech } from "logos:constants/parts-of-speech";
+import type { DictionaryEntry } from "logos/adapters/dictionaries/dictionary-entry";
 import type { Client } from "logos/client";
 import { Logger } from "logos/logger";
 
-type DictionaryProvisions =
-	/** Provides definitions of a lemma. */
-	| "definitions"
-	/** Provides a lemma's etymology. */
-	| "etymology"
-	/** Provides relations between a lemma and other words. */
-	| "relations"
-	/** Provides words that rhyme with a given lemma. */
-	| "rhymes";
-
-interface TaggedValue<T> {
-	tags?: string[];
-	value: T;
-}
-
-interface Expression extends TaggedValue<string> {}
-
-interface Definition extends TaggedValue<string> {
-	definitions?: Definition[];
-	expressions?: Expression[];
-	relations?: Relations;
-}
-
-interface Relations {
-	synonyms?: string[];
-	antonyms?: string[];
-	diminutives?: string[];
-	augmentatives?: string[];
-}
-
-interface Rhymes extends TaggedValue<string> {}
-
-interface Etymology extends TaggedValue<string | undefined> {}
-
-type InflectionTable = { title: string; fields: Discord.CamelizedDiscordEmbedField[] }[];
-
-interface DictionaryEntry {
-	/** The topic word of an entry. */
-	lemma: string;
-
-	/** The part of speech of the lemma. */
-	partOfSpeech: [detected: PartOfSpeech, text: string];
-
-	/** The definitions for the lemma in its native language. */
-	nativeDefinitions?: Definition[];
-
-	/** The definitions for the lemma. */
-	definitions?: Definition[];
-
-	/** Relations between the lemma and other words. */
-	relations?: Relations;
-
-	/** Rhythmic composition of the lemma. */
-	rhymes?: Rhymes;
-
-	/** The expressions for the lemma. */
-	expressions?: Expression[];
-
-	/** The etymologies for the lemma. */
-	etymologies?: Etymology[];
-
-	/** The inflection of the lemma. */
-	inflectionTable?: InflectionTable;
-
-	sources: [link: string, licence: Licence][];
-}
-
 abstract class DictionaryAdapter<DataType = unknown> {
 	readonly log: Logger;
 	readonly client: Client;
 	readonly identifier: string;
-	readonly provides: DictionaryProvisions[];
+	readonly provides: DictionarySection[];
 	readonly supports: LearningLanguage[];
 	readonly isFallback: boolean;
 
@@ -86,7 +19,7 @@ abstract class DictionaryAdapter<DataType = unknown> {
 			provides,
 			supports,
 			isFallback = false,
-		}: { identifier: string; provides: DictionaryProvisions[]; supports: LearningLanguage[]; isFallback?: boolean },
+		}: { identifier: string; provides: DictionarySection[]; supports: LearningLanguage[]; isFallback?: boolean },
 	) {
 		this.log = Logger.create({ identifier, isDebug: client.environment.isDebug });
 		this.client = client;
@@ -137,4 +70,4 @@ abstract class DictionaryAdapter<DataType = unknown> {
 }
 
 export { DictionaryAdapter };
-export type { Definition, DictionaryEntry, Relations, Rhymes, Expression, Etymology, DictionaryProvisions };
+export type { DictionaryEntry };