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

package/src/helpers/index.js

@@ -0,0 +1,127 @@
+export {measureTextWidth} from './createMeasurementElement';
+export {getLanguagesWithWordFormSupport} from './getLanguagesWithWordFormSupport';
+export {default as formatNumber} from './formatNumber';
+export {getLanguagesWithWordComplexity} from './getLanguagesWithWordComplexity';
+export {createAnchorOpeningTag} from './shortlinker';
+export {default as getWordComplexityHelper} from './getWordComplexityHelper';
+export {default as getWordComplexityConfig} from './getWordComplexityConfig';
+
+import * as htmlEntities from './htmlEntities';
+
+export {htmlEntities};
+
+export function countWords(str) {
+  const wordsArray = str.trim().split(/\s+/);
+
+  return wordsArray.length;
+}
+
+/**
+ * To find the first string in the second string
+ * @param firstStr
+ * @param secondStr
+ * @returns {*}
+ */
+export const isIncludes = (firstStr, secondStr) => {
+  const keywordParts = firstStr.split(' ');
+  return keywordParts.every(part => secondStr.toLowerCase().includes(part));
+};
+
+/**
+ * Helper function to check if the HTML string contains the keyword in subheadings.
+ * @param {string} htmlString - The HTML string.
+ * @param {string} keyword - The keyword.
+ * @returns {boolean} True if the HTML string contains the keyword in subheadings, false otherwise.
+ */
+export function containsKeywordInSubheadings(htmlString, keyword) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(htmlString, 'text/html');
+
+  const subheadings = doc.querySelectorAll('h2, h3, h4, h5, h6');
+
+  for (let i = 0; i < subheadings.length; i++) {
+    if (subheadings[i].innerText.toLowerCase().includes(keyword)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ *
+ * @param htmlString
+ * @param getCharCount
+ * @returns {*|{charCount: *, wordCount: *}}
+ */
+export function countWordInHtml(htmlString, getCharCount = false) {
+  const textOnly = htmlString.replace(/<[^>]*>/g, ' ');
+  const words = textOnly.trim().split(/[\p{L}\p{N}]+(?:-[\p{L}\p{N}]+)*/gu);
+  const validWords = words.filter(word => word.length > 0);
+  const wordCount = validWords.length;
+  if (!getCharCount) {
+    return wordCount;
+  }
+  const cleanedString = textOnly.replace(/\s/g, '');
+  const charCount = cleanedString.length;
+  return {wordCount, charCount};
+}
+
+/**
+ *
+ * @param htmlString
+ * @param keyword
+ * @returns {{keywordCount: number, totalWords: number, density: string}}
+ */
+export function calculateKeywordDensity(htmlString, keyword) {
+  const spacedHtml = htmlString.replace(/(<[^>]+>)/g, ' $1 ');
+  const tempElement = document.createElement('div');
+  tempElement.innerHTML = spacedHtml;
+  const textContent = tempElement.textContent || tempElement.innerText || '';
+  const cleanedText = textContent
+    .trim()
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+
+  const lowerCaseKeyword = keyword.toLowerCase();
+
+  const escapedKeyword = lowerCaseKeyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const keywordCount = (cleanedText.match(new RegExp(escapedKeyword, 'g')) || []).length;
+
+  const totalWords = cleanedText.split(/\s+/).filter(word => word.length > 0).length;
+
+  const density = (keywordCount / totalWords) * 100;
+
+  return {
+    keywordCount: keywordCount,
+    totalWords: totalWords,
+    density: density.toFixed(2)
+  };
+}
+
+/**
+ *
+ * @param htmlString
+ * @returns {{isMissing: boolean, missingAltTags: *[], imgTags: *}|{isMissing: boolean, imgTags: *[]}|{isMissing: boolean, imgTags: *}}
+ */
+export function checkMissingAlt(htmlString) {
+  const imgTags = htmlString.match(/<img[^>]*>/g);
+
+  if (!imgTags) {
+    return {isMissing: false, imgTags: []};
+  }
+
+  const missingAltTags = [];
+
+  imgTags.forEach(imgTag => {
+    if (!/alt\s*=\s*["'][^"']*["']/.test(imgTag) || /alt\s*=\s*["']["']/.test(imgTag)) {
+      missingAltTags.push(imgTag);
+    }
+  });
+
+  if (missingAltTags.length === 0) {
+    return {isMissing: false, imgTags};
+  } else {
+    return {isMissing: true, imgTags, missingAltTags};
+  }
+}

package/src/helpers/shortlinker/Shortlinker.js

@@ -0,0 +1,75 @@
+/**
+ * Shortlinker to handle appending parameters to a link.
+ */
+export default class Shortlinker {
+	/**
+	 * Initialize the Shortlinker class.
+	 *
+	 * @param {Object} [config={}] Optional configuration.
+	 */
+	constructor( config = {} ) {
+		this.configure( config );
+	}
+
+	/**
+	 * Saves the passed configuration.
+	 *
+	 * @param {Object} config             The configuration.
+	 * @param {Object} [config.params={}] The default params to create the query string with.
+	 *
+	 * @returns {void}
+	 */
+	configure( config ) {
+		this._config = {
+			params: {},
+			...config,
+		};
+	}
+
+	/**
+	 * Creates a query string from a params object.
+	 *
+	 * @param {Object} params Params for in the query string.
+	 *
+	 * @returns {string} URI encoded query string.
+	 */
+	static createQueryString( params ) {
+		return Object.keys( params )
+			.map( key => `${ encodeURIComponent( key ) }=${ encodeURIComponent( params[ key ] ) }` )
+			.join( "&" );
+	}
+
+	/**
+	 * Creates a link by combining the params from the config and appending them to the url.
+	 *
+	 * @param {string} url         The base url.
+	 * @param {Object} [params={}] Optional params for in the url.
+	 *
+	 * @returns {string} The url with query string.
+	 */
+	append( url, params = {} ) {
+		let link = encodeURI( url );
+		const queryString = Shortlinker.createQueryString( {
+			...this._config.params,
+			...params,
+		} );
+
+		if ( queryString !== "" ) {
+			link += "?" + queryString;
+		}
+
+		return link;
+	}
+
+	/**
+	 * Creates an anchor opening tag; uses the append function to create the url.
+	 *
+	 * @param {string} url         The base url.
+	 * @param {Object} [params={}] Optional params for in the url.
+	 *
+	 * @returns {string} The anchor opening tag.
+	 */
+	createAnchorOpeningTag( url, params = {} ) {
+		return `<a href='${ this.append( url, params ) }' target='_blank'>`;
+	}
+}

package/src/helpers/shortlinker/index.js

@@ -0,0 +1 @@
+export * from "./singleton";

package/src/helpers/shortlinker/singleton.js

@@ -0,0 +1,68 @@
+import Shortlinker from "./Shortlinker";
+
+// Set global scope.
+let globalScope;
+
+// In the browser, window exists so that is the global scope.
+if ( typeof window === "undefined" ) {
+	// Inside a web worker, self exists so that is the global scope.
+	if ( typeof self === "undefined" ) {
+		// Fall back tot the `global`, because that is the global scope in Node.JS.
+		globalScope = global;
+	} else {
+		globalScope = self;
+	}
+} else {
+	globalScope = window;
+}
+
+globalScope.yoast = globalScope.yoast || {};
+globalScope.yoast.shortlinker = globalScope.yoast.shortlinker || null;
+
+/**
+ * Retrieves the Shortlinker instance.
+ *
+ * @returns {Shortlinker} The Shortlinker.
+ */
+function getShortlinker() {
+	if ( globalScope.yoast.shortlinker === null ) {
+		globalScope.yoast.shortlinker = new Shortlinker();
+	}
+	return globalScope.yoast.shortlinker;
+}
+
+/**
+ * Configures the Shortlinker instance.
+ *
+ * @param {Object} config             The configuration.
+ * @param {Object} [config.params={}] The default params for in the url.
+ *
+ * @returns {void}
+ */
+export function configureShortlinker( config ) {
+	( getShortlinker() ).configure( config );
+}
+
+/**
+ * Creates a link by combining the params from the config and appending them to the url.
+ *
+ * @param {string} url         The url.
+ * @param {Object} [params={}] Optional extra params for in the url.
+ *
+ * @returns {string} The url with query string.
+ */
+export function createShortlink( url, params = {} ) {
+	return ( getShortlinker() ).append( url, params );
+}
+
+/**
+ * Creates an anchor opening tag.
+ *
+ * @param {string} url         The url.
+ * @param {Object} [params={}] Optional extra params for in the url.
+ *
+ * @returns {string} The anchor opening tag.
+ */
+export function createAnchorOpeningTag( url, params = {} ) {
+	return ( getShortlinker() ).createAnchorOpeningTag( url, params );
+}

package/src/helpers/types.js

@@ -0,0 +1,34 @@
+/**
+ * Gets the parsed type name of subjects.
+ *
+ * @param {array|object|string|number} subject The subject to get the parsed type from.
+ * @returns {string} The parsed type name.
+ */
+var getType = function( subject ) {
+	if ( Array.isArray( subject ) ) {
+		return "array";
+	}
+	return typeof subject;
+};
+
+/**
+ * Validates the type of subjects. Throws an error if the type is invalid.
+ *
+ * @param {object} subject The object containing all subjects.
+ * @param {string} expectedType The expected type.
+ * @returns {boolean} Returns true if types matches expected type. Otherwise returns false.
+ */
+var isSameType = function( subject, expectedType ) {
+	var passedType = getType( subject );
+	return passedType === expectedType;
+};
+
+export {
+	getType,
+	isSameType,
+};
+
+export default {
+	getType: getType,
+	isSameType: isSameType,
+};

package/src/index.js

@@ -0,0 +1,60 @@
+import * as assessments from './scoring/assessments';
+import * as bundledPlugins from './bundledPlugins';
+import * as helpers from './helpers';
+import * as markers from './markers';
+import * as interpreters from './scoring/interpreters';
+import * as languageProcessing from './languageProcessing';
+import * as values from './values';
+import * as assessors from './scoring/assessors';
+import Assessor from './scoring/assessors/assessor';
+import ContentAssessor from './scoring/assessors/contentAssessor';
+import SeoAssessor from './scoring/assessors/seoAssessor';
+import Paper from './values/Paper';
+import AssessmentResult from './values/AssessmentResult';
+import Assessment from './scoring/assessments/assessment';
+import {DIFFICULTY} from './languageProcessing/researches/getFleschReadingScore';
+
+import Factory from './helpers/factory';
+
+/*
+ * Everything exported here is put on the `yoast.analysis` global in the plugin.
+ */
+export {
+  Assessor,
+  ContentAssessor,
+  SeoAssessor,
+  Paper,
+  AssessmentResult,
+  Assessment,
+  assessments,
+  assessors,
+  bundledPlugins,
+  helpers,
+  markers,
+  interpreters,
+  languageProcessing,
+  values,
+  DIFFICULTY,
+  Factory
+};
+
+/*
+ * Used for backwards compatibility reasons.
+ * For new exports, please add it as a named dependency above instead.
+ */
+export default {
+  Assessor,
+  ContentAssessor,
+  SeoAssessor,
+
+  Paper,
+  AssessmentResult,
+
+  assessments,
+  bundledPlugins,
+  helpers,
+  markers,
+  interpreters,
+  languageProcessing,
+  values
+};