axyseo 2.0.0-alpha.0.0.20 → 2.0.0-alpha.0.0.4

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

@@ -0,0 +1,59 @@
+/** @module config/transitionWords */
+
+export const singleWords = [ "ainsi", "alors", "aussi", "car", "cependant", "certainement", "certes", "conséquemment", "d'abord",
+	"d'ailleurs", "d'après", "davantage", "désormais", "deuxièmement", "donc", "dorénavant", "effectivement", "également",
+	"enfin", "ensuite", "entre-temps", "essentiellement", "excepté", "finalement", "globalement", "jusqu'ici", "là-dessus",
+	"lorsque", "mais", "malgré", "néanmoins", "notamment", "partant", "plutôt", "pourtant", "précédemment", "premièrement",
+	"probablement", "puis", "puisque", "quoique", "sauf", "selon", "semblablement", "sinon", "suivant", "toutefois", "troisièmement" ];
+
+export const multipleWords = [ "à cause de", "à ce jour", "à ce propos", "à ce sujet", "à cet égard", "à cette fin", "à compter de",
+	"à condition que", "à défaut de", "à force de", "à juste titre", "à la lumière de", "à la suite de", "à l'aide de", "à l'appui de",
+	"à l'encontre de", "à l'époque actuelle", "à l'exception de", "à l'exclusion de", "à l'heure actuelle", "à l'image de", "à l'instar de",
+	"à l'inverse", "à l'inverse de", "à l'opposé", "à la condition que", "à mesure que", "à moins que", "à nouveau", "à partir de", "à première vue",
+	"à savoir", "à seule fin que", "à supposer que", "à tel point que", "à tout prendre", "à vrai dire", "afin de", "afin d'attirer l'attention sur",
+	"afin que", "ainsi donc", "ainsi que", "alors que", "antérieurement", "après cela", "après quoi", "après que", "à propos de", "en l'occurence",
+	"après réflexion", "après tout", "attendu que", "au cas où", "au contraire", "au fond", "au fur et à mesure", "au lieu de", "au même temps",
+	"au moment où", "au moyen de", "au point que", "au risque de", "au surplus", "au total", "aussi bien que", "aussitôt que", "autant que",
+	"autrement dit", "avant que", "avant tout", "ayant fini", "bien que", "c'est à dire que", "c'est ainsi que", "c'est dans ce but que",
+	"c'est dire", "c'est le cas de", "c'est la raison pour laquelle", "c'est pourquoi", "c'est qu'en effet", "c'est-à-dire",
+	"ça confirme que", "ça montre que", "ça prouve que", "cela étant", "cela dit", "cependant que", "compte tenu", "comme l'illustre",
+	"comme le souligne", "comme on pouvait s'y attendre", "comme quoi", "comme si", "commençons par examiner", "comparativement à", "conformément à",
+	"contrairement à", "considérons par exemple", "d'autant plus", "d'autant que", "d'autre part", "d'ici là", "d'où", "d'un autre côté",
+	"d'un côté", "d'une façon générale", "dans ce cas", "dans ces conditions", "dans cet esprit", "dans l'ensemble", "dans l'état actuel des choses",
+	"dans l'éventualité où", "dans l'hypothèse où", "dans la mesure où", "dans le but de", "dans le cadre de", "dans le cas où",
+	"dans les circonstances actuelles", "dans les grandes lignes", "dans un autre ordre d'idée", "dans un délai de", "de ce fait",
+	"de cette façon", "de crainte que", "de façon à", "de façon à ce que", "de façon que", "de fait", "de l'autre côté", "de la même manière",
+	"de la même façon que", "de manière que", "de même", "de même qu'à", "de même que", "de nos jours", "de peur que", "de prime abord",
+	"de sorte que", "de surcroît", "de telle manière que", "de telle sorte que", "de toute évidence", "de toute façon", "de toute manière",
+	"depuis que", "dès lors que", "dès maintenant", "dès qua", "dès que", "du fait que", "du moins", "du moment que", "du point de vue de",
+	"du reste", "d'ici là", "d'ores et déjà", "en admettant que", "en attendant que", "en bref", "en cas de", "en cas que", "en ce cas",
+	"en ce domaine", "en ce moment", "en ce qui a trait à", "en ce qui concerne", "en ce sens", "en cela", "en comparaison de",
+	"en conclusion", "en conformité avec", "en conséquence", "en d'autres termes", "en définitive", "en dépit de", "pour cela",
+	"en dernier lieu", "en deuxième lieu", "en effet", "en face de", "en fait", "en fin de compte", "en général",
+	"en guise de conclusion", "en matière de", "en même temps que", "en outre", "en particulier", "en plus", "en premier lieu",
+	"en principe", "en raison de", "en réalité", "en règle générale", "en résumé", "en revanche", "en second lieu", "en somme",
+	"en sorte que", "en supposant que", "en tant que", "en terminant", "en théorie", "en tout cas", "en tout premier lieu", "en troisième lieu",
+	"en un mot", "en vérité", "en vue que", "encore que", "encore une fois", "entre autres", "et même", "et puis", "étant donné qu'à",
+	"étant donné que", "face à", "grâce à", "il est à noter que", "il est indéniable que", "il est question de",
+	"il est vrai que", "il faut dire aussi que", "il faut reconnaître que", "il faut souligner que", "il ne faut pas oublier que",
+	"il s'ensuit que", "il suffit de prendre pour exemple", "jusqu'ici", "il y a aussi", "jusqu'à ce que", "jusqu'à ce jour",
+	"jusqu'à maintenant", "jusqu'à présent", "jusqu'au moment où", "jusqu'ici", "l'aspect le plus important de", "l'exemple le plus significatif",
+	"jusqu'au moment où", "la preuve c'est que", "loin que", "mais en réalité", "malgré cela", "malgré tout", "même si", "mentionnons que",
+	"mis à part le fait que", "notons que", "nul doute que", "ou bien", "outre cela", "où que", "par ailleurs",
+	"par conséquent", "par contre", "par exception", "par exemple", "par la suite", "par l'entremise de", "par l'intermédiaire de",
+	"par rapport à", "par suite", "par suite de", "par surcroît", "parce que", "pareillement", "partant de ce fait", "pas du tout",
+	"pendant que", "plus précisément", "plus tard", "pour ainsi dire", "pour autant que", "pour ce qui est de", "pour ces motifs",
+	"pour ces raisons", "pour cette raison", "pour commencer", "pour conclure", "pour le moment", "pour marquer la causalité", "pour l'instant",
+	"pour peu que", "pour prendre un autre exemple", "pour que", "pour résumé", "pour terminer", "pour tout dire", "pour toutes ces raisons",
+	"pourvu que", "prenons le cas de", "quand bien même que", "quand même", "quant à", "quel que soit", "qui plus est", "surtout quand",
+	"qui que", "quitte à", "quoi qu'il en soit", "quoi que", "quoiqu'il en soit", "sans délai", "sans doute", "sans parler de", "sans préjuger",
+	"sans tarder", "sauf si", "selon que", "si bien que", "si ce n'est que", "si l'on songe que", "sitôt que", "somme toute", "sur ce point",
+	"surtout si", "sous cette réserve", "sous prétexte que", "sous réserve de", "sous réserve que", "suivant que", "supposé que", "sur le plan de",
+	"tandis que", "tant et si bien que", "tant que", "tel que", "tellement que", "touchant à", "tout à fait", "tout bien pesé", "tout compte fait",
+	"tout d'abord", "tout de même", "tout en reconnaissant que", "une fois de plus",
+	"vu que" ];
+
+
+export const allWords = singleWords.concat( multipleWords );
+
+export default allWords;

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

@@ -0,0 +1,15 @@
+/** @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 [
+	[ "à première vue", "mais à bien considérer les choses" ], [ "à première vue", "mais toute réflexion faite" ],
+	[ "aussi", "que" ], [ "autant de", "que" ], [ "certes", "mais" ], [ "d'un côté", "de l'autre côté" ],
+	[ "d'un côté", "de l'autre" ], [ "d'un côté", "d'un autre côté" ], [ "d'une part", "d'autre part" ],
+	[ "d'une parte", "de l'autre parte" ], [ "moins de", "que" ], [ "non seulement", "mais aussi" ], [ "non seulement", "mais en outre" ],
+	[ "non seulement", "mais encore" ], [ "plus de", "que" ], [ "quelque", "que" ], [ "si", "que" ], [ "soit", "soit" ],
+	[ "tantôt", "tantôt" ],	[ "tout d'abord", "ensuite" ], [ "tout", "que" ],
+];
+

package/src/languageProcessing/languages/fr/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: 9,
+};

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

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

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

@@ -0,0 +1,67 @@
+import { normalizeSingle } from "../../../helpers/sanitize/quotes";
+
+const contractionPrefixes = "^(c'|d'|l'|s')";
+const contractionRegex = new RegExp( contractionPrefixes );
+
+/**
+ * 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;
+
+	// Normalize single quotes before checking for contractions.
+	word = normalizeSingle( word );
+
+	/*
+	 * We want to remove the definite article l', preposition d' from a word,
+	 * since an article or preposition doesn't add any complexity to the word.
+	 */
+	if ( contractionRegex.test( word ) ) {
+		word = word.replace( contractionRegex, "" );
+	}
+
+	// The word is not complex if it's less than or the same as the length limit, i.e. 9 characters for French.
+	if ( word.length <= lengthLimit ) {
+		return false;
+	}
+
+	// The word is not complex if it's in the frequency list.
+	if ( frequencyList.includes( word ) ) {
+		return false;
+	}
+
+	/*
+	 * In French where capital letter beginning decreases the complexity of a word,
+	 * word longer than 9 characters is not complex if it starts with capital letter.
+	 */
+	if ( word[ 0 ].toLowerCase() === word[ 0 ] ) {
+		const standardSPluralSuffixesRegex = new RegExp( premiumData.suffixGroupsComplexity.standardSuffixesWithSplural );
+		const standardXPluralSuffixesRegex = new RegExp( premiumData.suffixGroupsComplexity.standardSuffixesWithXplural );
+		const irregularPluralSingularSuffixes = premiumData.suffixGroupsComplexity.irregularPluralSingularSuffixes;
+		const irregularPluralSuffixRegex = new RegExp( irregularPluralSingularSuffixes[ 0 ] );
+
+		/*
+		 * If a word is longer than 9 characters and doesn't start with capital letter,
+		 * we check further whether it is a plural that ends on the -s or -x plural suffix. If it is, we remove the plural suffix
+		 * and check if the singular word can be found in the frequency list.
+		 * if it is a plural that does not end on -s or -x but on -aux, we replace the plural -aux suffix with the singular suffix -al.
+		 * The word is not complex if the singular form is in the list.
+		 */
+		if ( standardSPluralSuffixesRegex.test( word ) || standardXPluralSuffixesRegex.test( word ) ) {
+			word = word.substring( 0, word.length - 1 );
+		} else if ( irregularPluralSuffixRegex.test( word ) ) {
+			word = word.replace( irregularPluralSuffixRegex, irregularPluralSingularSuffixes[ 1 ] );
+		}
+		return ! frequencyList.includes( word );
+	}
+
+	return false;
+}

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

@@ -0,0 +1,34 @@
+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 = ['le', 'la', 'les', 'une', "l'un", "l'une"];
+const reflexivePronouns = ['se', 'me', 'te', "s'y", "m'y", "t'y", 'nous nous', 'vous vous'];
+const elisionAuxiliaryExceptionWords = ["c'", "s'", 'peut-'];
+
+const options = {
+  Clause,
+  stopwords,
+  auxiliaries,
+  regexes: {
+    auxiliaryRegex: createRegexFromArray(auxiliaries),
+    stopCharacterRegex: /(,)(?=[ \n\r\t'"+\-»«‹›<>])/gi,
+    followingAuxiliaryExceptionRegex: createRegexFromArray(followingAuxiliaryExceptionWords),
+    directPrecedenceExceptionRegex: createRegexFromArray(reflexivePronouns),
+    elisionAuxiliaryExceptionRegex: createRegexFromArray(elisionAuxiliaryExceptionWords, true)
+  }
+};
+
+/**
+ * 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 getFrenchClauses(sentence) {
+  return getClauses(sentence, options);
+}

package/src/languageProcessing/languages/fr/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'), 'fr', false);
+
+  if (morphologyData) {
+    return word => stem(word, morphologyData);
+  }
+
+  return baseStemmer;
+}

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

@@ -0,0 +1,72 @@
+import {forEach, includes} from 'lodash';
+import {languageProcessing} from '../../../index';
+const {getWords, matchRegularParticiples} = languageProcessing;
+
+import {
+  irregularsRegular,
+  irregularsEndingInS,
+  irregularsIrregular
+} from '../../config/internal/passiveVoiceIrregulars';
+
+/**
+ * Returns an array of matches of irregular participles with suffixes.
+ *
+ * @param {string} word The word to match on.
+ * @param {Array} irregulars The list of irregulars to match.
+ * @param {string} suffixes The suffixes to match the word with.
+ *
+ * @returns {Array} A list with matched irregular participles.
+ */
+const matchFrenchParticipleWithSuffix = function(word, irregulars, suffixes) {
+  const matches = [];
+  forEach(irregulars, function(irregular) {
+    const irregularParticiplesRegex = new RegExp('^' + irregular + suffixes + '?$', 'ig');
+    const participleMatch = word.match(irregularParticiplesRegex);
+    if (participleMatch) {
+      matches.push(participleMatch[0]);
+    }
+  });
+  return matches;
+};
+
+/**
+ * Matches a word for a few lists of irregular participles.
+ *
+ * @param {string} word The word to match.
+ * @returns {Array} The matches.
+ */
+const matchIrregularParticiples = function(word) {
+  // Match different classes of participles with suffixes.
+  let matches = [].concat(matchFrenchParticipleWithSuffix(word, irregularsRegular, '(e|s|es)'));
+  matches = matches.concat(matchFrenchParticipleWithSuffix(word, irregularsEndingInS, '(e|es)'));
+
+  // Match irregular participles that don't require adding a suffix.
+  if (includes(irregularsIrregular, word)) {
+    matches.push(word);
+  }
+
+  return matches;
+};
+
+/**
+ * Creates an array of 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);
+  const foundParticiples = [];
+
+  forEach(words, function(word) {
+    const regularParticiplesRegex = [/\S+(é|ée|és|ées)($|[ \n\r\t.,'()"+\-;!?:/»«‹›<>])/gi];
+    if (
+      matchRegularParticiples(word, regularParticiplesRegex).length !== 0 ||
+      matchIrregularParticiples(word).length !== 0
+    ) {
+      foundParticiples.push(word);
+    }
+  });
+  return foundParticiples;
+}