hdoc-tools 0.7.19 → 0.7.21

package/hdoc-build.js

@@ -1,41 +1,53 @@
 (function () {
     'use strict';
 
-    const fs = require('fs-extra'),
+    const dree = require('dree'),
+        fs = require('fs-extra'),
         path = require('path'),
-        dree = require('dree'),
-        zipper = require('zip-local'),
-        validate = require(path.join(__dirname, 'hdoc-validate.js'));
+        URL = require("url").URL,
+        validate = require(path.join(__dirname, 'hdoc-validate.js')),
+        hdoc = require(path.join(__dirname, 'hdoc-module.js')),
+        zipper = require('zip-local');
 
     let conversion_attempted = 0,
         conversion_success = 0,
         conversion_failed = 0,
+        includes_found = 0,
+        includes_success = 0,
+        includes_failed = 0,
         docId = '',
         md_files = [];
 
-    function expand_variables(text) {
-        text = text.replaceAll('{{BUILD_NUMBER}}', '0');
-
-        let build_date = new Date().toISOString();
-        build_date = build_date.replace('T', ' ');
-        build_date = build_date.substring(0, 19);
-
-        text = text.replaceAll('{{BUILD_DATE}}', build_date);
-        return text;
-    }
-
-    function transform_markdown_and_save_html(file_path, md) {
+    const transform_markdown_and_save_html  = function (file_path, md) {
         conversion_attempted++;
         if (fs.existsSync(file_path)) {
             // Load markdown file
-            let md_txt = expand_variables(fs.readFileSync(file_path, 'utf8'));
+            let md_txt = hdoc.expand_variables(fs.readFileSync(file_path, 'utf8'));
+
+            // Pull in external includes
+            const includes_processed = hdoc.process_includes(file_path, md_txt);
+            md_txt = includes_processed.body;
+            includes_found += includes_processed.found;
+            includes_success += includes_processed.success;
+            includes_failed += includes_processed.failed;
+            if (includes_processed.errors.length > 0) {
+                for (let i = 0; i < includes_processed.errors.length; i++) {
+                    console.error(includes_processed.errors[i]);
+                }
+            }
 
             // Render markdown into HTML
+            let frontmatter_content = '';
             var html_txt = md.render(md_txt.toString());
 
+
+            if (frontmatter_content.length) {
+                html_txt = "<!--[[FRONTMATTER\r\n" + frontmatter_content + "]]-->\r\n" + html_txt;
+            }
+ 
             // Save HTML into HTML file
             const target_file = file_path.replace(path.extname(file_path), '.html');
-            fs.writeFileSync(target_file, html_txt, function writeJSON(err) {
+            fs.writeFile(target_file, html_txt, function writeJSON(err) {
                 if (err) return console.log('Error writing:', target_file, '\r\n', err);
             });
             conversion_success++;
@@ -44,7 +56,7 @@
         conversion_failed++;
         console.error('MD file does not exist:', file_path);
         return false;
-    }
+    };
 
     // File callbacks for scans
     const fileCallback = function (element) {
@@ -79,14 +91,14 @@
 
         // Load the hdocbook-project.json file to get the docId
         // use the docId to get the book config
-        const   hdocbook_project_config_path = path.join(source_path, 'hdocbook-project.json'),
-                hdocbook_project = require(hdocbook_project_config_path);
+        const hdocbook_project_config_path = path.join(source_path, 'hdocbook-project.json'),
+            hdocbook_project = require(hdocbook_project_config_path);
 
         docId = hdocbook_project.docId;
 
-        const   book_path = path.join(source_path, docId),
-                hdocbook_path = path.join(book_path, 'hdocbook.json'),
-                hdocbook_config = require(hdocbook_path);
+        const book_path = path.join(source_path, docId),
+            hdocbook_path = path.join(book_path, 'hdocbook.json'),
+            hdocbook_config = require(hdocbook_path);
 
         console.log(`Building: ${docId} v${hdocbook_config.version}...\r\n`);
 
@@ -118,9 +130,11 @@
         });
         console.log(`                MD files found: ${conversion_attempted}`);
         console.log(`Successfully converted to HTML: ${conversion_success}`);
-        console.log(`             Failed to convert: ${conversion_failed}`);
+        console.log(`             Failed to convert: ${conversion_failed}\r\n`);
+        console.log(`                Includes Found: ${includes_found}`);
+        console.log(`              Includes Success: ${includes_success}`);
+        console.log(`               Includes Failed: ${includes_failed}\r\n`);
 
-        console.log(`\r\nValidating paths in generated HTML files`);
         const validation_success = validate.run(work_path, docId, verbose);
         if (!validation_success) {
             process.exit(1);

package/hdoc-db.js

@@ -0,0 +1,158 @@
+const { nextTick } = require('process');
+
+(function() {
+    'use strict';
+
+    const   dree = require('dree'),
+            fs = require('fs-extra'),
+            html2text = require('html-to-text'),
+            sqlite3 = require('sqlite3'),
+            path = require('path');
+
+    const  table_name = 'hbdocs';
+
+    let     db_name = 'hbdocs.db',
+            hdocbook_meta = null,
+            md_files = [];
+
+    // File callbacks for scan
+    const file_callback = function (element) {
+        if (path.extname(element.path) === '.md' && !element.path.includes('_work')) {
+            md_files.push(element);
+        } else if (element.name === 'hdocbook.json') {
+            // hdocbook meta data, read and store
+            hdocbook_meta = require(element.path);
+        }
+    };
+
+    const create_table = function(db) {
+        db.exec(`
+        create table ${table_name} (
+        relative_url text primary key not null,
+        book_id text not null,
+        title text not null,
+        content text not null,
+        tags text null,
+        audience text not null
+        );
+        `, (err)  => {
+            if (err !== null) {
+                console.error(`Error creating table [${table_name}]: ${err}`);
+                return false;
+            } else {
+                console.log(`  Table created successfully: ${table_name}`);
+                return true;
+            }
+        });
+        return true;
+    };
+
+    const build_db = function(db, md, book_def, md_files) {
+        for (let i = 0; i < md_files.length; i++) {
+            db.exec(`
+            insert into ${table_name} 
+                (book_id, title, relative_url, content, tags, audience)
+            values
+                (
+                    '${book_def.docId}',
+                    '${book_def.title}',
+                    '${md_files[i].relativePath}',
+                    'Some file content',
+                    '${book_def.tags.join(';')}',
+                    '${book_def.audience.join(';')}'
+                );
+            `, (err)  => {
+                if (err !== null) {
+                    console.error(`Error inserting record [${md_files[i].relativePath}]: ${err}`);
+                    return false;
+                } else {
+                    console.log(`  Record inserted successfully: ${md_files[i].relativePath}`);
+                    return true;
+                }
+            });
+        }
+    };
+
+    const transform_markdown  = function (file_path, md) {
+        if (fs.existsSync(file_path)) {
+            // Load markdown file
+            let md_txt = hdoc.expand_variables(fs.readFileSync(file_path, 'utf8'));
+
+            // Pull in external includes
+            const includes_processed = hdoc.process_includes(file_path, md_txt);
+            md_txt = includes_processed.body;
+            includes_found += includes_processed.found;
+            includes_success += includes_processed.success;
+            includes_failed += includes_processed.failed;
+            if (includes_processed.errors.length > 0) {
+                for (let i = 0; i < includes_processed.errors.length; i++) {
+                    console.error(includes_processed.errors[i]);
+                }
+            }
+
+            // Render markdown into HTML
+            var html_txt = md.render(md_txt.toString());
+
+            // Save HTML into HTML file
+            const target_file = file_path.replace(path.extname(file_path), '.html');
+            fs.writeFile(target_file, html_txt, function writeJSON(err) {
+                if (err) return console.log('Error writing:', target_file, '\r\n', err);
+            });
+            conversion_success++;
+            return true;
+        }
+        conversion_failed++;
+        console.error('MD file does not exist:', file_path);
+        return false;
+    };
+
+    const dree_options = {
+        descendants: true,
+        depth: 10,
+        extensions: ['md','json'],
+        hash: false,
+        normalize: true,
+        size: false,
+        sizeInBytes: false,
+        stat: false,
+        symbolicLinks: false
+    };
+
+    exports.run = function(source_path, md) {
+        /*
+            STEVE - The purpose of this command is to allow content developers to do local builds of
+                    the SQlite database and index file, for validation before commit and build 
+        */
+        dree.scan(source_path, dree_options, file_callback);
+
+        if (hdocbook_meta === null) {
+            console.error('hdocbook.json was not found, or has no content');
+            process.exit(1);
+        }
+        if (md_files.length === 0) {
+            console.error('No markdown files detected in', source_path);
+            process.exit(1);
+        }
+
+        db_name = path.join(source_path, db_name);
+        if (fs.existsSync(db_name)) {
+            try {
+                fs.removeSync(db_name);
+            } catch (e) {
+                console.error(`Failed to delete existing db file: ${db_name}`);
+            }
+        }
+
+        let db = new sqlite3.Database(db_name, (err) => {
+            if (err) {
+                console.error('Error creating database:', err);
+                process.exit(1);
+            }
+            console.log(`DB file created successfully: ${db_name}`);
+            if (create_table(db)) {
+                if (!hdocbook_meta.tags) hdocbook_meta.tags = [];
+                build_db(db, md, hdocbook_meta, md_files );
+            }
+        });
+    };
+})();

package/hdoc-module.js

@@ -0,0 +1,146 @@
+(function () {
+    'use strict';
+
+    const request = require('sync-request');
+
+    let includesCache = {};
+
+    exports.content_type_for_ext = function (ext) {
+        switch (ext) {
+            case '.z':
+                return 'application/x-compress';
+            case '.tgz':
+                return 'application/x-compressed';
+            case '.gz':
+                return 'application/x-gzip';
+            case '.zip':
+                return 'application/x-zip-compressed';
+            case '.xml':
+                return 'application/xml';
+            case '.bmp':
+                return 'image/bmp';
+            case '.gif':
+                return 'image/gif';
+            case '.jpg':
+                return 'image/jpeg';
+            case '.png':
+                return 'image/png';
+            case '.tiff':
+                return 'image/tiff';
+            case '.ico':
+                return 'image/x-icon';
+            case '.png':
+                return 'image/png';
+            case '.svg':
+                return 'image/svg+xml';
+            case '.css':
+                return 'text/css';
+            case '.htm':
+            case '.html':
+                return 'text/html';
+            case '.txt':
+                return 'text/plain';
+            case '.md':
+                return 'text/plain';
+            case '.json':
+                return 'application/json';
+            case '.js':
+                return 'application/javascript';
+            default:
+                return 'application/octet-stream';
+        }
+    };
+
+    exports.valid_url = function (s) {
+        let response = {
+            valid: false,
+            urlProps: {}
+        };
+        try {
+            response.urlProps = new URL(s);
+            response.valid = true;
+        } catch (err) {
+            response.valid = false;
+        }
+        return response;
+    };
+
+    exports.expand_variables = function (text, docId = '') {
+        if (docId !== '') {
+            text = text.replaceAll('{{DOC_ID}}', docId);
+        }
+        text = text.replaceAll('{{BUILD_NUMBER}}', '0');
+
+        let build_date = new Date().toISOString();
+        build_date = build_date.replace('T', ' ');
+        build_date = build_date.substring(0, 19);
+        text = text.replaceAll('{{BUILD_DATE}}', build_date);
+        return text;
+    };
+
+
+    exports.process_includes = function (file_path, body) {
+        let response = {
+            body: '',
+            found: 0,
+            success: 0,
+            failed: 0,
+            errors: []
+        };
+
+        // Search body for INCLUDEs
+        const regexp = /\[\[INCLUDE .*]]/g;
+        const body_array = [...body.matchAll(regexp)];
+
+        for (let i = 0; i < body_array.length; i++) {
+            response.found++;
+
+            // Extract include data from array
+            const include_value = body_array[i][0];
+
+            let link;
+            try {
+                link = include_value.split(' ')[1];
+                link = link.substring(0, link.length - 2);
+            } catch (e) {
+                response.failed++;
+                response.errors.push(`Error parsing INCLUDE [${include_value}] from [${file_path}]: ${err}`);
+                continue;
+            }
+
+            if (includesCache[link] !== undefined) {
+                console.log(`Serving From Cache: ${link}`);
+                body = body.replace(include_value, includesCache[link]);
+                continue;
+            }
+
+            // Validate link in INCLUDE
+            try {
+                new URL(link);
+            } catch (err) {
+                response.failed++;
+                response.errors.push(`Error validating INCLUDE link [${link}] from [${file_path}]: ${e}`);
+                continue;
+            }
+
+            let file_content;
+            try {
+                const file_response = request('GET', link);
+                if (file_response.statusCode === 200) {
+                    file_content = file_response.getBody('UTF8');
+                } else {
+                    throw `Unexpected Status ${file_response.statusCode}`;
+                }
+            } catch (e) {
+                response.failed++;
+                response.errors.push(`Error getting INCLUDE link content [${link}] from [${file_path}]: ${e}`);
+                continue;
+            }
+            response.success++;
+            includesCache[link] = file_content;
+            body = body.replace(include_value, file_content);
+        }
+        response.body = body;
+        return response;
+    };
+})();

package/hdoc-serve.js

@@ -1,11 +1,15 @@
 (function () {
    'use strict';
 
-   const fs = require('fs');
-   var path = require('path');
-   const stream = require('stream');
-   var express = require('express');
-   var port = 3000;
+   const express = require('express'),
+      fs = require('fs'),
+      path = require('path'),
+      hdoc = require(path.join(__dirname, 'hdoc-module.js')),
+      stream = require('stream');
+
+   let port = 3000;
+   let docId;
+   let hdocbook_config;
 
    exports.run = function (ui_path, source_path, md) {
 
@@ -20,20 +24,19 @@
                port = process.argv[x];
             }
          }
-      }   
+      }
 
       console.log('Hornbill HDocBook Preview/Dev Server', '\r\n');
-      //console.log('    Server Path:', __dirname);
       console.log('   UI Root Path:', ui_path);
       console.log('  Document Path:', source_path, '\r\n');
       console.log('    Server Port:', port);
 
-      if(fs.existsSync(path.join(source_path, 'hdocbook-project.json')) == false) {
+      if (fs.existsSync(path.join(source_path, 'hdocbook-project.json')) == false) {
          console.log("No hdocbook-project.js file found in working folder. Unable to continue.");
          return -1;
       }
 
-      // Get an express server instance
+      // Get an express server instance   
       var app = express();
 
       // In the root of the project there is a hdocbook.json file which includes
@@ -44,14 +47,13 @@
       var hdocbook_project = require(hdocbook_project_config_path);
 
       // Get the ID of the hdocbook we are serving
-      var docId = hdocbook_project.docId;
+      docId = hdocbook_project.docId;
 
       // Get the path of the book.json file
       const hdocbook_path = path.join(source_path, docId, 'hdocbook.json');
 
       // Pull in the book config file
-      var hdocbook_config = require(hdocbook_path);
-      var hdocbook_mtime = fs.statSync(hdocbook_path).mtime;
+      hdocbook_config = require(hdocbook_path);
 
       app.get('/_books/library.json', function (req, res) {
          let library = {
@@ -64,65 +66,6 @@
          res.send(JSON.stringify(library, null, 3));
       });
 
-      function content_type_for_ext(ext) {
-         switch (ext) {
-            case '.z':
-               return 'application/x-compress';
-            case '.tgz':
-               return 'application/x-compressed';
-            case '.gz':
-               return 'application/x-gzip';
-            case '.zip':
-               return 'application/x-zip-compressed';
-            case '.xml':
-               return 'application/xml';
-            case '.bmp':
-               return 'image/bmp';
-            case '.gif':
-               return 'image/gif';
-            case '.jpg':
-               return 'image/jpeg';
-            case '.png':
-               return 'image/png';
-            case '.tiff':
-               return 'image/tiff';
-            case '.ico':
-               return 'image/x-icon';
-            case '.png':
-               return 'image/png';
-            case '.svg':
-               return 'image/svg+xml';
-            case '.css':
-               return 'text/css';
-            case '.htm':
-            case '.html':
-               return 'text/html';
-            case '.txt':
-               return 'text/plain';
-            case '.md':
-               return 'text/plain';
-            case '.json':
-               return 'application/json';
-            case '.js':
-               return 'application/javascript';
-            default:
-               return 'application/octet-stream';
-         }
-      }
-
-      function expand_variables(text) {
-         // For debug mode our base path is our root??
-         text = text.replaceAll('{{DOC_ID}}', docId);
-         text = text.replaceAll('{{BUILD_NUMBER}}', '0');
-
-         let build_date = new Date().toISOString();
-         build_date = build_date.replace('T', ' ');
-         build_date = build_date.substring(0, 19);
-
-         text = text.replaceAll('{{BUILD_DATE}}', build_date);
-         return text;
-      }
-
       function transform_markdown_and_send_html(req, res, file_path) {
 
          if (fs.existsSync(file_path)) {
@@ -130,8 +73,21 @@
             // it to the caller
 
             // Load markdown file
-            let md_txt = expand_variables(fs.readFileSync(file_path).toString());
-
+            let md_txt = hdoc.expand_variables(fs.readFileSync(file_path).toString(), docId);
+
+            // Pull in external includes
+            const includes_processed = hdoc.process_includes(file_path, md_txt);
+            md_txt = includes_processed.body;
+            if (includes_processed.errors.length > 0) {
+               console.error(`Error(s) when processing includes in ${file_path}`);
+                for (let i = 0; i < includes_processed.errors.length; i++) {
+                    console.error(includes_processed.errors[i]);
+                }
+            } else {
+               if (includes_processed.found > 0) {
+                  console.log(`Includes injected into document: ${includes_processed.success}`);
+               }
+            }
             // Render markdown into HTML
             let frontmatter_content = '';
             var html_txt = md.render(md_txt.toString());
@@ -155,9 +111,9 @@
       }
 
       function send_content_file(req, res, file_path) {
-         let content_txt = expand_variables(fs.readFileSync(file_path).toString());
+         let content_txt = hdoc.expand_variables(fs.readFileSync(file_path).toString(), docId);
 
-         let contentType = content_type_for_ext(path.extname(file_path));
+         let contentType = hdoc.content_type_for_ext(path.extname(file_path));
 
          if (path.extname(file_path) == '.md') {
             res.setHeader('Content-Disposition', 'inline');
@@ -170,7 +126,7 @@
 
       function send_file(req, res, file_path) {
          // Need to set the content type here??
-         let contentType = content_type_for_ext(path.extname(file_path));
+         let contentType = hdoc.content_type_for_ext(path.extname(file_path));
          res.setHeader('Content-Type', contentType);
 
          const r = fs.createReadStream(file_path);
@@ -214,64 +170,11 @@
 
       app.get('/_books/*', function (req, res) {
 
-         let url = req.url;
-
-         let segs = url.split('/');
-         if (segs.length == 4 && segs[1] == '_books' && segs[3] == 'book.json') {
-            // Special case of a virtual file here, we need to check  the book ID and
-            // if its our book, send the json
-            if (hdocbook_config.docId == segs[2]) {
-               res.setHeader('Content-Type', 'application/json');
-               res.send(JSON.stringify(hdocbook_config, null, 3));
-            } else {
-               // Return a 404 error here
-               res.setHeader('Content-Type', 'text/html');
-               res.status(404).send('Specified bookId ' + segs[2] + ' not found');
-            }
-            return;
-         } else if (segs.length == 3 && segs[1] == '_books' && segs[2] == 'index.json') {
-            // For development mode, we always have an index with one book in it, the one being developed
-            if (hdocbook_config) {
-               let index = {
-                  books: [{
-                     docId: hdocbook_config.docId,
-                     title: hdocbook_config.title,
-                     description: hdocbook_config.description,
-                     version: hdocbook_config.version
-                  }]
-               };
-               res.setHeader('Content-Type', 'application/json');
-               res.send(JSON.stringify(index, null, 3));
-            } else {
-               // Return a 404 error here
-               res.setHeader('Content-Type', 'text/html');
-               res.status(404).send('Specified bookId ' + segs[2] + ' not found');
-            }
-            return;
-         }
+         let url = req.url.replace('/_books/', '/');
 
-         url = url.replace('/_books/', '/');
-         
          console.log('URL Requested:', url);
 
          let file_path = path.join(source_path, url);
-         let ui_file_path = path.join(ui_path, url);
-
-         // If the requested file is found in the UI folder
-         if (url == '/') {
-            if (fs.existsSync(path.join(ui_file_path, 'index.html'))) {
-               // We want the index.html, send it here
-               send_file(req, res, path.join(ui_file_path, 'index.html'));
-               return;
-            }
-            // Return a 404 error here
-            send_content_resource_404(req, res);
-            return;
-         } else if (fs.existsSync(ui_file_path)) {
-            // File is found in  the UI folder, that takes priority, send the file
-            send_file(req, res, ui_file_path);
-            return;
-         }
 
          if (path.extname(file_path) == '.html') {
             // 1a. check for html files, and send/transform as required
@@ -287,12 +190,14 @@
                   return;
                }
             }
+
          } else if (path.extname(file_path) == '.md') {
             // If the markdown file exists, just send to caller as is
             if (fs.existsSync(file_path)) {
                send_content_file(req, res, file_path);
                return true;
             }
+
          } else if (path.extname(file_path).length == 0) {
             // 2. If we request a file, without any file extension
             if (fs.existsSync(file_path + '.md')) {
@@ -323,7 +228,7 @@
 
          // Return a 404 error here
          send_content_resource_404(req, res);
-      });    
+      });
 
       // Catch all
       app.get('/*', function (req, res) {
@@ -358,9 +263,9 @@
 
          let _vars = ['{{DOC_ID}}', '{{BUILD_NUMBER}}', '{{BUILD_DATE}}'];
          console.log("Server Vars:");
-         for(let x = 0; x < _vars.length; x++) {
+         for (let x = 0; x < _vars.length; x++) {
             let name = _vars[x];
-            console.log("   ", name, " = ",  expand_variables(name));
+            console.log("   ", name, " = ", hdoc.expand_variables(name, docId));
          }
       });
 

package/hdoc-validate.js

@@ -7,6 +7,7 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
         dree = require('dree'),
         fs = require('fs'),
         path = require('path'),
+        hdoc = require(path.join(__dirname, 'hdoc-module.js')),
         URL = require("url").URL;
 
     let errors = {},
@@ -15,20 +16,12 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
         filecount = 0,
         htmlFiles = [];
 
-    const stringIsAValidUrl = (s) => {
-        try {
-            new URL(s);
-            return true;
-        } catch (err) {
-            return false;
-        }
-    };
 
     const checkLinks = function (source_path, htmlFile, links) {
         for (let i = 0; i < links.length; i++) {
 
             // Validate that link is a valid URL first
-            if (!stringIsAValidUrl(links[i])) {
+            if (!hdoc.valid_url(links[i]).valid) {
 
                 // Could be a relative path, check
                 const fileExists = doesFileExist(source_path, htmlFile, links[i]);
@@ -91,11 +84,12 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
         return links;
     };
 
-
     exports.run = function (source_path, doc_id, verbose) {
         // Get a list of HTML files in source_path
         dree.scan(source_path, dreeOptions, fileCallback);
 
+        console.log(`Performing Validation and Building SEO Link List...`);
+
         let listContent = '';
         for (let i = 0; i < htmlFiles.length; i++) {
 
@@ -118,7 +112,7 @@ const parseLinkDestination = require('markdown-it/lib/helpers/parse_link_destina
         }
         try {
             // Write list
-            const listFile = path.join(source_path, doc_id, 'list.txt');
+            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) {

package/hdoc.js

@@ -54,8 +54,9 @@ const { createCipheriv } = require('crypto');
    let source_path = process.cwd();
    let ui_path = path.join(__dirname, 'ui');
 
-   let command = ''; // Our command to run
-   let verbose = false;
+   let   command = '', // Our command to run
+         verbose = false,
+         build_index = false;
 
    // Get options from command args
    for (let x = 0; x < process.argv.length; x++) {
@@ -83,6 +84,7 @@ const { createCipheriv } = require('crypto');
       if (process.argv[x] === '-v') {
          verbose = true;
       }
+
    }
 
    console.log('Hornbill HDocBook Tools v' + getHdocPackageVersion(packageFile), '\r\n');
@@ -102,8 +104,11 @@ const { createCipheriv } = require('crypto');
       const init = require(path.join(__dirname, 'hdoc-init.js'));
       init.run(__dirname, source_path, md);
    } else if (command == 'help') {
-      const init = require(path.join(__dirname, 'hdoc-help.js'));
-      init.run();
+      const help = require(path.join(__dirname, 'hdoc-help.js'));
+      help.run();
+   } else if (command == 'buildindex') {
+      const build_db = require(path.join(__dirname, 'hdoc-db.js'));
+      build_db.run(source_path, md);
    } else {
       console.log('Unknown command:', command, '\r\n');
       console.log('Run hdoc help for information regarding this tool.\r\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdoc-tools",
-  "version": "0.7.19",
+  "version": "0.7.21",
   "description": "Hornbill HDocBook Development Support Tool",
   "main": "hdoc.js",
   "bin": {
@@ -8,9 +8,11 @@
   },
   "files": [
     "hdoc.js",
+    "hdoc-db.js",
     "hdoc-build.js",
     "hdoc-help.js",
     "hdoc-init.js",
+    "hdoc-module.js",
     "hdoc-serve.js",
     "hdoc-stats.js",
     "hdoc-validate.js",
@@ -40,7 +42,9 @@
     "markdown-it-front-matter": "^0.2.3",
     "multer": "^1.4.5-lts.1",
     "prompt": "^1.3.0",
+    "sqlite3": "^5.1.4",
     "stream": "0.0.2",
+    "sync-request": "^6.1.0",
     "words-count": "^2.0.2",
     "zip-local": "^0.3.5"
   }

package/ui/js/doc.hornbill.js

@@ -94,7 +94,6 @@ function listenForHrefClicks()
     //-- trap all link click events - we want to handle links so can cancel and load content ourselves
     $("A").off("click").on("click", function(ev)
     {
-
         let ele =  this;
         if(ele.href)
         {
@@ -304,7 +303,7 @@ function loadContentUrl(linkRef,fromPageRefresh,fromPopState)
             view.$nextTick(function()
             {
                 //-- find any navigation links that match url and highlight
-                listenForHrefClicks();                
+//                listenForHrefClicks();
                 highlightNavigationLinkFromUrl(linkRef);   
 
                 //-- scroll to element that match hash (if have one)
@@ -315,6 +314,8 @@ function loadContentUrl(linkRef,fromPageRefresh,fromPopState)
             });
             view.$forceUpdate();
         }
+
+        listenForHrefClicks();
     });
 }
 

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Hornbill Docs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.