hunspell-reader 8.3.2 → 8.4.0

package/dist/{IterableHunspellReader.d.ts → IterableHunspellReaderLegacy.d.ts}

@@ -1,6 +1,6 @@
 import type { Sequence } from 'gensequence';
-import type { Aff } from './aff.js';
 import type { AffWord } from './affDef.js';
+import type { Aff } from './affLegacy.js';
 import type { WordInfo } from './types.js';
 export { WordInfo } from './types.js';
 export interface HunspellSrcData {
@@ -9,7 +9,7 @@ export interface HunspellSrcData {
     /** the hunspell dictionary entries complete with affix flags */
     dic: string[];
 }
-export declare class IterableHunspellReader implements Iterable<string> {
+export declare class IterableHunspellReaderLegacy implements Iterable<string> {
     readonly src: HunspellSrcData;
     readonly aff: Aff;
     constructor(src: HunspellSrcData);
@@ -67,7 +67,7 @@ export declare class IterableHunspellReader implements Iterable<string> {
      * @param dicFile - path to dic file.
      * @returns IterableHunspellReader
      */
-    static createFromFiles(affFile: string, dicFile: string): Promise<IterableHunspellReader>;
+    static createFromFiles(affFile: string, dicFile: string): Promise<IterableHunspellReaderLegacy>;
 }
 export declare function createMatchingWordsFilter(): (t: string) => boolean;
-//# sourceMappingURL=IterableHunspellReader.d.ts.map
+//# sourceMappingURL=IterableHunspellReaderLegacy.d.ts.map

package/dist/{IterableHunspellReader.js → IterableHunspellReaderLegacy.js}

@@ -1,11 +1,11 @@
 import * as fs from 'fs/promises';
 import { genSequence } from 'gensequence';
 import pkgIconvLite from 'iconv-lite';
-import { parseAffFileToAff } from './affReader.js';
+import { parseAffFileToAffLegacy } from './affReader.js';
 import { filterOrderedList } from './util.js';
 const { decode } = pkgIconvLite;
 const defaultEncoding = 'UTF-8';
-export class IterableHunspellReader {
+export class IterableHunspellReaderLegacy {
     src;
     aff;
     constructor(src) {
@@ -105,7 +105,7 @@ export class IterableHunspellReader {
      * @returns IterableHunspellReader
      */
     static async createFromFiles(affFile, dicFile) {
-        const aff = await parseAffFileToAff(affFile, defaultEncoding);
+        const aff = await parseAffFileToAffLegacy(affFile, defaultEncoding);
         const buffer = await fs.readFile(dicFile);
         const dicFileContent = decode(buffer, aff.affInfo.SET);
         const dic = dicFileContent
@@ -113,10 +113,10 @@ export class IterableHunspellReader {
             .slice(1) // The first entry is the count of entries.
             .map((a) => a.trim())
             .filter((line) => !!line);
-        return new IterableHunspellReader({ aff, dic });
+        return new IterableHunspellReaderLegacy({ aff, dic });
     }
 }
 export function createMatchingWordsFilter() {
     return filterOrderedList((a, b) => a !== b);
 }
-//# sourceMappingURL=IterableHunspellReader.js.map
+//# sourceMappingURL=IterableHunspellReaderLegacy.js.map

package/dist/aff.d.ts

@@ -1,14 +1,17 @@
-import type { AffInfo, AffWord, AffWordFlags, Fx, Rule, Substitution } from './affDef.js';
+import type { AffInfo } from './affDef.js';
 import { Converter } from './converter.js';
 /** The `word` field in a Converted AffWord has been converted using the OCONV mapping */
-export type ConvertedAffWord = AffWord;
+export interface ConvertedAffixWord extends AffixWord {
+    originalWord: string;
+}
 export declare class Aff {
-    affInfo: AffInfo;
-    protected rules: Map<string, Rule>;
+    #private;
+    readonly affInfo: AffInfo;
+    protected affData: AffData;
     protected _oConv: Converter;
     protected _iConv: Converter;
     private _maxSuffixDepth;
-    constructor(affInfo: AffInfo);
+    constructor(affInfo: AffInfo, filename: string);
     get maxSuffixDepth(): number;
     set maxSuffixDepth(value: number);
     /**
@@ -16,34 +19,210 @@ export declare class Aff {
      * For performance reasons, only the `word` field is mapped with OCONV.
      * @param {string} line - the line from the .dic file.
      */
-    applyRulesToDicEntry(line: string, maxDepth?: number): ConvertedAffWord[];
+    applyRulesToDicEntry(line: string, maxDepth?: number): ConvertedAffixWord[];
     /**
      * @internal
      */
-    applyRulesToWord(affWord: AffWord, remainingDepth: number): AffWord[];
-    applyAffixesToWord(affixRules: Fx[], affWord: AffWord, remainingDepth: number): AffWord[];
-    applyAffixToWord(affix: Fx, affWord: AffWord, combinableSfx: string): AffWord[];
-    substitute(affix: Fx, affWord: AffWord, sub: Substitution): AffWord;
-    getMatchingRules(rules: string): Rule[];
-    joinRules(rules: string[]): string;
-    separateRules(rules: string): string[];
+    applyRulesToWord(affWord: AffixWord, remainingDepth: number): AffixWord[];
+    applyAffixesToWord(affWord: AffixWord, remainingDepth: number): AffixWord[];
+    applyAffixToWord(rule: FxRule, affWord: AffixWord, combinableSfx: FxRule[]): AffixWord[];
+    getMatchingRules(flags: string): AffRule[];
+    /**
+     * Convert the applied rule indexes to AFF Letters.
+     * Requires that the affixWord was generated with trace mode turned on.
+     * @param affixWord - the generated AffixWord.
+     */
+    getFlagsValuesForAffixWord(affixWord: AffixWord): string[] | undefined;
     get iConv(): Converter;
     get oConv(): Converter;
+    setTraceMode(value: boolean): void;
+}
+export declare function compareAff(a: AffixWord, b: AffixWord): number;
+export declare enum AffixFlags {
+    none = 0,
+    /**
+     * COMPOUNDFLAG flag
+     *
+     * Words signed with COMPOUNDFLAG may be in compound words (except when word shorter than COMPOUNDMIN).
+     * Affixes with COMPOUNDFLAG also permits compounding of affixed words.
+     *
+     */
+    isCompoundPermitted = 1,
+    /**
+     * COMPOUNDBEGIN flag
+     *
+     * Words signed with COMPOUNDBEGIN (or with a signed affix) may be first elements in compound words.
+     *
+     */
+    canBeCompoundBegin = 2,// default false
+    /**
+     * COMPOUNDMIDDLE flag
+     *
+     * Words signed with COMPOUNDMIDDLE (or with a signed affix) may be middle elements in compound words.
+     *
+     */
+    canBeCompoundMiddle = 4,// default false
+    /**
+     * COMPOUNDLAST flag
+     *
+     * Words signed with COMPOUNDLAST (or with a signed affix) may be last elements in compound words.
+     *
+     */
+    canBeCompoundEnd = 8,// default false
+    /**
+     * COMPOUNDPERMITFLAG flag
+     *
+     * Prefixes are allowed at the beginning of compounds, suffixes are allowed at the end of compounds by default.
+     * Affixes with COMPOUNDPERMITFLAG may be inside of compounds.
+     *
+     */
+    isOnlyAllowedInCompound = 16,
+    /**
+     * COMPOUNDFORBIDFLAG flag
+     *
+     * Suffixes with this flag forbid compounding of the affixed word.
+     *
+     */
+    isCompoundForbidden = 32,
+    /**
+     * WARN flag
+     *
+     * This flag is for rare words, which are also often spelling mistakes, see option -r of command line Hunspell and FORBIDWARN.
+     */
+    isWarning = 64,
+    /**
+     * KEEPCASE flag
+     *
+     * Forbid uppercased and capitalized forms of words signed with KEEPCASE flags. Useful for special orthographies (measurements and
+     * currency often keep their case in uppercased texts) and writing systems (e.g. keeping lower case of IPA characters). Also valuable
+     * for words erroneously written in the wrong case.
+     */
+    isKeepCase = 128,
+    /**
+     * FORCEUCASE flag
+     *
+     * Last word part of a compound with flag FORCEUCASE forces capitalization of the whole compound word.
+     * Eg. Dutch word "straat" (street) with FORCEUCASE flags will allowed only in capitalized compound forms,
+     * according to the Dutch spelling rules for proper names.
+     */
+    isForceUCase = 256,
+    /**
+     * FORBIDDENWORD flag
+     *
+     * This flag signs forbidden word form. Because affixed forms are also forbidden, we can subtract a subset from set of the
+     * accepted affixed and compound words. Note: useful to forbid erroneous words, generated by the compounding mechanism.
+     */
+    isForbiddenWord = 512,
+    /**
+     * NOSUGGEST flag
+     *
+     * Words signed with NOSUGGEST flag are not suggested (but still accepted when typed correctly). Proposed flag for vulgar
+     * and obscene words (see also SUBSTANDARD).
+     */
+    isNoSuggest = 1024,
+    /**
+     * NEEDAFFIX flag
+     *
+     * This flag signs virtual stems in the dictionary, words only valid when affixed. Except, if the dictionary word has a homonym
+     * or a zero affix. NEEDAFFIX works also with prefixes and prefix + suffix combinations (see tests/pseudoroot5.*).
+     */
+    isNeedAffix = 2048
+}
+type RuleIdx = number;
+type SingleFlag = string;
+type WordFlags = string;
+type DictionaryLine = string;
+interface DictionaryEntry {
+    word: string;
+    /** flags are the part after the `/`, `word/FLAGS` */
+    flags: string;
+    /** The original dictionary line. */
+    line: string;
+}
+export interface AffixWordSource {
+    /** Original dictionary entry */
+    dict: DictionaryEntry;
+    /** Optional applied rules, trace mode must be turned on. */
+    appliedRules?: number[] | undefined;
+}
+export interface AffixWord extends AffixWordSource {
+    /** The word */
+    word: string;
+    /** Rules to apply */
+    rules: FxRule[] | undefined;
+    /** Flags */
+    flags: AffixFlags;
+}
+declare class AffData {
+    #private;
+    private affInfo;
+    readonly filename: string;
+    rules: AffRule[];
+    mapToRuleIdx: Map<SingleFlag, RuleIdx | RuleIdx[]>;
+    mapWordRulesToRuleIndexes: Map<WordFlags, RuleIdx[]>;
+    mapWordRulesToRules: Map<WordFlags, AffRule[]>;
+    affFlagType: 'long' | 'num' | 'char';
+    missingFlags: Set<string>;
+    private _mapRuleIdxToRules;
+    trace: boolean;
+    constructor(affInfo: AffInfo, filename: string);
+    dictLineToEntry(line: DictionaryLine): DictionaryEntry;
+    dictLineToAffixWord(line: DictionaryLine): AffixWord;
+    toAffixWord(source: AffixWordSource | AffixWord, word: string, flags: AffixFlags, rules: AffRule[] | undefined): AffixWord;
+    getRules(rules: WordFlags): AffRule[];
+    getRuleIndexes(rules: WordFlags): RuleIdx[];
+    rulesToFlags(rules: AffRule[]): AffixFlags;
+    getRulesForIndexes(indexes: undefined): undefined;
+    getRulesForIndexes(indexes: RuleIdx[]): AffRule[];
+    getRulesForIndexes(indexes: RuleIdx[] | undefined): AffRule[] | undefined;
+    getRulesForAffSubstitution(sub: AffSubstitution): AffRule[] | undefined;
+}
+type AffType = 'P' | 'S';
+interface AffFx {
+    type: AffType;
+    id: string;
+    combinable: boolean;
+    substitutionsForRegExps: AffSubstitutionsForRegExp[];
+}
+interface AffSubstitution {
+    type: AffType;
+    remove: string;
+    attach: string;
+    attachRules?: RuleIdx[];
+    replace: RegExp;
+}
+interface AffSubstitutionsForRegExp {
+    match: RegExp;
+    substitutionsGroupedByRemove: Map<RegExp, AffSubstitution[]>;
+}
+type AffRule = FlagRule | FxRule;
+type FxRule = PfxRule | SfxRule;
+type RuleType = 'S' | 'P' | 'F';
+interface RuleBase {
+    id: string;
+    idx: number;
+    type: RuleType;
+    flags: AffixFlags;
+    px?: AffFx;
+}
+interface FlagRule extends RuleBase {
+    type: 'F';
+    flags: AffixFlags;
+}
+interface PfxRule extends RuleBase {
+    type: 'P';
+    fx: AffFx;
+}
+interface SfxRule extends RuleBase {
+    type: 'S';
+    fx: AffFx;
 }
-declare function signature(aff: AffWord): string;
-export declare function processRules(affInfo: AffInfo): Map<string, Rule>;
-export declare function logAffWord(affWord: AffWord, message: string): AffWord;
-export declare function affWordToColoredString(affWord: AffWord): string;
-export declare function flagsToString(flags: AffWordFlags): string;
-export declare function asAffWord(word: string, rules?: string, flags?: AffWordFlags): AffWord;
-export declare function compareAff(a: AffWord, b: AffWord): 0 | 1 | -1;
+type AffFlagType = 'long' | 'num' | 'char';
 /**
- * Returns a filter function that will filter adjacent AffWords
- * It compares the word and the flags.
+ *
+ * @param FLAG - the FLAG value from the aff file
+ * @returns the AffFlagType or throws
  */
-export declare function filterAff(): (t: AffWord) => boolean;
-export declare const debug: {
-    signature: typeof signature;
-};
+export declare function toAffFlagType(FLAG: string | undefined): AffFlagType;
 export {};
 //# sourceMappingURL=aff.d.ts.map