sudachi-ts 0.1.21 → 0.1.22

package/build/src/dictionary/dictionaryFactory.js

@@ -46,6 +46,15 @@ export class DictionaryFactory {
         }
         const loader = new PluginLoader(anchor);
         const defaultConfig = Config.parse(DEFAULT_CONFIG_JSON).setAnchor(anchor);
+        let editConnectionPluginConfs = config.getPlugins('editConnectionCostPlugin');
+        if (!editConnectionPluginConfs || editConnectionPluginConfs.length === 0) {
+            editConnectionPluginConfs = defaultConfig.getPlugins('editConnectionCostPlugin');
+        }
+        if (editConnectionPluginConfs && editConnectionPluginConfs.length > 0) {
+            for (const loaded of await loader.loadEditConnectionCostPlugins(editConnectionPluginConfs, grammar, lexicon)) {
+                loaded.plugin.edit(grammar);
+            }
+        }
         let inputTextPluginConfs = config.getPlugins('inputTextPlugin');
         if (!inputTextPluginConfs || inputTextPluginConfs.length === 0) {
             inputTextPluginConfs = defaultConfig.getPlugins('inputTextPlugin');

package/build/src/index.d.ts

@@ -24,7 +24,7 @@ export { DEPTH, MAX_COMPONENT_LENGTH, POS } from './dictionary/pos.js';
 export { PartialPOS, PosMatcher } from './dictionary/posMatcher.js';
 export { WordInfo } from './dictionary/wordInfo.js';
 export { DoubleArray } from './dictionary-build/doubleArray.js';
-export { EditConnectionCostPlugin, InputTextPlugin, type LoadedPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, } from './plugins/index.js';
+export { EditConnectionCostPlugin, InputTextPlugin, type LoadedPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, TargetedConnectionCostPlugin, } from './plugins/index.js';
 export type { NonBreakChecker } from './sentdetect/sentenceDetector.js';
 export { DEFAULT_LIMIT, SentenceDetector, } from './sentdetect/sentenceDetector.js';
 export { applyMask, dic, dicIdMask, MAX_DIC_ID, MAX_WORD_ID, make, word, } from './utils/wordId.js';

package/build/src/index.js

@@ -15,7 +15,7 @@ export { DEPTH, MAX_COMPONENT_LENGTH, POS } from './dictionary/pos.js';
 export { PartialPOS, PosMatcher } from './dictionary/posMatcher.js';
 export { WordInfo } from './dictionary/wordInfo.js';
 export { DoubleArray } from './dictionary-build/doubleArray.js';
-export { EditConnectionCostPlugin, InputTextPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, } from './plugins/index.js';
+export { EditConnectionCostPlugin, InputTextPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, TargetedConnectionCostPlugin, } from './plugins/index.js';
 export { DEFAULT_LIMIT, SentenceDetector, } from './sentdetect/sentenceDetector.js';
 export { applyMask, dic, dicIdMask, MAX_DIC_ID, MAX_WORD_ID, make, word, } from './utils/wordId.js';
 export { addNth, hasNth, MAX_LENGTH, nth } from './utils/wordMask.js';

package/build/src/plugins/base.d.ts

@@ -1,4 +1,4 @@
-import type { Settings } from '../config/settings.js';
+import { Settings } from '../config/settings.js';
 export declare abstract class Plugin {
     protected settings: Settings;
     constructor();

package/build/src/plugins/base.js

@@ -1,7 +1,8 @@
+import { Settings } from '../config/settings.js';
 export class Plugin {
     settings;
     constructor() {
-        this.settings = { getString: () => null };
+        this.settings = Settings.empty();
     }
     setSettings(settings) {
         this.settings = settings;

package/build/src/plugins/connection/base.d.ts

@@ -1,7 +1,8 @@
 import type { Grammar } from '../../dictionary/grammar.js';
+import type { Lexicon } from '../../dictionary/lexicon.js';
 import { Plugin } from '../base.js';
 export declare abstract class EditConnectionCostPlugin extends Plugin {
-    setUp(_grammar: Grammar): void;
+    setUp(_grammar: Grammar, _lexicon?: Lexicon): void;
     abstract edit(grammar: Grammar): void;
     inhibitConnection(grammar: Grammar, left: number, right: number): void;
 }

package/build/src/plugins/connection/base.js

@@ -1,6 +1,6 @@
 import { Plugin } from '../base.js';
 export class EditConnectionCostPlugin extends Plugin {
-    setUp(_grammar) { }
+    setUp(_grammar, _lexicon) { }
     inhibitConnection(grammar, left, right) {
         grammar.setConnectCost(left, right, grammar.INHIBITED_CONNECTION);
     }

package/build/src/plugins/connection/targetedConnectionCostPlugin.d.ts

@@ -0,0 +1,13 @@
+import type { Grammar } from '../../dictionary/grammar.js';
+import type { Lexicon } from '../../dictionary/lexicon.js';
+import { EditConnectionCostPlugin } from './base.js';
+export declare class TargetedConnectionCostPlugin extends EditConnectionCostPlugin {
+    private rules;
+    setUp(grammar: Grammar, lexicon?: Lexicon): void;
+    edit(grammar: Grammar): void;
+    private resolveRule;
+    private resolveWordId;
+    private normalizePos;
+    private requireConnectionRule;
+    private requireEntryTarget;
+}

package/build/src/plugins/connection/targetedConnectionCostPlugin.js

@@ -0,0 +1,102 @@
+import { EditConnectionCostPlugin } from './base.js';
+export class TargetedConnectionCostPlugin extends EditConnectionCostPlugin {
+    rules = [];
+    setUp(grammar, lexicon) {
+        if (!lexicon) {
+            throw new Error('TargetedConnectionCostPlugin requires the lexicon during setup');
+        }
+        const rawRules = this.settings.toObject().rules;
+        if (!Array.isArray(rawRules) || rawRules.length === 0) {
+            throw new Error('rules is undefined');
+        }
+        this.rules = rawRules.map((rule, index) => this.resolveRule(grammar, lexicon, rule, index + 1));
+    }
+    edit(grammar) {
+        for (const rule of this.rules) {
+            grammar.setConnectCost(rule.leftRightId, rule.rightLeftId, rule.cost);
+        }
+    }
+    resolveRule(grammar, lexicon, rule, ruleIndex) {
+        const parsedRule = this.requireConnectionRule(rule, ruleIndex);
+        const leftWordId = this.resolveWordId(grammar, lexicon, parsedRule.left, 'rule', ruleIndex, 'left');
+        const rightWordId = this.resolveWordId(grammar, lexicon, parsedRule.right, 'rule', ruleIndex, 'right');
+        return {
+            leftRightId: lexicon.getRightId(leftWordId),
+            rightLeftId: lexicon.getLeftId(rightWordId),
+            cost: parsedRule.cost,
+        };
+    }
+    resolveWordId(grammar, lexicon, target, ruleLabel, ruleIndex, side) {
+        if (typeof target.surface !== 'string' || target.surface === '') {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} surface must be a non-empty string`);
+        }
+        if (typeof target.reading !== 'string' || target.reading === '') {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} reading must be a non-empty string`);
+        }
+        const pos = this.normalizePos(target.pos, ruleLabel, ruleIndex, side);
+        const posId = grammar.getPartOfSpeechId(pos);
+        if (posId < 0) {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} POS ${pos.join(',')} was not found in the loaded grammar`);
+        }
+        const wordId = lexicon.getWordId(target.surface, posId, target.reading);
+        if (wordId < 0) {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} entry ${target.surface} (${pos.join(',')} / ${target.reading}) was not found in the loaded lexicon`);
+        }
+        return wordId;
+    }
+    normalizePos(pos, ruleLabel, ruleIndex, side) {
+        if (!Array.isArray(pos) || pos.length === 0) {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} pos must be a non-empty string list`);
+        }
+        const normalized = pos.map((item) => {
+            if (typeof item !== 'string') {
+                throw new Error(`${ruleLabel} ${ruleIndex} ${side} pos must contain only strings`);
+            }
+            return item;
+        });
+        while (normalized.length < 6) {
+            normalized.push('*');
+        }
+        return normalized.slice(0, 6);
+    }
+    requireConnectionRule(rule, ruleIndex) {
+        if (typeof rule !== 'object' || rule === null) {
+            throw new Error(`rule ${ruleIndex} must be an object`);
+        }
+        const obj = rule;
+        const left = obj.left;
+        const right = obj.right;
+        const cost = obj.cost;
+        if (typeof cost !== 'number') {
+            throw new Error(`rule ${ruleIndex} cost must be a number`);
+        }
+        return {
+            left: this.requireEntryTarget(left, ruleIndex, 'left'),
+            right: this.requireEntryTarget(right, ruleIndex, 'right'),
+            cost,
+        };
+    }
+    requireEntryTarget(value, ruleIndex, side) {
+        if (typeof value !== 'object' || value === null) {
+            throw new Error(`rule ${ruleIndex} ${side} must be an object`);
+        }
+        const obj = value;
+        const surface = obj.surface;
+        const pos = obj.pos;
+        const reading = obj.reading;
+        if (typeof surface !== 'string') {
+            throw new Error(`rule ${ruleIndex} ${side} surface must be a string`);
+        }
+        if (!Array.isArray(pos)) {
+            throw new Error(`rule ${ruleIndex} ${side} pos must be a string list`);
+        }
+        if (typeof reading !== 'string') {
+            throw new Error(`rule ${ruleIndex} ${side} reading must be a string`);
+        }
+        return {
+            surface,
+            pos: pos,
+            reading,
+        };
+    }
+}

package/build/src/plugins/index.d.ts

@@ -1,6 +1,7 @@
 export { Plugin } from './base.js';
 export { EditConnectionCostPlugin } from './connection/base.js';
 export { InhibitConnectionPlugin } from './connection/inhibitConnectionPlugin.js';
+export { TargetedConnectionCostPlugin } from './connection/targetedConnectionCostPlugin.js';
 export { MorphemeFormatterPlugin } from './formatter/base.js';
 export { SimpleMorphemeFormatter } from './formatter/simpleMorphemeFormatter.js';
 export { WordSegmentationFormatter } from './formatter/wordSegmentationFormatter.js';

package/build/src/plugins/index.js

@@ -1,6 +1,7 @@
 export { Plugin } from './base.js';
 export { EditConnectionCostPlugin } from './connection/base.js';
 export { InhibitConnectionPlugin } from './connection/inhibitConnectionPlugin.js';
+export { TargetedConnectionCostPlugin } from './connection/targetedConnectionCostPlugin.js';
 export { MorphemeFormatterPlugin } from './formatter/base.js';
 export { SimpleMorphemeFormatter } from './formatter/simpleMorphemeFormatter.js';
 export { WordSegmentationFormatter } from './formatter/wordSegmentationFormatter.js';

package/build/src/plugins/loader.d.ts

@@ -1,6 +1,7 @@
 import { PathAnchor } from '../config/pathAnchor.js';
 import type { Settings } from '../config/settings.js';
 import type { Grammar } from '../dictionary/grammar.js';
+import type { Lexicon } from '../dictionary/lexicon.js';
 import type { Plugin } from './base.js';
 import type { EditConnectionCostPlugin } from './connection/base.js';
 import type { MorphemeFormatterPlugin } from './formatter/base.js';
@@ -11,6 +12,10 @@ export interface LoadedPlugin<T extends Plugin> {
     plugin: T;
     className: string;
 }
+type PluginConfig = {
+    className: string;
+    settings: Settings;
+};
 export declare class PluginLoader {
     private readonly anchor;
     constructor(anchor?: PathAnchor);
@@ -19,27 +24,16 @@ export declare class PluginLoader {
     loadPathRewritePlugin(className: string, settings: Settings): Promise<LoadedPlugin<PathRewritePlugin>>;
     loadEditConnectionCostPlugin(className: string, settings: Settings): Promise<LoadedPlugin<EditConnectionCostPlugin>>;
     loadMorphemeFormatterPlugin(className: string, settings: Settings): Promise<LoadedPlugin<MorphemeFormatterPlugin>>;
-    loadInputTextPlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<InputTextPlugin>[]>;
-    loadOovProviderPlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<OovProviderPlugin>[]>;
-    loadPathRewritePlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<PathRewritePlugin>[]>;
-    loadEditConnectionCostPlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<EditConnectionCostPlugin>[]>;
+    loadInputTextPlugins(configs: PluginConfig[], grammar: Grammar): Promise<LoadedPlugin<InputTextPlugin>[]>;
+    loadOovProviderPlugins(configs: PluginConfig[], grammar: Grammar): Promise<LoadedPlugin<OovProviderPlugin>[]>;
+    loadPathRewritePlugins(configs: PluginConfig[], grammar: Grammar): Promise<LoadedPlugin<PathRewritePlugin>[]>;
+    loadEditConnectionCostPlugins(configs: PluginConfig[], grammar: Grammar, lexicon: Lexicon): Promise<LoadedPlugin<EditConnectionCostPlugin>[]>;
     private loadPlugin;
+    private loadConfiguredPlugins;
     private findPluginClass;
     private isPluginConstructor;
     private resolveClassSpecifier;
     private isPathLikeSpecifier;
-    private isBuiltIn;
     private getBuiltIn;
 }
+export {};

package/build/src/plugins/loader.js

@@ -2,6 +2,7 @@ import { isAbsolute, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { PathAnchor } from '../config/pathAnchor.js';
 import { InhibitConnectionPlugin } from './connection/inhibitConnectionPlugin.js';
+import { TargetedConnectionCostPlugin } from './connection/targetedConnectionCostPlugin.js';
 import { DefaultInputTextPlugin } from './inputText/defaultInputTextPlugin.js';
 import { IgnoreYomiganaPlugin } from './inputText/ignoreYomiganaPlugin.js';
 import { ProlongedSoundMarkInputTextPlugin } from './inputText/prolongedSoundMarkPlugin.js';
@@ -37,37 +38,19 @@ export class PluginLoader {
         return { plugin, className };
     }
     async loadInputTextPlugins(configs, grammar) {
-        const results = [];
-        for (const config of configs) {
-            const loaded = await this.loadInputTextPlugin(config.className, config.settings);
-            loaded.plugin.setUp(grammar);
-            results.push(loaded);
-        }
-        return results;
+        return this.loadConfiguredPlugins(configs, grammar, (config) => this.loadInputTextPlugin(config.className, config.settings), (plugin) => plugin.setUp(grammar));
     }
     async loadOovProviderPlugins(configs, grammar) {
-        const results = [];
-        for (const config of configs) {
-            const loaded = await this.loadOovProviderPlugin(config.className, config.settings);
-            loaded.plugin.setUp(grammar);
-            results.push(loaded);
-        }
-        return results;
+        return this.loadConfiguredPlugins(configs, grammar, (config) => this.loadOovProviderPlugin(config.className, config.settings), (plugin) => plugin.setUp(grammar));
     }
     async loadPathRewritePlugins(configs, grammar) {
-        const results = [];
-        for (const config of configs) {
-            const loaded = await this.loadPathRewritePlugin(config.className, config.settings);
-            loaded.plugin.setUp(grammar);
-            results.push(loaded);
-        }
-        return results;
+        return this.loadConfiguredPlugins(configs, grammar, (config) => this.loadPathRewritePlugin(config.className, config.settings), (plugin) => plugin.setUp(grammar));
     }
-    async loadEditConnectionCostPlugins(configs, grammar) {
+    async loadEditConnectionCostPlugins(configs, grammar, lexicon) {
         const results = [];
         for (const config of configs) {
             const loaded = await this.loadEditConnectionCostPlugin(config.className, config.settings);
-            loaded.plugin.setUp(grammar);
+            await loaded.plugin.setUp(grammar, lexicon);
             results.push(loaded);
         }
         return results;
@@ -75,8 +58,9 @@ export class PluginLoader {
     async loadPlugin(className, settings) {
         try {
             let PluginClass;
-            if (this.isBuiltIn(className)) {
-                PluginClass = this.getBuiltIn(className);
+            const builtInClass = this.getBuiltIn(className);
+            if (builtInClass !== null) {
+                PluginClass = builtInClass;
             }
             else {
                 const classSpecifier = await this.resolveClassSpecifier(className);
@@ -91,6 +75,15 @@ export class PluginLoader {
             throw new Error(`Failed to load plugin ${className}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async loadConfiguredPlugins(configs, grammar, loadPlugin, setUp) {
+        const results = [];
+        for (const config of configs) {
+            const loaded = await loadPlugin(config);
+            await setUp(loaded.plugin, grammar);
+            results.push(loaded);
+        }
+        return results;
+    }
     findPluginClass(module, className) {
         if (typeof module === 'object' && module !== null) {
             const obj = module;
@@ -138,9 +131,6 @@ export class PluginLoader {
             className.startsWith('..\\') ||
             isAbsolute(className));
     }
-    isBuiltIn(name) {
-        return (name in BUILT_IN_PLUGINS || name.split('.').pop() in BUILT_IN_PLUGINS);
-    }
     getBuiltIn(name) {
         if (name in BUILT_IN_PLUGINS) {
             return BUILT_IN_PLUGINS[name];
@@ -149,7 +139,7 @@ export class PluginLoader {
         if (shortName in BUILT_IN_PLUGINS) {
             return BUILT_IN_PLUGINS[shortName];
         }
-        throw new Error(`Plugin ${name} not found in built-ins`);
+        return null;
     }
 }
 const BUILT_IN_PLUGINS = {
@@ -163,6 +153,7 @@ const BUILT_IN_PLUGINS = {
     JoinKatakanaOovPlugin,
     JoinNumericPlugin,
     InhibitConnectionPlugin,
+    TargetedConnectionCostPlugin,
     'com.worksap.nlp.sudachi.DefaultInputTextPlugin': DefaultInputTextPlugin,
     'com.worksap.nlp.sudachi.IgnoreYomiganaPlugin': IgnoreYomiganaPlugin,
     'com.worksap.nlp.sudachi.ProlongedSoundMarkInputTextPlugin': ProlongedSoundMarkInputTextPlugin,
@@ -173,4 +164,5 @@ const BUILT_IN_PLUGINS = {
     'com.worksap.nlp.sudachi.JoinKatakanaOovPlugin': JoinKatakanaOovPlugin,
     'com.worksap.nlp.sudachi.JoinNumericPlugin': JoinNumericPlugin,
     'com.worksap.nlp.sudachi.InhibitConnectionPlugin': InhibitConnectionPlugin,
+    'com.worksap.nlp.sudachi.TargetedConnectionCostPlugin': TargetedConnectionCostPlugin,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sudachi-ts",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "TypeScript port of Sudachi morphological analyzer for Japanese text",
   "keywords": [
     "morphological-analyzer",