axyseo 2.0.0-alpha.0.0.19 → 2.0.0-alpha.0.0.2

package/src/languageProcessing/languages/es/config/sentenceLength.js

@@ -0,0 +1,3 @@
+export default {
+	recommendedLength: 25,
+};

package/src/languageProcessing/languages/es/config/stopWords.js

@@ -0,0 +1,33 @@
+/**
+ * Returns a list with stopwords for the Spanish passive voice assessment.
+ * @returns {Array} The list with stopwords.
+ */
+export default [
+	"pero",
+	"ora",
+	"aunque",
+	"aun",
+	"mientras",
+	"porque",
+	"apenas",
+	"si",
+	"antes",
+	"después",
+	"cómo",
+	"como",
+	"empero",
+	"que",
+	"cuanto",
+	"cuando",
+	"cual",
+	"cuales",
+	"quién",
+	"quien",
+	"quienes",
+	"dónde",
+	"adónde",
+	"cuyo",
+	"cuyos",
+	"cuya",
+	"cuyas",
+];

package/src/languageProcessing/languages/es/config/transitionWords.js

@@ -0,0 +1,40 @@
+/** @module config/transitionWords */
+
+export const singleWords = [ "además", "adicional", "así", "asimismo", "aún", "aunque", "ciertamente", "como", "concluyendo", "conque",
+	"contrariamente", "cuando", "decididamente", "decisivamente", "después", "diferentemente", "efectivamente", "entonces", "especialmente",
+	"específicamente", "eventualmente", "evidentemente", "finalmente", "frecuentemente", "generalmente", "igualmente", "lógicamente", "luego",
+	"mas", "mientras", "pero", "por", "porque", "posteriormente", "primero", "principalmente", "pronto", "próximamente", "pues", "raramente",
+	"realmente", "seguidamente", "segundo", "semejantemente", "si", "siguiente", "sino", "súbitamente", "supongamos", "también", "tampoco",
+	"tercero", "verbigracia", "vice-versa", "ya" ];
+export const multipleWords = [ "a causa de", "a continuación", "a diferencia de", "a fin de cuentas", "a la inversa", "a la misma vez", "a más de",
+	"a más de esto", "a menos que", "a no ser que", "a pesar de", "a pesar de eso", "a pesar de todo", "a peser de", "a propósito", "a saber",
+	"a todo esto", "ahora bien", "al contrario", "al fin y al cabo", "al final", "al inicio", "al mismo tiempo", "al principio", "ante todo",
+	"antes bien", "antes de", "antes de nada", "antes que nada", "aparte de", "as así como", "así como", "así mismo", "así pues", "así que",
+	"así y todo", "aún así", "claro está que", "claro que", "claro que sí", "como caso típico", "como decíamos", "como era de esperar",
+	"como es de esperar", "como muestra", "como resultado",	"como se ha notado", "como sigue", "comparado con", "con el objeto de",
+	"con el propósito de", "con que", "con relación a", "con tal de que", "con todo", "dado que", "de ahí", "de cierta manera", "de cualquier manera",
+	"de cualquier modo", "de ello resulta que", "de este modo", "de golpe", "de hecho", "de igual manera", "de igual modo", "de igualmanera",
+	"de la manera siguiente", "de la misma forma", "de la misma manera", "de manera semejante", "del mismo modo", "de modo que", "de nuevo",
+	"de otra manera", "de otro modo", "de pronto", "de qualquier manera", "de repente", "de suerte que", "de tal modo", "de todas formas",
+	"de todas maneras", "de todos modos", "de veras", "debido a", "debido a que", "del mismo modo", "dentro de poco", "desde entonces",
+	"después de", "después de todo", "ejemplo de esto", "el caso es que", "en aquel tiempo", "en cambio", "en cierto modo", "en comparación con",
+	"en conclusión", "en concreto", "en conformidad con", "en consecuencia", "en consiguiente", "en contraste con", "en cualquier caso", "en cuanto",
+	"en cuanto a", "en definitiva", "en efecto", "en el caso de que", "en este sentido", "en fin", "en fin de cuentas", "en general", "en lugar de",
+	"en otras palabras", "en otro orden", "en otros términos", "en particular", "en primer lugar", "en primer término", "en primera instancia",
+	"en realidad", "en relación a",	"en relación con", "en representación de", "en resumen", "en resumidas cuentas", "en segundo lugar", "en seguida",
+	"en síntesis", "en suma", "en todo caso", "en último término", "en verdad", "en vez de", "en virtud de", "entre ellas figura",
+	"entre ellos figura", "es cierto que", "es decir", "es evidente que", "es incuestionable", "es indudable", "es más", "está claro que",
+	"esto indica", "excepto si", "generalmente por ejemplo",	"gracias a", "hasta aquí", "hasta cierto punto", "hasta el momento", "hay que añadir",
+	"igual que", "la mayor parte del tiempo", "la mayoría del tiempo", "lo que es peor", "más tarde", "mejor dicho", "mientras tanto",
+	"mirándolo todo", "nadie puede ignorar", "no faltaría más", "no obstante", "o sea", "otra vez", "otro aspecto", "para ilustrar", "para concluir",
+	"para conclusión", "para continuar", "para empezar", "para finalizar", "para mencionar una cosa", "para que", "para resumir", "para terminar",
+	"pongamos por caso", "por añadidura", "por cierto", "por consiguiente", "por ejemplo", "por el consiguiente", "por el contrario",
+	"por el hecho que",	"por eso", "por esta razón", "por esto", "por fin", "por la mayor parte", "por lo general", "por lo que",
+	"por lo tanto", "por otro lado", "por otra parte", "por otro lado", "por supuesto", "por tanto", "por último", "por un lado", "por una parte",
+	"primero que nada", "primero que todo",	"pues bien", "puesto que", "rara vez", "resulta que", "sea como sea", "seguidamente entre tanto",
+	"si bien", "siempre que", "siempre y cuando", "sigue que", "sin duda", "sin embargo", "sin ir más lejos", "sobre todo", "supuesto que",
+	"tal como", "tales como", "tan pronto como", "tanto como", "una vez", "ya que" ];
+
+export const allWords = singleWords.concat( multipleWords );
+
+export default allWords;

package/src/languageProcessing/languages/es/config/twoPartTransitionWords.js

@@ -0,0 +1,10 @@
+/** @module config/twoPartTransitionWords */
+
+/**
+ * Returns an array with two-part transition words to be used by the assessments.
+ * @returns {Array} The array filled with two-part transition words.
+ */
+export default [ [ "de un lado", "de otra parte" ], [ "de un lado", "de otro" ], [ "no", "sino que" ], [ "no", "sino" ],
+	[ "por un lado", "por otro lado" ], [ "por una parte", "por otra parte" ], [ "por una parte", "por otra" ],
+	[ "tanto", "como" ], [ "bien", "bien" ] ];
+

package/src/languageProcessing/languages/es/config/wordComplexity.js

@@ -0,0 +1,4 @@
+// This is a config for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.
+export default {
+	wordLength: 7,
+};

package/src/languageProcessing/languages/es/helpers/calculateFleschReadingScore.js

@@ -0,0 +1,18 @@
+import {helpers} from '../../../index';
+const {formatNumber} = helpers;
+
+/**
+ * Returns the Flesch reading score for Spanish.
+ *
+ * @param {Object} statistics The Flesch reading statistics.
+ *
+ * @returns {number} The Flesch reading score for Spanish.
+ */
+export default function calculateScore(statistics) {
+  const score =
+    206.84 -
+    (1.02 * statistics.numberOfWords) / statistics.numberOfSentences -
+    0.6 * statistics.syllablesPer100Words;
+
+  return formatNumber(score);
+}

package/src/languageProcessing/languages/es/helpers/checkIfWordIsComplex.js

@@ -0,0 +1,56 @@
+const vowels = "aeiuoyáéíóúñ";
+const consonants = "bcdfghjklmnpqrstvwxzñ";
+
+const vowelsSuffix = "[" + vowels + "](s)$";
+const vowelsSuffixRegex = new RegExp( vowelsSuffix );
+
+const consonantSuffix = "[" + consonants + "](es)$";
+const consonantSuffixRegex = new RegExp( consonantSuffix );
+
+const suffixes = "(s|es)$";
+const suffixesRegex = new RegExp( suffixes );
+
+/**
+ * Checks if a word is complex.
+ * This is a helper for the Word Complexity assessment. As such, this helper is not bundled in Yoast SEO.
+ *
+ * @param {object} config The configuration needed for assessing the word's complexity, e.g., the frequency list.
+ * @param {string} word The word to check.
+ * @param {object}	premiumData The object that contains data for the assessment including the frequency list.
+ *
+ * @returns {boolean} Whether or not a word is complex.
+ */
+export default function checkIfWordIsComplex( config, word, premiumData ) {
+	const lengthLimit = config.wordLength;
+	const frequencyList = premiumData.frequencyList.list;
+
+	// The Spanish word is not complex if its length is 7 characters or fewer.
+	if ( word.length <= lengthLimit ) {
+		return false;
+	}
+
+	// The Spanish word starts with a capital and thus is assumed to be a named entity.
+	if ( word[ 0 ].toLowerCase() !== word[ 0 ] ) {
+		return false;
+	}
+
+	// The word is not complex if it's in the frequency list.
+	if ( frequencyList.includes( word ) ) {
+		return false;
+	}
+	/*
+	* If a word is longer than 7 characters and has a plural ending in -es or -s, we remove the ending
+	* and check if the singular form can be found in the frequency list.
+	* The word is not complex if the singular form is in the list.
+	*/
+	// It's important to check consonant suffixes before vowel suffixes so order should not be altered.
+	if ( consonantSuffixRegex.test( word ) ) {
+		word = word.replace( suffixesRegex, "" );
+		return ! frequencyList.includes( word );
+	} else if ( vowelsSuffixRegex.test( word ) ) {
+		word = word.replace( suffixesRegex, "" );
+		return ! frequencyList.includes( word );
+	}
+
+	return true;
+}

package/src/languageProcessing/languages/es/helpers/getClauses.js

@@ -0,0 +1,29 @@
+import {languageProcessing} from '../../../index';
+const {createRegexFromArray, getClauses} = languageProcessing;
+
+import Clause from '../values/Clause';
+import auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';
+import stopwords from '../config/stopWords.js';
+const followingAuxiliaryExceptionWords = ['el', 'la', 'los', 'las', 'una'];
+
+const options = {
+  Clause,
+  stopwords,
+  auxiliaries: auxiliaries,
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries),
+    stopCharacterRegex: /([:,])(?=[ \n\r\t'"+\-»«‹›<>])/gi,
+    followingAuxiliaryExceptionRegex: createRegexFromArray(followingAuxiliaryExceptionWords)
+  }
+};
+
+/**
+ * Gets the clauses from a sentence by determining sentence breakers.
+ *
+ * @param {string} sentence The sentence to split up in clauses.
+ *
+ * @returns {Array} The array with all clauses that have an auxiliary.
+ */
+export default function getSpanishClauses(sentence) {
+  return getClauses(sentence, options);
+}

package/src/languageProcessing/languages/es/helpers/getStemmer.js

@@ -0,0 +1,22 @@
+import {get} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {baseStemmer} = languageProcessing;
+
+import stem from './internal/stem';
+
+/**
+ * Returns the stemmer for a researcher.
+ *
+ * @param {Researcher} researcher The researcher.
+ *
+ * @returns {Function} The stemmer.
+ */
+export default function getStemmer(researcher) {
+  const morphologyData = get(researcher.getData('morphology'), 'es', false);
+
+  if (morphologyData) {
+    return word => stem(word, morphologyData);
+  }
+
+  return baseStemmer;
+}

package/src/languageProcessing/languages/es/helpers/internal/checkVerbStemModifications.js

@@ -0,0 +1,41 @@
+import buildFormRule from "../../../../../languageProcessing/helpers/morphology/buildFormRule.js";
+import createRulesFromArrays from "../../../../../languageProcessing/helpers/morphology/createRulesFromArrays.js";
+import searchAndReplaceWithOneRegex from "../../../../../languageProcessing/helpers/regex/searchAndReplaceWithOneRegex";
+
+/**
+ * Checks whether a given word is a verb to which certain stem modifications need to be applied.
+ *
+ * @param {string}  word                The word to check.
+ * @param {Object}  morphologyDataES    The Spanish morphology data.
+ *
+ * @returns {string|null} The modified stem if any modifications apply or null.
+ */
+export default function checkVerbStemModifications( word, morphologyDataES ) {
+	const verbStemModifications = morphologyDataES.verbStemModifications;
+
+	const quToCReplacement = searchAndReplaceWithOneRegex( word, verbStemModifications.quToC );
+
+	// This modification is checked separately because it's sometimes combined wit the dipththong modification.
+	if ( quToCReplacement ) {
+		// Check diphthong replacement.
+		const ueToOReplacement = searchAndReplaceWithOneRegex( quToCReplacement, verbStemModifications.ueToOSimple );
+
+		if ( ueToOReplacement ) {
+			return ueToOReplacement;
+		}
+
+		return quToCReplacement;
+	}
+
+	// All of the modifications checked in this step are mutually exclusive.
+	const verbWithStemReplacement = buildFormRule(
+		word,
+		createRulesFromArrays( [ ...verbStemModifications.stemModifications, verbStemModifications.ueToO ] )
+	);
+
+	if ( verbWithStemReplacement ) {
+		return verbWithStemReplacement;
+	}
+
+	return null;
+}

package/src/languageProcessing/languages/es/helpers/internal/getParticiples.js

@@ -0,0 +1,35 @@
+import {languageProcessing} from '../../../index';
+const {getWords} = languageProcessing;
+
+import participleStems from '../../config/internal/passiveVoiceParticiples';
+
+/**
+ * Checks if a Spanish word is a participle.
+ * @param {string} word A Spanish word.
+ * @returns {boolean} Returns true if word is a Spanish participle, and false otherwise.
+ */
+function isParticiple(word) {
+  const participleSuffixes = ['a', 'o', 'as', 'os'];
+  // For each participle suffixes, check if the word ends in one of them.
+  return participleSuffixes.some(suffix => {
+    // Make sure only possible participles are targeted (minimum length being "> 3")
+    if (word.length > 3 && word.endsWith(suffix)) {
+      // If the word ends with one of the suffixes, retrieve the stem.
+      const stem = word.slice(0, -suffix.length);
+      // Check if the stem is in the list of participle stems: return true if it is, otherwise return false.
+      return participleStems.includes(stem);
+    }
+  });
+}
+
+/**
+ * Creates an array of participles for the participles found in a clause.
+ *
+ * @param {string} clauseText The clause to find participles in.
+ *
+ * @returns {Array} The list with participles.
+ */
+export default function getParticiples(clauseText) {
+  const words = getWords(clauseText);
+  return words.filter(word => isParticiple(word));
+}