hdoc-tools 0.9.49 → 0.9.50

package/hdoc-validate.js

@@ -1,496 +1,496 @@
-(function () {
-    'use strict';
-
-    const axios = require('axios'),
-        cheerio = require('cheerio'),
-        dree = require('dree'),
-        fs = require('fs'),
-        path = require('path'),
-        https = require('https'),
-        hdoc = require(path.join(__dirname, 'hdoc-module.js')),
-        translator = require('american-british-english-translator'),
-        { trueCasePathSync } = require('true-case-path');
-
-    const spellcheck_options = {
-        british: true,
-        spelling: true
-    },
-        regex_nav_paths = /[a-z0-9-\/]+[a-z0-9]+#{0,1}[a-z0-9-\/]+/,
-        agent = new https.Agent({
-            rejectUnauthorized: false
-        });
-
-    let errors = {},
-        messages = {},
-        warnings = {},
-        html_to_validate = [],
-        md_to_validate = [],
-        exclude_links = {},
-        exclude_spellcheck = {},
-        exclude_h1_count = {};
-
-    const spellcheckContent = async function (sourceFile, excludes) {
-        let spelling_errors = {};
-        let words = [];
-        const text = fs.readFileSync(sourceFile.path, 'utf8');
-        const source_path = sourceFile.relativePath.replace('.' + sourceFile.extension, '');
-        const translate_output = translator.translate(text, spellcheck_options);
-        if (Object.keys(translate_output).length) {
-            for (const key in translate_output) {
-                if (translate_output.hasOwnProperty(key)) {
-                    let error_message = `Line ${key} - British spelling:`;
-                    for (let i = 0; i < translate_output[key].length; i++) {
-                        for (const spelling in translate_output[key][i]) {
-                            if (translate_output[key][i].hasOwnProperty(spelling) && (typeof translate_output[key][i][spelling].details === 'string')) {
-                                if (!excludes[source_path]) {
-                                    errors[sourceFile.relativePath].push(`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`);
-                                    spelling_errors[spelling] = true;
-                                } else if (!excludes[source_path].includes(spelling.toLowerCase())) {
-                                    errors[sourceFile.relativePath].push(`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`);
-                                    spelling_errors[spelling] = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if (Object.keys(spelling_errors).length) {
-            for (const word in spelling_errors) {
-                if (spelling_errors.hasOwnProperty(word)) {
-                    words.push(word);
-                }
-            }
-        }
-        return words;
-    };
-
-    const checkNavigation = async function (source_path, flat_nav) {
-        let nav_errors = [];
-        for (let key in flat_nav) {
-            if (flat_nav.hasOwnProperty(key)) {
-                // doc paths should only contain a-z - characters
-                const invalid_chars = key.replace(regex_nav_paths, '');
-                if (invalid_chars !== '') {
-                    nav_errors.push(`Navigation path [${key}] contains the following invalid characters: [${[...invalid_chars].join('] [')}]`);
-                }
-                const key_split = key.split('#');
-                const key_no_hash = key_split[0];
-
-                // Validate path exists - key should be a html file at this point
-                let file_exists = true;
-                let file_name = path.join(source_path, key_no_hash + '.html');
-                if (!fs.existsSync(file_name)) {
-                    file_name = path.join(source_path, key_no_hash + '.htm');
-                    if (!fs.existsSync(file_name)) {
-                        file_name = path.join(source_path, key_no_hash, 'index.html');
-                        if (!fs.existsSync(file_name)) {
-                            file_name = path.join(source_path, key_no_hash, 'index.htm');
-                            if (!fs.existsSync(file_name)) {
-                                file_exists = false;
-                                nav_errors.push(`Navigation path [${key_no_hash}] file does not exist.`);
-                            }
-                        }
-                    }
-                }
-
-                if (file_exists) {
-                    const true_file = trueCasePathSync(file_name).replace(source_path, '').replaceAll('\\', '/');
-                    const relative_file = file_name.replace(source_path, '').replaceAll('\\', '/');
-                    if (true_file !== relative_file) {
-                        nav_errors.push(`Navigation path [${key}] for filename [${relative_file}] does not match filename case [${true_file}].`);
-                    }
-                }
-
-                // Validate path spellings
-                const paths = key.split('/');
-                for (let i = 0; i < paths.length; i++) {
-                    const path_words = paths[i].split('-');
-                    for (let j = 0; j < path_words.length; j++) {
-                        const translate_output = translator.translate(path_words[j], spellcheck_options);
-                        if (Object.keys(translate_output).length) {
-                            for (const spell_val in translate_output) {
-                                if (translate_output.hasOwnProperty(spell_val)) {
-                                    for (const spelling in translate_output[spell_val][0]) {
-                                        if (translate_output[spell_val][0].hasOwnProperty(spelling)) {
-                                            nav_errors.push(`Navigation path [${key}] key contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                // Validate display names/bookmarks
-                console.log(key)
-                for (let i = 0; i < flat_nav[key].length; i++) {
-                    if (flat_nav[key][i].link === key) {
-                        const translate_output = translator.translate(flat_nav[key][i].text, spellcheck_options);
-                        if (Object.keys(translate_output).length) {
-                            for (const spell_val in translate_output) {
-                                if (translate_output.hasOwnProperty(spell_val)) {
-                                    for (let j = 0; j < translate_output[spell_val].length; j++) {
-                                        for (const spelling in translate_output[spell_val][j]) {
-                                            if (translate_output[spell_val][j].hasOwnProperty(spelling)) {
-                                                nav_errors.push(`Navigation path [${key}] display text contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-            }
-        }
-        return nav_errors;
-    };
-
-    const checkLinks = async function (source_path, htmlFile, links, hdocbook_config) {
-        for (let i = 0; i < links.length; i++) {
-
-            // Validate that link is a valid URL first
-            const valid_url = hdoc.valid_url(links[i]);
-            if (!valid_url) {
-                // Could be a relative path, check
-                if (links[i].startsWith('/')) {
-                    const link_root = links[i].split('/')[0];
-                    if (link_root !== hdocbook_config.docId) continue;
-                }
-                isRelativePath(source_path, htmlFile, links[i]);
-            } else {
-                messages[htmlFile.relativePath].push(`Link is a properly formatted external URL: ${links[i]}`);
-
-                // Skip if it's the auto-generated edit url, as these could be part of a private repo which would return a 404
-                if (links[i] === hdoc.get_github_api_path(hdocbook_config.publicSource, htmlFile.relativePath).edit_path.replace(path.extname(htmlFile.relativePath), '.md')) {
-                    continue;
-                }
-
-                if (valid_url.protocol === 'mailto:') {
-                    continue;
-                }
-
-                // Skip if the link is excluded in the project config
-                if (exclude_links[links[i]]) {
-                    continue;
-                }
-                if (links[i].toLowerCase().includes('docs.hornbill.com') || links[i].toLowerCase().includes('docs-internal.hornbill.com')) {
-                    errors[htmlFile.relativePath].push(`Links to Hornbill Docs should rooted and not fully-qualified: ${links[i]}`);
-                    continue;
-                }
-
-                try {
-                    await axios.get(links[i], {
-                        httpsAgent: agent
-                    });
-                    messages[htmlFile.relativePath].push(`Link is a valid external URL: ${links[i]}`);
-                } catch (e) {
-                    // Handle errors
-                    errors[htmlFile.relativePath].push(`Link is not responding: ${links[i]} - [${e.message}]`);
-                }
-            }
-        }
-    };
-
-    const checkImages = async function (source_path, htmlFile, links) {
-        for (let i = 0; i < links.length; i++) {
-
-            // Validate that image is a valid URL first
-            if (!hdoc.valid_url(links[i])) {
-                // Could be a relative path, check image exists
-                doesFileExist(source_path, htmlFile, links[i]);
-            } else {
-                messages[htmlFile.relativePath].push(`Image link is a properly formatted external URL: ${links[i]}`);
-                // Do a Get to the URL to see if it exists
-                try {
-                    const res = await axios.get(links[i]);
-                    messages[htmlFile.relativePath].push(`Image link is a valid external URL: ${links[i]}`);
-                } catch (e) {
-                    // Handle errors
-                    errors[htmlFile.relativePath].push(`Unexpected Error from external image link: ${links[i]} - ${e.message}`);
-                }
-            }
-        }
-    };
-
-    const checkTags = async function (htmlFile) {
-        // Check if file  is excluded from tag check
-        const file_no_ext = htmlFile.relativePath.replace(path.extname(htmlFile.relativePath), '');
-        if (exclude_h1_count[file_no_ext]) return;
-
-        // Check tags
-        const htmlBody = fs.readFileSync(htmlFile.path, 'utf8');
-        const $ = cheerio.load(htmlBody);
-
-        const h1_tags = $('h1').map(function () {
-            return $(this);
-        }).get();
-        if (h1_tags.length && h1_tags.length > 1) {
-            let error_msg = `${h1_tags.length} <h1> tags found in content: `;
-            for (let i = 0; i < h1_tags.length; i++) {
-                error_msg += h1_tags[i].text();
-                if (i < h1_tags.length - 1) error_msg += '; ';
-            }
-            errors[htmlFile.relativePath].push(error_msg);
-        }
-    };
-
-    const dreeOptions = {
-        descendants: true,
-        depth: 10,
-        extensions: ['htm', 'html', 'md'],
-        hash: false,
-        normalize: true,
-        size: false,
-        sizeInBytes: false,
-        stat: false,
-        symbolicLinks: false
-    };
-
-    // File scan callback
-    const fileCallback = function (element) {
-        if (element.extension.toLowerCase() === 'md') {
-            md_to_validate.push(element);
-        } else {
-            html_to_validate.push(element);
-        }
-    };
-
-    const isRelativePath = function (source_path, html_path, relative_path) {
-        const rel_path_ext = path.extname(relative_path);
-        let response = {
-            is_rel_path: false,
-            has_md_extension: rel_path_ext === '.md'
-        };
-
-        const supported_relpaths = [
-            path.sep + 'index.htm',
-            path.sep + 'index.html',
-            '.htm',
-            '.html',
-            '.md'
-        ];
-
-        // Remove explicit anchor links and _books prefix
-        relative_path = relative_path.split('#')[0].replace('_books/', '');
-
-        // Make full file path
-        const file_path = path.join(source_path, relative_path);
-
-        // Does path exist?
-        if (fs.existsSync(file_path)) {
-            response.is_rel_path = true;
-        } else {
-            // Path 
-            for (let i = 0; i < supported_relpaths.length; i++) {
-                if (fs.existsSync(`${file_path}${supported_relpaths[i]}`)) {
-                    response.is_rel_path = true;
-                    break;
-                }
-            }
-        }
-        if (response.has_md_extension) {
-            errors[html_path.relativePath].push(`Relative link contains MD extension, but should not: ${relative_path}`);
-        } else {
-            if (response.is_rel_path) {
-                messages[html_path.relativePath].push(`Relative path exists: ${relative_path}`);
-            } else {
-                errors[html_path.relativePath].push(`Link path does not exist: ${relative_path}`);
-            }
-        }
-    }
-
-    const doesFileExist = function (source_path, html_path, relative_path) {
-        // Remove explicit anchor links and _books prefix
-        relative_path = relative_path.split('#')[0].replace('_books/', '');
-        const file_path = path.join(source_path, relative_path);
-        if (!fs.existsSync(file_path) && !fs.existsSync(file_path + path.sep + 'index.htm') && !fs.existsSync(file_path + 'index.html') && !fs.existsSync(file_path + '.htm') && !fs.existsSync(file_path + '.html')) {
-            errors[html_path.relativePath].push(`Book resource does not exist: ${relative_path}`);
-            return false;
-        } else {
-            messages[html_path.relativePath].push(`Book resource exists: ${relative_path}`);
-        }
-        return true;
-    };
-
-    // Takes a dree element, returns an object with a pair of arrays
-    const getLinks = function (file) {
-        messages[file.relativePath].push('Parsing HTML file');
-        const htmlBody = fs.readFileSync(file.path, 'utf8');
-        let links = {
-            href: [],
-            img: []
-        };
-        const $ = cheerio.load(htmlBody);
-        const hrefs = $('a').map(function (i) {
-            return $(this).attr('href');
-        }).get();
-        const srcs = $('img').map(function (i) {
-            return $(this).attr('src');
-        }).get();
-        links.href.push(...hrefs);
-        links.img.push(...srcs);
-        return links;
-    };
-
-    exports.run = async function (source_path, doc_id, verbose, hdocbook_config, hdocbook_project, nav_items, prod_families, prods_supported, gen_exclude) {
-        console.log(`Performing Validation and Building SEO Link List...`);
-
-        // Get a list of HTML files in source_path
-        dree.scan(source_path, dreeOptions, fileCallback);
-
-        // Check product family
-        let valid_product = false;
-        let meta_errors = [];
-        for (let i = 0; i < prod_families.products.length; i++) {
-            if (prod_families.products[i].id === hdocbook_config.productFamily) {
-                valid_product = true;
-            }
-        }
-        if (!valid_product) {
-            let val_prod_error = `Incorrect productFamily: ${hdocbook_config.productFamily}. Supported values:`;
-            for (let i = 0; i < prods_supported.length; i++) {
-                val_prod_error += `\n  - ${prods_supported[i]}`
-            }
-            meta_errors.push(val_prod_error)
-
-        }
-
-        // Check navigation spellings
-        const nav_errors = await checkNavigation(source_path, nav_items);
-        if (nav_errors.length > 0) meta_errors.push(...nav_errors);
-
-        if (meta_errors.length > 0) {
-            console.log('\r\n-----------------------');
-            console.log('   Validation Output   ');
-            console.log('-----------------------');
-            for (let i = 0; i < meta_errors.length; i++) {
-                console.log(`- ${meta_errors[i]}`);
-            }
-            console.log(`\r\n${meta_errors.length} Validation Errors Found`);
-            return false;
-        }
-
-        if (hdocbook_project.validation) {
-            if (hdocbook_project.validation.exclude_links && hdocbook_project.validation.exclude_links instanceof Array) {
-                hdocbook_project.validation.exclude_links.forEach(function (excl_link) {
-                    exclude_links[excl_link] = true;
-                });
-            }
-            if (hdocbook_project.validation.exclude_spellcheck && hdocbook_project.validation.exclude_spellcheck instanceof Array) {
-                hdocbook_project.validation.exclude_spellcheck.forEach(function (excl_sc) {
-                    exclude_spellcheck[excl_sc.document_path] = excl_sc.words;
-                });
-            }
-            if (hdocbook_project.validation.exclude_h1_count && hdocbook_project.validation.exclude_h1_count instanceof Array) {
-                hdocbook_project.validation.exclude_h1_count.forEach(function (excl_h1) {
-                    exclude_h1_count[excl_h1] = true;
-                });
-            }
-        }
-
-        let excl_output = [];
-
-        // Do spellchecking on markdown files
-        let md_files_spellchecked = {};
-        let mdPromiseArray = [];
-        for (let i = 0; i < md_to_validate.length; i++) {
-            errors[md_to_validate[i].relativePath] = [];
-            messages[md_to_validate[i].relativePath] = [];
-            warnings[md_to_validate[i].relativePath] = [];
-            mdPromiseArray.push(md_to_validate[i]);
-        }
-        await Promise.all(mdPromiseArray.map(async (file) => {
-            // Initiate maps for errors and verbose messages for markdown file
-            const exclusions = await spellcheckContent(file, exclude_spellcheck);
-            if (gen_exclude && exclusions.length > 0) excl_output.push({ document_path: file.relativePath.replace('.' + file.extension, ''), words: exclusions });
-            md_files_spellchecked[file.relativePath.replace('.' + file.extension, '')] = true;
-        }));
-
-        // Perform rest of validation against HTML files
-        let listContent = '';
-        let htmlPromiseArray = [];
-        for (let i = 0; i < html_to_validate.length; i++) {
-            errors[html_to_validate[i].relativePath] = [];
-            messages[html_to_validate[i].relativePath] = [];
-            warnings[html_to_validate[i].relativePath] = [];
-            htmlPromiseArray.push(html_to_validate[i]);
-        }
-        await Promise.all(mdPromiseArray.map(async (file) => {
-            // Check for British spellings in static HTML content
-            if (!md_files_spellchecked[file.relativePath.replace('.' + file.extension, '')]) {
-                const exclusions = await spellcheckContent(file, exclude_spellcheck);
-                if (gen_exclude && exclusions.length > 0) excl_output.push({ document_path: file.relativePath.replace('.' + file.extension, ''), words: exclusions });
-            }
-
-            const links = getLinks(file);
-            if (links.href.length === 0) {
-                messages[file.relativePath].push('No links found in file');
-            } else {
-                await checkLinks(source_path, file, links.href, hdocbook_config);
-            }
-            if (links.img.length === 0) {
-                messages[file.relativePath].push('No images found in file');
-            } else {
-                await checkImages(source_path, file, links.img);
-            }
-
-            // Check for multiple H1 tags
-            await checkTags(file);
-
-            // Build list content for Google 
-            listContent += `/${file.relativePath.replace(path.extname(file.relativePath), '')}`;
-            listContent += '\r\n';
-        }));
-
-        if (gen_exclude) console.log(JSON.stringify(excl_output, null, 2));
-
-        try {
-            // Write list
-            const listFile = path.join(source_path, doc_id, 'links.txt');
-            fs.writeFileSync(listFile, listContent);
-            console.log(`\r\nLink list text file created successfully: ${listFile}`);
-        } catch (err) {
-            console.error(err);
-        }
-
-        if (verbose) {
-            console.log('\r\n-------------');
-            console.log('   Verbose   ');
-            console.log('-------------');
-            for (const key in messages) {
-                if (messages.hasOwnProperty(key) && messages[key].length > 0) {
-                    console.log(`\r\nMessage output for ${key}`);
-                    for (let i = 0; i < messages[key].length; i++) {
-                        console.log(` - ${messages[key][i]}`);
-                    }
-                }
-            }
-        }
-
-        console.log('\r\n-----------------------');
-        console.log('   Validation Output   ');
-        console.log('-----------------------');
-        if (Object.keys(errors).length > 0) {
-            let error_count = 0;
-            for (const key in errors) {
-                if (errors.hasOwnProperty(key) && errors[key].length > 0) {
-                    console.log(`\r\n${errors[key].length} error(s) in ${key}`);
-                    for (let i = 0; i < errors[key].length; i++) {
-                        console.log(` - ${errors[key][i]}`);
-                        error_count++
-                    }
-                }
-            }
-            if (error_count > 0) {
-                console.log(`\r\n${error_count} Validation Errors Found`);
-                return false;
-            }
-        }
-
-        console.log(`\r\nNo Validation Errors Found!\n`);
-        return true;
-    };
+(function () {
+    'use strict';
+
+    const axios = require('axios'),
+        cheerio = require('cheerio'),
+        dree = require('dree'),
+        fs = require('fs'),
+        path = require('path'),
+        https = require('https'),
+        hdoc = require(path.join(__dirname, 'hdoc-module.js')),
+        translator = require('american-british-english-translator'),
+        { trueCasePathSync } = require('true-case-path');
+
+    const spellcheck_options = {
+        british: true,
+        spelling: true
+    },
+        regex_nav_paths = /[a-z0-9-\/]+[a-z0-9]+#{0,1}[a-z0-9-\/]+/,
+        agent = new https.Agent({
+            rejectUnauthorized: false
+        });
+
+    let errors = {},
+        messages = {},
+        warnings = {},
+        html_to_validate = [],
+        md_to_validate = [],
+        exclude_links = {},
+        exclude_spellcheck = {},
+        exclude_h1_count = {};
+
+    const spellcheckContent = async function (sourceFile, excludes) {
+        let spelling_errors = {};
+        let words = [];
+        const text = fs.readFileSync(sourceFile.path, 'utf8');
+        const source_path = sourceFile.relativePath.replace('.' + sourceFile.extension, '');
+        const translate_output = translator.translate(text, spellcheck_options);
+        if (Object.keys(translate_output).length) {
+            for (const key in translate_output) {
+                if (translate_output.hasOwnProperty(key)) {
+                    let error_message = `Line ${key} - British spelling:`;
+                    for (let i = 0; i < translate_output[key].length; i++) {
+                        for (const spelling in translate_output[key][i]) {
+                            if (translate_output[key][i].hasOwnProperty(spelling) && (typeof translate_output[key][i][spelling].details === 'string')) {
+                                if (!excludes[source_path]) {
+                                    errors[sourceFile.relativePath].push(`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`);
+                                    spelling_errors[spelling] = true;
+                                } else if (!excludes[source_path].includes(spelling.toLowerCase())) {
+                                    errors[sourceFile.relativePath].push(`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`);
+                                    spelling_errors[spelling] = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (Object.keys(spelling_errors).length) {
+            for (const word in spelling_errors) {
+                if (spelling_errors.hasOwnProperty(word)) {
+                    words.push(word);
+                }
+            }
+        }
+        return words;
+    };
+
+    const checkNavigation = async function (source_path, flat_nav) {
+        let nav_errors = [];
+        for (let key in flat_nav) {
+            if (flat_nav.hasOwnProperty(key)) {
+                // doc paths should only contain a-z - characters
+                const invalid_chars = key.replace(regex_nav_paths, '');
+                if (invalid_chars !== '') {
+                    nav_errors.push(`Navigation path [${key}] contains the following invalid characters: [${[...invalid_chars].join('] [')}]`);
+                }
+                const key_split = key.split('#');
+                const key_no_hash = key_split[0];
+
+                // Validate path exists - key should be a html file at this point
+                let file_exists = true;
+                let file_name = path.join(source_path, key_no_hash + '.html');
+                if (!fs.existsSync(file_name)) {
+                    file_name = path.join(source_path, key_no_hash + '.htm');
+                    if (!fs.existsSync(file_name)) {
+                        file_name = path.join(source_path, key_no_hash, 'index.html');
+                        if (!fs.existsSync(file_name)) {
+                            file_name = path.join(source_path, key_no_hash, 'index.htm');
+                            if (!fs.existsSync(file_name)) {
+                                file_exists = false;
+                                nav_errors.push(`Navigation path [${key_no_hash}] file does not exist.`);
+                            }
+                        }
+                    }
+                }
+
+                if (file_exists) {
+                    const true_file = trueCasePathSync(file_name).replace(source_path, '').replaceAll('\\', '/');
+                    const relative_file = file_name.replace(source_path, '').replaceAll('\\', '/');
+                    if (true_file !== relative_file) {
+                        nav_errors.push(`Navigation path [${key}] for filename [${relative_file}] does not match filename case [${true_file}].`);
+                    }
+                }
+
+                // Validate path spellings
+                const paths = key.split('/');
+                for (let i = 0; i < paths.length; i++) {
+                    const path_words = paths[i].split('-');
+                    for (let j = 0; j < path_words.length; j++) {
+                        const translate_output = translator.translate(path_words[j], spellcheck_options);
+                        if (Object.keys(translate_output).length) {
+                            for (const spell_val in translate_output) {
+                                if (translate_output.hasOwnProperty(spell_val)) {
+                                    for (const spelling in translate_output[spell_val][0]) {
+                                        if (translate_output[spell_val][0].hasOwnProperty(spelling)) {
+                                            nav_errors.push(`Navigation path [${key}] key contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Validate display names/bookmarks
+                console.log(key)
+                for (let i = 0; i < flat_nav[key].length; i++) {
+                    if (flat_nav[key][i].link === key) {
+                        const translate_output = translator.translate(flat_nav[key][i].text, spellcheck_options);
+                        if (Object.keys(translate_output).length) {
+                            for (const spell_val in translate_output) {
+                                if (translate_output.hasOwnProperty(spell_val)) {
+                                    for (let j = 0; j < translate_output[spell_val].length; j++) {
+                                        for (const spelling in translate_output[spell_val][j]) {
+                                            if (translate_output[spell_val][j].hasOwnProperty(spelling)) {
+                                                nav_errors.push(`Navigation path [${key}] display text contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+            }
+        }
+        return nav_errors;
+    };
+
+    const checkLinks = async function (source_path, htmlFile, links, hdocbook_config) {
+        for (let i = 0; i < links.length; i++) {
+
+            // Validate that link is a valid URL first
+            const valid_url = hdoc.valid_url(links[i]);
+            if (!valid_url) {
+                // Could be a relative path, check
+                if (links[i].startsWith('/')) {
+                    const link_root = links[i].split('/')[0];
+                    if (link_root !== hdocbook_config.docId) continue;
+                }
+                isRelativePath(source_path, htmlFile, links[i]);
+            } else {
+                messages[htmlFile.relativePath].push(`Link is a properly formatted external URL: ${links[i]}`);
+
+                // Skip if it's the auto-generated edit url, as these could be part of a private repo which would return a 404
+                if (links[i] === hdoc.get_github_api_path(hdocbook_config.publicSource, htmlFile.relativePath).edit_path.replace(path.extname(htmlFile.relativePath), '.md')) {
+                    continue;
+                }
+
+                if (valid_url.protocol === 'mailto:') {
+                    continue;
+                }
+
+                // Skip if the link is excluded in the project config
+                if (exclude_links[links[i]]) {
+                    continue;
+                }
+                if (links[i].toLowerCase().includes('docs.hornbill.com') || links[i].toLowerCase().includes('docs-internal.hornbill.com')) {
+                    errors[htmlFile.relativePath].push(`Links to Hornbill Docs should rooted and not fully-qualified: ${links[i]}`);
+                    continue;
+                }
+
+                try {
+                    await axios.get(links[i], {
+                        httpsAgent: agent
+                    });
+                    messages[htmlFile.relativePath].push(`Link is a valid external URL: ${links[i]}`);
+                } catch (e) {
+                    // Handle errors
+                    errors[htmlFile.relativePath].push(`Link is not responding: ${links[i]} - [${e.message}]`);
+                }
+            }
+        }
+    };
+
+    const checkImages = async function (source_path, htmlFile, links) {
+        for (let i = 0; i < links.length; i++) {
+
+            // Validate that image is a valid URL first
+            if (!hdoc.valid_url(links[i])) {
+                // Could be a relative path, check image exists
+                doesFileExist(source_path, htmlFile, links[i]);
+            } else {
+                messages[htmlFile.relativePath].push(`Image link is a properly formatted external URL: ${links[i]}`);
+                // Do a Get to the URL to see if it exists
+                try {
+                    const res = await axios.get(links[i]);
+                    messages[htmlFile.relativePath].push(`Image link is a valid external URL: ${links[i]}`);
+                } catch (e) {
+                    // Handle errors
+                    errors[htmlFile.relativePath].push(`Unexpected Error from external image link: ${links[i]} - ${e.message}`);
+                }
+            }
+        }
+    };
+
+    const checkTags = async function (htmlFile) {
+        // Check if file  is excluded from tag check
+        const file_no_ext = htmlFile.relativePath.replace(path.extname(htmlFile.relativePath), '');
+        if (exclude_h1_count[file_no_ext]) return;
+
+        // Check tags
+        const htmlBody = fs.readFileSync(htmlFile.path, 'utf8');
+        const $ = cheerio.load(htmlBody);
+
+        const h1_tags = $('h1').map(function () {
+            return $(this);
+        }).get();
+        if (h1_tags.length && h1_tags.length > 1) {
+            let error_msg = `${h1_tags.length} <h1> tags found in content: `;
+            for (let i = 0; i < h1_tags.length; i++) {
+                error_msg += h1_tags[i].text();
+                if (i < h1_tags.length - 1) error_msg += '; ';
+            }
+            errors[htmlFile.relativePath].push(error_msg);
+        }
+    };
+
+    const dreeOptions = {
+        descendants: true,
+        depth: 10,
+        extensions: ['htm', 'html', 'md'],
+        hash: false,
+        normalize: true,
+        size: false,
+        sizeInBytes: false,
+        stat: false,
+        symbolicLinks: false
+    };
+
+    // File scan callback
+    const fileCallback = function (element) {
+        if (element.extension.toLowerCase() === 'md') {
+            md_to_validate.push(element);
+        } else {
+            html_to_validate.push(element);
+        }
+    };
+
+    const isRelativePath = function (source_path, html_path, relative_path) {
+        const rel_path_ext = path.extname(relative_path);
+        let response = {
+            is_rel_path: false,
+            has_md_extension: rel_path_ext === '.md'
+        };
+
+        const supported_relpaths = [
+            path.sep + 'index.htm',
+            path.sep + 'index.html',
+            '.htm',
+            '.html',
+            '.md'
+        ];
+
+        // Remove explicit anchor links and _books prefix
+        relative_path = relative_path.split('#')[0].replace('_books/', '');
+
+        // Make full file path
+        const file_path = path.join(source_path, relative_path);
+
+        // Does path exist?
+        if (fs.existsSync(file_path)) {
+            response.is_rel_path = true;
+        } else {
+            // Path 
+            for (let i = 0; i < supported_relpaths.length; i++) {
+                if (fs.existsSync(`${file_path}${supported_relpaths[i]}`)) {
+                    response.is_rel_path = true;
+                    break;
+                }
+            }
+        }
+        if (response.has_md_extension) {
+            errors[html_path.relativePath].push(`Relative link contains MD extension, but should not: ${relative_path}`);
+        } else {
+            if (response.is_rel_path) {
+                messages[html_path.relativePath].push(`Relative path exists: ${relative_path}`);
+            } else {
+                errors[html_path.relativePath].push(`Link path does not exist: ${relative_path}`);
+            }
+        }
+    }
+
+    const doesFileExist = function (source_path, html_path, relative_path) {
+        // Remove explicit anchor links and _books prefix
+        relative_path = relative_path.split('#')[0].replace('_books/', '');
+        const file_path = path.join(source_path, relative_path);
+        if (!fs.existsSync(file_path) && !fs.existsSync(file_path + path.sep + 'index.htm') && !fs.existsSync(file_path + 'index.html') && !fs.existsSync(file_path + '.htm') && !fs.existsSync(file_path + '.html')) {
+            errors[html_path.relativePath].push(`Book resource does not exist: ${relative_path}`);
+            return false;
+        } else {
+            messages[html_path.relativePath].push(`Book resource exists: ${relative_path}`);
+        }
+        return true;
+    };
+
+    // Takes a dree element, returns an object with a pair of arrays
+    const getLinks = function (file) {
+        messages[file.relativePath].push('Parsing HTML file');
+        const htmlBody = fs.readFileSync(file.path, 'utf8');
+        let links = {
+            href: [],
+            img: []
+        };
+        const $ = cheerio.load(htmlBody);
+        const hrefs = $('a').map(function (i) {
+            return $(this).attr('href');
+        }).get();
+        const srcs = $('img').map(function (i) {
+            return $(this).attr('src');
+        }).get();
+        links.href.push(...hrefs);
+        links.img.push(...srcs);
+        return links;
+    };
+
+    exports.run = async function (source_path, doc_id, verbose, hdocbook_config, hdocbook_project, nav_items, prod_families, prods_supported, gen_exclude) {
+        console.log(`Performing Validation and Building SEO Link List...`);
+
+        // Get a list of HTML files in source_path
+        dree.scan(source_path, dreeOptions, fileCallback);
+
+        // Check product family
+        let valid_product = false;
+        let meta_errors = [];
+        for (let i = 0; i < prod_families.products.length; i++) {
+            if (prod_families.products[i].id === hdocbook_config.productFamily) {
+                valid_product = true;
+            }
+        }
+        if (!valid_product) {
+            let val_prod_error = `Incorrect productFamily: ${hdocbook_config.productFamily}. Supported values:`;
+            for (let i = 0; i < prods_supported.length; i++) {
+                val_prod_error += `\n  - ${prods_supported[i]}`
+            }
+            meta_errors.push(val_prod_error)
+
+        }
+
+        // Check navigation spellings
+        const nav_errors = await checkNavigation(source_path, nav_items);
+        if (nav_errors.length > 0) meta_errors.push(...nav_errors);
+
+        if (meta_errors.length > 0) {
+            console.log('\r\n-----------------------');
+            console.log('   Validation Output   ');
+            console.log('-----------------------');
+            for (let i = 0; i < meta_errors.length; i++) {
+                console.log(`- ${meta_errors[i]}`);
+            }
+            console.log(`\r\n${meta_errors.length} Validation Errors Found`);
+            return false;
+        }
+
+        if (hdocbook_project.validation) {
+            if (hdocbook_project.validation.exclude_links && hdocbook_project.validation.exclude_links instanceof Array) {
+                hdocbook_project.validation.exclude_links.forEach(function (excl_link) {
+                    exclude_links[excl_link] = true;
+                });
+            }
+            if (hdocbook_project.validation.exclude_spellcheck && hdocbook_project.validation.exclude_spellcheck instanceof Array) {
+                hdocbook_project.validation.exclude_spellcheck.forEach(function (excl_sc) {
+                    exclude_spellcheck[excl_sc.document_path] = excl_sc.words;
+                });
+            }
+            if (hdocbook_project.validation.exclude_h1_count && hdocbook_project.validation.exclude_h1_count instanceof Array) {
+                hdocbook_project.validation.exclude_h1_count.forEach(function (excl_h1) {
+                    exclude_h1_count[excl_h1] = true;
+                });
+            }
+        }
+
+        let excl_output = [];
+
+        // Do spellchecking on markdown files
+        let md_files_spellchecked = {};
+        let mdPromiseArray = [];
+        for (let i = 0; i < md_to_validate.length; i++) {
+            errors[md_to_validate[i].relativePath] = [];
+            messages[md_to_validate[i].relativePath] = [];
+            warnings[md_to_validate[i].relativePath] = [];
+            mdPromiseArray.push(md_to_validate[i]);
+        }
+        await Promise.all(mdPromiseArray.map(async (file) => {
+            // Initiate maps for errors and verbose messages for markdown file
+            const exclusions = await spellcheckContent(file, exclude_spellcheck);
+            if (gen_exclude && exclusions.length > 0) excl_output.push({ document_path: file.relativePath.replace('.' + file.extension, ''), words: exclusions });
+            md_files_spellchecked[file.relativePath.replace('.' + file.extension, '')] = true;
+        }));
+
+        // Perform rest of validation against HTML files
+        let listContent = '';
+        let htmlPromiseArray = [];
+        for (let i = 0; i < html_to_validate.length; i++) {
+            errors[html_to_validate[i].relativePath] = [];
+            messages[html_to_validate[i].relativePath] = [];
+            warnings[html_to_validate[i].relativePath] = [];
+            htmlPromiseArray.push(html_to_validate[i]);
+        }
+        await Promise.all(mdPromiseArray.map(async (file) => {
+            // Check for British spellings in static HTML content
+            if (!md_files_spellchecked[file.relativePath.replace('.' + file.extension, '')]) {
+                const exclusions = await spellcheckContent(file, exclude_spellcheck);
+                if (gen_exclude && exclusions.length > 0) excl_output.push({ document_path: file.relativePath.replace('.' + file.extension, ''), words: exclusions });
+            }
+
+            const links = getLinks(file);
+            if (links.href.length === 0) {
+                messages[file.relativePath].push('No links found in file');
+            } else {
+                await checkLinks(source_path, file, links.href, hdocbook_config);
+            }
+            if (links.img.length === 0) {
+                messages[file.relativePath].push('No images found in file');
+            } else {
+                await checkImages(source_path, file, links.img);
+            }
+
+            // Check for multiple H1 tags
+            await checkTags(file);
+
+            // Build list content for Google 
+            listContent += `/${file.relativePath.replace(path.extname(file.relativePath), '')}`;
+            listContent += '\r\n';
+        }));
+
+        if (gen_exclude) console.log(JSON.stringify(excl_output, null, 2));
+
+        try {
+            // Write list
+            const listFile = path.join(source_path, doc_id, 'links.txt');
+            fs.writeFileSync(listFile, listContent);
+            console.log(`\r\nLink list text file created successfully: ${listFile}`);
+        } catch (err) {
+            console.error(err);
+        }
+
+        if (verbose) {
+            console.log('\r\n-------------');
+            console.log('   Verbose   ');
+            console.log('-------------');
+            for (const key in messages) {
+                if (messages.hasOwnProperty(key) && messages[key].length > 0) {
+                    console.log(`\r\nMessage output for ${key}`);
+                    for (let i = 0; i < messages[key].length; i++) {
+                        console.log(` - ${messages[key][i]}`);
+                    }
+                }
+            }
+        }
+
+        console.log('\r\n-----------------------');
+        console.log('   Validation Output   ');
+        console.log('-----------------------');
+        if (Object.keys(errors).length > 0) {
+            let error_count = 0;
+            for (const key in errors) {
+                if (errors.hasOwnProperty(key) && errors[key].length > 0) {
+                    console.log(`\r\n${errors[key].length} error(s) in ${key}`);
+                    for (let i = 0; i < errors[key].length; i++) {
+                        console.log(` - ${errors[key][i]}`);
+                        error_count++
+                    }
+                }
+            }
+            if (error_count > 0) {
+                console.log(`\r\n${error_count} Validation Errors Found`);
+                return false;
+            }
+        }
+
+        console.log(`\r\nNo Validation Errors Found!\n`);
+        return true;
+    };
 })();