axyseo 2.0.0-alpha.0.0.2 → 2.0.0-alpha.0.0.21

package/src/languageProcessing/languages/sk/config/internal/passiveVoiceAuxiliaries.js

@@ -1,22 +0,0 @@
-// These auxiliaries are filtered from the beginning of word combinations in the prominent words.
-export const filteredAuxiliaries =  [
-	"byť",
-	"som",
-	"si",
-	"je",
-	"sme",
-	"ste",
-	"sú",
-	"bol",
-	"bola",
-	"boli",
-	"bolo",
-	"budem",
-	"budeš",
-	"bude",
-	"budeme",
-	"budete",
-	"budú",
-];
-
-export default filteredAuxiliaries;

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

@@ -1,34 +0,0 @@
-/**
- * Returns a list with stopwords for the Slovak passive voice assessment.
- *
- * @returns {Array}                 The list with stopwords.
- */
-export default [
-	"ktorí",
-	"ktorých",
-	"ktorými",
-	"ktorá",
-	"ktorého",
-	"ktorému",
-	"ktorom",
-	"ktorým",
-	"ktorý",
-	"ktoré",
-	"ktorej",
-	"ktorou",
-	"ktorú",
-	"lebo",
-	"keby",
-	"že",
-	"aby",
-	"alebo",
-	"keďže",
-	"kedže",
-	"lenže",
-	"ale",
-	"nakoľko",
-	"pretože",
-	"či",
-	"ak",
-	"kedy",
-];

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

@@ -1,23 +0,0 @@
-/** @module config/transitionWords */
-
-export const singleWords = [ "kvôli", "miesto", "pre", "oproti", "aj", "i", "ani", "ale", "avšak", "však", "preto", "tak", "teda",
-	"hoci", "aby", "ako", "keď", "keďže", "kým", "pokiaľ", "ohľadne", "takto", "tiež ", "potom", "takže", "odtiaľ", "odteraz",
-	"lebo", "akonáhle", "lenže", "okrem", "nakoľko", "pokým", "pretože", "čiže", "jednako", "doteraz", "dosiaľ", "najmä",
-	"napríklad", "napr.", "napokon", "predsa", "určite", "dodatočne", "ďalej", "následne", "napriek", "hlavne", "nakoniec",
-	"medzitým", "inak ", "ináč", "obdobne", "podobne", "predovšetkým", "naozaj", "spočiatku ", "najprv", "najskôr", "stručne",
-	"všeobecne", "samozrejme", "pravdaže", "doposiaľ", "nielen", "než", "síce", "pričom", "až", "jednak", "zato", "nielenže",
-	"ibaže", "skôr", "prv", "hoc", "namiesto", "buďto", "inakšie", "hneď", "kedykoľvek" ];
-
-export const multipleWords = [ "ako aj", "ako i", "a tak ďalej", "a tak", "aj tak", "a jednako", "a naopak", "a predsa", "ale jednako",
-	"ale predsa", "a tým", "a to", "i to", "jednako však", "predsa však", "to jest", "a preto", "i keby", "i keď", "čo aj",
-	"keby aj", "pretor, aby", "odvtedy čo", "zatiar čo", "vzhľadom na to, že", "berúc do úvahy, že", "napriek tomu, že",
-	"preto, aby", "za účelom", "za týmto účelom", "skôr či neskôr ", "hneď ako", "len čo", "pokiaľ ide o", "pokiaľ nie",
-	"pokiaľ viem", "po prvé", "čo sa týka", "až do", "až na", "až po", "z tohto dôvodu", "z toho dôvodu", "no predsa",
-	"iba ak", "ak nie", "keď nie", "tobôž nie", "pravdu povediac", "ako napríklad", "okrem toho ", "v podstate", "ako je uvedené ",
-	"v každom prípade", "na rozdiel od", "v porovnaní s", "v oboch prípadoch", "stručne povedané", "inými slovami",
-	"na jednej strane", "na druhej strane", "s týmto cieľom" ];
-
-export const allWords = singleWords.concat( multipleWords );
-
-export default allWords;
-

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

@@ -1,10 +0,0 @@
-/** @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 [ [ "buď, buď" ], [ "buď, alebo" ], [ "ani, ani" ], [ "aj, aj" ], [ "tak, ako" ], [ "nielenže, lež aj" ],
-	[ "nielen, lež aj" ], [ "nielen, lež i" ], [ "nielenže, lež ai" ], [ "či, alebo" ], [ "i, i" ], [ "nielen, ale i" ],
-	[ "síce, ale" ] ];
-

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

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

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

@@ -1,22 +0,0 @@
-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'), 'sk', false);
-
-  if (morphologyData) {
-    return word => stem(word, morphologyData);
-  }
-
-  return baseStemmer;
-}

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

@@ -1,16 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {getWords} = languageProcessing;
-
-/**
- * Creates an array of participles found in a clause.
- *
- * @param {string} clauseText The clause to find participles in.
- *
- * @returns {Array} The list with participles found.
- */
-export default function(clauseText) {
-  const words = getWords(clauseText);
-  const participleEndingsRegex = new RegExp('(ný|ní|tý|ná|tá|né|té)$');
-
-  return words.filter(word => participleEndingsRegex.test(word));
-}

package/src/languageProcessing/languages/sk/helpers/internal/stem.js

@@ -1,319 +0,0 @@
-/* eslint-disable max-statements,complexity */
-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015 Marek Šuppa
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-/**
- * Takes care of palatalisation.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}      The non-palatalised word or the original word if no such suffix is found.
- */
-function palatalise( word, morphologyData ) {
-	const palatalEndingsRegexes = morphologyData.externalStemmer.palatalEndingsRegexes;
-	// Check if word ends in a palatal ending and return the regex if it does.
-	const checkPalatalEnding = palatalEndingsRegexes.find( regex => new RegExp( regex[ 0 ] ).test( word ) );
-	if ( checkPalatalEnding ) {
-		return word.replace( new RegExp( checkPalatalEnding[ 0 ] ), checkPalatalEnding[ 1 ] );
-	}
-	return word.slice( 0, -1 );
-}
-
-/**
- * Removes case suffixes.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}     The word without case suffixes or the original word if no such suffix is found.
- */
-function removeCases( word, morphologyData ) {
-	const caseSuffixes = morphologyData.externalStemmer.caseSuffixes;
-	const caseRegexes = morphologyData.externalStemmer.caseRegexes;
-
-	if ( word.length > 7 && word.endsWith( caseSuffixes.caseSuffix1 ) ) {
-		// Return the word without the suffix
-		return word.slice( 0, -5 );
-	}
-	if ( word.length > 6 && word.endsWith( caseSuffixes.caseSuffix2 ) ) {
-		return palatalise( word.slice( 0, -3 ), morphologyData );
-	}
-	if ( word.length > 5 ) {
-		if ( caseSuffixes.caseSuffixes3.includes( word.slice( -3 ) ) ) {
-			return palatalise( word.slice( 0, -2 ), morphologyData );
-		} else if ( caseSuffixes.caseSuffixes4.includes( word.slice( -3 ) ) ) {
-			return word.slice( 0, -3 );
-		}
-	}
-	if ( word.length > 4 ) {
-		if ( word.endsWith( caseSuffixes.caseSuffix5 ) ) {
-			return palatalise( word.slice( 0, -1 ), morphologyData );
-		} else if ( caseSuffixes.caseSuffixes6.includes( word.slice( -2 ) ) ) {
-			return palatalise( word.slice( 0, -2 ), morphologyData );
-		} else if ( caseSuffixes.caseSuffixes7.includes( word.slice( -2 ) ) ) {
-			return word.slice( 0, -2 );
-		}
-	}
-	if ( word.length > 3 ) {
-		if ( new RegExp( caseRegexes.caseRegex1 ).test( word ) ) {
-			return  palatalise( word, morphologyData );
-		} else if ( new RegExp( caseRegexes.caseRegex2 ).test( word ) ) {
-			return word.slice( 0, -1 );
-		}
-	}
-	return word;
-}
-
-/**
- * Removes possessive suffixes.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}     The word without possessive suffixes or the original word if no such suffix is found.
- */
-function removePossessives( word, morphologyData ) {
-	const possessiveSuffixes = morphologyData.externalStemmer.possessiveSuffixes;
-
-	if ( word.length > 5 ) {
-		if ( word.endsWith( possessiveSuffixes.posSuffixOv ) ) {
-			return word.slice( 0, -2 );
-		}
-		if ( word.endsWith( possessiveSuffixes.posSuffixIn ) ) {
-			return palatalise( word.slice( 0, -1 ), morphologyData );
-		}
-	}
-	return word;
-}
-
-/**
- * Removes comparative and superlative affixes.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}     The word without comparative and superlative affixes or the original word if no such suffix is found.
- */
-function removeComparativeAndSuperlative( word, morphologyData ) {
-	const superlativePrefix = morphologyData.externalStemmer.superlativePrefix;
-	if ( word.length > 6 && word.startsWith( superlativePrefix ) ) {
-		word = word.slice( 3, word.length );
-	}
-
-	if ( word.length > 5 ) {
-		const comparativeSuffixes = morphologyData.externalStemmer.comparativeSuffixes;
-		if ( comparativeSuffixes.includes( word.slice( -3 ) ) ) {
-			word = palatalise( word.slice( 0, -2 ), morphologyData );
-		}
-	}
-	return word;
-}
-
-/**
- * Removes diminutive suffixes.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}      The word without diminutive suffixes or the original word if no such suffix is found.
- */
-function removeDiminutives( word, morphologyData ) {
-	const diminutiveSuffixes = morphologyData.externalStemmer.diminutiveSuffixes;
-	if ( word.length > 7 && word.endsWith( diminutiveSuffixes.diminutiveSuffix1 ) ) {
-		return word.slice( 0, -5 );
-	}
-	if ( word.length > 6 ) {
-		if ( diminutiveSuffixes.diminutiveSuffixes2.includes( word.slice( -4 ) ) ) {
-			return palatalise( word.slice( 0, -3 ), morphologyData );
-		}
-		if ( diminutiveSuffixes.diminutiveSuffixes3.includes( word.slice( -4 ) ) ) {
-			return palatalise( word.slice( 0, -4 ), morphologyData );
-		}
-	}
-	if ( word.length > 5 ) {
-		if ( diminutiveSuffixes.diminutiveSuffixes4.includes( word.slice( -3 ) ) ) {
-			return palatalise( word.slice( 0, -3 ), morphologyData );
-		}
-		if ( diminutiveSuffixes.diminutiveSuffixes5.includes( word.slice( -3 ) ) ) {
-			return word.slice( 0, -3 );
-		}
-	}
-	if ( word.length > 4 ) {
-		if ( diminutiveSuffixes.diminutiveSuffixes6.includes( word.slice( -2 ) ) ) {
-			return palatalise( word.slice( 0, -1 ), morphologyData );
-		}
-		if ( diminutiveSuffixes.diminutiveSuffixes7.includes( word.slice( -2 ) ) ) {
-			return word.slice( 0, -1 );
-		}
-	}
-	if ( word.length > 3 && word.endsWith( "k" ) && ! word.endsWith( "isk" ) ) {
-		return word.slice( 0, -1 );
-	}
-	return word;
-}
-
-/**
- * Removes augmentative suffixes.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}      The word without augmentative suffixes or the original word if no such suffix is found.
- */
-function removeAugmentatives( word, morphologyData ) {
-	const augmentativeSuffixes = morphologyData.externalStemmer.augmentativeSuffixes;
-	if ( word.length > 6 && word.endsWith( augmentativeSuffixes.augmentativeSuffix1 ) ) {
-		return word.slice( 0, -4 );
-	}
-	if ( word.length > 5 && augmentativeSuffixes.augmentativeSuffixes2.includes( word.slice( -3 ) ) ) {
-		return palatalise( word.slice( 0, -2 ), morphologyData );
-	}
-	return word;
-}
-
-/**
- * Removes derivational suffixes.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}       The word without derivational suffixes or the original word if no such suffix is found.
- */
-function stemDerivational( word, morphologyData ) {
-	const derivationalSuffixes = morphologyData.externalStemmer.derivationalSuffixes;
-	if ( word.length > 8 && word.endsWith( derivationalSuffixes.derivationalSuffix1 ) ) {
-		return word.slice( 0, -6 );
-	}
-	if ( word.length > 7 ) {
-		if ( word.endsWith( derivationalSuffixes.derivationalSuffix2 ) ) {
-			return palatalise( word.slice( 0, -4 ), morphologyData );
-		}
-		if ( derivationalSuffixes.derivationalSuffixes3.includes( word.slice( -5 ) ) ) {
-			return word.slice( 0, -5 );
-		}
-	}
-	if ( word.length > 6 ) {
-		if ( derivationalSuffixes.derivationalSuffixes4.includes( word.slice( -4 ) ) ) {
-			return word.slice( 0, -4 );
-		}
-		if ( derivationalSuffixes.derivationalSuffixes5.includes( word.slice( -4 ) ) ) {
-			return palatalise( word.slice( 0, -3 ), morphologyData );
-		}
-	}
-	if ( word.length > 5 ) {
-		if ( word.endsWith( derivationalSuffixes.derivationalSuffix6 ) ) {
-			return word.slice( 0, -3 );
-		}
-		if ( derivationalSuffixes.derivationalSuffixes7.includes( word.slice( -3 ) ) ) {
-			return palatalise( word.slice( 0, -2 ), morphologyData );
-		}
-		if ( derivationalSuffixes.derivationalSuffixes8.includes( word.slice( -3 ) ) ) {
-			return word.slice( 0, -3 );
-		}
-	}
-	if ( word.length > 4 ) {
-		if ( derivationalSuffixes.derivationalSuffixes9.includes( word.slice( -2 ) ) ) {
-			return word.slice( 0, -2 );
-		}
-		if ( derivationalSuffixes.derivationalSuffixes10.includes( word.slice( -2 ) ) ) {
-			return palatalise( word.slice( 0, -1 ), morphologyData );
-		}
-	}
-	const derivationalRegex = new RegExp( morphologyData.externalStemmer.derivationalRegex );
-	if ( word.length > 3 && derivationalRegex.test( word ) ) {
-		return word.slice( 0, -1 );
-	}
-	return word;
-}
-
-/**
- * Checks whether a word is in the full-form exception list and if so returns the canonical stem.
- *
- * @param {string} word	           				The word to be checked.
- * @param {Object} exceptionListWithFullForms   The exception list to check.
- *
- * @returns {string}                The canonical stem if word was found on the list or the original word otherwise.
- */
-const checkWordInFullFormExceptions = function( word, exceptionListWithFullForms ) {
-	for ( const paradigm of exceptionListWithFullForms ) {
-		if ( paradigm[ 1 ].includes( word ) ) {
-			return paradigm[ 0 ];
-		}
-	}
-	return null;
-};
-
-/**
- * Checks whether a stem is in an exception list of words with multiple stems and if so returns the canonical stem.
- *
- * @param {string} stemmedWord	            The stemmed word to be checked.
- * @param {Object} stemsThatBelongToOneWord The data that shows how non-canonical stems should be canonicalized.
- *
- * @returns {null|string} The canonical stem or null if nothing was found.
- */
-const canonicalizeStem = function( stemmedWord, stemsThatBelongToOneWord ) {
-	for ( const paradigm of stemsThatBelongToOneWord ) {
-		if ( paradigm.includes( stemmedWord ) ) {
-			return paradigm[ 0 ];
-		}
-	}
-	return null;
-};
-
-/**
- * Stems Slovak words.
- *
- * @param {string} word             The word to stem.
- * @param {Object} morphologyData   The Slovak morphology data.
- *
- * @returns {string}    The stemmed word.
- */
-export default function stem( word, morphologyData ) {
-	// Return stem of words on the full forms exception list.
-	const stemFromExceptionListWithFullForms = checkWordInFullFormExceptions( word, morphologyData.exceptionLists.exceptionStemsWithFullForms );
-	if ( stemFromExceptionListWithFullForms ) {
-		return stemFromExceptionListWithFullForms;
-	}
-	// Remove case suffixes
-	word = removeCases( word, morphologyData );
-	// Remove possessive suffixes
-	word = removePossessives( word, morphologyData );
-	// Remove comparative and superlative affixes
-	word = removeComparativeAndSuperlative( word, morphologyData );
-	// Remove diminutive suffixes
-	word = removeDiminutives( word, morphologyData );
-	// Remove augmentative suffixes
-	word = removeAugmentatives( word, morphologyData );
-	// Remove derivational suffixes
-	word = stemDerivational( word, morphologyData );
-
-	// Return canonical stem of words that get a few different stems depending on the form.
-	const canonicalStem = canonicalizeStem( word, morphologyData.exceptionLists.stemsThatBelongToOneWord );
-	if ( canonicalStem ) {
-		return canonicalStem;
-	}
-
-	return word;
-}

package/src/languageProcessing/languages/sk/values/Clause.js

@@ -1,39 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {values} = languageProcessing;
-const {Clause} = values;
-import getParticiples from '../helpers/internal/getParticiples';
-import nonPassives from '../../sk/config/internal/nonPassives';
-
-/**
- * Creates a Clause object for the Slovak language.
- */
-class SlovakClause extends Clause {
-  /**
-   * Constructor.
-   *
-   * @param {string} clauseText   The text of the clause.
-   * @param {Array} auxiliaries   The auxiliaries.
-   *
-   * @constructor
-   */
-  constructor(clauseText, auxiliaries) {
-    super(clauseText, auxiliaries);
-    this._participles = getParticiples(this.getClauseText());
-    this.checkParticiples();
-  }
-
-  /**
-   * Checks if any exceptions are applicable to this participle that would result in the clause not being passive.
-   * If no exceptions are found, the clause is passive.
-   *
-   * @returns {void}
-   */
-  checkParticiples() {
-    const foundParticiples = this.getParticiples().filter(
-      participle => !nonPassives.includes(participle)
-    );
-    this.setPassive(foundParticiples.length > 0);
-  }
-}
-
-export default SlovakClause;

package/src/languageProcessing/languages/sv/Researcher.js

@@ -1,45 +0,0 @@
-import {languageProcessing} from '../../../index';
-const {AbstractResearcher} = languageProcessing;
-
-// All config
-import firstWordExceptions from './config/firstWordExceptions';
-import {all as functionWords} from './config/functionWords';
-import transitionWords from './config/transitionWords';
-import twoPartTransitionWords from './config/twoPartTransitionWords';
-import keyphraseLength from './config/keyphraseLength';
-
-// All helpers
-import getStemmer from './helpers/getStemmer';
-import isPassiveSentence from './helpers/isPassiveSentence';
-
-/**
- * The researcher contains all the researches, helpers, data, and config.
- */
-export default class Researcher extends AbstractResearcher {
-  /**
-   * Constructor
-   * @param {Paper} paper The Paper object that is needed within the researches.
-   * @constructor
-   */
-  constructor(paper) {
-    super(paper);
-
-    // Delete the researches that are not available in Swedish.
-    delete this.defaultResearches.getFleschReadingScore;
-
-    Object.assign(this.config, {
-      language: 'sv',
-      passiveConstructionType: 'morphological',
-      firstWordExceptions,
-      functionWords,
-      transitionWords,
-      twoPartTransitionWords,
-      keyphraseLength
-    });
-
-    Object.assign(this.helpers, {
-      getStemmer,
-      isPassiveSentence
-    });
-  }
-}

package/src/languageProcessing/languages/sv/config/firstWordExceptions.js

@@ -1,15 +0,0 @@
-/**
- * Returns an array with exceptions for the sentence beginning researcher.
- *
- * @returns {string[]} The array filled with exceptions.
- */
-export default [
-	// Indefinite articles:
-	"ett",
-	// Definite articles:
-	"det", "den", "de",
-	// Numbers 1-10:
-	"en", "två", "tre", "fyra", "fem", "sex", "sju", "åtta", "nio", "tio",
-	// Demonstrative pronouns:
-	"denne", "denna", "detta", "dessa",
-];