es-reverse-conjugator/index.js

A npm package for spanish conjugation by mood, tense and pronoun

const irregular_dictionary = require("./irregulars/irregulars_dictionary");

const subjunctive_present = require("./tenses/subjunctive/present");
const subjunctive_present_perfect = require("./tenses/subjunctive/present_perfect");
const subjunctive_pluperfect = require("./tenses/subjunctive/pluperfect");
const subjunctive_imperfect = require("./tenses/subjunctive/imperfect");
const subjunctive_imperfect_se = require("./tenses/subjunctive/imperfect_se");
const subjunctive_future = require("./tenses/subjunctive/future");

const indicative_present = require("./tenses/indicative/present");
const indicative_preterite = require("./tenses/indicative/preterite");
const indicative_present_perfect = require("./tenses/indicative/present_perfect");
const indicative_past_perfect = require("./tenses/indicative/past_perfect");
const indicative_past_anterior = require("./tenses/indicative/past_anterior");
const indicative_imperfect = require("./tenses/indicative/imperfect");
const indicative_future = require("./tenses/indicative/future");
const indicative_future_perfect = require("./tenses/indicative/future_perfect");

const affirmative = require("./tenses/imperative/affirmative");
const negative = require("./tenses/imperative/negative");

const conditional_perfect = require("./tenses/conditional/perfect");
const conditional_simple_conditional = require("./tenses/conditional/simple_conditional");

function Conjugator(rootverb, tense, mood, pronoun) {
  // Make all inputs lower case
  //console.log(irregular_dictionary.irregulars_dictionary.rootverb)
  // Initiates Variables
  var conjugate;
  var conjugation;
  // Queries Irregular database
  try {
    //let my_irregulars = irregular_dictionary.irregulars_dictionary;
    let conjugation =
      irregular_dictionary.irregulars_dictionary[rootverb][mood][tense][
        pronoun
      ];
    return conjugation;
  } catch (error) {
    //------------------------ Indicitive
    //------------------------ Indicitive / Present
    if (tense == "present") {
      if (mood == "indicative") {
        conjugate = indicative_present.indicative_present;
      }
    }
    //------------------------ Indicitive / Imperfect
    if (tense == "imperfect") {
      if (mood == "indicative") {
        conjugate = indicative_imperfect.indicative_imperfect;
      }
    }
    //------------------------ Indicitive / Preterite
    if (tense == "preterite") {
      if (mood == "indicative") {
        conjugate = indicative_preterite.indicative_preterite;
      }
    }
    //------------------------ Indicitive / Future Simple
    if (tense == "future") {
      if (mood == "indicative") {
        conjugate = indicative_future.indicative_future;
      }
    }
    //------------------------ Indicitive / Present Perfect Compound Tense
    if (tense == "present_perfect") {
      if (mood == "indicative") {
        conjugate = indicative_present_perfect.indicative_present_perfect;
      }
    }
    //------------------------ Indicitive / Past Perfect Compound Tense
    if (tense == "past_perfect") {
      if (mood == "indicative") {
        conjugate = indicative_past_perfect.indicative_past_perfect;
      }
    }
    //------------------------ Indicitive / Past Anterior Compound Tense
    if (tense == "past_anterior") {
      if (mood == "indicative") {
        conjugate = indicative_past_anterior.indicative_past_anterior;
      }
    }
    //------------------------ Indicitive / Future Perfect Compound Tense
    if (tense == "future_perfect") {
      if (mood == "indicative") {
        conjugate = indicative_future_perfect.indicative_future_perfect;
      }
    }
    //------------------------ Conditional
    //------------------------ Conditional / Simple Conditional
    if (tense == "simple_conditional") {
      if (mood == "conditional") {
        conjugate =
          conditional_simple_conditional.conditional_simple_conditional;
      }
    }
    //------------------------ Conditional / Perfect
    if (tense == "perfect") {
      if (mood == "conditional") {
        conjugate = conditional_perfect.conditional_perfect;
      }
    }
    //------------------------ Imperitive
    //------------------------ Imperitive / Affirmative
    if (tense == "affirmative") {
      if (mood == "imperitive") {
        conjugate = affirmative.affirmative;
      }
    }
    //------------------------ Imperitive / Negative
    if (tense == "negative") {
      if (mood == "imperative") {
        conjugate = negative.negative;
      }
    }
    //------------------------ Subjunctive
    //------------------------ Subjunctive / Present
    if (tense == "present") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_present.subjunctive_present;
      }
    }
    //------------------------ Subjunctive / Present Perfect
    if (tense == "present_perfect") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_present_perfect.subjunctive_present_perfect;
      }
    }
    //------------------------ Subjunctive / Pluperfect
    if (tense == "pluperfect") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_pluperfect.subjunctive_pluperfect;
      }
    }
    //------------------------ Subjunctive / Future Perfect
    if (tense == "future_perfect") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_future_perfect.subjunctive_future_perfect;
      }
    }
    //------------------------ Subjunctive / Imperfect
    if (tense == "imperfect") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_imperfect.subjunctive_imperfect;
      }
    }
    //------------------------ Subjunctive / Imperfect se
    if (tense == "imperfect_se") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_imperfect_se.subjunctive_imperfect_se;
      }
    }
    //------------------------ Subjunctive / Future
    if (tense == "future") {
      if (mood == "subjunctive") {
        conjugate = subjunctive_future.subjunctive_future;
      }
    }

    try {
      conjugation = conjugate(rootverb, pronoun);
      return conjugation;
    } catch (error) {
      return "Error, unable to conjugate, please either submit issue or double check docs";
    }
  }
}

function ReverseConjugator(conjugatedWord, verbsToCheck = null) {
  // Initialize result array to store all possible matches
  const results = [];

  // Define all moods, tenses, and pronouns
  const moods = ["indicative", "subjunctive", "conditional", "imperative"];
  const tenses = [
    "present",
    "imperfect",
    "preterite",
    "future",
    "present_perfect",
    "past_perfect",
    "past_anterior",
    "future_perfect",
    "simple_conditional",
    "perfect",
    "affirmative",
    "negative",
    "imperfect_se",
    "pluperfect",
  ];
  const pronouns = ["yo", "tu", "usted", "nosotros", "vosotros", "ustedes"];

  // Check irregular verbs first since they're a finite set
  const irregular_verbs = Object.keys(
    irregular_dictionary.irregulars_dictionary
  );

  for (const verb of irregular_verbs) {
    const verbData = irregular_dictionary.irregulars_dictionary[verb];

    for (const mood of Object.keys(verbData)) {
      for (const tense of Object.keys(verbData[mood])) {
        for (const pronoun of Object.keys(verbData[mood][tense])) {
          if (verbData[mood][tense][pronoun] === conjugatedWord) {
            console.log("Found Iregular", verb, tense, mood, pronoun);
            results.push({
              verb,
              tense,
              mood,
              pronoun,
            });
          }
        }
      }
    }
  }

  // If the user provides specific verbs to check
  const verbList = verbsToCheck || [
    // Common verbs to check if no list is provided
    "hablar",
    "comer",
    "vivir",
    "ser",
    "estar",
    "ir",
    "hacer",
    "tener",
    "venir",
  ];

  // For each verb, try all combinations
  for (const verb of verbList) {
    // Skip if it's already an irregular we've checked
    if (irregular_verbs.includes(verb) && !verbsToCheck) continue;

    for (const mood of moods) {
      for (const tense of tenses) {
        for (const pronoun of pronouns) {
          try {
            const conjugated = Conjugator(verb, tense, mood, pronoun);
            if (conjugated === conjugatedWord) {
              results.push({
                verb,
                tense,
                mood,
                pronoun,
              });
            }
          } catch (error) {
            // Skip combinations that don't exist
            continue;
          }
        }
      }
    }
  }

  return results;
}

module.exports.Conjugator = Conjugator;
module.exports.ReverseConjugator = ReverseConjugator;