reorganize code

Author: neverRare

src/main.ts

@@ -2,12 +2,11 @@
 
 import { closestString } from "@std/text/closest-string";
 import BrowserDetector from "browser-dtector";
-import { dictionary } from "./dictionary/dictionary.ts";
-import { parseDictionary } from "./dictionary/parser.ts";
-import { Dictionary } from "./dictionary/type.ts";
 import PROJECT_DATA from "../project_data.json" with { type: "json" };
 import { extractResultError, Result, ResultError } from "./compound.ts";
-import { loadCustomDictionary } from "./dictionary/dictionary.ts";
+import { dictionary, loadCustomDictionary } from "./dictionary/dictionary.ts";
+import { parseDictionary } from "./dictionary/parser.ts";
+import { Dictionary } from "./dictionary/type.ts";
 import {
   assertQuotaExceededError,
   checkLocalStorage,

src/parser/parser_lib.ts

@@ -35,33 +35,22 @@ export class Parser<T> {
     }
     return this[rawParser](0).map(({ value }) => value);
   }
-  #rawMap<U>(mapper: (value: T) => U): Parser<U> {
-    return new Parser((input) =>
-      this[rawParser](input)
-        .map(({ value, length }): ValueLength<U> => ({
-          value: mapper(value),
-          length,
-        }))
-    );
-  }
+
   map<U>(mapper: (value: T) => U): Parser<U> {
     return withPosition(this)
       .#rawMap((value) =>
         withPositionedError(() => mapper(value.value), value)
       );
   }
-  #rawFilter(mapper: (value: T) => boolean): Parser<T> {
-    return new Parser((input) =>
-      this[rawParser](input).filter(({ value }) => mapper(value))
-    );
-  }
+
   filter(mapper: (value: T) => boolean): Parser<T> {
     return withPosition(this)
       .#rawFilter((value) =>
         withPositionedError(() => mapper(value.value), value)
       )
       .map(({ value }) => value);
   }
+
   then<U>(mapper: (value: T) => Parser<U>): Parser<U> {
     return new Parser((position) =>
       this[rawParser](position)
@@ -75,21 +64,41 @@ export class Parser<T> {
         )
     );
   }
+
   sort(comparer: (left: T, right: T) => number): Parser<T> {
     return new Parser((input) =>
       this[rawParser](input)
         .sort((left, right) => comparer(left.value, right.value))
     );
   }
+
   sortBy(mapper: (value: T) => number): Parser<T> {
     return this.sort((left, right) => mapper(left) - mapper(right));
   }
+
   with<U>(parser: Parser<U>): Parser<U> {
     return sequence(this, parser).map(([_, arrayResult]) => arrayResult);
   }
+
   skip<U>(parser: Parser<U>): Parser<T> {
     return sequence(this, parser).map(([arrayResult]) => arrayResult);
   }
+
+  #rawMap<U>(mapper: (value: T) => U): Parser<U> {
+    return new Parser((input) =>
+      this[rawParser](input)
+        .map(({ value, length }): ValueLength<U> => ({
+          value: mapper(value),
+          length,
+        }))
+    );
+  }
+
+  #rawFilter(mapper: (value: T) => boolean): Parser<T> {
+    return new Parser((input) =>
+      this[rawParser](input).filter(({ value }) => mapper(value))
+    );
+  }
 }
 export type Position = Readonly<{ position: number; length: number }>;
 export class PositionedError extends ResultError {

src/translator/adjective.ts

@@ -1,5 +1,5 @@
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { mapNullable, nullableAsArray } from "../misc/misc.ts";
 import * as TokiPona from "../parser/ast.ts";
 import { UntranslatableError } from "../translator2/error.ts";

src/translator/as_string.ts

@@ -1,5 +1,5 @@
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { adjective, compoundAdjective } from "./adjective.ts";
 import * as EnglishComposer from "./composer.ts";
 import { noun, simpleNounForms } from "./noun.ts";

src/translator/determiner.ts

@@ -1,6 +1,6 @@
 import { zip } from "@std/collections/zip";
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { FilteredError } from "../translator2/error.ts";
 import { word } from "../translator2/word.ts";
 import * as English from "./ast.ts";

src/translator/noun.ts

@@ -1,5 +1,5 @@
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { mapNullable, nullableAsArray } from "../misc/misc.ts";
 import { settings } from "../settings.ts";
 import { condense } from "../translator2/misc.ts";

src/translator/pronoun.ts

@@ -1,5 +1,5 @@
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { word } from "../translator2/word.ts";
 import * as English from "./ast.ts";
 import { fromNounForms, PartialNoun } from "./noun.ts";

src/translator/verb.ts

@@ -1,5 +1,5 @@
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { nullableAsArray } from "../misc/misc.ts";
 import { settings } from "../settings.ts";
 import { FilteredError } from "../translator2/error.ts";

src/translator/word_unit.ts

@@ -1,6 +1,6 @@
-import { Definition } from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
 import { dictionary } from "../dictionary/dictionary.ts";
+import { Definition } from "../dictionary/type.ts";
 import * as TokiPona from "../parser/ast.ts";
 import { TranslationTodoError } from "../translator2/error.ts";
 import { number, numberAsText } from "../translator2/number.ts";

src/translator2/adjective.ts

@@ -1,5 +1,5 @@
-import * as Dictionary from "../dictionary/type.ts";
 import { IterableResult } from "../compound.ts";
+import * as Dictionary from "../dictionary/type.ts";
 import { nullableAsArray } from "../misc/misc.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";