opendoc-theme 2.0.0

data/assets/js/toolbar.js

@@ -0,0 +1,130 @@
+---
+---
+(function () {
+    // Hard coded max-width for mobile view
+    window.isMobileView = function () {
+        return window.innerWidth < 992
+    }
+
+    // Documents - Section toggle
+
+    // Site-nav
+    // --------------------------
+    var menuToggle = document.getElementById('menu-toggle')
+    var showMenu = function showMenu() {
+        menuToggle.checked = true
+        document.body.classList.add('menu-toggled')
+    }
+    var hideMenu = function hideMenu() {
+        menuToggle.checked = false
+        document.body.classList.remove('menu-toggled')
+    }
+    menuToggle.addEventListener('change', function () {
+        if (menuToggle.checked) {
+            showMenu()
+        } else {
+            hideMenu()
+        }
+    })
+
+    var welcomeButton = document.getElementsByClassName('welcome-button')[0]
+    if (welcomeButton) {
+        welcomeButton.onclick = showMenu
+    }
+
+    // Hide site-nav on navigation
+    window.addEventListener('link-click', function () {
+        if (isMobileView()) {
+            hideMenu()
+        }
+    })
+
+    // Edit button
+    // --------------------------
+    var editButtons = document.querySelectorAll('.edit-btn')
+    editButtons.forEach(function (btn) {
+        btn.addEventListener('click', function () {
+            var repoUrl = '{{ site.github.repository_url }}' + '/blob/master/'
+            var page = pageIndex[window.location.pathname]
+            var pageUrl = page ? page.escapedPath : null
+            if (pageUrl) {
+                console.log('opening:', pageUrl)
+                repoUrl += pageUrl
+            }
+            window.open(repoUrl, '_blank')
+        })
+    })
+
+    // Print button
+    // --------------------------
+    var printButtons = document.querySelectorAll('.print-btn')
+
+    printButtons.forEach(function (btn) {
+        btn.addEventListener('click', function () {
+            window.open('./export.pdf', '_blank')
+        })
+    })
+
+    // Share button 
+    // -------------------------
+    var shareButtons = document.querySelectorAll('.share-btn')
+    shareButtons.forEach(function(btn) {
+        btn.addEventListener('click', function() {
+            if (navigator.share) {
+                navigator.share({
+                    title: {{ site.title | jsonify }},
+                    text: document.title,
+                    url: window.location.href
+                }).then()
+            }
+        })
+    })
+
+    // Floating Action Button
+    // -----------------------
+    var floatingActionButtonTrigger = document.getElementById('fab-trigger')
+    var floatingActionButton = document.getElementById('fab')
+    floatingActionButtonTrigger.addEventListener('click', function () {
+        floatingActionButton.classList.toggle('open')
+    });
+
+    var fabOverlay = document.getElementById('fab-overlay')
+    fabOverlay.addEventListener('click', function() {
+        floatingActionButton.classList.remove('open')
+    })    
+
+    var backToTopButton = document.getElementById('back-to-top')
+    backToTopButton.addEventListener('click', function() {
+        // jump.js
+        Jump(-(window.pageYOffset || document.documentElement.scrollTop), {
+            duration: 300
+        })
+    })
+
+    // show/hide back-to-top button on scroll and on load
+    function scrollListener() {
+        var scrollTop = window.pageYOffset || document.documentElement.scrollTop
+        if (scrollTop > (window.innerHeight * 2)) {
+            backToTopButton.classList.remove('hidden')
+        } else {
+            backToTopButton.classList.add('hidden')
+        }
+    }
+
+    scrollListener()
+
+    window.addEventListener("scroll", scrollListener)
+
+    //  Search Button for mobile 
+    // --------------------------
+    var searchButtons = document.querySelectorAll('.search-btn')
+    var searchBoxElement = document.getElementById('search-box')
+    searchButtons.forEach(function(btn) {
+        btn.addEventListener('click', function() {
+            document.body.classList.toggle('search-toggled')
+            if (document.body.classList.contains('search-toggled')) {
+                searchBoxElement.focus()
+            }
+        })
+    })
+})()

data/assets/siteIndex.json

@@ -0,0 +1,56 @@
+---
+---
+{% assign index_array = "" | split: ',' %}
+{%- for page in site.html_pages -%}
+{%- unless page.exclude -%}
+{% unless page.name == 'index.html' or page.name == 'index.md' %}
+{%- assign page_url = page.url -%}
+{%- assign split_content = page.content | markdownify | split: '<h2' | splice: 1  -%}
+        
+{%- comment -%}Deal with h1 section{%- endcomment -%}
+{%- assign page_header = split_content.first | split: '>' -%}
+{%- assign page_header = page_header[1] | split: '</h1' -%}
+{%- assign page_header = page_header[0] -%}
+{%- assign header_section = '<h1' | append: split_content.first  | strip_html | newline_to_br | strip_newlines | replace: '<br />', ' ' | replace: '\', '' | strip | smartify | normalize_whitespace -%}
+{%- capture item -%}
+{
+"title": "{{ page_header}}",
+"documentTitle": "{%- include_cached document-title.txt dir=page.dir info="title" -%}",
+"url": "{{page_url | relative_url }}",
+"text": "{{ header_section }}"
+}
+{% endcapture %}
+{%- assign index_array = index_array | push: item -%}
+
+{%- comment -%}Then deal with h2 sections {%- endcomment -%}
+{%- for section in split_content offset:1 -%}
+{%- assign section_header_html = section | split: 'id="' -%}
+{%- assign section_header_html = section_header_html[1] | split: '">' -%}
+
+{%- comment -%}Get section id{%- endcomment -%}
+{%- assign section_id = section_header_html[0] -%}
+{%- comment -%}Get section url{%- endcomment -%}
+{%- assign section_url = page_url | append: '#' | append: section_id -%}
+
+{%- comment -%}Get section header{%- endcomment -%}
+{%- assign section_header = section_header_html | shift | join | split: '</h2' -%}
+{%- assign section_header = section_header[0] | strip_html -%}
+
+{%- comment -%}Get section body{%- endcomment -%}
+{%- assign full_section = '<h2 ' | append:section | strip_html | newline_to_br | strip_newlines | replace: '<br />', ' ' | replace: '\', '' | strip | smartify | normalize_whitespace -%}
+{%- capture item -%}
+{
+"title": "{{ section_header | smartify }}",
+"documentTitle": "{%- include_cached document-title.txt dir=page.dir info="title" -%}",
+"url": "{{ section_url | relative_url }}",
+"text": "{{ full_section }}"
+}
+{% endcapture %}
+{%- assign index_array = index_array | push: item -%}
+
+{%- endfor -%}
+{%- endunless -%}
+{%- endunless -%}
+{%- endfor -%}
+
+[{{ index_array | join: ','}}]

data/assets/startup/build.sh

@@ -0,0 +1,18 @@
+---
+---
+#!/bin/bash
+
+echo 'Started script to generate PDFs'
+echo 'Installing node dependencies'
+npm i glob jsdom js-yaml p-all
+if [[ (-z "${PDF_GEN_API_SERVER}") || (-z "${PDF_GEN_API_KEY}") ]]; then
+  npm i html-pdf
+fi
+node _site/assets/startup/pdf-gen.js
+if [ "{{ site.offline_search_only }}" == "true" ]; then
+    node _site/assets/startup/prebuild-lunr-index.js
+    echo 'Generating Lunr Index complete'
+else
+    echo 'Skipping Lunr Index'
+fi
+echo 'End script'

data/assets/startup/docprint.html

@@ -0,0 +1,20 @@
+<!-- layout for printing individual documents-->
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  <link rel="icon" href="./assets/images/favicon.ico">
+  <link rel="stylesheet" href="./assets/styles/normalize.css">
+  <link rel="stylesheet" href="./assets/styles/main.css">
+</head>
+
+<body id=print-content>
+  <div id="main-content" class="site-main">
+  </div>
+</body>
+
+</html>

data/assets/startup/pdf-gen.js

@@ -0,0 +1,309 @@
+const fs = require('fs')
+const fsp = require('fs').promises
+const pAll = require('p-all')
+const https = require('https')
+const glob = require('glob')
+const path = require('path')
+const jsdom = require('jsdom')
+const jsyaml = require('js-yaml')
+const sitePath = __dirname + '/../..'
+
+// Env vars to generate PDFs on AWS Lambda
+let pdfGenVarsPresent = true
+let pdf
+let PDF_GEN_CONCURRENCY
+
+if (process.env.PDF_GEN_API_KEY === undefined || process.env.PDF_GEN_API_SERVER === undefined) {
+    console.log('Env var PDF_GEN_API_KEY or PDF_GEN_API_SERVER for AWS Lambda not present: Generating PDFs locally instead.')
+    pdf = require('html-pdf')
+    pdfGenVarsPresent = false
+    PDF_GEN_CONCURRENCY = 1 // When generating locally make it synchronous
+} else {
+    PDF_GEN_CONCURRENCY = process.env.PDF_GEN_CONCURRENCY !== undefined ?
+        parseInt(process.env.PDF_GEN_CONCURRENCY) :
+        50 // Tuned for Netlify
+    console.log(`Env vars detected: Generating PDFs on AWS Lambda with concurrency of ${PDF_GEN_CONCURRENCY}`)
+}
+
+// These options are only applied when PDFs are built locally
+const localPdfOptions = {
+    height: '594mm',        // allowed units: mm, cm, in, px
+    width: '420mm',
+    base: 'file://' + sitePath + '/',
+    border: {
+        right: '100px', // default is 0, units: mm, cm, in, px
+        left: '100px',
+    },
+    header: {
+        height: '80px',
+    },
+    footer: {
+        height: '80px',
+    },
+}
+
+// List of top-level folder names which may contain html but are not to be printed
+const printIgnoreFolders = ['assets', 'files', 'iframes', 'images']
+// List of top-level .html files which are not to be printed
+const printIgnoreFiles = ['export.html', 'index.html']
+
+// Tracking statistics
+let numPdfsStarted = 0
+let numPdfsError = 0
+let numPdfsSuccess = 0
+let numTotalPdfs = 0
+const TIMER = 'Time to create PDFs'
+
+const main = async () => {
+
+    // creating exports of individual documents
+    console.time(TIMER)
+    const docFolders = getDocumentFolders(sitePath, printIgnoreFolders)
+    await exportPdfTopLevelDocs(sitePath)
+    await exportPdfDocFolders(sitePath, docFolders)
+    console.log(`PDFs created with success:${numPdfsSuccess} error:${numPdfsError} total:${numTotalPdfs}`)
+    console.timeEnd(TIMER)
+}
+
+const exportPdfTopLevelDocs = async (sitePath) => {
+    let htmlFilePaths = glob.sync('*.html', { cwd: sitePath })
+    htmlFilePaths = htmlFilePaths.filter((filepath) => !printIgnoreFiles.includes(filepath))
+    htmlFilePaths = htmlFilePaths.map((filepath) => path.join(sitePath, filepath))
+    // Remove folders without HTML files (don't want empty pdfs)
+    if (htmlFilePaths.length === 0) return
+    numTotalPdfs++
+    const configFilepath = path.join(sitePath, '..', '_config.yml')
+    if (configFileHasValidOrdering(configFilepath)) {
+        const configYml = yamlToJs(configFilepath)
+        htmlFilePaths = reorderHtmlFilePaths(htmlFilePaths, configYml.order)
+    }
+    await createPdf(htmlFilePaths, sitePath)
+}
+
+const exportPdfDocFolders = (sitePath, docFolders) => {
+    const actions = []
+    for (let folder of docFolders) {
+        // find all the folders containing html files
+        const folderPath = path.join(sitePath, folder)
+        let htmlFilePaths = glob.sync('*.html', { cwd: folderPath })
+        htmlFilePaths = htmlFilePaths.filter((filepath) => !printIgnoreFiles.includes(filepath))
+        htmlFilePaths = htmlFilePaths.map((filepath) => path.join(folderPath, filepath))
+
+        // Remove folders without HTML files (don't want empty pdfs)
+        if (htmlFilePaths.length === 0) return
+        numTotalPdfs++
+        const indexFilepath = path.join(sitePath, '..', folder, 'index.md')
+        if (indexFileHasValidOrdering(indexFilepath)) {
+            const configMd = markdownToJs(indexFilepath)
+            const order = configMd.order
+            htmlFilePaths = reorderHtmlFilePaths(htmlFilePaths, order)
+        }
+        actions.push((() => createPdf(htmlFilePaths, folderPath)))
+    }
+    return pAll(actions, { concurrency: PDF_GEN_CONCURRENCY })
+}
+
+// Concatenates the contents in .html files, and outputs export.pdf in the specified output folder
+const createPdf = (htmlFilePaths, outputFolderPath) => {
+    logStartedPdf(outputFolderPath)
+    // docprint.html is our template to build pdf up from.
+    const exportHtmlFile = fs.readFileSync(__dirname + '/docprint.html')
+    const exportDom = new jsdom.JSDOM(exportHtmlFile)
+    const exportDomBody = exportDom.window.document.body
+    const exportDomMain = exportDom.window.document.getElementById('main-content')
+    let addedTitle = false
+    let addedDocTitle = false
+
+    htmlFilePaths.forEach(function (filePath) {
+        const file = fs.readFileSync(filePath)
+        const dom = new jsdom.JSDOM(file, {
+            resources: 'usable' // to get JSDOM to load stylesheets
+        })
+
+        // html-pdf can't deal with these
+        removeTagsFromDom(dom, 'script')
+        removeTagsFromDom(dom, 'iframe')
+
+        // If a <img src=...> link src begins with '/', it is a relative link
+        // and needs to be prepended with '.' to show up in the pdf. Does not
+        // work for Lambda functions as the images are not available server side.
+        const imgsrcs = dom.window.document.getElementsByTagName('img')
+        for (let i = 0; i < imgsrcs.length; i++) {
+            const imgsrc = imgsrcs[i]
+            if (imgsrc.src.startsWith('/')) {
+                imgsrc.src = '.' + imgsrc.src
+            } else if (imgsrc.src.startsWith('.')) {
+                imgsrc.src = outputFolderPath + imgsrc.src.substr(1)
+            }
+        }
+
+        // Site titles needs only be added once
+        if (!addedTitle) {
+            try {
+                const oldTitle = dom.window.document.getElementsByClassName('site-header-text')[0]
+                exportDomBody.insertBefore(oldTitle, exportDomMain)
+                addedTitle = true
+            } catch (error) {
+                console.log('Failed to append Title, skipping: ' + error)
+            }
+        }
+        // Document titles too
+        if (!addedDocTitle) {
+            try {
+                const oldDocTitle = dom.window.document.getElementsByClassName('description-container')[0]
+                exportDomBody.insertBefore(oldDocTitle, exportDomMain)
+                const hr = dom.window.document.createElement('HR')
+                exportDomBody.insertBefore(hr, exportDomMain)
+                addedDocTitle = true
+            } catch (error) {
+                console.log('Failed to append Doc Title, skipping: ' + error)
+            }
+        }
+
+        // Concat all the id:main-content divs
+        try {
+            const oldNode = dom.window.document.getElementById('main-content')
+            exportDomMain.innerHTML += oldNode.innerHTML
+        } catch (error) {
+            console.log('Failed to append Node, skipping: ' + error)
+        }
+        dom.window.close()
+    })
+
+    if (!pdfGenVarsPresent) {
+        return new Promise((resolve, reject) => {
+            pdf.create(exportDom.serialize(), localPdfOptions).toFile(path.join(outputFolderPath, 'export.pdf'), (err, res) => {
+                if (err) {
+                    logErrorPdf('Creating PDFs locally', err)
+                    return reject()
+                }
+                logSuccessPdf(res.filename)
+                resolve()
+            })
+            exportDom.window.close()
+        })
+    } else {
+        // Code for this API lives at https://github.com/opendocsg/pdf-lambda
+        const requestOptions = {
+            method: 'POST',
+            responseType: 'arraybuffer',
+            headers: {
+                'x-api-key': process.env.PDF_GEN_API_KEY,
+                'content-type': 'application/json',
+            },
+        }
+        return new Promise(function(resolve, reject) {
+            const request = https.request(process.env.PDF_GEN_API_SERVER, requestOptions, function(res) {
+                if (res.statusCode < 200 || res.statusCode >= 300) {
+                    logErrorPdf('Request status code', res.statusCode)
+                    reject()
+                }
+                const chunks = []
+                res.on('data', function(d) {
+                    chunks.push(d)
+                })
+                res.on('end', function() {
+                    const buf = Buffer.concat(chunks)
+                    resolve(buf)
+                })
+            })
+            request.on('error', (err) => {
+                logErrorPdf('Request encountered error', err)
+                reject()
+            })
+            // POST request body
+            request.write(JSON.stringify({
+                'serializedDom': exportDom.serialize()
+            }))
+            request.end()
+            exportDom.window.close()
+        }).then((buffer) => {
+            const outputPdfPath = path.join(outputFolderPath, 'export.pdf')
+            return fsp.writeFile(outputPdfPath, buffer)
+                .then(() => {
+                    logSuccessPdf(outputPdfPath)
+                }).catch((err) => {
+                    logErrorPdf('Writing out file', err)
+                })
+        }).catch((error) => {
+            logErrorPdf('Request promise', error)
+        })
+    }
+}
+
+const logStartedPdf = (outputFolderPath) => {
+    numPdfsStarted++
+    console.log(`createpdf started for:${outputFolderPath} (${numPdfsStarted}/${numTotalPdfs})`)
+}
+
+const logErrorPdf = (origin, error) => {
+    numPdfsError++
+    console.log(`createpdf error for: ${origin}: ${error}(${numPdfsError}/${numTotalPdfs})`)
+}
+
+const logSuccessPdf = (outputPdfPath) => {
+    numPdfsSuccess++
+    console.log(`createpdf success for:${outputPdfPath} (${numPdfsSuccess}/${numTotalPdfs})`)
+}
+
+// Returns a list of the valid document (i.e. folder) paths
+const getDocumentFolders = (sitePath, printIgnoreFolders) => {
+    return fs.readdirSync(sitePath).filter(function (filePath) {
+        return fs.statSync(path.join(sitePath, filePath)).isDirectory() &&
+            !printIgnoreFolders.includes(filePath)
+    })
+}
+
+// Returns true if config file contains section_order field
+const configFileHasValidOrdering = (configFilepath) => {
+    try {
+        const configYml = yamlToJs(configFilepath)
+        return 'order' in configYml
+    } catch (error) {
+        return false
+    }
+}
+
+// Returns true if index.md exists and contains order field
+const indexFileHasValidOrdering = (indexFilepath) => {
+    try {
+        const configMd = markdownToJs(indexFilepath)
+        return 'order' in configMd
+    } catch (error) {
+        return false
+    }
+}
+
+// Mutates the htmlFilepath array to match order provided in order
+const reorderHtmlFilePaths = (htmlFilePaths, order) => {
+    const orderedHtmlFilePaths = []
+    for (let i = 0; i < order.length; i++) {
+        const name = path.basename(order[i], '.md')
+        htmlFilePaths.some((filePath) => {
+            if (path.basename(filePath, '.html') === name) {
+                orderedHtmlFilePaths.push(filePath)
+            }
+        })
+    }
+    return orderedHtmlFilePaths
+}
+
+// Removes <tag></tag> from dom and everything in between them
+const removeTagsFromDom = (dom, tagname) => {
+    const tags = dom.window.document.getElementsByTagName(tagname)
+    for (let i = tags.length - 1; i >= 0; i--) {
+        tags[i].parentNode.removeChild(tags[i])
+    }
+}
+
+// converts .md to JS Object
+const markdownToJs = (filepath) => {
+    const configString = fs.readFileSync(filepath).toString().replace(/---/g, '')
+    return jsyaml.safeLoad(configString)
+}
+
+const yamlToJs = (filepath) => {
+    return jsyaml.safeLoad(fs.readFileSync(filepath))
+}
+
+main()