@inshapardaz/likhari-react 0.1.20 → 0.1.21-dev.194

package/dist/spellcheck/spellDictionaries.d.ts

@@ -0,0 +1,40 @@
+/** Languages the spellchecker has a dictionary slot for. */
+export type SpellLanguage = 'en' | 'ur' | 'pa-shahmukhi';
+/** A Hunspell dictionary as the two text files every Hunspell dictionary ships with. */
+export interface HunspellFiles {
+    /** Affix file: language, encoding, character rules. */
+    aff: string;
+    /** Dictionary file: one word per line, with optional affix flags. */
+    dic: string;
+}
+export interface Speller {
+    correct(word: string): boolean;
+    suggest(word: string): string[];
+}
+type Loader = () => Promise<HunspellFiles>;
+/**
+ * Registers a dictionary for a language. Call once at startup with files you
+ * have licence to ship — e.g. the Urdu `.aff`/`.dic` pair — either as strings
+ * or as a loader that fetches them on demand. Registering again replaces the
+ * previous dictionary for that language.
+ */
+export declare function registerSpellDictionary(language: SpellLanguage, files: HunspellFiles | Loader): void;
+/** Whether a dictionary is registered for the language. */
+export declare function hasSpellDictionary(language: SpellLanguage): boolean;
+/**
+ * The speller for a language, loading its dictionary the first time it is
+ * asked for. Resolves to null when no dictionary is registered, so callers
+ * can skip spellchecking that language rather than flag every word.
+ */
+export declare function getSpeller(language: SpellLanguage): Promise<Speller> | null;
+/** A word in a text, with its position as character offsets. */
+export interface WordSpan {
+    word: string;
+    start: number;
+    end: number;
+}
+export declare function wordsIn(text: string): WordSpan[];
+/** The words in `text` the speller does not recognise. */
+export declare function misspellingsIn(text: string, speller: Speller): WordSpan[];
+export {};
+//# sourceMappingURL=spellDictionaries.d.ts.map

package/dist/spellcheck/spellDictionaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spellDictionaries.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellDictionaries.ts"],"names":[],"mappings":"AAEA,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,GAAG,cAAc,CAAC;AAEzD,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACjC;AAED,KAAK,MAAM,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;AAmB3C;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAGpG;AAED,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAS3E;AAED,gEAAgE;AAChE,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AASD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAMhD;AAED,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,EAAE,CAEzE"}

package/dist/spellcheck/spellDictionaries.js

@@ -0,0 +1,62 @@
+import nspell from 'nspell';
+const loaders = new Map();
+const spellers = new Map();
+async function fetchText(url) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Spellcheck dictionary failed to load: ${url}`);
+    return response.text();
+}
+/** English ships with the editor: its files are fetched on first use. */
+const englishLoader = async () => ({
+    aff: await fetchText(new URL('./dictionaries/en/index.aff', import.meta.url).href),
+    dic: await fetchText(new URL('./dictionaries/en/index.dic', import.meta.url).href),
+});
+loaders.set('en', englishLoader);
+/**
+ * Registers a dictionary for a language. Call once at startup with files you
+ * have licence to ship — e.g. the Urdu `.aff`/`.dic` pair — either as strings
+ * or as a loader that fetches them on demand. Registering again replaces the
+ * previous dictionary for that language.
+ */
+export function registerSpellDictionary(language, files) {
+    loaders.set(language, typeof files === 'function' ? files : async () => files);
+    spellers.delete(language);
+}
+/** Whether a dictionary is registered for the language. */
+export function hasSpellDictionary(language) {
+    return loaders.has(language);
+}
+/**
+ * The speller for a language, loading its dictionary the first time it is
+ * asked for. Resolves to null when no dictionary is registered, so callers
+ * can skip spellchecking that language rather than flag every word.
+ */
+export function getSpeller(language) {
+    const loader = loaders.get(language);
+    if (!loader)
+        return null;
+    let speller = spellers.get(language);
+    if (!speller) {
+        speller = loader().then(({ aff, dic }) => nspell(aff, dic));
+        spellers.set(language, speller);
+    }
+    return speller;
+}
+/**
+ * Letters and combining marks, with apostrophes inside a word kept. The
+ * Unicode classes cover Arabic-script letters and their diacritics, so Urdu
+ * and Shahmukhi words are found the same way English ones are.
+ */
+const WORD = /[\p{L}\p{M}]+(?:['’][\p{L}\p{M}]+)*/gu;
+export function wordsIn(text) {
+    return [...text.matchAll(WORD)].map((match) => ({
+        word: match[0],
+        start: match.index ?? 0,
+        end: (match.index ?? 0) + match[0].length,
+    }));
+}
+/** The words in `text` the speller does not recognise. */
+export function misspellingsIn(text, speller) {
+    return wordsIn(text).filter((span) => !speller.correct(span.word));
+}

package/dist/spellcheck/spellcheckActions.d.ts

@@ -0,0 +1,21 @@
+import { type FindMatch } from '../find/findReplaceActions.js';
+import { type Speller } from './spellDictionaries.js';
+/** The checker for each text direction: English for LTR blocks, Urdu for RTL. */
+export interface Checkers {
+    ltr?: Speller;
+    rtl?: Speller;
+}
+/** The part of a misspelled word that falls inside one text node. */
+export interface Segment {
+    key: string;
+    start: number;
+    end: number;
+}
+export interface Misspelling {
+    word: string;
+    match: FindMatch;
+    segments: Segment[];
+}
+/** Every word in the document its block's checker does not recognise. */
+export declare function $collectMisspellings(checkers: Checkers): Misspelling[];
+//# sourceMappingURL=spellcheckActions.d.ts.map

package/dist/spellcheck/spellcheckActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spellcheckActions.d.ts","sourceRoot":"","sources":["../../src/spellcheck/spellcheckActions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,EAAW,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,qEAAqE;AACrE,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,CAmBtE"}

package/dist/spellcheck/spellcheckActions.js

@@ -0,0 +1,38 @@
+import { $textGroups, $locate } from '../find/findReplaceActions.js';
+import { wordsIn } from './spellDictionaries.js';
+/** Every word in the document its block's checker does not recognise. */
+export function $collectMisspellings(checkers) {
+    const found = [];
+    for (const group of $textGroups()) {
+        const direction = group[0].getParentOrThrow().getDirection();
+        const speller = direction === 'rtl' ? checkers.rtl : checkers.ltr;
+        if (!speller)
+            continue;
+        const text = group.map((node) => node.getTextContent()).join('');
+        for (const span of wordsIn(text)) {
+            if (speller.correct(span.word))
+                continue;
+            const start = $locate(group, span.start, false);
+            const end = $locate(group, span.end, true);
+            found.push({
+                word: span.word,
+                match: { anchorKey: start.key, anchorOffset: start.offset, focusKey: end.key, focusOffset: end.offset },
+                segments: segmentsOf(group, span.start, span.end),
+            });
+        }
+    }
+    return found;
+}
+function segmentsOf(group, start, end) {
+    const segments = [];
+    let offset = 0;
+    for (const node of group) {
+        const length = node.getTextContent().length;
+        const from = Math.max(start, offset);
+        const to = Math.min(end, offset + length);
+        if (to > from)
+            segments.push({ key: node.getKey(), start: from - offset, end: to - offset });
+        offset += length;
+    }
+    return segments;
+}

package/dist/theme/editor.css

@@ -870,3 +870,130 @@
   opacity: 0.8;
   white-space: nowrap;
 }
+
+/* Spellcheck panel: same top-right floating spot as the find widget, which
+   closes when this opens. */
+.likhari-spell-panel {
+  position: absolute;
+  z-index: 5;
+  top: 8px;
+  right: 16px;
+  width: max-content;
+  max-width: min(360px, calc(100% - 32px));
+  max-height: 60%;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 8px;
+  border: 1px solid var(--editor-line);
+  border-radius: 6px;
+  background: var(--editor-paper-dim);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.12);
+  font-size: 13px;
+}
+
+.likhari-spell-panel[dir='rtl'] {
+  right: auto;
+  left: 16px;
+}
+
+.likhari-spell-header,
+.likhari-spell-controls {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 6px;
+  margin-bottom: 6px;
+}
+
+.likhari-spell-controls select {
+  min-width: 0;
+  max-width: 100%;
+}
+
+.likhari-spell-panel button {
+  padding: 2px 8px;
+  border: 1px solid var(--editor-line);
+  border-radius: 4px;
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+}
+
+.likhari-spell-panel button:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.likhari-spell-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  padding: 0 !important;
+  border: none !important;
+}
+
+.likhari-spell-note {
+  margin: 4px 0;
+  opacity: 0.8;
+}
+
+.likhari-spell-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.likhari-spell-list li {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 0;
+  border-top: 1px solid var(--editor-line);
+}
+
+.likhari-spell-word {
+  font-weight: 600;
+  color: #b42318 !important;
+}
+
+.likhari-spell-suggestion {
+  font-size: 12px;
+}
+
+/* Misspelled words, underlined like the browser's own spellcheck. Styled
+   through the CSS Custom Highlight API by SpellHighlightPlugin. */
+::highlight(likhari-spelling) {
+  text-decoration: red wavy underline;
+  text-decoration-skip-ink: none;
+}
+
+.likhari-spell-nav {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 4px;
+  margin-bottom: 6px;
+}
+
+.likhari-spell-status {
+  opacity: 0.8;
+}
+
+.likhari-spell-item {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding-top: 6px;
+  border-top: 1px solid var(--editor-line);
+}
+
+.likhari-spell-suggestions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inshapardaz/likhari-react",
-  "version": "0.1.20",
+  "version": "0.1.21-dev.194",
   "description": "React implementation of the Likhari editor, built on @lexical/react.",
   "license": "MIT",
   "repository": {
@@ -29,10 +29,12 @@
     "*.css"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node ../../scripts/fix-esm-extensions.mjs ./dist && node ../../scripts/copy-assets.mjs src dist \"**/*.css\"",
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/fix-esm-extensions.mjs ./dist && node ../../scripts/copy-assets.mjs src dist \"**/*.css\" && node ../../scripts/copy-assets.mjs src dist \"**/*.aff\" && node ../../scripts/copy-assets.mjs src dist \"**/*.dic\" && node ../../scripts/copy-assets.mjs src dist \"**/*.txt\"",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@inshapardaz/likhari-converters": "^0.1.0",
+    "@inshapardaz/likhari-core": "^0.1.0",
     "@lexical/link": "^0.20.0",
     "@lexical/list": "^0.20.0",
     "@lexical/react": "^0.20.0",
@@ -40,10 +42,9 @@
     "@lexical/selection": "^0.20.0",
     "@lexical/table": "^0.20.0",
     "@lexical/utils": "^0.20.0",
-    "@inshapardaz/likhari-converters": "^0.1.0",
-    "@inshapardaz/likhari-core": "^0.1.0",
     "@tabler/icons-react": "^3.46.0",
-    "lexical": "^0.20.0"
+    "lexical": "^0.20.0",
+    "nspell": "^2.1.5"
   },
   "peerDependencies": {
     "@mantine/core": "^9.6.3",
@@ -53,6 +54,7 @@
   },
   "devDependencies": {
     "@mantine/core": "^9.6.3",
-    "@mantine/hooks": "^9.6.3"
+    "@mantine/hooks": "^9.6.3",
+    "@types/nspell": "^2.1.6"
   }
 }