@remit/ui 0.0.120 → 0.0.121

package/src/components/rich-text-spellcheck-provider.ts

@@ -27,17 +27,39 @@ export interface SpellWorkerPort {
  */
 export const SUGGEST_DEADLINE_MS = 5000;
 
+/**
+ * How long a pass waits before the checker is called stopped. Hunspell answers
+ * a paragraph in single-digit milliseconds, so anything past this is a wedged
+ * engine rather than a slow one — and a wedged engine is invisible: the marks
+ * simply stop moving while `spellcheck` stays off, which on screen is text with
+ * nothing wrong in it. The deadline is what turns that into a failure the
+ * writer is told about and the browser's own checker takes back.
+ */
+export const CHECK_DEADLINE_MS = 5000;
+
+interface Waiting {
+	settle(response: CheckResponse): void;
+	drop(): void;
+}
+
 export const openSpellProvider = (
 	language: LanguageTag,
+	base: string,
 	port: SpellWorkerPort,
+	bytesExpected = 0,
 ): SpellProvider => {
-	const pending = new Map<string, (response: CheckResponse) => void>();
+	const pending = new Map<string, Waiting>();
 	const asking = new Map<
 		string,
 		{ settle(response: SuggestResponse): void; abandon(reason: Error): void }
 	>();
 	const listeners = new Set<(status: ProviderStatus) => void>();
-	let status: ProviderStatus = { state: "opening", language };
+	let status: ProviderStatus = {
+		state: "opening",
+		language,
+		bytesLoaded: 0,
+		bytesTotal: 0,
+	};
 
 	/**
 	 * A check that never comes back costs a pass; a suggestion that never comes
@@ -62,6 +84,15 @@ export const openSpellProvider = (
 	};
 
 	port.listen((message) => {
+		if (message.type === "opening") {
+			publish({
+				state: "opening",
+				language,
+				bytesLoaded: message.bytesLoaded,
+				bytesTotal: message.bytesTotal,
+			});
+			return;
+		}
 		if (message.type === "ready") {
 			publish({ state: "ready", language });
 			return;
@@ -87,20 +118,22 @@ export const openSpellProvider = (
 			});
 			return;
 		}
-		const settle = pending.get(message.requestId);
-		if (!settle) return;
+		const waiting = pending.get(message.requestId);
+		if (!waiting) return;
 		pending.delete(message.requestId);
-		settle({
+		waiting.settle({
 			requestId: message.requestId,
 			revision: message.revision,
 			findings: message.findings,
 		});
 	});
-	port.fail((detail) => {
-		publish({ state: "failed", language, reason: "worker", detail });
+	const stopped = (detail: string): void => {
+		if (status.state !== "failed")
+			publish({ state: "failed", language, reason: "worker", detail });
 		abandonSuggestions(detail);
-	});
-	port.post({ type: "open", language });
+	};
+	port.fail(stopped);
+	port.post({ type: "open", language, base, bytesExpected });
 
 	return {
 		language,
@@ -113,7 +146,27 @@ export const openSpellProvider = (
 		},
 		check: (request) =>
 			new Promise((resolve) => {
-				pending.set(request.requestId, resolve);
+				const deadline = setTimeout(() => {
+					pending.delete(request.requestId);
+					stopped(
+						`the ${language} checker did not answer within ${CHECK_DEADLINE_MS}ms`,
+					);
+					// An empty answer rather than a promise nobody settles: the pass is
+					// over, and the marks it would have painted are the ones the failed
+					// status has just cleared.
+					resolve({
+						requestId: request.requestId,
+						revision: request.revision,
+						findings: [],
+					});
+				}, CHECK_DEADLINE_MS);
+				pending.set(request.requestId, {
+					settle: (response) => {
+						clearTimeout(deadline);
+						resolve(response);
+					},
+					drop: () => clearTimeout(deadline),
+				});
 				port.post({ type: "check", ...request });
 			}),
 		suggest: (request) =>
@@ -139,6 +192,7 @@ export const openSpellProvider = (
 				port.post({ type: "suggest", ...request });
 			}),
 		close: () => {
+			for (const waiting of pending.values()) waiting.drop();
 			pending.clear();
 			abandonSuggestions("the checker closed");
 			listeners.clear();

package/src/components/rich-text-spellcheck-words.ts

@@ -1,10 +1,9 @@
 /**
- * The placeholder a real dictionary replaces (#707): a word list small enough
- * to read, so the marks and the corrections can be driven end to end before an
- * engine exists. The tokeniser is the part that stays — a provider is handed
- * paragraph text and decides for itself where the words are.
+ * The tokeniser. A provider is handed paragraph text and decides for itself
+ * where the words are, so this is the one place that answers what a word is —
+ * and the session ignore list keys off the same normalisation, so ignoring a
+ * word at the start of a sentence ignores it in the middle of the next one.
  */
-import type { LanguageTag } from "./rich-text-spellcheck.js";
 
 export interface WordRange {
 	readonly start: number;
@@ -14,365 +13,28 @@ export interface WordRange {
 /** What a correction menu shows, and what the engine is asked for. */
 export const SUGGESTION_LIMIT = 5;
 
-const ENGLISH: ReadonlySet<string> = new Set([
-	"a",
-	"about",
-	"address",
-	"after",
-	"afternoon",
-	"again",
-	"agenda",
-	"all",
-	"already",
-	"also",
-	"always",
-	"an",
-	"and",
-	"answer",
-	"any",
-	"apologies",
-	"approved",
-	"are",
-	"as",
-	"at",
-	"attached",
-	"available",
-	"be",
-	"because",
-	"been",
-	"before",
-	"both",
-	"budget",
-	"but",
-	"by",
-	"calendar",
-	"call",
-	"can",
-	"change",
-	"client",
-	"colleague",
-	"come",
-	"confirm",
-	"could",
-	"customer",
-	"day",
-	"deadline",
-	"decision",
-	"definitely",
-	"delivery",
-	"did",
-	"do",
-	"document",
-	"does",
-	"done",
-	"down",
-	"draft",
-	"each",
-	"email",
-	"end",
-	"environment",
-	"even",
-	"every",
-	"few",
-	"figures",
-	"find",
-	"first",
-	"follow",
-	"for",
-	"forward",
-	"friday",
-	"from",
-	"get",
-	"give",
-	"go",
-	"good",
-	"had",
-	"has",
-	"have",
-	"he",
-	"help",
-	"her",
-	"here",
-	"him",
-	"his",
-	"how",
-	"i",
-	"if",
-	"in",
-	"into",
-	"invoice",
-	"is",
-	"it",
-	"its",
-	"just",
-	"keep",
-	"know",
-	"last",
-	"let",
-	"like",
-	"long",
-	"look",
-	"made",
-	"make",
-	"many",
-	"may",
-	"me",
-	"meeting",
-	"message",
-	"month",
-	"more",
-	"morning",
-	"most",
-	"much",
-	"must",
-	"my",
-	"necessary",
-	"need",
-	"new",
-	"next",
-	"no",
-	"not",
-	"note",
-	"notes",
-	"now",
-	"number",
-	"numbers",
-	"occurred",
-	"of",
-	"off",
-	"office",
-	"on",
-	"once",
-	"one",
-	"only",
-	"or",
-	"other",
-	"our",
-	"out",
-	"over",
-	"own",
-	"page",
-	"payment",
-	"people",
-	"please",
-	"presentation",
-	"price",
-	"process",
-	"product",
-	"project",
-	"put",
-	"quarter",
-	"question",
-	"read",
-	"ready",
-	"receipt",
-	"receive",
-	"received",
-	"recommend",
-	"regards",
-	"report",
-	"review",
-	"right",
-	"same",
-	"say",
-	"schedule",
-	"see",
-	"send",
-	"sent",
-	"separate",
-	"service",
-	"she",
-	"should",
-	"show",
-	"since",
-	"so",
-	"some",
-	"sorry",
-	"still",
-	"such",
-	"summary",
-	"support",
-	"take",
-	"team",
-	"tell",
-	"than",
-	"thanks",
-	"that",
-	"the",
-	"their",
-	"them",
-	"then",
-	"there",
-	"these",
-	"they",
-	"thing",
-	"think",
-	"this",
-	"those",
-	"through",
-	"time",
-	"to",
-	"today",
-	"together",
-	"tomorrow",
-	"too",
-	"two",
-	"up",
-	"update",
-	"us",
-	"use",
-	"version",
-	"very",
-	"want",
-	"was",
-	"way",
-	"we",
-	"week",
-	"welcome",
-	"well",
-	"were",
-	"what",
-	"when",
-	"where",
-	"which",
-	"while",
-	"who",
-	"why",
-	"will",
-	"with",
-	"word",
-	"work",
-	"would",
-	"year",
-	"yes",
-	"you",
-	"your",
-]);
-
-const DICTIONARIES: ReadonlyMap<string, ReadonlySet<string>> = new Map([
-	["en", ENGLISH],
-]);
-
-export const dictionaryFor = (
-	language: LanguageTag,
-): ReadonlySet<string> | null =>
-	DICTIONARIES.get(language.toLowerCase().split("-")[0]) ?? null;
-
-/**
- * The form a word is looked up and remembered under. The session's ignore list
- * uses it too, so ignoring a word at the start of a sentence ignores it in the
- * middle of the next one.
- */
 export const normaliseWord = (word: string): string =>
 	word.toLowerCase().replace(/’/g, "'");
 
-export const findMisspellings = (
-	text: string,
-	words: ReadonlySet<string>,
-): readonly WordRange[] => {
+/**
+ * Every word in the text, in order. Single letters are not offered: they are
+ * initials and list markers far more often than they are misspellings.
+ */
+export const wordsIn = (text: string): readonly WordRange[] => {
 	const pattern = /\p{L}[\p{L}\p{M}'’]*/gu;
 	const found: WordRange[] = [];
 	let match = pattern.exec(text);
 	while (match) {
-		const word = match[0];
-		if (word.length > 1 && !words.has(normaliseWord(word))) {
-			found.push({ start: match.index, end: match.index + word.length });
+		if (match[0].length > 1) {
+			found.push({ start: match.index, end: match.index + match[0].length });
 		}
 		match = pattern.exec(text);
 	}
 	return found;
 };
 
-const NEAR_ENOUGH = 2;
-
-/**
- * Optimal string alignment: insertions, deletions, substitutions and the
- * swapped pair of letters that is most of what a keyboard produces. Rows are
- * abandoned once every cell in one is further away than a suggestion may be.
- */
-const editDistance = (word: string, candidate: string): number => {
-	let twoBack: number[] = [];
-	let previous = Array.from({ length: candidate.length + 1 }, (_, at) => at);
-	for (let row = 1; row <= word.length; row += 1) {
-		const current = [row];
-		let best = row;
-		for (let column = 1; column <= candidate.length; column += 1) {
-			const cost = word[row - 1] === candidate[column - 1] ? 0 : 1;
-			let step = Math.min(
-				current[column - 1] + 1,
-				previous[column] + 1,
-				previous[column - 1] + cost,
-			);
-			if (
-				row > 1 &&
-				column > 1 &&
-				word[row - 1] === candidate[column - 2] &&
-				word[row - 2] === candidate[column - 1]
-			) {
-				step = Math.min(step, twoBack[column - 2] + 1);
-			}
-			current[column] = step;
-			if (step < best) best = step;
-		}
-		if (best > NEAR_ENOUGH) return NEAR_ENOUGH + 1;
-		twoBack = previous;
-		previous = current;
-	}
-	return previous[candidate.length];
-};
-
-const sharedPrefix = (word: string, candidate: string): number => {
-	let shared = 0;
-	while (
-		shared < word.length &&
-		shared < candidate.length &&
-		word[shared] === candidate[shared]
-	) {
-		shared += 1;
-	}
-	return shared;
-};
-
-/** A suggestion arrives dressed the way the word it replaces was written. */
-const wearingTheCaseOf = (word: string, suggestion: string): string => {
-	const upper = word.toUpperCase();
-	if (word === upper && word !== word.toLowerCase())
-		return suggestion.toUpperCase();
-	if (word[0] === upper[0] && word[0] !== word.toLowerCase()[0]) {
-		return suggestion[0].toUpperCase() + suggestion.slice(1);
-	}
-	return suggestion;
-};
-
-/**
- * The corrections a word list can offer without an engine: everything within a
- * couple of keystrokes, nearest first, and the one that starts the same way
- * ahead of the one that does not.
- */
-export const suggestionsFor = (
-	word: string,
-	words: ReadonlySet<string>,
-): readonly string[] => {
-	const target = normaliseWord(word);
-	if (target.length < 2 || words.has(target)) return [];
-	const ranked: { candidate: string; distance: number; prefix: number }[] = [];
-	for (const candidate of words) {
-		if (Math.abs(candidate.length - target.length) > NEAR_ENOUGH) continue;
-		const distance = editDistance(target, candidate);
-		if (distance > NEAR_ENOUGH) continue;
-		ranked.push({
-			candidate,
-			distance,
-			prefix: sharedPrefix(target, candidate),
-		});
-	}
-	ranked.sort(
-		(left, right) =>
-			left.distance - right.distance ||
-			right.prefix - left.prefix ||
-			left.candidate.localeCompare(right.candidate),
-	);
-	return ranked
-		.slice(0, SUGGESTION_LIMIT)
-		.map(({ candidate }) => wearingTheCaseOf(word, candidate));
-};
+export const findMisspellings = (
+	text: string,
+	known: (word: string) => boolean,
+): readonly WordRange[] =>
+	wordsIn(text).filter((range) => !known(text.slice(range.start, range.end)));

package/src/components/rich-text-spellcheck-worker-provider.ts

@@ -1,11 +1,11 @@
 /**
  * The `spellcheck.provider` a composer hands the editor, over a real worker.
- * A language with no dictionary answers null and no worker ever starts.
+ * A language this build carries no dictionary for answers null and no worker
+ * ever starts, which is what the editor turns into `unavailable`.
  *
  * Its own module, and deliberately not on the package barrel: a bundler emits
- * the worker chunk for whatever graph reaches this `new URL`, and until the
- * build carries an engine (#692, decision 11) that chunk has no business in an
- * app build.
+ * the worker chunk for whatever graph reaches this `new URL`, and a build that
+ * stages no dictionaries has no business carrying that chunk.
  */
 
 import type {
@@ -13,9 +13,13 @@ import type {
 	SpellProvider,
 	SpellWorkerResponse,
 } from "./rich-text-spellcheck.js";
+import {
+	dictionaryTagFor,
+	spellcheckBase,
+	spellcheckBytes,
+} from "./rich-text-spellcheck-languages.js";
 import type { SpellWorkerPort } from "./rich-text-spellcheck-provider.js";
 import { openSpellProvider } from "./rich-text-spellcheck-provider.js";
-import { dictionaryFor } from "./rich-text-spellcheck-words.js";
 
 const workerPort = (worker: Worker): SpellWorkerPort => ({
 	post: (message) => worker.postMessage(message),
@@ -33,10 +37,16 @@ const workerPort = (worker: Worker): SpellWorkerPort => ({
 export const openSpellcheckWorker = async (
 	language: LanguageTag,
 ): Promise<SpellProvider | null> => {
-	if (!dictionaryFor(language)) return null;
+	const tag = dictionaryTagFor(language);
+	if (!tag) return null;
 	const worker = new Worker(
 		new URL("./rich-text-spellcheck-worker.ts", import.meta.url),
 		{ type: "module" },
 	);
-	return openSpellProvider(language, workerPort(worker));
+	return openSpellProvider(
+		tag,
+		spellcheckBase(),
+		workerPort(worker),
+		spellcheckBytes(tag),
+	);
 };