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

package/src/parsedPaper/research/researches/LinkStatistics.js

@@ -0,0 +1,128 @@
+import urlMethods from "url";
+
+/* Internal dependencies */
+import Research from "./Research";
+
+/**
+ * Calculates link statistics.
+ * E.g. which links a node or its children contains, and whether these links are:
+ *  * internal (points to a page in the same domain), external (a page in another domain) or other.
+ *  * marked as follow (search engines are allowed to follow this link) or no-follow (search engines are not allowed to follow the link).
+ *
+ *  @memberOf module:parsedPaper/research
+ */
+class LinkStatistics extends Research {
+	/**
+	 * Checks whether the given link is marked for search engines to not follow.
+	 *
+	 * @param {module:parsedPaper/structure.FormattingElement} linkElement The link to check.
+	 *
+	 * @returns {boolean} `true` if the link is marked as 'no-follow'.
+	 *
+	 * @private
+	 */
+	_isNoFollow( linkElement ) {
+		const rel = linkElement.getAttribute( "rel" );
+
+		if ( ! rel ) {
+			return false;
+		}
+
+		// Check if the `rel` attribute includes "nofollow".
+		return rel.split( /\s+/ ).includes( "nofollow" );
+	}
+
+	/**
+	 * Checks whether the given protocol string is either HTTP or HTTPS.
+	 *
+	 * @param {String} protocol The protocol string to check.
+	 *
+	 * @returns {boolean} Whether the protocol is either HTTP or HTTPS.
+	 *
+	 * @private
+	 */
+	_isHttp( protocol ) {
+		if ( ! protocol ) {
+			return false;
+		}
+
+		return ( protocol === "http:" || protocol === "https:" );
+	}
+
+	/**
+	 * Checks whether the given link is:
+	 *  * internal: points to a web page in the same domain as the current site.
+	 *  * external: points to a web page in another domain as the current site.
+	 *  * other: e.g. uses another protocol like `ftp`.
+	 *
+	 * @param {module:parsedPaper/structure.FormattingElement} linkElement The link to check.
+	 * @param {string}                                         domain The domain to check against.
+	 *
+	 * @returns {"external"|"internal"|"other"} Whether the link points to an external, internal or other web page.
+	 *
+	 * @private
+	 */
+	_whichTarget( linkElement, domain ) {
+		const link = linkElement.getAttribute( "href" );
+
+		if ( ! link ) {
+			return "other";
+		}
+
+		const url = urlMethods.parse( link );
+
+		if ( ! this._isHttp( url.protocol ) || url.hash ) {
+			return "other";
+		}
+
+		if ( url.hostname === domain ) {
+			return "internal";
+		}
+
+		return "external";
+	}
+
+	/**
+	 * Returns the permalink from the metadata.
+	 *
+	 * @param {module:parsedPaper/structure.Node} metadata The metadata to retrieve the permalink from.
+	 *
+	 * @returns {string} The permalink.
+	 *
+	 * @private
+	 */
+	_getPermalink( metadata ) {
+		const permalinkElement = metadata.children.find( child => child.tag === "permalink" );
+		const paragraph = permalinkElement.children[ 0 ];
+		return paragraph.textContainer.text;
+	}
+
+	/**
+	 * Calculates link statistics for the given node.
+	 *
+	 * @param {module:parsedPaper/structure.Node} node     The node to calculate the research for.
+	 * @param {module:parsedPaper/structure.Node} metadata The document's metadata.
+	 *
+	 * @returns {Promise<Object[]>} The research results.
+	 */
+	calculateFor( node, metadata ) {
+		// Collect link elements.
+		const links = node.textContainer.formatting.filter( element => element.type === "a" );
+
+		// URL of the current page.
+		const permalink = this._getPermalink( metadata );
+		const url = urlMethods.parse( permalink );
+
+		// Collect statistics about the links.
+		const results = links.map( link => {
+			const noFollow = this._isNoFollow( link );
+			const target = this._whichTarget( link, url.hostname );
+
+			return { link, noFollow, target };
+		} );
+
+		return Promise.resolve( results );
+	}
+}
+
+export default LinkStatistics;

package/src/parsedPaper/research/researches/Research.js

@@ -0,0 +1,50 @@
+import { flatten } from "lodash";
+import { LeafNode } from "../../structure/tree";
+
+/**
+ * A research that can be applied to the tree.
+ *
+ * @memberOf module:parsedPaper/research
+ *
+ * @abstract
+ */
+class Research {
+	/**
+	 * Checks if the given node is a leaf node for this research.
+	 *
+	 * @param {module:parsedPaper/structure.Node} node The node to check.
+	 *
+	 * @returns {boolean} If the given node is considered a leaf node for this research.
+	 *
+	 */
+	isLeafNode( node ) { // eslint-disable-line no-unused-vars
+		return node instanceof LeafNode;
+	}
+
+	/**
+	 * Calculates the result of the research for the given Node.
+	 *
+	 * @param {module:parsedPaper/structure.Node} node The node to calculate the research for.
+	 * @param {module:parsedPaper/structure.Node} metadata The document's metadata.
+	 *
+	 * @returns {Promise<*>} The result of the research.
+	 *
+	 * @abstract
+	 */
+	calculateFor( node, metadata ) { // eslint-disable-line no-unused-vars
+		console.warn( "calculateFor should be implemented by a child class of Researcher." );
+	}
+
+	/**
+	 * Merges results of this research according to a predefined strategy.
+	 *
+	 * @param {Array<*>} results The results of this research to merge.
+	 *
+	 * @returns {*} The merged results.
+	 */
+	mergeChildrenResults( results ) { // eslint-disable-line no-unused-vars
+		return flatten( results );
+	}
+}
+
+export default Research;

package/src/parsedPaper/research/researches/index.js

@@ -0,0 +1 @@
+export { default as Headings } from "./Headings";

package/src/parsedPaper/structure/tree/FormattingElement.js

@@ -0,0 +1,67 @@
+import SourceCodeLocation from "./SourceCodeLocation";
+
+/**
+ * Represents formatting elements (e.g. link, image, bold text) within a document.
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class FormattingElement {
+	/**
+	 * Represents a formatting element (e.g. link, image, bold text) within a document.
+	 *
+	 * @param {string} type               The type of this element ("link", "image", "bold", etc.).
+	 * @param {Object} sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 * @param {Object} [attributes=null]  The attributes (as key-value pairs, e.g. `{ href: '...' }` ).
+	 */
+	constructor( type, sourceCodeLocation, attributes = null ) {
+		/**
+		 * Type of formatting element (e.g. "strong", "a").
+		 * @type {string}
+		 */
+		this.type = type;
+		/**
+		 * Attributes of this element (e.g. "href", "id").
+		 * @type {?Object}
+		 */
+		this.attributes = attributes;
+		/**
+		 * Location inside of the source code.
+		 * @type {SourceCodeLocation}
+		 */
+		this.sourceCodeLocation = new SourceCodeLocation( sourceCodeLocation );
+		/**
+		 * Start of this element's content within the parent textContainer's text.
+		 * @type {?number}
+		 */
+		this.textStartIndex = null;
+		/**
+		 * End of this element's content within the parent textContainer's text.
+		 * @type {?number}
+		 */
+		this.textEndIndex = null;
+		/**
+		 * This formatting element's parent.
+		 * @type {LeafNode}
+		 */
+		this.parent = null;
+	}
+
+	/**
+	 * Returns the attribute with the given name if it exists.
+	 *
+	 * @param {string} name The name of the attribute.
+	 *
+	 * @returns {false|*} The attribute or `false` if the attribute does not exist.
+	 */
+	getAttribute( name ) {
+		if ( ! this.attributes ) {
+			return false;
+		}
+		if ( name in this.attributes ) {
+			return this.attributes[ name ];
+		}
+		return false;
+	}
+}
+
+export default FormattingElement;

package/src/parsedPaper/structure/tree/SourceCodeLocation.js

@@ -0,0 +1,31 @@
+/**
+ * A location of an element in the source code.
+ */
+class SourceCodeLocation {
+	/**
+	 * A location of an element in the source code.
+	 *
+	 * @param {Object?} startTag The location of the start tag of the element, if it has one.
+	 * @param {number} startTag.startOffset The start position of the start tag.
+	 * @param {number} startTag.endOffset The end position of the start tag.
+	 *
+	 * @param {Object?} endTag The location of the end tag of the element, if it has one.
+	 * @param {number} endTag.startOffset The start position of the end tag.
+	 * @param {number} endTag.endOffset The end position of the end tag.
+	 *
+	 * @param {Object} startOffset The start position of the element.
+	 * @param {Object} endOffset The end position of the element.
+	 */
+	constructor( { startTag, endTag, startOffset, endOffset } ) {
+		if ( startTag ) {
+			this.startTag = { startOffset: startTag.startOffset, endOffset: startTag.endOffset };
+		}
+		if ( endTag ) {
+			this.endTag = { startOffset: endTag.startOffset, endOffset: endTag.endOffset };
+		}
+		this.startOffset = startOffset;
+		this.endOffset = endOffset;
+	}
+}
+
+export default SourceCodeLocation;

package/src/parsedPaper/structure/tree/TextContainer.js

@@ -0,0 +1,85 @@
+import { isEmpty } from "lodash";
+import { parseTextIntoSentences } from "../../build/linguisticParsing/parseText";
+
+/**
+ * Represents a text (with optional formatting element(s)) within a document that can be read by a reader.
+ *
+ * Example (in the case of HTML):
+ * ```html
+ * This text is <strong id="elem-id">very strong</strong>.
+ * ```
+ * is transformed to:
+ * ```js
+ * TextContainer {
+ *     text: "This text is very strong".
+ *     formatting: [
+ *         FormattingElement {
+ *             type: "strong",
+ *             sourceStartIndex: 13, // "This text is ".length
+ *             sourceEndIndex: 54,   // "This text is <strong id="elem-id">very strong</strong>".length
+ *             textStartIndex: 13,  // "This text is ".length
+ *             textEndIndex: 24,    // "This text is very strong".length
+ *             attributes: {
+ *                 id: "elem-id"
+ *             }
+ *         }
+ *     ]
+ * }
+ * ```
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class TextContainer {
+	/**
+	 * Represents a text (with optional formatting element(s)) within a document that can be read by a reader.
+	 */
+	constructor() {
+		/**
+		 * Clean, analyzable text, without formatting.
+		 * @type {string}
+		 */
+		this.text = "";
+		/**
+		 * This text's formatting (e.g. bold text, links, etc.).
+		 * @type {Array<module:parsedPaper/structure.FormattingElement>}
+		 */
+		this.formatting = [];
+
+		/**
+		 * A cache for the tree representations of this container's text.
+		 */
+		this._tree = {};
+	}
+
+	/**
+	 * Adds a text string to this container's text.
+	 *
+	 * @param {string} text The text to be added to the TextContainer.
+	 *
+	 * @returns {void}
+	 */
+	appendText( text ) {
+		// If the text changes, the 'linguistic' tree should be rebuilt. This means the cache should be cleared.
+		this.text += text;
+		this._tree = {};
+	}
+
+	/**
+	 * Returns the tree representation of this container's text.
+	 *
+	 * If the cache is filled, it will return the cached tree.
+	 * If the cache is empty, it will additionally construct the tree and fill the cache.
+	 *
+	 * @returns {Object} The tree representation of the text.
+	 */
+	getTree() {
+		if ( ! isEmpty( this._tree ) ) {
+			return this._tree;
+		}
+
+		this._tree = parseTextIntoSentences( this.text );
+		return this._tree;
+	}
+}
+
+export default TextContainer;

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

@@ -0,0 +1,22 @@
+import FormattingElement from "./FormattingElement";
+import { Heading, LeafNode, List, ListItem, MetadataMiscellaneous, MetadataText, Node, Paragraph, StructuredNode } from "./nodes";
+import TextContainer from "./TextContainer";
+
+/**
+ * The collection of elements used in constructing the tree structure.
+ *
+ * @module parsedPaper/structure
+ */
+export {
+	Heading,
+	LeafNode,
+	List,
+	ListItem,
+	MetadataText,
+	MetadataMiscellaneous,
+	Node,
+	Paragraph,
+	StructuredNode,
+	TextContainer,
+	FormattingElement,
+};

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

@@ -0,0 +1,26 @@
+import LeafNode from "./LeafNode";
+
+/**
+ * A header in a document.
+ *
+ * @extends module:parsedPaper/structure.LeafNode
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class Heading extends LeafNode {
+	/**
+	 * Makes a new header object.
+	 *
+	 * @param {number} level              The header level (e.g. 1 for main heading, 2 for subheading lvl 2, etc.)
+	 * @param {Object} sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 */
+	constructor( level, sourceCodeLocation ) {
+		super( "Heading", sourceCodeLocation );
+		/**
+		 * Heading's level (e.g. 1 for "h1", 2 for "h2", ... ).
+		 * @type {number}
+		 */
+		this.level = level;
+	}
+}
+export default Heading;

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

@@ -0,0 +1,75 @@
+import TextContainer from "../TextContainer";
+import Node from "./Node";
+/**
+ * A node at the end of the tree that may only contain formatting elements,
+ * these include headings and paragraphs.
+ *
+ * @extends module:parsedPaper/structure.Node
+ *
+ * @memberOf module:parsedPaper/structure
+ *
+ * @abstract
+ */
+class LeafNode extends Node {
+	/**
+	 * Creates a new leaf 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.
+	 *
+	 * @returns {void}
+	 */
+	constructor( type, sourceCodeLocation ) {
+		super( type, sourceCodeLocation );
+		/**
+		 * A container for keeping this leaf node's text.
+		 * @type {module:parsedPaper/structure.TextContainer}
+		 */
+		this.textContainer = new TextContainer();
+	}
+
+	/**
+	 * Retrieves the heading text (from the TextContainer).
+	 *
+	 * @returns {string} The text of the heading.
+	 */
+	get text() {
+		return this.textContainer.text;
+	}
+
+	/**
+	 * Sets the heading text (via the TextContainer).
+	 *
+	 * @param {string} text The text to assign as the heading text.
+	 *
+	 * @returns {void}
+	 */
+	set text( text ) {
+		this.textContainer.text = text;
+	}
+
+	/**
+	 * Appends text to this leaf node.
+	 *
+	 * @param {string} text The text to append.
+	 *
+	 * @returns {void}
+	 */
+	appendText( text ) {
+		this.textContainer.appendText( text );
+	}
+
+	/**
+	 * Adds formatting and sets the formatting's parent to this leaf node.
+	 *
+	 * @param {FormattingElement} formatting The formatting to add.
+	 *
+	 * @returns {void}
+	 */
+	addFormatting( formatting ) {
+		formatting.parent = this;
+		this.textContainer.formatting.push( formatting );
+	}
+}
+
+export default LeafNode;

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

@@ -0,0 +1,47 @@
+import StructuredNode from "./StructuredNode";
+import ListItem from "./ListItem";
+
+/**
+ * Represents a list of items.
+ *
+ * @extends module:parsedPaper/structure.Node
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class List extends StructuredNode {
+	/**
+	 * Represents a list of items.
+	 *
+	 * @param {boolean} ordered            Whether the list is ordered or not.
+	 * @param {Object}  sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 *
+	 * @returns {void}
+	 */
+	constructor( ordered, sourceCodeLocation ) {
+		super( "List", sourceCodeLocation );
+		/**
+		 * If this list is ordered.
+		 * @type {boolean}
+		 */
+		this.ordered = ordered;
+		/**
+		 * This node's children (should only be list items).
+		 * @type {ListItem[]}
+		 */
+		this.children = [];
+	}
+
+	/**
+	 * Appends the child to this List's children.
+	 *
+	 * @param {ListItem} child The child to add.
+	 * @returns {void}
+	 */
+	addChild( child ) {
+		if ( ! ( child instanceof ListItem ) ) {
+			console.warn( "Added child is not a ListItem!" );
+		}
+		this.children.push( child );
+	}
+}
+export default List;

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

@@ -0,0 +1,26 @@
+import LeafNode from "./LeafNode";
+/**
+ * Represents an item within a list.
+ *
+ * @extends module:parsedPaper/structure.Node
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class ListItem extends LeafNode {
+	/**
+	 * Represents an item within a list.
+	 *
+	 * @param {Object} sourceCodeLocation The parse5 formatted location of the element inside of the source code.
+	 *
+	 * @returns {void}
+	 */
+	constructor( sourceCodeLocation ) {
+		super( "ListItem", sourceCodeLocation );
+		/**
+		 * This ListItem's child nodes.
+		 * @type {Node[]}
+		 */
+		this.children = [];
+	}
+}
+export default ListItem;

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

@@ -0,0 +1,46 @@
+import Node from "./Node";
+
+/**
+ * Represents miscellaneous metadata within the metadata tree branch.
+ *
+ * @extends module:parsedPaper/structure.LeafNode
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class MetadataMiscellaneous extends Node {
+	/**
+	 * Creates a new MetadataMiscellaneous node.
+	 *
+	 * @param {string} type The type of this node.
+	 * @param {*} [data=null] The data.
+	 *
+	 * @constructor
+	 */
+	constructor( type = "MetadataMiscellaneous", data = null ) {
+		super( type, null );
+
+		this._data = data;
+	}
+
+	/**
+	 * Retrieves the data.
+	 *
+	 * @returns {*} The data.
+	 */
+	get data() {
+		return this._data;
+	}
+
+	/**
+	 * Sets the data.
+	 *
+	 * @param {*} data The data to keep.
+	 *
+	 * @returns {void}
+	 */
+	set data( data ) {
+		this._data = data;
+	}
+}
+
+export default MetadataMiscellaneous;

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

@@ -0,0 +1,26 @@
+import LeafNode from "./LeafNode";
+
+/**
+ * Represents a text within the metadata tree branch.
+ *
+ * @extends module:parsedPaper/structure.LeafNode
+ *
+ * @memberOf module:parsedPaper/structure
+ */
+class MetadataText extends LeafNode {
+	/**
+	 * Creates a new MetadataText node.
+	 *
+	 * @param {string} type The type of this node.
+	 * @param {string} text The text of this node.
+	 *
+	 * @constructor
+	 */
+	constructor( type = "MetadataText", text = "" ) {
+		super( type, null );
+
+		this.text = text;
+	}
+}
+
+export default MetadataText;