move freeform node yet again

Author: neverRare

src/translator/ast.ts

@@ -90,10 +90,10 @@ export type Preposition = Readonly<{
   object: NounPhrase;
   emphasis: boolean;
 }>;
-export type Sentence =
+export type Sentence = Readonly<{
+  clauses: ReadonlyArray<Clause>;
+  punctuation: string;
+}>;
+export type Sentences =
   | Readonly<{ type: "free form"; text: string }>
-  | Readonly<{
-    type: "sentence";
-    clauses: ReadonlyArray<Clause>;
-    punctuation: string;
-  }>;
+  | Readonly<{ type: "sentences"; sentences: ReadonlyArray<Sentence> }>;

src/translator/composer.ts

@@ -132,24 +132,22 @@ function clause(ast: English.Clause): string {
   }
 }
 function sentence(sentence: English.Sentence): string {
-  let text: string;
-  switch (sentence.type) {
+  const capitalized = capitalize(sentence.clauses.map(clause).join(", "));
+  return `${capitalized}${sentence.punctuation}`;
+}
+export function multipleSentences(
+  sentences: English.Sentences,
+): string {
+  switch (sentences.type) {
     case "free form":
-      text = sentence.text;
-      break;
-    case "sentence":
-      text = `${
-        sentence.clauses.map(clause).join(", ")
-      }${sentence.punctuation}`;
-      break;
+      return capitalize(sentences.text);
+    case "sentences":
+      return sentences.sentences.map(sentence).join(" ");
   }
+}
+function capitalize(text: string): string {
   return text.replace(
     /(?<![<&\p{Alpha}\p{Nd}\p{Nl}\p{No}])[\p{Alpha}\p{Nd}\p{Nl}\p{No}]/u,
     (character) => character.toLocaleUpperCase(),
   );
 }
-export function multipleSentences(
-  sentences: ReadonlyArray<English.Sentence>,
-): string {
-  return sentences.map(sentence).join(" ");
-}

src/translator/sentence.ts

@@ -177,23 +177,23 @@ function sentence(
 }
 export function multipleSentences(
   sentences: TokiPona.MultipleSentences,
-): ArrayResult<ReadonlyArray<English.Sentence>> {
+): ArrayResult<English.Sentences> {
   switch (sentences.type) {
     case "single word": {
       const { word } = sentences;
       return new ArrayResult(dictionary.get(word)!.definitions)
         .flatMap(definitionAsPlainString)
-        .map<English.Sentence>((definition) => ({
+        .map((definition) => ({
           type: "free form",
           text: definition,
-        }))
-        .map((definition) => [definition]);
+        }));
     }
     case "sentences":
       return ArrayResult.combine(
         ...sentences.sentences.map((value, i) =>
           sentence(value, i === sentences.sentences.length - 1)
         ),
-      );
+      )
+        .map((sentences) => ({ type: "sentences", sentences }));
   }
 }