@valueerror/ltjs-lang-it 0.0.0-stage → 0.1.0

package/src/lang/it/language/Italian.js

@@ -0,0 +1,95 @@
+// Java: org.languagetool.language.Italian
+import { LanguageWithModel } from '@valueerror/ltjs-core/src/core/LanguageWithModel.js';
+import { LanguageMaintainedState } from '@valueerror/ltjs-core/src/core/LanguageMaintainedState.js';
+import { Contributor } from '@valueerror/ltjs-core/src/core/language/Contributor.js';
+import { createComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { SRXSentenceTokenizer } from '@valueerror/ltjs-core/src/core/text/tokenizers/SRXSentenceTokenizer.js';
+import { WhitespaceBeforePunctuationRule } from '@valueerror/ltjs-core/src/core/rules/WhitespaceBeforePunctuationRule.js';
+import { CommaWhitespaceRule } from '@valueerror/ltjs-core/src/core/rules/CommaWhitespaceRule.js';
+import { DoublePunctuationRule } from '@valueerror/ltjs-core/src/core/rules/DoublePunctuationRule.js';
+import { GenericUnpairedBracketsRule } from '@valueerror/ltjs-core/src/core/rules/GenericUnpairedBracketsRule.js';
+import { UppercaseSentenceStartRule } from '@valueerror/ltjs-core/src/core/rules/UppercaseSentenceStartRule.js';
+import { MultipleWhitespaceRule } from '@valueerror/ltjs-core/src/core/rules/MultipleWhitespaceRule.js';
+import { MorfologikItalianSpellerRule } from '../rules/MorfologikItalianSpellerRule.js';
+import { ItalianWordRepeatRule } from '../rules/ItalianWordRepeatRule.js';
+import { ItalianTagger } from '../tagging/ItalianTagger.js';
+import { ItalianSynthesizer } from '../synthesis/ItalianSynthesizer.js';
+
+// Java: Italian
+export class Italian extends LanguageWithModel {
+  static FQCN = 'org.languagetool.language.Italian';
+
+  // Java: Italian#getName()
+  getName() {
+    return 'Italian';
+  }
+
+  // Java: Italian#getShortCode()
+  getShortCode() {
+    return 'it';
+  }
+
+  // Java: Italian#getCountries()
+  getCountries() {
+    return ['IT', 'CH'];
+  }
+
+  // Java: Italian#createDefaultTagger()
+  createDefaultTagger() {
+    return new ItalianTagger();
+  }
+
+  // Java: Italian#createDefaultSentenceTokenizer()
+  createDefaultSentenceTokenizer() {
+    return new SRXSentenceTokenizer(this);
+  }
+
+  // Java: Italian#getMaintainers()
+  getMaintainers() {
+    return [new Contributor('Paolo Bianchini')];
+  }
+
+  // Java: Italian#getRelevantRules(ResourceBundle,UserConfig,Language,List)
+  getRelevantRules(messages, userConfig, motherTongue, altLanguages) {
+    return [
+      new WhitespaceBeforePunctuationRule(messages),
+      new CommaWhitespaceRule(messages),
+      new DoublePunctuationRule(messages),
+      new GenericUnpairedBracketsRule(messages,
+        ['[', '(', '{', '»', '«'],
+        [']', ')', '}', '«', '»']),
+      new MorfologikItalianSpellerRule(messages, this, userConfig, altLanguages),
+      new UppercaseSentenceStartRule(messages, this),
+      new ItalianWordRepeatRule(messages, this),
+      new MultipleWhitespaceRule(messages, this),
+    ];
+  }
+
+  // Java: Italian#getRelevantLanguageModelRules(ResourceBundle,LanguageModel,UserConfig)
+  getRelevantLanguageModelRules() {
+    return []; // ItalianConfusionProbabilityRule needs a language model (ngram, DEV-001); DEV-026: null model gives an empty list
+  }
+
+  // Java: Italian#createDefaultDisambiguator()
+  createDefaultDisambiguator() {
+    return createComponent('org.languagetool.tagging.disambiguation.rules.it.ItalianRuleDisambiguator');
+  }
+
+  // Java: Italian#createDefaultSynthesizer()
+  createDefaultSynthesizer() {
+    return ItalianSynthesizer.INSTANCE;
+  }
+
+  // Java: Italian#getMaintainedState()
+  getMaintainedState() {
+    return LanguageMaintainedState.ActivelyMaintained;
+  }
+
+  // Java: Italian#createDefaultSpellingRule(ResourceBundle)
+  createDefaultSpellingRule(messages) {
+    return new MorfologikItalianSpellerRule(messages, this, null, null);
+  }
+}
+
+registerClass(Italian.FQCN, Italian);

package/src/lang/it/rules/DateCheckFilter.js

@@ -0,0 +1,64 @@
+// Java: org.languagetool.rules.it.DateCheckFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Calendar } from '@valueerror/ltjs-core/src/lib/java/Calendar.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { AbstractDateCheckFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractDateCheckFilter.js';
+
+// Java: DateCheckFilter
+export class DateCheckFilter extends AbstractDateCheckFilter {
+  static FQCN = 'org.languagetool.rules.it.DateCheckFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.it.DateCheckFilter()' }];
+
+  // Java: DateCheckFilter#getCalendar()
+  getCalendar() {
+    return Calendar.getInstance(Locale.UK);
+  }
+
+  // Java: DateCheckFilter#getDayOfWeek(String) and #getDayOfWeek(Calendar) (overloads, one JS method dispatching on the argument type)
+  getDayOfWeek(arg) {
+    if (arg instanceof Calendar) {
+      const englishDay = arg.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.UK);
+      if (englishDay === 'Sunday') return 'domenica';
+      if (englishDay === 'Monday') return 'lunedì';
+      if (englishDay === 'Tuesday') return 'martedì';
+      if (englishDay === 'Wednesday') return 'mercoledì';
+      if (englishDay === 'Thursday') return 'giovedì';
+      if (englishDay === 'Friday') return 'venerdì';
+      if (englishDay === 'Saturday') return 'sabato';
+      return '';
+    }
+    const dayStr = arg;
+    const day = toLowerCase(dayStr);
+    if (day.startsWith('do') || day === 'domenica') return Calendar.SUNDAY;
+    if (day.startsWith('lu') || day === 'lunedì') return Calendar.MONDAY;
+    if (day.startsWith('ma') || day === 'martedì') return Calendar.TUESDAY;
+    if (day.startsWith('me') || day === 'mercoledì') return Calendar.WEDNESDAY;
+    if (day.startsWith('gi') || day === 'giovedì') return Calendar.THURSDAY;
+    if (day.startsWith('ve') || day === 'venerdì') return Calendar.FRIDAY;
+    if (day.startsWith('sa') || day === 'sabato') return Calendar.SATURDAY;
+    throw new RuntimeException("Could not find day of week for '" + dayStr + "'");
+  }
+
+  // Java: DateCheckFilter#getMonth(String)
+  getMonth(monthStr) {
+    const mon = toLowerCase(monthStr);
+    if (mon.startsWith('gen')) return 1;
+    if (mon.startsWith('feb')) return 2;
+    if (mon.startsWith('mar')) return 3;
+    if (mon.startsWith('apr')) return 4;
+    if (mon.startsWith('mag')) return 5;
+    if (mon.startsWith('giu')) return 6;
+    if (mon.startsWith('lug')) return 7;
+    if (mon.startsWith('ago')) return 8;
+    if (mon.startsWith('set')) return 9;
+    if (mon.startsWith('ott')) return 10;
+    if (mon.startsWith('nov')) return 11;
+    if (mon.startsWith('dic')) return 12;
+    throw new RuntimeException("Could not find month '" + monthStr + "'");
+  }
+}
+
+registerClass(DateCheckFilter.FQCN, DateCheckFilter);

package/src/lang/it/rules/ItalianWordRepeatRule.js

@@ -0,0 +1,37 @@
+// Java: org.languagetool.rules.it.ItalianWordRepeatRule
+import { WordRepeatRule } from '@valueerror/ltjs-core/src/core/rules/WordRepeatRule.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+
+// Java: ItalianWordRepeatRule
+export class ItalianWordRepeatRule extends WordRepeatRule {
+  static FQCN = 'org.languagetool.rules.it.ItalianWordRepeatRule';
+
+  // Java: ItalianWordRepeatRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+  }
+
+  // Java: ItalianWordRepeatRule#getId()
+  getId() {
+    return 'ITALIAN_WORD_REPEAT_RULE';
+  }
+
+  // Java: ItalianWordRepeatRule#ignore(AnalyzedTokenReadings[],int)
+  ignore(tokens, position) {
+    if (this.wordRepetitionOf('così', tokens, position)) {
+      return true; // "Mi è sembrato così così."
+    }
+    if (this.wordRepetitionOf('passo', tokens, position)) {
+      return true; // "che passo passo vanno verso la rovina"
+    }
+    if (this.wordRepetitionOf('piano', tokens, position)) {
+      return true; // "Piano, piano, signor podestà."
+    }
+    if (this.wordRepetitionOf('via', tokens, position)) {
+      return true; // "Il lessico si andava via via modificando."
+    }
+    return super.ignore(tokens, position);
+  }
+}
+
+registerComponent(ItalianWordRepeatRule.FQCN, (...args) => new ItalianWordRepeatRule(...args));

package/src/lang/it/rules/MorfologikItalianSpellerRule.js

@@ -0,0 +1,48 @@
+// Java: org.languagetool.rules.it.MorfologikItalianSpellerRule
+import { MorfologikSpellerRule } from '@valueerror/ltjs-core/src/core/rules/spelling/morfologik/MorfologikSpellerRule.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { isCapitalizedWord } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+
+const RESOURCE_FILENAME = '/it/hunspell/it_IT.dict';
+
+// Java: MorfologikItalianSpellerRule
+export class MorfologikItalianSpellerRule extends MorfologikSpellerRule {
+  static FQCN = 'org.languagetool.rules.it.MorfologikItalianSpellerRule';
+
+  // Java: MorfologikItalianSpellerRule(ResourceBundle,Language,UserConfig,List)
+  constructor(messages, language, userConfig, altLanguages) {
+    super(messages, language, userConfig, altLanguages);
+  }
+
+  // Java: MorfologikItalianSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikItalianSpellerRule#getId()
+  getId() {
+    return 'MORFOLOGIK_RULE_IT_IT';
+  }
+
+  // Java: MorfologikItalianSpellerRule#orderSuggestions(List,String)
+  orderSuggestions(suggestions, word) {
+    const newSuggestions = [];
+    const originalSuggestionsStr = [];
+    for (const suggestion of suggestions) {
+      originalSuggestionsStr.push(suggestion.getReplacement());
+    }
+    for (const suggestion of suggestions) {
+      const suggestionStr = suggestion.getReplacement();
+      // original word is not capitalized, suggestion is capitalized, and lowercase suggestion also exists
+      if (!isCapitalizedWord(word) && isCapitalizedWord(suggestionStr)
+          && originalSuggestionsStr.includes(toLowerCase(suggestionStr))) {
+        continue;
+      }
+      newSuggestions.push(suggestion);
+    }
+    return newSuggestions;
+  }
+}
+
+registerComponent(MorfologikItalianSpellerRule.FQCN, (...args) => new MorfologikItalianSpellerRule(...args));

package/src/lang/it/synthesis/ItalianSynthesizer.js

@@ -0,0 +1,20 @@
+// Java: org.languagetool.synthesis.it.ItalianSynthesizer
+import { registerComponent, sharedComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { BaseSynthesizer } from '@valueerror/ltjs-core/src/core/tagging/synthesis/BaseSynthesizer.js';
+
+// Java: ItalianSynthesizer
+export class ItalianSynthesizer extends BaseSynthesizer {
+  static FQCN = 'org.languagetool.synthesis.it.ItalianSynthesizer';
+
+  // Java: ItalianSynthesizer#INSTANCE
+  static get INSTANCE() {
+    return sharedComponent(ItalianSynthesizer.FQCN);
+  }
+
+  // Java: ItalianSynthesizer#ItalianSynthesizer() (the deprecated (Language) constructor delegates here)
+  constructor() {
+    super(null, '/it/italian_synth.dict', '/it/italian_tags.txt', 'it');
+  }
+}
+
+registerComponent(ItalianSynthesizer.FQCN, () => new ItalianSynthesizer());

package/src/lang/it/tagging/ItalianRuleDisambiguator.js

@@ -0,0 +1,23 @@
+// Java: org.languagetool.tagging.disambiguation.rules.it.ItalianRuleDisambiguator
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { AbstractDisambiguator } from '@valueerror/ltjs-core/src/core/tagging/disambiguation/AbstractDisambiguator.js';
+import { XmlRuleDisambiguator } from '@valueerror/ltjs-core/src/core/disambiguation/XmlRuleDisambiguator.js';
+import { Italian } from '../language/Italian.js';
+
+// Java: ItalianRuleDisambiguator
+export class ItalianRuleDisambiguator extends AbstractDisambiguator {
+  static FQCN = 'org.languagetool.tagging.disambiguation.rules.it.ItalianRuleDisambiguator';
+
+  // Java: ItalianRuleDisambiguator#disambiguator (field initialiser: a second Italian instance)
+  constructor() {
+    super();
+    this.disambiguator = new XmlRuleDisambiguator(new Italian());
+  }
+
+  // Java: ItalianRuleDisambiguator#disambiguate(AnalyzedSentence)
+  disambiguate(input, checkCanceled = null) {
+    return this.disambiguator.disambiguate(input, checkCanceled);
+  }
+}
+
+registerComponent(ItalianRuleDisambiguator.FQCN, () => new ItalianRuleDisambiguator());

package/src/lang/it/tagging/ItalianTagger.js

@@ -0,0 +1,16 @@
+// Java: org.languagetool.tagging.it.ItalianTagger
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { BaseTagger } from '@valueerror/ltjs-core/src/core/tagging/BaseTagger.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+
+// Java: ItalianTagger
+export class ItalianTagger extends BaseTagger {
+  static FQCN = 'org.languagetool.tagging.it.ItalianTagger';
+
+  // Java: ItalianTagger#ItalianTagger()
+  constructor() {
+    super('/it/italian.dict', Locale.ITALIAN);
+  }
+}
+
+registerComponent(ItalianTagger.FQCN, () => new ItalianTagger());