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

package/src/parsedPaper/structure/tree/nodes/Node.js

@@ -0,0 +1,154 @@
+import { has, get } from "lodash";
+import SourceCodeLocation from "../SourceCodeLocation";
+
+/**
+ * Abstract class representing a node in the structured tree.
+ * @abstract
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class Node {
+	/**
+	 * Makes a new Node.
+	 *
+	 * @param {string} type               The type of Node (should be unique for each child class of Node).
+	 * @param {?Object} sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 *
+	 * @abstract
+	 */
+	constructor( type, sourceCodeLocation ) {
+		/**
+		 * Type of node (unique for each child class of Node).
+		 * @type {string}
+		 */
+		this.type = type;
+
+		if ( sourceCodeLocation ) {
+			/**
+			 * Location inside of the source code.
+			 * @type {SourceCodeLocation}
+			 */
+			this.sourceCodeLocation = new SourceCodeLocation( sourceCodeLocation );
+		}
+
+		/**
+		 * The parent node of this node.
+		 * @type {module:parsedPaper/structure.Node|null}
+		 */
+		this.parent = null;
+
+		/**
+		 * Cache for the research results.
+		 * @type {Object}
+		 * @private
+		 */
+		this._researchResult = {};
+	}
+
+	/**
+	 * Stores the research result on this node.
+	 *
+	 * @param {string} researchName   The name of the research of which to store the results.
+	 * @param {Object} researchResult The results to store.
+	 *
+	 * @returns {void}
+	 */
+	setResearchResult( researchName, researchResult ) {
+		this._researchResult[ researchName ] = researchResult;
+	}
+
+	/**
+	 * Returns the research result for the research with the given name.
+	 *
+	 * @param {string} researchName The name of the research of which to return the stored results.
+	 *
+	 * @returns {Object|null} The stored results, or null if not found.
+	 */
+	getResearchResult( researchName ) {
+		return get( this._researchResult, researchName, null );
+	}
+
+	/**
+	 * Checks whether results exist for the research with the given name.
+	 *
+	 * @param {string} researchName The name of the research to check.
+	 *
+	 * @returns {boolean} Whether results exists for the research with the given name.
+	 */
+	hasResearchResult( researchName ) {
+		return has( this._researchResult, researchName );
+	}
+
+	/**
+	 * Maps the given function to each Node in this tree.
+	 *
+	 * @param {module:parsedPaper/structure.Node.mapFunction} mapFunction The function that should be mapped to each Node in the tree.
+	 *
+	 * @returns {module:parsedPaper/structure.Node} A new tree, after the given function has been mapped on each Node.
+	 */
+	map( mapFunction ) {
+		// Map function over contents of this node.
+		const node = mapFunction( this );
+		if ( node.children && node.children.length > 0 ) {
+			// Map function over node's children (if it has any).
+			node.children = node.children.map( child => child.map( mapFunction ) );
+		}
+		return node;
+	}
+
+	/**
+	 * Callback function for the Node's map-function.
+	 *
+	 * @callback module:parsedPaper/structure.Node.mapFunction
+	 *
+	 * @param {module:parsedPaper/structure.Node} currentValue The current Node being processed.
+	 *
+	 * @returns {module:parsedPaper/structure.Node} The current Node after being processed by this function.
+	 */
+
+	/**
+	 * Executes the given function on each node in this tree.
+	 *
+	 * @param{function} fun The function to apply to each node in the tree.
+	 *
+	 * @returns {void}
+	 */
+	forEach( fun ) {
+		fun( this );
+		if ( this.children && this.children.length > 0 ) {
+			this.children.forEach( fun );
+		}
+	}
+
+	/**
+	 * Custom replacer function for replacing 'parent' with nothing.
+	 * This is done to remove cycles from the tree.
+	 *
+	 * @param {string} key   The key.
+	 * @param {Object} value The value.
+	 *
+	 * @returns {Object} The (optionally replaced) value.
+	 *
+	 * @private
+	 */
+	static _removeParent( key, value ) {
+		if ( key === "parent" ) {
+			return;
+		}
+		return value;
+	}
+
+	/**
+	 * Transforms this tree to a string representation.
+	 * For use in e.g. logging to the console or to a text file.
+	 *
+	 * @param {number|string} [indentation = 2] The space with which to indent each successive level in the JSON tree.
+	 *
+	 * @returns {string} This tree, transformed to a string.
+	 */
+	toString( indentation = 2 ) {
+		return JSON.stringify( this, Node._removeParent, indentation );
+	}
+}
+
+export default Node;

package/src/parsedPaper/structure/tree/nodes/Paragraph.js

@@ -0,0 +1,24 @@
+import LeafNode from "./LeafNode";
+
+/**
+ * Represents a paragraph with text within a document.
+ *
+ * @extends module:parsedPaper/structure.LeafNode
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class Paragraph extends LeafNode {
+	/**
+	 * A paragraph within a document.
+	 *
+	 * @param {Object}  sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 * @param {boolean} [isImplicit=false] If this paragraph is implicit.
+	 */
+	constructor( sourceCodeLocation, isImplicit = false ) {
+		super( "Paragraph", sourceCodeLocation );
+
+		this.isImplicit = isImplicit;
+	}
+}
+
+export default Paragraph;

package/src/parsedPaper/structure/tree/nodes/StructuredNode.js

@@ -0,0 +1,52 @@
+import Node from "./Node";
+/**
+ * Represents a piece of structure that is present in the original text, but is not relevant for the further analysis
+ * of the text.
+ *
+ * Talking about HTML, this would encompass thing like `<div>`, `<section>`, `<aside>`, `<fieldset>`
+ * and other HTML block elements.
+ *
+ * @extends module:parsedPaper/structure.Node
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class StructuredNode extends Node {
+	/**
+	 * Represents a piece of structure that is present in the original text, but is not relevant for the further
+	 * analysis of the text.
+	 *
+	 * Talking about HTML, this would encompass thing like `<div>`, `<section>`, `<aside>`, `<fieldset>`
+	 * and other HTML block elements.
+	 *
+	 * @param {string} tag                The tag used in the node.
+	 * @param {?Object} sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 *
+	 * @returns {void}
+	 */
+	constructor( tag, sourceCodeLocation ) {
+		super( "StructuredNode", sourceCodeLocation );
+		/**
+		 * Type of structured node (e.g. "div", "section" etc.).
+		 * @type {string}
+		 */
+		this.tag = tag;
+		/**
+		 * This node's child nodes.
+		 * @type {module:parsedPaper/structure.Node[]}
+		 */
+		this.children = [];
+	}
+
+	/**
+	 * Adds a child and sets its parent to this node.
+	 *
+	 * @param {module:parsedPaper/structure.Node} child The child to add.
+	 *
+	 * @returns {void}
+	 */
+	addChild( child ) {
+		child.parent = this;
+		this.children.push( child );
+	}
+}
+export default StructuredNode;

package/src/parsedPaper/structure/tree/nodes/index.js

@@ -0,0 +1,21 @@
+import Heading from "./Heading";
+import LeafNode from "./LeafNode";
+import List from "./List";
+import ListItem from "./ListItem";
+import MetadataMiscellaneous from "./MetadataMiscellaneous";
+import MetadataText from "./MetadataText";
+import Node from "./Node";
+import Paragraph from "./Paragraph";
+import StructuredNode from "./StructuredNode";
+
+export {
+	Heading,
+	LeafNode,
+	List,
+	ListItem,
+	MetadataText,
+	MetadataMiscellaneous,
+	Node,
+	Paragraph,
+	StructuredNode,
+};

package/src/scoring/assessments/assessment.js

@@ -0,0 +1,63 @@
+/* eslint-disable no-unused-vars */
+import {sanitizeString} from '../../languageProcessing';
+import {filterShortcodesFromHTML, removeHtmlBlocks} from '../../languageProcessing/helpers';
+import {POINT, priorityRate, statusRate} from '../../../const/analysis';
+
+/**
+ * The base class for an Assessment.
+ */
+class Assessment {
+  /**
+   * Executes the assessment and return its result.
+   *
+   * @param {Paper}       paper       The paper to run this assessment on.
+   * @param {Researcher}  researcher  The researcher used for the assessment.
+   * @param i18n
+   * @returns {AssessmentResult} The result of the assessment.
+   */
+  getResult(paper, researcher, i18n) {
+    throw 'The method getResult is not implemented';
+  }
+
+  /**
+   * Checks whether the assessment is applicable.
+   *
+   * @param {Paper}       paper       The paper to run this assessment on.
+   * @param {Researcher}  researcher  The researcher used for the assessment.
+   *
+   * @returns {boolean} Whether the assessment is applicable, defaults to `true`.
+   */
+  isApplicable(paper, researcher) {
+    return true;
+  }
+
+  /**
+   * Tests whether a `Paper` has enough content for assessments to be displayed.
+   *
+   * @param {Paper} paper            The paper to run this assessment on.
+   * @param {number} contentNeededForAssessment  The minimum length in characters a text must have for assessments to be displayed.
+   *
+   * @returns {boolean} `true` if the text is of the required length, `false` otherwise.
+   */
+  hasEnoughContentForAssessment(paper, contentNeededForAssessment = 50) {
+    let text = paper.getText();
+    text = removeHtmlBlocks(text);
+    text = filterShortcodesFromHTML(text, paper._attributes && paper._attributes.shortcodes);
+
+    return sanitizeString(text).length >= contentNeededForAssessment;
+  }
+
+  /**
+   *
+   * @param priority
+   * @param status
+   * @returns {number}
+   */
+  getScore(priority, status) {
+    return POINT * priorityRate[`${priority}`] * statusRate[`${status}`];
+  }
+}
+
+/* eslint-enable no-unused-vars */
+
+export default Assessment;

package/src/scoring/assessments/index.js

@@ -0,0 +1,58 @@
+// Readability assessments.
+import ParagraphTooLongAssessment from './readability/ParagraphTooLongAssessment';
+import SentenceBeginningsAssessment from './readability/SentenceBeginningsAssessment';
+import SentenceLengthInTextAssessment from './readability/SentenceLengthInTextAssessment';
+import TransitionWordsAssessment from './readability/TransitionWordsAssessment';
+
+// SEO assessments.
+import InternalLinksAssessment from './seo/InternalLinksAssessment';
+import IntroductionKeywordAssessment from './seo/IntroductionKeywordAssessment';
+import KeyphraseLengthAssessment from './seo/KeyphraseLengthAssessment';
+import KeyphraseDensityAssessment from './seo/KeywordDensityAssessment';
+import MetaDescriptionKeywordAssessment from './seo/MetaDescriptionKeywordAssessment';
+import MetaDescriptionLengthAssessment from './seo/MetaDescriptionLengthAssessment';
+import OutboundLinksAssessment from './seo/OutboundLinksAssessment';
+import PageTitleWidthAssessment from './seo/PageTitleWidthAssessment';
+import SingleH1Assessment from './seo/SingleH1Assessment';
+import SubheadingsKeywordAssessment from './seo/SubHeadingsKeywordAssessment';
+import TextLengthAssessment from './seo/TextLengthAssessment';
+import SlugKeywordAssessment from './seo/UrlKeywordAssessment';
+import ImageCountAssessment from './seo/ImageCountAssessment';
+import KeyphraseAssessment from './seo/KeyphraseAssessment';
+import SingleTitleAssessment from '../../../scoring/assessments/seo/SingleTitleAssessment';
+import UrlLengthAssessment from '../../../scoring/assessments/seo/UrlLengthAssessment';
+import NumberInMetaTitleAssessment from '../../../scoring/assessments/seo/NumberInMetaTitleAssessment';
+import TextImagesAssessment from '../../../scoring/assessments/seo/TextImagesAssessment';
+import MetaTitleKeywordAssessment from '../../../scoring/assessments/seo/MetaTitleKeywordAssessment';
+
+const readability = {
+  ParagraphTooLongAssessment,
+  SentenceBeginningsAssessment,
+  SentenceLengthInTextAssessment,
+  TransitionWordsAssessment
+};
+
+// We expose the deprecated assessments for backwards compatibility.
+const seo = {
+  ImageCountAssessment,
+  NumberInMetaTitleAssessment,
+  InternalLinksAssessment,
+  TextImagesAssessment,
+  MetaTitleKeywordAssessment,
+  IntroductionKeywordAssessment,
+  SingleTitleAssessment,
+  KeyphraseLengthAssessment,
+  UrlLengthAssessment,
+  KeyphraseDensityAssessment,
+  MetaDescriptionKeywordAssessment,
+  MetaDescriptionLengthAssessment,
+  OutboundLinksAssessment,
+  PageTitleWidthAssessment,
+  SingleH1Assessment,
+  SubheadingsKeywordAssessment,
+  TextLengthAssessment,
+  SlugKeywordAssessment,
+  KeyphraseAssessment
+};
+
+export {readability, seo};

package/src/scoring/assessments/readability/ParagraphTooLongAssessment.js

@@ -0,0 +1,173 @@
+import {merge} from 'lodash';
+import React from 'react';
+import {Text} from '@shopify/polaris';
+import {inRangeEndInclusive as inRange} from '../../helpers/assessments/inRange';
+import AssessmentResult from '../../../values/AssessmentResult';
+import Assessment from '../assessment';
+
+/**
+ * Represents the assessment that will look if the text has too long paragraphs.
+ */
+export default class ParagraphTooLongAssessment extends Assessment {
+  /**
+   * Sets the identifier and the config.
+   *
+   * @param {object} config       The configuration to use.
+   *
+   * @returns {void}
+   */
+  constructor(config = {}) {
+    super();
+
+    const defaultConfig = {
+      id: 'textParagraphTooLong',
+      priority: 'high',
+      docUrl:
+        'https://docs.avada.io/seo-suite-help-center/seo-audit/on-page-seo/checklist#paragraph-length',
+      fixPosition: 'longParagraph',
+      ctaType: 'fix',
+      parameters: {
+        recommendedLength: 150,
+        maximumRecommendedLength: 150
+      },
+      title: 'Paragraph length',
+      content: {
+        bad: 'Paragraph too long. Keep paragraph length less than 150 words for readability.',
+        improve: '',
+        good: 'Paragraph is optimized, with less than 150 words.'
+      }
+    };
+
+    this.identifier = 'textParagraphTooLong';
+    this._config = merge(defaultConfig, config);
+  }
+
+  /**
+   * Check if there is language-specific config, and if so, overwrite the current config with it.
+   *
+   * @param {Researcher} researcher The researcher to use.
+   *
+   * @returns {Object} The config that should be used.
+   */
+  getConfig(researcher) {
+    const currentConfig = this._config;
+    const languageSpecificConfig = researcher.getConfig('paragraphLength');
+
+    /*
+     * If a language has a specific paragraph length config, check further if the assessment is run in product pages.
+     * If it's run in product pages, override the default config parameters with the language specific config for product pages,
+     * otherwise override it with the language specific config for default pages analysis.
+     */
+    if (languageSpecificConfig) {
+      currentConfig.parameters = this._isProduct
+        ? languageSpecificConfig.productPageParams
+        : languageSpecificConfig.defaultPageParams;
+    }
+
+    return currentConfig;
+  }
+
+  /**
+   *
+   * @param paragraphsLength
+   * @param tooLongParagraphs
+   * @param config
+   * @param i18n
+   * @returns {{score: number, body: React.JSX.Element, status: string}}
+   */
+  calculateResult({paragraphsLength, config, i18n}) {
+    let status = '';
+    if (paragraphsLength.length === 0) {
+      status = 'good';
+    }
+
+    const longestParagraphLength = paragraphsLength[0].countLength;
+
+    if (longestParagraphLength <= config.parameters.recommendedLength) {
+      status = 'good';
+    }
+
+    if (
+      inRange(
+        longestParagraphLength,
+        config.parameters.recommendedLength,
+        config.parameters.maximumRecommendedLength
+      )
+    ) {
+      status = 'good';
+    }
+
+    if (longestParagraphLength > config.parameters.maximumRecommendedLength) {
+      status = 'bad';
+    }
+
+    const score = this.getScore(this._config.priority, status);
+
+    return {
+      score,
+      status,
+      body: (
+        <Text as={'span'}>
+          {this._config.content[status]}{' '}
+          {this._config.docUrl && (
+            <a href={this._config.docUrl} target="_blank" rel="noreferrer">
+              Learn more
+            </a>
+          )}
+        </Text>
+      )
+    };
+  }
+
+  /**
+   * Sort the paragraphs based on word count.
+   *
+   * @param {Array} paragraphs The array with paragraphs.
+   *
+   * @returns {Array} The array sorted on word counts.
+   */
+  sortParagraphs(paragraphs) {
+    return paragraphs.sort(function(a, b) {
+      return b.countLength - a.countLength;
+    });
+  }
+
+  /**
+   * Runs the getParagraphLength module, based on this returns an assessment result with score and text.
+   *
+   * @param {Paper} paper             The paper to use for the assessment.
+   * @param {Researcher} researcher   The researcher used for calling research.
+   * @param i18n
+   * @returns {object} The assessment result.
+   */
+  getResult(paper, researcher, i18n) {
+    let paragraphsLength = researcher.getResearch('getParagraphLength');
+
+    paragraphsLength = this.sortParagraphs(paragraphsLength);
+    const config = this.getConfig(researcher);
+
+    const paragraphLengthResult = this.calculateResult({
+      paragraphsLength,
+      config,
+      i18n
+    });
+    const assessmentResult = new AssessmentResult({config: this._config});
+
+    assessmentResult.setScore(paragraphLengthResult.score);
+    assessmentResult.setStatus(paragraphLengthResult.status);
+    assessmentResult.setBody(paragraphLengthResult.body);
+
+    return assessmentResult;
+  }
+
+  /**
+   * Checks if the paragraphTooLong assessment is applicable to the paper.
+   *
+   * @param {Paper} paper The paper to check.
+   *
+   * @returns {boolean} Returns true if the assessment is applicable to the paper.
+   */
+  isApplicable(paper) {
+    return this.hasEnoughContentForAssessment(paper);
+  }
+}

package/src/scoring/assessments/readability/SentenceBeginningsAssessment.js

@@ -0,0 +1,132 @@
+import {merge, partition, sortBy} from 'lodash';
+import React from 'react';
+import {Text} from '@shopify/polaris';
+import AssessmentResult from '../../../values/AssessmentResult';
+import Assessment from '../assessment';
+import {TextBlockIcon} from '@shopify/polaris-icons';
+
+const maximumConsecutiveDuplicates = 2;
+
+/**
+ * Represents the assessment that checks whether there are three or more consecutive sentences beginning with the same word.
+ */
+export default class SentenceBeginningsAssessment extends Assessment {
+  /**
+   * Sets the identifier and the config.
+   *
+   * @param {object} config The configuration to use.
+   *
+   * @returns {void}
+   */
+  constructor(config = {}) {
+    super();
+
+    const defaultConfig = {
+      id: 'sentenceBeginnings',
+      priority: 'medium',
+      ctaType: 'fix',
+      docUrl:
+        'https://docs.avada.io/seo-suite-help-center/seo-audit/on-page-seo/checklist#sentence-beginnings',
+      fixPosition: 'description',
+      icon: TextBlockIcon,
+      title: 'Sentence beginnings',
+      content: {
+        improve: '',
+        bad:
+          'Found sentences with repetitive beginnings. Change the wording for more engaging content.',
+        good: 'No sentences with repetitive beginnings found.'
+      }
+    };
+
+    this.identifier = 'sentenceBeginnings';
+    this._config = merge(defaultConfig, config);
+  }
+
+  /**
+   * Counts and groups the number too often used sentence beginnings and determines the lowest count within that group.
+   *
+   * @param {array} sentenceBeginnings The array containing the objects containing the beginning words and counts.
+   *
+   * @returns {object} The object containing the total number of too often used beginnings and the lowest count within those.
+   */
+  groupSentenceBeginnings(sentenceBeginnings) {
+    const tooOften = partition(sentenceBeginnings, function(word) {
+      return word.count > maximumConsecutiveDuplicates;
+    });
+
+    if (tooOften[0].length === 0) {
+      return {total: 0};
+    }
+
+    const sortedCounts = sortBy(tooOften[0], function(word) {
+      return word.count;
+    });
+
+    return {total: tooOften[0].length, lowestCount: sortedCounts[0].count};
+  }
+
+  /**
+   *
+   * @param groupedSentenceBeginnings
+   * @returns {{score: number, body: React.JSX.Element, status: string}}
+   */
+  calculateSentenceBeginningsResult(groupedSentenceBeginnings) {
+    let status = '';
+    if (groupedSentenceBeginnings.total > 0) {
+      status = 'bad';
+    } else {
+      status = 'good';
+    }
+
+    const score = this.getScore(this._config.priority, status);
+
+    return {
+      score,
+      status,
+      body: (
+        <Text as={'span'}>
+          {this._config.content[status]}{' '}
+          {this._config.docUrl && (
+            <a href={this._config.docUrl} target="_blank" rel="noreferrer">
+              Learn more
+            </a>
+          )}
+        </Text>
+      )
+    };
+  }
+
+  /**
+   *
+   * @param paper
+   * @param researcher
+   * @param i18n
+   * @returns {AssessmentResult}
+   */
+  getResult(paper, researcher, i18n) {
+    const sentenceBeginnings = researcher.getResearch('getSentenceBeginnings');
+    const groupedSentenceBeginnings = this.groupSentenceBeginnings(sentenceBeginnings);
+    const calculatedResult = this.calculateSentenceBeginningsResult(groupedSentenceBeginnings);
+    const assessmentResult = new AssessmentResult({config: this._config});
+
+    assessmentResult.setStatus(calculatedResult.status);
+    assessmentResult.setStatus(calculatedResult.status);
+    assessmentResult.setBody(calculatedResult.body);
+
+    return assessmentResult;
+  }
+
+  /**
+   * Checks if the sentence beginnings assessment is applicable to the paper.
+   *
+   * @param {Object}      paper       The paper to check.
+   * @param {Researcher}  researcher  The researcher object.
+   *
+   * @returns {boolean} Returns true if the language is available and the paper is not empty.
+   */
+  isApplicable(paper, researcher) {
+    return (
+      this.hasEnoughContentForAssessment(paper) && researcher.hasResearch('getSentenceBeginnings')
+    );
+  }
+}