Commit f837389ba02268ce5ee180e09bba96a337be406b | snowbound

arc/platforms.md+3-2

 @@ -177,8 +177,9 @@ keyboard, the toolbar and the macOS menu bar all run commands from it.
   browser keeps its own window and tab chords. Dialogs are the browser's; Insert, and Open
   without a folder to give, ask for files to copy in; printing downloads the PDF. Servers and
   recording are still to come.
-- Spelling is Hunspell's American English dictionary through `spellbook`, fetched beside the
+- Spelling is Hunspell's dictionaries through `spellbook`, each fetched beside the module the
-  module; Add to Dictionary keeps its words in the browser's files. Text the bundled faces
+  first time a word in its language is checked, text no run tags counting as the browser's
+  language; Add to Dictionary keeps its words in the browser's files. Text the bundled faces
   lack takes Noto's, fetched by script the first time a page holds it (a CJK face cut to
   the national standards' characters by `tools/web/subset_cjk.py`; emoji in Noto Color
   Emoji's COLRv1 outlines, which `draw` paints itself), and the page is laid out again.

crates/canvas/src/spelling.rs+71-12

 @@ -8,6 +8,7 @@ use onestore::page::text::Paragraph;
 use std::collections::{HashMap, HashSet};
 use std::hash::{DefaultHasher, Hash, Hasher};
 use std::ops::Range;
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{Arc, Mutex, mpsc};
 /// Checked paragraphs kept before the cache starts over.
 @@ -36,6 +37,7 @@ pub fn pick(language: u32, available: &[String]) -> Option<&str> {
     // A bare tag is the locale Windows picks, most often the language's own country.
     let home = match bare {
         "en" => "US".to_owned(),
+        "pt" => "BR".to_owned(),
         _ => bare.to_uppercase(),
     };
     let wanted = if region.is_empty() {
 @@ -70,7 +72,8 @@ pub(crate) struct Mark {
 /// A word of a paragraph: its bytes, its language, and whether its spelling is checked.
 struct Word {
     range: Range<usize>,
-    language: u32,
+    /// The run's language, an LCID; `None` where untagged.
+    language: Option<u32>,
     checked: bool,
 }
 @@ -157,9 +160,7 @@ fn words(paragraph: &Paragraph) -> Vec<Word> {
             }
             words.push(Word {
                 range: at + offset..at + end,
-                language: format(at + offset)
+                language: format(at + offset).language,
-                    .language
-                    .unwrap_or(crate::language::EN_US),
                 checked: word.chars().any(char::is_lowercase),
             });
         }
 @@ -203,7 +204,8 @@ fn repeated(text: &str, words: &[Word]) -> Vec<bool> {
 /// The marks `dictionary` gives each of `paragraphs`, asking it once: each word repeating
 /// the one before it, and each other checked word it finds misspelled.
-fn check(paragraphs: &[&Paragraph], dictionary: &dyn Dictionary) -> Vec<Vec<Mark>> {
+/// Checks `paragraphs`, reading text no run tags as language `untagged`.
+fn check(paragraphs: &[&Paragraph], dictionary: &dyn Dictionary, untagged: u32) -> Vec<Vec<Mark>> {
     let words: Vec<(Vec<Word>, Vec<bool>)> = paragraphs
         .iter()
         .map(|paragraph| {
 @@ -220,7 +222,10 @@ fn check(paragraphs: &[&Paragraph], dictionary: &dyn Dictionary) -> Vec<Vec<Mark
                 .iter()
                 .zip(repeated)
                 .filter(|(word, repeated)| word.checked && !**repeated)
-                .map(|(word, _)| (&paragraph.text()[word.range.clone()], word.language))
+                .map(|(word, _)| {
+                    let language = word.language.unwrap_or(untagged);
+                    (&paragraph.text()[word.range.clone()], language)
+                })
         })
         .collect();
     let mut misspelled = dictionary.misspelled(&asked).into_iter();
 @@ -309,6 +314,8 @@ impl State {
 struct Shared {
     dictionary: Box<dyn Dictionary>,
+    /// The language text no run tags is checked in, an LCID: US English, as OneNote's.
+    untagged: AtomicU32,
     state: Mutex<State>,
 }
 @@ -324,6 +331,7 @@ impl Spelling {
     pub fn new(dictionary: Box<dyn Dictionary>, redraw: std::task::Waker) -> Self {
         let shared = Arc::new(Shared {
             dictionary,
+            untagged: AtomicU32::new(crate::language::EN_US),
             state: Mutex::default(),
         });
         let (jobs, receiver) = mpsc::channel::<(u64, Paragraph)>();
 @@ -341,7 +349,8 @@ impl Spelling {
                         .collect();
                     let paragraphs: Vec<&Paragraph> =
                         jobs.iter().map(|(_, paragraph)| paragraph).collect();
-                    let marks = check(&paragraphs, &*worker.dictionary);
+                    let untagged = worker.untagged.load(Ordering::Relaxed);
+                    let marks = check(&paragraphs, &*worker.dictionary, untagged);
                     let mut state = worker.state.lock().unwrap();
                     for ((key, paragraph), marks) in jobs.iter().zip(marks) {
                         state.pending.remove(key);
 @@ -379,17 +388,30 @@ impl Spelling {
         if let Some(marks) = self.shared.state.lock().unwrap().marks(key, paragraph) {
             return marks;
         }
-        let marks = check(&[paragraph], &*self.shared.dictionary).remove(0);
+        let untagged = self.shared.untagged.load(Ordering::Relaxed);
+        let marks = check(&[paragraph], &*self.shared.dictionary, untagged).remove(0);
         let mut state = self.shared.state.lock().unwrap();
         state.keep(key, paragraph, marks);
         state.marks(key, paragraph).unwrap_or_default()
     }
+    /// Checks every paragraph again when next asked, as after a dictionary arrived.
+    pub fn recheck(&self) {
+        self.shared.state.lock().unwrap().checked.clear();
+    }
+    /// Checks text no run tags in `language`, an LCID, as a browser's text is in its own.
+    pub fn untagged(&self, language: u32) {
+        self.shared.untagged.store(language, Ordering::Relaxed);
+        self.recheck();
+    }
     /// Corrections for `word` in `language`, best first.
     pub(crate) fn suggest(&self, word: &str, language: Option<u32>) -> Vec<String> {
-        self.shared
+        self.shared.dictionary.suggest(
-            .dictionary
+            word,
-            .suggest(word, language.unwrap_or(crate::language::EN_US))
+            language.unwrap_or(self.shared.untagged.load(Ordering::Relaxed)),
+        )
     }
     /// Ignore: leaves `word` unmarked everywhere until the app quits.
 @@ -470,10 +492,13 @@ pub(crate) mod tests {
         let hunspell: Vec<String> = ["en_AU", "en_US", "fr_FR"].map(String::from).into();
         assert_eq!(pick(1033, &hunspell), Some("en_US"));
         assert_eq!(pick(1036, &hunspell), Some("fr_FR"));
+        let portuguese: Vec<String> = ["pt_PT", "pt_BR"].map(String::from).into();
+        assert_eq!(pick(1046, &portuguese), Some("pt_BR"));
+        assert_eq!(pick(2070, &portuguese), Some("pt_PT"));
     }
     fn marked(paragraph: &Paragraph) -> Vec<(&str, bool)> {
-        check(&[paragraph], &Fake)
+        check(&[paragraph], &Fake, crate::language::EN_US)
             .remove(0)
             .into_iter()
             .map(|mark| (&paragraph.text()[mark.range], mark.repeated))
 @@ -583,4 +608,38 @@ pub(crate) mod tests {
             .expect("the spelling thread wakes the host");
         assert_eq!(spelling.marks(&french).len(), 2);
     }
+    #[test]
+    fn arriving_dictionaries_and_untagged_languages_check_paragraphs_again() {
+        struct Late(Arc<std::sync::atomic::AtomicBool>);
+        impl Dictionary for Late {
+            fn misspelled(&self, words: &[(&str, u32)]) -> Vec<bool> {
+                match self.0.load(std::sync::atomic::Ordering::Relaxed) {
+                    true => Fake.misspelled(words),
+                    false => vec![false; words.len()],
+                }
+            }
+            fn suggest(&self, _: &str, _: u32) -> Vec<String> {
+                Vec::new()
+            }
+            fn learn(&self, _: &str) {}
+        }
+        let arrived = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let spelling = Spelling::new(
+            Box::new(Late(Arc::clone(&arrived))),
+            std::task::Waker::noop().clone(),
+        );
+        let paragraph = Paragraph::new("Ths sentense here".into(), Format::default());
+        assert!(spelling.marks_now(&paragraph).is_empty());
+        arrived.store(true, std::sync::atomic::Ordering::Relaxed);
+        assert!(
+            spelling.marks_now(&paragraph).is_empty(),
+            "kept until asked again"
+        );
+        spelling.recheck();
+        assert_eq!(spelling.marks_now(&paragraph).len(), 2);
+        // Untagged text is US English until the host says otherwise.
+        spelling.untagged(1036);
+        assert_eq!(spelling.marks_now(&paragraph).len(), 3);
+    }
 }

crates/snowbound/src/spell_web.rs+62-32

...	@@ -1,59 +1,89 @@	...	@@ -1,59 +1,89 @@
1	//! Spelling in the browser, which gives pages no checker to ask: Hunspell's American English	1	//! Spelling in the browser, which gives pages no checker to ask: Hunspell dictionaries through
2	//! dictionary through `spellbook`, which `index.html` fetches beside the module, with the	2	//! `spellbook`, each fetched beside the module the first time a word in its language is
3	//! words Add to Dictionary learns kept in the browser's files.	3	//! checked, with the words Add to Dictionary learns kept in the browser's files.
4		4
5	use canvas::spelling::{Dictionary, pick};	5	use canvas::spelling::{Dictionary, pick};
6	use std::{io::Write, sync::Mutex};	6	use std::{collections::BTreeMap, io::Write, sync::Mutex};
7		7
8	/// The dictionary's files, where `web::start` puts them, and the words learned.
9	pub const AFFIX: &str = "/Dictionaries/en_US.aff";
10	pub const WORDS: &str = "/Dictionaries/en_US.dic";
11	const LEARNED: &str = "/Settings/dictionary.txt";	8	const LEARNED: &str = "/Settings/dictionary.txt";
12		9
13	struct Checker(Mutex<spellbook::Dictionary>);	10	/// The dictionaries the site has, as `en_US`, which `platform::start` lists.
		11	static AVAILABLE: Mutex<Vec<String>> = Mutex::new(Vec::new());
		12	/// The dictionaries asked for, by name: `None` until one arrives, or where it failed to.
		13	static LOADED: Mutex<BTreeMap<String, Option<spellbook::Dictionary>>> = Mutex::new(BTreeMap::new());
14		14
		15	struct Checker;
		16
		17	/// The checker, where the site has dictionaries.
15	pub fn dictionary() -> Option<Box<dyn Dictionary>> {	18	pub fn dictionary() -> Option<Box<dyn Dictionary>> {
16	let affix = notebook::fs::read_to_string(AFFIX).ok()?;	19	let available = AVAILABLE.lock().ok()?;
17	let words = notebook::fs::read_to_string(WORDS).ok()?;	20	(!available.is_empty()).then(\|\| Box::new(Checker) as Box<dyn Dictionary>)
18	let mut dictionary = spellbook::Dictionary::new(&affix, &words).ok()?;	21	}
19	for word in notebook::fs::read_to_string(LEARNED)	22
20	.unwrap_or_default()	23	/// Lists the dictionaries the site has.
21	.lines()	24	pub fn offer(names: Vec<String>) {
22	{	25	if let Ok(mut available) = AVAILABLE.lock() {
23	let _ = dictionary.add(word);	26	*available = names;
24	}	27	}
25	Some(Box::new(Checker(Mutex::new(dictionary))))
26	}	28	}
27		29
28	/// Whether the dictionary serves `language`, an LCID.	30	/// Dictionary `name` arrived as its affix and word files.
29	fn serves(language: u32) -> bool {	31	pub fn arrived(name: &str, affix: &str, words: &str) {
30	pick(language, &["en_US".to_owned()]).is_some()	32	let dictionary = spellbook::Dictionary::new(affix, words)
		33	.ok()
		34	.map(\|mut dictionary\| {
		35	for word in notebook::fs::read_to_string(LEARNED)
		36	.unwrap_or_default()
		37	.lines()
		38	{
		39	let _ = dictionary.add(word);
		40	}
		41	dictionary
		42	});
		43	if let Ok(mut loaded) = LOADED.lock() {
		44	loaded.insert(name.to_owned(), dictionary);
		45	}
		46	}
		47
		48	/// Runs `check` with the dictionary serving `language`, an LCID, asking for it the first
		49	/// time; `None` until it arrives, or where none serves the language.
		50	fn with<T>(language: u32, check: impl FnOnce(&mut spellbook::Dictionary) -> T) -> Option<T> {
		51	let name = pick(language, &AVAILABLE.lock().ok()?)?.to_owned();
		52	let mut loaded = LOADED.lock().ok()?;
		53	match loaded.get_mut(&name) {
		54	Some(dictionary) => dictionary.as_mut().map(check),
		55	None => {
		56	loaded.insert(name.clone(), None);
		57	crate::platform::fetch_dictionary(&name);
		58	None
		59	}
		60	}
31	}	61	}
32		62
33	impl Dictionary for Checker {	63	impl Dictionary for Checker {
34	fn misspelled(&self, words: &[(&str, u32)]) -> Vec<bool> {	64	fn misspelled(&self, words: &[(&str, u32)]) -> Vec<bool> {
35	let Ok(dictionary) = self.0.lock() else {
36	return vec![false; words.len()];
37	};
38	words	65	words
39	.iter()	66	.iter()
40	.map(\|(word, language)\| serves(*language) && !dictionary.check(word))	67	.map(\|(word, language)\| {
		68	with(*language, \|dictionary\| !dictionary.check(word)).unwrap_or(false)
		69	})
41	.collect()	70	.collect()
42	}	71	}
43		72
44	fn suggest(&self, word: &str, language: u32) -> Vec<String> {	73	fn suggest(&self, word: &str, language: u32) -> Vec<String> {
45	let mut suggestions = Vec::new();	74	with(language, \|dictionary\| {
46	if serves(language)	75	let mut suggestions = Vec::new();
47	&& let Ok(dictionary) = self.0.lock()
48	{
49	dictionary.suggest(word, &mut suggestions);	76	dictionary.suggest(word, &mut suggestions);
50	}	77	suggestions
51	suggestions	78	})
		79	.unwrap_or_default()
52	}	80	}
53		81
54	fn learn(&self, word: &str) {	82	fn learn(&self, word: &str) {
55	if let Ok(mut dictionary) = self.0.lock() {	83	if let Ok(mut loaded) = LOADED.lock() {
56	let _ = dictionary.add(word);	84	for dictionary in loaded.values_mut().flatten() {
		85	let _ = dictionary.add(word);
		86	}
57	}	87	}
58	let _ = notebook::fs::OpenOptions::new()	88	let _ = notebook::fs::OpenOptions::new()
59	.create(true)	89	.create(true)

crates/snowbound/src/web.rs+26-10

 @@ -80,6 +80,9 @@ extern "C" {
     /// Fetches `fonts/{name}` for `font_arrived`.
     #[wasm_bindgen(js_name = fetchFont)]
     fn fetch_font(name: &str);
+    /// Fetches dictionary `name`'s files for `dictionary_arrived`.
+    #[wasm_bindgen(js_name = fetchDictionary)]
+    pub fn fetch_dictionary(name: &str);
     #[wasm_bindgen(js_name = storeFiles)]
     fn store_files(changes: js_sys::Array);
 }
 @@ -865,14 +868,14 @@ pub mod smb {
     }
 }
-/// Starts Snowbound on the page's canvas, `index.html` having fetched `fonts` and, where it
+/// Starts Snowbound on the page's canvas, `index.html` having fetched `fonts` and the names
-/// could, the spelling dictionary's affix and word files. `module` is the module's own
+/// of the spelling dictionaries the site has. `module` is the module's own exports, which
-/// exports, which the glue calls.
+/// the glue calls.
 #[wasm_bindgen]
 pub async fn start(
     module: JsValue,
     fonts: Vec<js_sys::Uint8Array>,
-    dictionary: Vec<js_sys::Uint8Array>,
+    dictionaries: Vec<String>,
 ) -> Result<(), JsValue> {
     std::panic::set_hook(Box::new(|info| report(info)));
     let window = web_sys::window().ok_or("No window")?;
 @@ -901,12 +904,7 @@ pub async fn start(
     canvas.set_width(host(|host| host.size.width));
     canvas.set_height(host(|host| host.size.height));
     restore(load_files().await?);
-    if let [affix, words] = dictionary.as_slice() {
+    crate::spell::offer(dictionaries);
-        notebook::fs::restore("/Dictionaries", notebook::fs::Saved::Directory);
-        for (path, file) in [(crate::spell::AFFIX, affix), (crate::spell::WORDS, words)] {
-            notebook::fs::restore(path, notebook::fs::Saved::File(file.to_vec(), 0.0));
-        }
-    }
     for folder in load_folders().await?.iter() {
         let folder = js_sys::Array::from(&folder);
         let root = folder.get(0).as_string().unwrap_or_default();
 @@ -916,6 +914,10 @@ pub async fn start(
     let state = open(fonts)
         .await
         .map_err(|error| JsValue::from_str(&error.to_string()))?;
+    // Text no run tags is in the browser's language, as typed in it.
+    if let Some(spelling) = &state.spelling {
+        spelling.untagged(canvas::language::lcid(&input_language()));
+    }
     STATE.with_borrow_mut(|slot| *slot = Some(state));
     attach(module);
     request_frame();
 @@ -1423,6 +1425,20 @@ pub fn font_arrived(name: String, bytes: Vec<u8>) {
     })));
 }
+/// Spelling dictionary `name` arrived as its affix and word files: words in its languages
+/// are checked again.
+#[wasm_bindgen]
+pub fn dictionary_arrived(name: String, affix: String, words: String) {
+    crate::spell::arrived(&name, &affix, &words);
+    send(UserEvent::Then(Box::new(|state| {
+        if let Some(spelling) = &state.spelling {
+            spelling.recheck();
+        }
+        state.window.request_redraw();
+        Ok(())
+    })));
+}
 /// Parks the text area while the page takes no text, keeping it writable for the
 /// interface's fields.
 fn park_input(state: &State) {

crates/snowbound/web/glue.js+18-8

 @@ -287,19 +287,29 @@ export function pickNotebook() {
     .catch((error) => error.name === "AbortError" || console.error("Opening the folder", error));
 }
+// The bytes at `url`, inflated where it ends in .gz.
+async function inflated(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`${url}: ${response.status}`);
+  const body = url.endsWith(".gz")
+    ? new Response(response.body.pipeThrough(new DecompressionStream("gzip")))
+    : response;
+  return body.arrayBuffer();
+}
 export function fetchFont(name) {
-  fetch(`fonts/${name}`)
+  inflated(`fonts/${name}`)
-    .then((response) => {
-      if (!response.ok) return Promise.reject(response.status);
-      const body = name.endsWith(".gz")
-        ? new Response(response.body.pipeThrough(new DecompressionStream("gzip")))
-        : response;
-      return body.arrayBuffer();
-    })
     .then((data) => wasm.font_arrived(name, new Uint8Array(data)))
     .catch((error) => console.warn("Font", name, error));
 }
+export function fetchDictionary(name) {
+  const text = new TextDecoder();
+  Promise.all(["aff", "dic"].map((kind) => inflated(`dictionaries/${name}.${kind}.gz`)))
+    .then(([affix, words]) => wasm.dictionary_arrived(name, text.decode(affix), text.decode(words)))
+    .catch((error) => console.warn("Dictionary", name, error));
+}
 export function requestFrame() {
   if (!framePending) {
     framePending = true;

crates/snowbound/web/index.html+5-4

 @@ -83,13 +83,14 @@
   }
   try {
     const fetched = (url) => bytes(url).then((data) => new Uint8Array(data));
-    const [, fonts, dictionary] = await Promise.all([
+    const [, fonts, dictionaries] = await Promise.all([
       init({ module_or_path: module }),
       Promise.all(FONTS.map((name) => fetched(`fonts/${name}.ttf`))),
-      // Spelling waits for none: without the dictionary, words go unmarked.
+      // The spelling dictionaries the site has, fetched as pages need them; without the
-      Promise.all(["aff", "dic"].map((kind) => fetched(`dictionaries/en_US.${kind}`))).catch(() => []),
+      // list, words go unmarked.
+      fetch("dictionaries/index.json").then((response) => response.json()).catch(() => []),
     ]);
-    await snowbound.start(snowbound, fonts, dictionary);
+    await snowbound.start(snowbound, fonts, dictionaries);
     status.remove();
     console.info(`Snowbound loaded in ${Math.round(performance.now())} ms`);
   } catch (error) {

tools/release_web.py+48-5

...	@@ -8,6 +8,7 @@ static folder and publishes it to the share's web/ folder.	...	@@ -8,6 +8,7 @@ static folder and publishes it to the share's web/ folder.
8	import argparse	8	import argparse
9	import gzip	9	import gzip
10	import hashlib	10	import hashlib
		11	import json
11	import os	12	import os
12	from pathlib import Path	13	from pathlib import Path
13	import shutil	14	import shutil
...	@@ -28,6 +29,22 @@ EMOJI_URL = 'https://github.com/googlefonts/noto-emoji/raw/v2.051/fonts/Noto-COL	...	@@ -28,6 +29,22 @@ EMOJI_URL = 'https://github.com/googlefonts/noto-emoji/raw/v2.051/fonts/Noto-COL
28	EMOJI_SHA256 = '0ae57fe58645638523ba35f388d93739d292539a9acb84df5700c81b1e1a28d2'	29	EMOJI_SHA256 = '0ae57fe58645638523ba35f388d93739d292539a9acb84df5700c81b1e1a28d2'
29	# As `EMOJI` in src/web.rs names it.	30	# As `EMOJI` in src/web.rs names it.
30	EMOJI_FONT = 'Noto-COLRv1.ttf.gz'	31	EMOJI_FONT = 'Noto-COLRv1.ttf.gz'
		32	# Spelling dictionaries: the name the page asks for, the nixpkgs hunspellDicts package, its
		33	# files' stem, and the SPDX licences it comes under, each checked to allow redistribution
		34	# (the LGPL's text with the GPL's, which it amends). Add a row to offer another language.
		35	DICTIONARIES = [
		36	('en_US', 'en_US', 'en_US', ['BSD-3-Clause']),
		37	('en_GB', 'en_GB-ise', 'en_GB', ['BSD-3-Clause']),
		38	('de_DE', 'de_DE', 'de_DE', ['GPL-2.0-only', 'GPL-3.0-only']),
		39	('fr_FR', 'fr-moderne', 'fr-moderne', ['MPL-2.0']),
		40	('es_ES', 'es_ES', 'es_ES', ['GPL-3.0-only', 'LGPL-3.0-only', 'MPL-1.1']),
		41	('pt_BR', 'pt_BR', 'pt_BR', ['LGPL-3.0-only', 'GPL-3.0-only']),
		42	('pt_PT', 'pt_PT', 'pt_PT', ['GPL-2.0-only', 'LGPL-2.1-only', 'MPL-1.1']),
		43	('it_IT', 'it_IT', 'it_IT', ['GPL-3.0-only']),
		44	('nl_NL', 'nl_NL', 'nl_NL', ['BSD-3-Clause', 'CC-BY-3.0']),
		45	('sv_SE', 'sv_SE', 'sv_SE', ['LGPL-3.0-only', 'GPL-3.0-only']),
		46	('ru_RU', 'ru_RU', 'ru_RU', ['MPL-2.0', 'LGPL-3.0-only', 'GPL-3.0-only']),
		47	]
31	# Size over speed where it costs little: the module is most of the first load.	48	# Size over speed where it costs little: the module is most of the first load.
32	PROFILE = ['--config', 'profile.release.opt-level="s"']	49	PROFILE = ['--config', 'profile.release.opt-level="s"']
33		50
...	@@ -75,11 +92,7 @@ def build(out):	...	@@ -75,11 +92,7 @@ def build(out):
75	bound = out / 'snowbound_web_bg.wasm'	92	bound = out / 'snowbound_web_bg.wasm'
76	run([tool('wasm-opt', 'binaryen'), '-Oz', '--strip-debug', '--strip-producers', bound, '-o', bound])	93	run([tool('wasm-opt', 'binaryen'), '-Oz', '--strip-debug', '--strip-producers', bound, '-o', bound])
77	shutil.copy(WEB / 'index.html', out)	94	shutil.copy(WEB / 'index.html', out)
78	# Hunspell's American English dictionary (SCOWL, BSD-3-Clause), for spelling.	95	dictionaries(out / 'dictionaries')
79	(out / 'dictionaries').mkdir()
80	store = Path(tool('hunspell', 'hunspellDicts.en_US', store=True))
81	for name in ('share/hunspell/en_US.aff', 'share/hunspell/en_US.dic', 'share/doc/hunspell-dict-en-us-wordlist.txt'):
82	shutil.copy(store / name, out / 'dictionaries')
83	(out / 'fonts').mkdir()	96	(out / 'fonts').mkdir()
84	for font in sorted(FONTS.glob('*')):	97	for font in sorted(FONTS.glob('*')):
85	if font.suffix in ('.ttf', '.txt'):	98	if font.suffix in ('.ttf', '.txt'):
...	@@ -90,6 +103,36 @@ def build(out):	...	@@ -90,6 +103,36 @@ def build(out):
90	print(f'{path.stat().st_size:>12,} {path.relative_to(out)}')	103	print(f'{path.stat().st_size:>12,} {path.relative_to(out)}')
91		104
92		105
		106	def dictionaries(folder):
		107	"""The Hunspell dictionaries in DICTIONARIES as UTF-8, gzipped for the glue to inflate,
		108	each beside its readme, the texts of the licences they come under in licenses/, and their
		109	names in index.json for the page to pick from (`pick` in canvas/src/spelling.rs)."""
		110	(folder / 'licenses').mkdir(parents=True)
		111	texts = Path(tool('spdx', 'spdx-license-list-data.text', store=True)) / 'text'
		112	for name, package, stem, licenses in DICTIONARIES:
		113	store = Path(tool('hunspell', f'hunspellDicts.{package}', store=True))
		114	affix = (store / f'share/hunspell/{stem}.aff').read_bytes()
		115	# Hunspell names the files' encoding in the affix file's SET line.
		116	encoding = next((line.split()[1] for line in affix.decode('latin-1').splitlines()
		117	if line.startswith('SET ')), 'UTF-8')
		118	for kind in ('aff', 'dic'):
		119	text = (store / f'share/hunspell/{stem}.{kind}').read_bytes().decode(encoding)
		120	# One encoding and one line ending for spellbook, which reads only UTF-8. An
		121	# 8-bit file's flags are its characters by default, as FLAG UTF-8 keeps them.
		122	utf8 = 'SET UTF-8' if encoding == 'UTF-8' or 'FLAG ' in text else 'SET UTF-8\nFLAG UTF-8'
		123	text = ''.join((utf8 if line.startswith('SET ') else line) + '\n'
		124	for line in text.splitlines())
		125	(folder / f'{name}.{kind}.gz').write_bytes(gzip.compress(text.encode(), 9, mtime=0))
		126	# Where a package has no readme, its affix file's header comment names the licences.
		127	readme = list((store / 'share/doc').glob('*.txt'))
		128	notice = readme[0].read_bytes() if readme else \
		129	''.join(line + '\n' for line in affix.decode(encoding).splitlines() if line.startswith('#')).encode()
		130	(folder / f'{name}.txt').write_bytes(notice + f'\nLicences: {", ".join(licenses)} (licenses/)\n'.encode())
		131	for license in licenses:
		132	shutil.copyfile(texts / f'{license}.txt', folder / 'licenses' / f'{license}.txt')
		133	(folder / 'index.json').write_text(json.dumps([name for name, *_ in DICTIONARIES]))
		134
		135
93	def fallbacks(fonts):	136	def fallbacks(fonts):
94	"""Noto's faces for scripts the bundled ones lack, which the page fetches as it needs them	137	"""Noto's faces for scripts the bundled ones lack, which the page fetches as it needs them
95	(`FALLBACKS` in src/web.rs), under the SIL Open Font License."""	138	(`FALLBACKS` in src/web.rs), under the SIL Open Font License."""

author	clover caruso <git@paperclover.net> 2026-10-02 12:09:48-07:00
committer	clover caruso <git@paperclover.net> 2026-10-02 12:53:12-07:00
log	f837389ba02268ce5ee180e09bba96a337be406b
tree	44c9676ca81879e4006f58c1b30dadbe14ef43a4
parent	21adbb5dfae140e40626cefd52ed377a44977c7f
signature	Signed by SSH key SHA256:52mNGHRsVFBDED9IAX5pe+LRWUefqTbxEReunq21QvU

feat: the web build checks spelling in ten more languages (#64)