implement sandbox tagging and optional recognition of these words

Author: neverRare

dictionary.txt

@@ -151,11 +151,11 @@ e:
     `[`marks the start of a direct object`]`(particle def);
 
 eliki:
-#     # sandbox
-#
-#     trial(n);
-#     adversity(n);
-#     bittersweet(adj opinion);
+    @sandbox;
+
+    trial(n);
+    adversity(n);
+    bittersweet(adj opinion);
 
 en:
     # core

dist/index.html

@@ -129,6 +129,8 @@ <h1>
         Randomize output order</label>
       <label><input id="multiline" type="checkbox" />
         Multiline input</label>
+      <label><input id="sandbox" type="checkbox" />
+        Recognize marginal words</label>
       <label for="quantity">Singular and plural forms</label>
       <select id="quantity">
         <option selected value="both">Show all</option>

src/dictionary/dictionary.ts

@@ -1,8 +1,11 @@
+import { settings } from "../settings.ts";
 import { dictionary as globalDictionary } from "./global_dictionary.ts";
-import { Definition, Dictionary } from "./type.ts";
+import { Definition, Dictionary, Entry } from "./type.ts";
 
 // all of these global constants are mutable
 
+let sandbox = false;
+
 const customDictionary: Dictionary = new Map();
 export const dictionary: Dictionary = new Map();
 
@@ -15,6 +18,12 @@ export const tokiPonaWordSet: Set<string> = new Set();
 
 update();
 
+export function updateSandboxInclusion(): void {
+  if (sandbox !== settings.sandbox) {
+    sandbox = settings.sandbox;
+    update();
+  }
+}
 export function loadCustomDictionary(dictionary: Dictionary): void {
   customDictionary.clear();
   for (const [key, value] of dictionary) {
@@ -24,10 +33,14 @@ export function loadCustomDictionary(dictionary: Dictionary): void {
 }
 function update() {
   dictionary.clear();
-  const words = new Set([
-    ...globalDictionary.keys(),
-    ...customDictionary.keys(),
-  ]);
+  const words = new Set(
+    [
+      ...globalDictionary.entries(),
+      ...customDictionary.entries(),
+    ]
+      .filter(([_, entry]) => !entry.sandbox || settings.sandbox)
+      .map(([word]) => word),
+  );
   for (const word of words) {
     const entry = customDictionary.get(word) ?? globalDictionary.get(word)!;
     if (entry.definitions.length > 0) {

src/dictionary/parser.ts

@@ -80,6 +80,7 @@ const closeBracket = lex(matchString("]", "close bracket"));
 const comma = lex(matchString(",", "comma"));
 const semicolon = lex(matchString(";", "semicolon"));
 const slash = lex(matchString("/", "slash"));
+const atSign = lex(matchString("@", "slash"));
 
 const keyword = memoize(<T extends string>(keyword: T) =>
   lex(
@@ -629,15 +630,19 @@ const positionedHead = sequence(
   .map(([init, last]) => [...init, last]);
 const entry = withSource(
   ignore.with(
-    allWithCheck(
-      new CheckedParser(
-        sequence(unescapedWord, choiceOnlyOne(openParenthesis, slash)),
-        definition.skip(semicolon),
+    sequence(
+      optionalAll(sequence(atSign, keyword("sandbox"), semicolon)),
+      allWithCheck(
+        new CheckedParser(
+          sequence(unescapedWord, choiceOnlyOne(openParenthesis, slash)),
+          definition.skip(semicolon),
+        ),
       ),
     ),
   ),
 )
-  .map(([definitions, source]): Entry => ({
+  .map(([[sandbox, definitions], source]): Entry => ({
+    sandbox: sandbox != null,
     definitions,
     source: source.trimEnd(),
   }));

src/dictionary/type.ts

@@ -94,6 +94,7 @@ export type Definition =
   | Readonly<{ type: "preposition"; preposition: string }>
   | Readonly<{ type: "interjection"; interjection: string }>;
 export type Entry = Readonly<{
+  sandbox: boolean;
   definitions: ReadonlyArray<Definition>;
   source: string;
 }>;

src/main.ts

@@ -4,7 +4,11 @@ import { closestString } from "@std/text/closest-string";
 import BrowserDetector from "browser-dtector";
 import PROJECT_DATA from "../project_data.json" with { type: "json" };
 import { extractResultError, Result, ResultError } from "./compound.ts";
-import { dictionary, loadCustomDictionary } from "./dictionary/dictionary.ts";
+import {
+  dictionary,
+  loadCustomDictionary,
+  updateSandboxInclusion,
+} from "./dictionary/dictionary.ts";
 import { parseDictionary } from "./dictionary/parser.ts";
 import { Dictionary } from "./dictionary/type.ts";
 import {
@@ -181,6 +185,7 @@ function main() {
 
   // load settings
   loadFromLocalStorage();
+  updateSandboxInclusion();
 
   // states for storing previous dictionary states for discarding dictionary edits
   let lastSavedText: string = customDictionaryTextBox.value;
@@ -332,6 +337,7 @@ function main() {
   });
   confirmButton.addEventListener("click", () => {
     loadFromDom();
+    updateSandboxInclusion();
     updateLabel();
     settingsDialogBox.close();
   });

src/settings.ts

@@ -4,13 +4,15 @@ export type Redundancy = "both" | "condensed" | "default only";
 export type Settings = {
   randomize: boolean;
   multiline: boolean;
+  sandbox: boolean;
   quantity: Redundancy;
   tense: Redundancy;
 };
 // the default value may change, also change `index.html`
 export const defaultSettings: Readonly<Settings> = Object.freeze({
   randomize: false,
   multiline: false,
+  sandbox: false,
   quantity: "both",
   tense: "both",
 });