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

package/src/config/wordBoundaries.js

@@ -0,0 +1,23 @@
+/**
+ * Returns the word boundaries.
+ * @returns {string[]} The array of word boundaries.
+ */
+export default function() {
+	return [
+		// Whitespace is always a word boundary.
+		" ", "\\n", "\\r", "\\t",
+		// NO-BREAK SPACE.
+		"\u00a0",
+		// \u06d4 - Urdu full stop
+		"\u06d4",
+		// \u061f - Arabic question mark
+		"\u061f",
+		// \u060C - Arabic comma
+		"\u060C",
+		// \u061B - Arabic semicolon
+		"\u061B",
+		" ",
+
+		".", ",", "'", "(", ")", "\"", "+", "-", ";", "!", "?", ":", "/", "»", "«", "‹", "›", "<", ">",
+		"”", "“", "〝", "〞", "〟", "‟", "„" ];
+}

package/src/config/wordBoundariesWithoutPunctuation.js

@@ -0,0 +1,9 @@
+/*
+ * A regex string that can be used to split a string on whitespaces, en-dashes, and hyphens.
+ */
+export const WORD_BOUNDARY_WITH_HYPHEN = "[\\s\\u2013\\u002d]";
+
+/*
+ * A regex string that can be used to split a string on whitespaces and en-dashes.
+ */
+export const WORD_BOUNDARY_WITHOUT_HYPHEN = "[\\s\\u2013]";

package/src/const/analysis.js

@@ -0,0 +1,41 @@
+export const POINT = 100;
+export const priorityRate = {
+  high: 1,
+  medium: 0.75,
+  low: 0.5
+};
+export const statusRate = {
+  good: 1,
+  improve: 0.5,
+  bad: 0
+};
+
+export const technicalSEOCategory = [
+  'singleH1',
+  'metaDescriptionLength',
+  'urlLength',
+  'internalLinks',
+  'externalLinks',
+  'titleWidth',
+  'textImages',
+  'schema',
+  'singleTitle'
+];
+
+export const contentSEOCategory = [
+  'introductionKeyword',
+  'sentenceBeginnings',
+  'textSentenceLength',
+  'textLength',
+  'titleKeyword',
+  'keyphraseLength',
+  'textTransitionWords',
+  'keyphraseDensity',
+  'slugKeyword',
+  'keyphrase',
+  'textParagraphTooLong',
+  'subheadingsKeyword',
+  'images',
+  'numberTitle',
+  'metaDescriptionKeyword'
+];

package/src/errors/invalidType.js

@@ -0,0 +1,14 @@
+/**
+ * The InvalidTypeError is thrown when an invalid type is passed as an argument.
+ */
+export default class InvalidTypeError extends Error {
+	/**
+	 * Constructs an InvalidTypeError.
+	 * @param {string} message The message to show when the error is thrown.
+	 * @constructor
+	 */
+	constructor( message )  {
+		super( message );
+		this.name = "InvalidTypeError";
+	}
+}

package/src/errors/missingArgument.js

@@ -0,0 +1,14 @@
+/**
+ * The MissingArgumentError is thrown when a required argument is not passed.
+ */
+export default class MissingArgumentError extends Error {
+	/**
+	 * Constructs a MissingArgumentError.
+	 * @param {string} message The message to show when the error is thrown.
+	 * @constructor
+	 */
+	constructor( message )  {
+		super( message );
+		this.name = "MissingArgumentError";
+	}
+}

package/src/helpers/createMeasurementElement.js

@@ -0,0 +1,40 @@
+const elementId = "yoast-measurement-element";
+
+/**
+ * Creates an hidden element with the purpose to calculate the sizes of elements and adds these elements to the body.
+ *
+ * @returns {HTMLElement} The created hidden element.
+ */
+const createMeasurementElement = function() {
+	const hiddenElement = document.createElement( "div" );
+
+	hiddenElement.id = elementId;
+
+	// Styles to prevent unintended scrolling in Gutenberg.
+	hiddenElement.style.position = "absolute";
+	hiddenElement.style.left = "-9999em";
+	hiddenElement.style.top = 0;
+	hiddenElement.style.height = 0;
+	hiddenElement.style.overflow = "hidden";
+	hiddenElement.style.fontFamily = "arial, sans-serif";
+	hiddenElement.style.fontSize = "20px";
+	hiddenElement.style.fontWeight = "400";
+
+	document.body.appendChild( hiddenElement );
+	return hiddenElement;
+};
+
+/**
+ * Measures the width of the text using a hidden element.
+ *
+ * @param {string} text The text to measure the width for.
+ * @returns {number} The width in pixels.
+ */
+export const measureTextWidth = function( text ) {
+	let element = document.getElementById( elementId );
+	if ( ! element ) {
+		element = createMeasurementElement();
+	}
+	element.innerText = text;
+	return element.offsetWidth;
+};

package/src/helpers/domManipulation.js

@@ -0,0 +1,65 @@
+import { forEach } from "lodash";
+
+/**
+ * Adds a class to an element
+ *
+ * @param {HTMLElement} element The element to add the class to.
+ * @param {string} className The class to add.
+ * @returns {void}
+ */
+var addClass = function( element, className ) {
+	var classes = element.className.split( " " );
+
+	if ( -1 === classes.indexOf( className ) ) {
+		classes.push( className );
+	}
+
+	element.className = classes.join( " " );
+};
+
+/**
+ * Removes a class from an element
+ *
+ * @param {HTMLElement} element The element to remove the class from.
+ * @param {string} className The class to remove.
+ * @returns {void}
+ */
+var removeClass = function( element, className ) {
+	var classes = element.className.split( " " );
+	var foundClass = classes.indexOf( className );
+
+	if ( -1 !== foundClass ) {
+		classes.splice( foundClass, 1 );
+	}
+
+	element.className = classes.join( " " );
+};
+
+/**
+ * Removes multiple classes from an element
+ *
+ * @param {HTMLElement} element The element to remove the classes from.
+ * @param {Array} classes A list of classes to remove
+ * @returns {void}
+ */
+var removeClasses = function( element, classes ) {
+	forEach( classes, this.removeClass.bind( null, element ) );
+};
+
+/**
+ * Checks whether an element has a specific class.
+ *
+ * @param {HTMLElement} element The element to check for the class.
+ * @param {string} className The class to look for.
+ * @returns {boolean} Whether or not the class is present.
+ */
+var hasClass = function( element, className ) {
+	return element.className.indexOf( className ) > -1;
+};
+
+export default {
+	hasClass: hasClass,
+	addClass: addClass,
+	removeClass: removeClass,
+	removeClasses: removeClasses,
+};

package/src/helpers/errors.js

@@ -0,0 +1,26 @@
+import { isUndefined } from "lodash";
+
+/**
+ * Shows and error trace of the error message in the console if the console is available.
+ *
+ * @param {string} [errorMessage=""] The error message.
+ * @returns {void}
+ */
+function showTrace( errorMessage ) {
+	if ( isUndefined( errorMessage ) ) {
+		errorMessage = "";
+	}
+
+	if (
+		! isUndefined( console ) &&
+		! isUndefined( console.trace )
+	) {
+		console.trace( errorMessage );
+	}
+}
+
+export { showTrace };
+
+export default {
+	showTrace: showTrace,
+};

package/src/helpers/factory.js

@@ -0,0 +1,219 @@
+import { isUndefined } from "lodash";
+
+/**
+ * FactoryProto is a mock factory function.
+ *
+ */
+export default class FactoryProto {
+	/**
+	 * Returns a mock element that lodash accepts as an element.
+	 *
+	 * @returns {object} Mock HTML element.
+	 */
+	static buildMockElement() {
+		const mockElement = [];
+		mockElement.nodeType = 1;
+
+		return mockElement;
+	}
+
+	/**
+	 * Returns a mock researcher.
+	 *
+	 * @param {Object} expectedValue Expected value.
+	 * @param {boolean} [multiValue=false] Whether the researcher has multiple values.
+	 * @param {boolean} [hasMorphologyData=false] Whether the researcher has morphology data.
+	 * @param {Object|boolean} [config=false] Optional config to be used for an assessment.
+	 * @param {Object|boolean} [helpers=false] Optional helpers to be used for an assessment.
+	 *
+	 * @returns {Object} Mock researcher.
+	 */
+	static buildMockResearcher( expectedValue, multiValue = false, hasMorphologyData = false,
+		config = false, helpers = false ) {
+		if ( multiValue && ( typeof expectedValue === "object" || typeof helpers === "object" || typeof config === "object" ) ) {
+			return {
+				/**
+				 * Returns research results by research name for multi-value mock researches.
+				 *
+				 * @param {string} research The name of the research.
+				 *
+				 * @returns {Object} The results of the research.
+				 */
+				getResearch: function( research ) {
+					return expectedValue[ research ];
+				},
+
+				/**
+				 * Returns whether the worker has the specified research.
+				 * @param {string} research The name of the research.
+				 * @returns {boolean} Whether the worker has the research.
+				 */
+				hasResearch: function( research ) {
+					return ! isUndefined( expectedValue[ research ] );
+				},
+
+				/**
+				 * Adds a research.
+				 * @param {string} name The name of the research.
+				 * @param {Object} research The research to register.
+				 *
+				 * @returns {void}
+				 */
+				addResearch: function( name, research ) {
+					expectedValue[ name ] = research;
+				},
+
+				/**
+				 * Checks whether morphology data is available.
+				 *
+				 * @returns {boolean} True if the researcher has access to morphology data.
+				 */
+				getData: function() {
+					return hasMorphologyData;
+				},
+
+				/**
+				 * Returns the helper to be used for the assessment.
+				 * @param {string} name The name of the helper.
+				 *
+				 * @returns {function} The helper for the assessment.
+				 */
+				getHelper: function( name ) {
+					return helpers[ name ];
+				},
+
+				/**
+				 * Checks whether a helper with the given name exists.
+				 * @param {string} name The name to check.
+				 *
+				 * @returns {boolean} True if the helper exists.
+				 */
+				hasHelper: function( name ) {
+					return ! isUndefined( helpers[ name ] );
+				},
+
+				/**
+				 * Adds a helper under the given name.
+				 * @param {string} name The name.
+				 * @param {function} helper The helper.
+				 *
+				 * @returns {void}
+				 */
+				addHelper: function( name, helper ) {
+					if ( ! helpers ) {
+						helpers = {};
+					}
+					helpers[ name ] = helper;
+				},
+
+				/**
+				 * Returns the config to be used for the assessment.
+				 * @param {string} name The name of the config.
+				 *
+				 * @returns {function} The config for the assessment.
+				 */
+				getConfig: function( name ) {
+					return config[ name ];
+				},
+
+				/**
+				 * Checks if the config exists.
+				 * @param {string} name The name of the config
+				 *
+				 * @returns {boolean} Whether the config exists.
+				 */
+				hasConfig: function( name ) {
+					return ! isUndefined( config[ name ] );
+				},
+
+				/**
+				 * Adds a configuration.
+				 * @param {string} name The name of the config.
+				 * @param {Object} researchConfig The config.
+				 *
+				 * @returns {void}
+				 */
+				addConfig: function( name, researchConfig ) {
+					config[ name ] = researchConfig;
+				},
+			};
+		}
+		return {
+			/**
+			 * Returns research results.
+			 *
+			 * @returns {Object} The results of the research.
+			 */
+			getResearch: function() {
+				return expectedValue;
+			},
+
+			/**
+			 * Check whether morphology data is available.
+			 *
+			 * @returns {boolean} True if the researcher has access to morphology data.
+			 */
+			getData: function() {
+				return hasMorphologyData;
+			},
+
+			/**
+			 * Returns the helpers to be used for the assessment.
+			 *
+			 * @returns {Object} The helpers for the assessment.
+			 */
+			getHelper: function() {
+				return helpers;
+			},
+
+			/**
+			 * Checks whether a helper with the given name exists.
+			 * @param {string} name The name to check.
+			 *
+			 * @returns {boolean} True if the helper exists.
+			 */
+			hasHelper: function( name ) {
+				return ! isUndefined( helpers[ name ] );
+			},
+
+			/**
+			 * Returns the config to be used for the assessment.
+			 *
+			 * @returns {Object} The config for the assessment results.
+			 */
+			getConfig: function() {
+				return config;
+			},
+
+			/**
+			 * Returns whether the worker has the specified config.
+			 * @param {string} name The name of the config.
+			 * @returns {boolean} Whether the worker has the specified config.
+			 */
+			hasConfig: function( name ) {
+				return ! isUndefined( expectedValue[ name ] );
+			},
+		};
+	}
+
+	/**
+	 * This method repeats a string and returns a new string based on the string and the amount of repetitions.
+	 *
+	 * @param {string} string      String to repeat.
+	 * @param {int}    repetitions Number of repetitions.
+	 *
+	 * @returns {string} The result.
+	 */
+	static buildMockString( string, repetitions ) {
+		let resultString = "";
+
+		string = string || "Test ";
+		repetitions = repetitions || 1;
+
+		for ( let i = 0; i < repetitions; i++ ) {
+			resultString += string;
+		}
+
+		return resultString;
+	}
+}

package/src/helpers/formatNumber.js

@@ -0,0 +1,12 @@
+/**
+ * Returns rounded number to fix floating point bug http://floating-point-gui.de
+ * @param {number} number The unrounded number
+ * @returns {number} Rounded number
+ */
+export default function( number ) {
+	if ( Math.round( number ) === number ) {
+		return Math.round( number );
+	}
+
+	return Math.round( number * 10 ) / 10;
+}

package/src/helpers/formatString.js

@@ -0,0 +1,33 @@
+import { escapeRegExp } from "lodash";
+
+/**
+ * Formats a string with named parameters as defined in the given parameter mapping.
+ *
+ * E.g. `"Hello %par_1% and %par_2%"` plus the map `{ par_1: "world", par_2: "you!" }`
+ * gives: `"Hello world and you!"`.
+ *
+ * @param {string} string           The string to be formatted.
+ * @param {Object} formatMap        The mapping in the form of parameter - value pairs.
+ * @param {string} [delimiter="%%"] The string used to delimit parameters in the to be formatted string.
+ *
+ * @returns {string} The formatted string.
+ */
+export default function( string, formatMap, delimiter = "%%" ) {
+	delimiter = escapeRegExp( delimiter );
+	const parameterRegex = new RegExp( `${delimiter}(.+?)${delimiter}`, "g" );
+	let match;
+	let formattedString = string;
+
+	// Try to match and replace each occurrence of "%%something%%" in the string.
+	while ( ( match = parameterRegex.exec( string ) ) !== null ) {
+		const key = match[ 1 ];
+		// Create regex from parameter (e.g. "%%key%%")
+		const replaceRegex = new RegExp( `${delimiter}${ escapeRegExp( key ) }${delimiter}`, "g" );
+		// Replace occurrence (if parameter exists in the format map).
+		if ( key in formatMap ) {
+			formattedString = formattedString.replace( replaceRegex, formatMap[ key ] );
+		}
+	}
+
+	return formattedString;
+}

package/src/helpers/getLanguagesWithWordComplexity.js

@@ -0,0 +1,8 @@
+/**
+ * Returns an array of languages with Word complexity support.
+ *
+ * @returns {string[]} A list of languages that have Word complexity support.
+ */
+export function getLanguagesWithWordComplexity() {
+	return [ "en", "es", "de", "fr" ];
+}

package/src/helpers/getLanguagesWithWordFormSupport.js

@@ -0,0 +1,11 @@
+/**
+ * Checks which languages have morphology support inside YoastSEO.js.
+ *
+ * @returns {string[]} A list of languages that have morphology support.
+ */
+export function getLanguagesWithWordFormSupport() {
+	const supportedLanguages = [ "en", "de", "es", "fr", "it", "nl", "ru", "id", "pt", "pl", "ar", "sv", "he", "hu",
+		"nb", "tr", "cs", "sk", "el", "ja" ];
+
+	return supportedLanguages;
+}

package/src/helpers/getWordComplexityConfig.js

@@ -0,0 +1,20 @@
+import wordComplexityConfigEnglish from "../languageProcessing/languages/en/config/wordComplexity.js";
+import wordComplexityConfigGerman from "../languageProcessing/languages/de/config/wordComplexity.js";
+import wordComplexityConfigSpanish from "../languageProcessing/languages/es/config/wordComplexity.js";
+import wordComplexityConfigFrench from "../languageProcessing/languages/fr/config/wordComplexity.js";
+
+/**
+ * Gets the word complexity assessment's config.
+ *
+ * @param {string} language The researcher language.
+ * @returns {function} The word complexity assessment's config.
+ */
+export default function getWordComplexityConfig( language ) {
+	const configs = {
+		de: wordComplexityConfigGerman,
+		en: wordComplexityConfigEnglish,
+		es: wordComplexityConfigSpanish,
+		fr: wordComplexityConfigFrench,
+	};
+	return configs[ language ];
+}

package/src/helpers/getWordComplexityHelper.js

@@ -0,0 +1,20 @@
+import wordComplexityHelperGerman from "../languageProcessing/languages/de/helpers/checkIfWordIsComplex.js";
+import wordComplexityHelperEnglish from "../languageProcessing/languages/en/helpers/checkIfWordIsComplex.js";
+import wordComplexityHelperSpanish from "../languageProcessing/languages/es/helpers/checkIfWordIsComplex.js";
+import wordComplexityHelperFrench from "../languageProcessing/languages/fr/helpers/checkIfWordIsComplex.js";
+
+/**
+ * Gets the word complexity assessment helper.
+ *
+ * @param {string} language The researcher language.
+ * @returns {function} The word complexity assessment's helper.
+ */
+export default function getWordComplexityHelper( language ) {
+	const helpers = {
+		de: wordComplexityHelperGerman,
+		en: wordComplexityHelperEnglish,
+		es: wordComplexityHelperSpanish,
+		fr: wordComplexityHelperFrench,
+	};
+	return helpers[ language ];
+}

package/src/helpers/htmlEntities.js

@@ -0,0 +1,41 @@
+// Contains 1) special characters usually converted into HTML entities (cf. _wp_specialchars).
+// And 2) their corresponding HTML entities, stripped from the initial ampersand (e.g. 'lt;' instead of '<').
+const htmlEntities = new Map( [
+	[ "amp;", "&" ],
+	[ "lt;", "<" ],
+	[ "gt;", ">" ],
+	[ "quot;", '"' ],
+	[ "apos;", "'" ],
+	[ "ndash;", "–" ],
+	[ "mdash;", "—" ],
+	[ "copy;", "©" ],
+	[ "reg;", "®" ],
+	[ "trade;", "™" ],
+	[ "pound;", "£" ],
+	[ "yen;", "¥" ],
+	[ "euro;", "€" ],
+	[ "dollar;", "$" ],
+	[ "deg;", "°" ],
+	[ "asymp;", "≈" ],
+	[ "ne;", "≠" ],
+	[ "nbsp;", " " ],
+] );
+
+// Regex to find all HTML entities.
+const htmlEntitiesRegex = new RegExp( "&(" + [ ...htmlEntities.keys() ].join( "|" ) + ")", "ig" );
+
+// Contains special characters along with their hashed HTML entities (e.g. '#amp;' instead of '&amp;' for the ampersand character '&').
+const hashedHtmlEntities = new Map();
+htmlEntities.forEach( ( value, key ) => hashedHtmlEntities.set( "#" + key, value ) );
+
+// Regex to find hashed HTML entities attached to the beginning (hashedHtmlEntitiesRegexStart) or to the end of a string (hashedHtmlEntitiesRegexEnd).
+const hashedHtmlEntitiesRegexStart = new RegExp( "^(" + [ ...hashedHtmlEntities.keys() ].join( "|" ) + ")" );
+const hashedHtmlEntitiesRegexEnd = new RegExp( "(" + [ ...hashedHtmlEntities.keys() ].join( "|" ) + ")$" );
+
+export {
+	htmlEntities,
+	htmlEntitiesRegex,
+	hashedHtmlEntities,
+	hashedHtmlEntitiesRegexStart,
+	hashedHtmlEntitiesRegexEnd,
+};

package/src/helpers/includesAny.js

@@ -0,0 +1,19 @@
+import { includes } from "lodash";
+
+/**
+ * Checks if any of the values is in the collection.
+ *
+ * @param {Object|array} collection The collection to check in.
+ * @param {array}        values     The array of values.
+ *
+ * @returns {boolean} Whether a value was found in the collection.
+ */
+export default function includesAny( collection, values ) {
+	for ( let i = 0; i < values.length; i++ ) {
+		if ( includes( collection, values[ i ] ) ) {
+			return true;
+		}
+	}
+
+	return false;
+}