@tenjuu99/blog 0.1.9 → 0.1.10

package/lib/applyTemplate.js

@@ -1,8 +1,8 @@
 "use strict"
-import fs from "node:fs/promises";
 import applyCss from './cssGenerator.js'
-import { includeFilter } from './filter.js'
+import includeFilter from './includeFilter.js'
 import { templateDir, cssDir } from './dir.js'
+import { staticFile, staticFiles, warmUp } from './files.js'
 import { watchers } from './watcher.js'
 
 let templates = {}
@@ -11,16 +11,24 @@ const applyTemplate = async (name = 'default.html') => {
   if (templates[name]) {
     return templates[name]
   }
-  let templateContent = await fs.readFile(`${templateDir}/${name}`, 'utf8')
-  templateContent = await includeFilter(templateContent)
+  let templateContent = await staticFile(`template/${name}`)
+  templateContent = includeFilter(templateContent)
   templateContent = await applyCss(templateContent)
   templates[name] = templateContent
   return templateContent
 }
 
+const warmUpTemplate = async () => {
+  await warmUp()
+  const templates = staticFiles()
+    .filter(file => file[0].indexOf('template/') === 0)
+    .map(f => applyTemplate(f[0].split('/')[1]))
+  await Promise.all(templates)
+}
+
 watchers.push({
   paths: [cssDir, templateDir],
   callback: () => { templates = {} }
 })
 
-export default applyTemplate
+export { applyTemplate, warmUpTemplate }

package/lib/cssGenerator.js

@@ -1,9 +1,10 @@
 "use strict"
 import fs from "node:fs/promises";
+import { staticFile } from './files.js'
 import { minifyCss } from './minify.js'
 import { createHash } from 'crypto'
 import path from 'path'
-import { distDir as distRoot, cssDir } from './dir.js'
+import { distDir, cssDir } from './dir.js'
 import { watchers } from './watcher.js'
 import { styleText } from 'node:util'
 import config from './config.js'
@@ -26,14 +27,14 @@ const cssGenerator = async (src, dist) => {
   }
   let css = ''
   for (const cssFile of src.split(',')) {
-    css += await fs.readFile(`${cssDir}/${cssFile}`)
+    css += staticFile(`css/${cssFile}`)
   }
   css = minifyCss(css)
   cacheBuster[key] = createHash('md5').update(css).digest('hex')
 
-  return await fs.mkdir(`${distRoot}${path.dirname(dist)}`, { recursive: true }).then(() => {
-    fs.writeFile(`${distRoot}${dist}`, css)
-    console.log(styleText('green', '[generate]'), `${src} => ${distRoot}${dist}`)
+  return await fs.mkdir(`${distDir}${path.dirname(dist)}`, { recursive: true }).then(() => {
+    fs.writeFile(`${distDir}${dist}`, css)
+    console.log(styleText('green', '[generate]'), `${src} => ${distDir}${dist}`)
     return cacheBuster[key]
   })
 }

package/lib/distribute.js

@@ -1,23 +1,33 @@
 "use strict"
 import fs from "node:fs/promises";
+import { existsSync, mkdirSync } from "node:fs";
 import path from 'path'
 import { minifyHtml } from './minify.js'
 import render from './render.js'
 import { styleText } from 'node:util'
 import config from './config.js'
+import { cacheDir } from './dir.js'
+import { applyTemplate, warmUpTemplate } from './applyTemplate.js'
 
-const distribute = async (data, deleted, srcDir, distDir) => {
-  if (deleted) {
-    for (const obj of deleted) {
-      console.log(styleText('red', '[unlink]'), `${distDir}${obj.__output}`)
-      fs.unlink(`${distDir}${obj.__output}`)
-    }
-    delete data['__deleted']
-  }
+const indexFile = `${cacheDir}/index.json`
+
+const renderPage = async (page) => {
+  const template = page.template
+  return [page.name, await render(template, page)]
+}
+
+const distribute = async (data, srcDir, distDir) => {
+  await warmUpTemplate()
+  const promises = []
+  const newIndex = []
   for (const name in data) {
-    const template = data[name].template
-    const rendered = await render(template, data[name])
-    let writeTo = `${distDir}${data[name].__output}`
+    promises.push(renderPage(data[name]))
+    newIndex.push({ name: data.name, url: data.url, __output: data.__output })
+  }
+  const renderedString = await Promise.all(promises)
+  for (const page of renderedString) {
+    const [ pageName, rendered ] = page
+    let writeTo = `${distDir}${data[pageName].__output}`
     fs.mkdir(path.dirname(writeTo), { recursive: true}).then(() => {
       fs.writeFile(writeTo, minifyHtml(rendered))
       console.log(styleText('green', '[generate]'), writeTo)
@@ -33,6 +43,25 @@ const distribute = async (data, deleted, srcDir, distDir) => {
       })
     })
   })
+
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir)
+  }
+  fs.readFile(indexFile, 'utf8')
+    .then(text => {
+      const oldIndex = JSON.parse(text)
+      deleted = oldIndex.filter(oi => !newIndex.map(ni => ni.__output).includes(oi.__output))
+      fs.writeFile(indexFile, JSON.stringify(newIndex))
+      if (deleted) {
+        for (const obj of deleted) {
+          console.log(styleText('red', '[unlink]'), `${distDir}${obj.__output}`)
+          fs.unlink(`${distDir}${obj.__output}`)
+        }
+      }
+    })
+    .catch(error => {
+      fs.writeFile(indexFile, JSON.stringify(newIndex))
+    })
 }
 
 export default distribute

package/lib/files.js

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import { templateDir, cssDir } from './dir.js'
+import { watchers } from './watcher.js'
+
+let staticFilesContainer = {}
+let loaded = false
+
+const warmUp = async () => {
+  if (loaded) {
+    return
+  }
+  const templateFiles = await fs.readdir(templateDir).then(files => files.map(f => [`template/${f}`, `${templateDir}/${f}`]))
+  const cssFiles = await fs.readdir(cssDir).then(files => files.map(f => [`css/${f}`, `${cssDir}/${f}`]))
+  const files = [...templateFiles, ...cssFiles]
+  const loadFiles = files.map(file => fs.readFile(file[1], 'utf8').then(content => [file[0], content]))
+  staticFilesContainer = Object.fromEntries(await Promise.all(loadFiles))
+  loaded = true
+}
+
+const staticFile = (name) => {
+  if (!loaded) {
+    throw new Error('not initialized')
+  }
+  if (staticFilesContainer[name]) {
+    return staticFilesContainer[name]
+  }
+  if (name.indexOf('template/') === 0) {
+    return fs.readFile(templateDir + '/' + name.replace('template/', ''))
+  }
+}
+
+const staticFiles = () => {
+  return Object.entries(staticFilesContainer)
+}
+watchers.push({
+  paths: [cssDir, templateDir],
+  callback: async () => {
+    loaded = false
+    await warmUp()
+  }
+})
+
+export { staticFile, staticFiles, warmUp }

package/lib/filter.js

@@ -1,5 +1,4 @@
 import helper from '../lib/helper.js'
-import includeFilter from './includeFilter.js'
 import { srcDir } from './dir.js'
 import config from './config.js'
 import replaceVariablesFilter from './replaceVariablesFilter.js'
@@ -122,6 +121,5 @@ const replaceScriptFilter = async (text, variables) => {
 export {
   replaceIfFilter,
   replaceScriptFilter,
-  replaceVariablesFilter,
-  includeFilter
+  replaceVariablesFilter
 }

package/lib/generate.js

@@ -1,16 +1,19 @@
 "use strict"
 import distribute from './distribute.js'
-import { indexing, allData, deleted } from './indexer.js'
+import { indexing, allData } from './indexer.js'
 import { srcDir, distDir } from './dir.js'
 import { styleText } from 'node:util'
 
 const generate = async () => {
-  const start = performance.now()
+  let start = performance.now()
   await indexing()
+  let end = performance.now()
+  console.log(styleText('blue', '[indexing: ' + (end - start) + "ms]"))
 
-  await distribute(allData, deleted, srcDir, distDir)
-  const end = performance.now()
-  console.log(styleText('blue', '[build: ' + (end - start) + "ms]"))
+  start = performance.now()
+  await distribute(allData, srcDir, distDir)
+  end = performance.now()
+  console.log(styleText('blue', '[distribute: ' + (end - start) + "ms]"))
 }
 
 export default generate

package/lib/includeFilter.js

@@ -1,31 +1,31 @@
-import fs from "node:fs/promises";
 import { minifyCss } from './minify.js'
 import { templateDir, cssDir } from './dir.js'
+import { staticFile } from './files.js'
 
 const alreadyLoaded = {}
 
-const includeFilter = async (text) => {
+const includeRegexp = new RegExp(/\{\s*include\('(template|css)\/([\w\./]+)'\)\s*\}/g)
+
+const includeFilter = (text) => {
   let replaced = text
-  const includeRegexp = new RegExp(/\{\s*include\('(template|css)\/([\w\./]+)'\)\s*\}/g)
-  const include = [...text.matchAll(includeRegexp)].map(matched => [matched[0], matched[1], matched[2]])
+  const include = [...text.matchAll(includeRegexp)].map(matched => {
+    return { toBeReplace: matched[0], type: matched[1], filename: matched[2] }
+  })
+  if (include.length === 0) {
+    return replaced
+  }
   for (const index in include) {
-    const [toBeReplace, type, filename] = [...include[index]]
+    const {toBeReplace, type, filename} = include[index]
     let content
     const cacheKey = `${type}/${filename}`
     if (!alreadyLoaded[cacheKey]) {
-      switch (type) {
-        case 'template':
-          content = await fs.readFile(`${templateDir}/${filename}`, 'utf8')
-          break
-        case 'css':
-          content = await fs.readFile(`${cssDir}/${filename}`, 'utf8')
-          break
-        default:
-          throw new Error('type does not match neither `template` nor `css`.');
+      content = staticFile(cacheKey)
+      if (typeof content === 'undefined') {
+        throw new Error(cacheKey + ' is not found')
       }
       // include を再帰的に解決する
       if (content.match(includeRegexp)) {
-        content = await includeFilter(content)
+        content = includeFilter(content)
       }
       alreadyLoaded[cacheKey] = content
     } else {

package/lib/indexer.js

@@ -1,45 +1,40 @@
 "use strict"
-import { writeFile, readFile } from "node:fs/promises";
-import { readdirSync, existsSync, mkdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { readdirSync } from "node:fs";
 import { pageDir, cacheDir } from './dir.js'
 import makePageData from './pageData.js'
 
-const indexFile = `${cacheDir}/index.json`
-
-let newIndex = []
 let allData = {}
-let deleted = []
 
-const collect = (dir, files = {}, namePrefix = '') => {
+/**
+ * @param {string} dir
+ * @param {string} namePrefix
+ * @param {Array<Promise>} promises
+ * @return {Promise<string[]>[]}
+ */
+const collect = (dir, namePrefix = '', promises = []) => {
   const dirents = readdirSync(dir, { withFileTypes: true })
   dirents.forEach((dirent) => {
     if (dirent.isDirectory()) {
-      collect(`${dirent.path}/${dirent.name}`, files, namePrefix + dirent.name + '/')
+      collect(`${dirent.path}/${dirent.name}`, namePrefix + dirent.name + '/', promises)
     } else {
       if (dirent.name.match(/\.(md|html)$/)) {
-        const pageData = makePageData(`${namePrefix}${dirent.name}`)
-        allData[pageData.name] = pageData
-        const { name, url, __output } = pageData
-        newIndex.push({ name, url, __output })
+        const name = `${namePrefix}${dirent.name}`
+        promises.push(readFile(`${dir}/${dirent.name}`, 'utf8').then(f => [name, f]))
       }
     }
   })
+  return promises
 }
 
 const indexing = async () => {
-  newIndex = []
   allData = {}
-  deleted = []
-  if (!existsSync(cacheDir)) {
-    mkdirSync(cacheDir)
-  }
-  const oldIndex = await readFile(indexFile, 'utf8').then(text => JSON.parse(text)).catch(error => [])
-
-  collect(pageDir)
-  writeFile(indexFile, JSON.stringify(newIndex))
 
-  // 旧インデックスから差分を計算して削除対象をピックアップする
-  deleted = oldIndex.filter(oi => !newIndex.map(ni => ni.__output).includes(oi.__output))
+  const files = await Promise.all(collect(pageDir))
+  files.forEach((file) => {
+    const pageData = makePageData(file[0], file[1])
+    allData[pageData.name] = pageData
+  })
 }
 
-export { indexing, allData, deleted }
+export { indexing, allData }

package/lib/pageData.js

@@ -1,14 +1,7 @@
 "use strict"
-import fs from "node:fs";
-import { pageDir } from './dir.js'
 import config from './config.js'
 
-const load = (path) => {
-  return fs.readFileSync(path, 'utf8')
-}
-
-const makePageData = (filename) => {
-  const content = load(`${pageDir}/${filename}`)
+const makePageData = (filename, content) => {
   const [name, ext] = filename.split('.')
   return parse(content, name, ext)
 }
@@ -53,12 +46,6 @@ const parse = (content, name, ext) => {
     })
   )
   const metaDataMerged = Object.assign(metaDataDefault, metaData)
-  if (!metaDataMerged.description) {
-    metaDataMerged.description = markdownReplaced.replace(/(<([^>]+)>)/gi, '').slice(0, 200).replaceAll("\n", '') + '...'
-  }
-  if (!metaDataMerged.og_description) {
-    metaDataMerged.og_description = metaDataMerged.og_description
-  }
   metaDataMerged['__output'] = name === 'index' ? '/index.html' : `${metaDataMerged.url}.${metaDataMerged.ext}`
 
   return metaDataMerged

package/lib/render.js

@@ -1,11 +1,11 @@
 import {
   replaceIfFilter,
   replaceScriptFilter,
-  replaceVariablesFilter,
-  includeFilter
+  replaceVariablesFilter
 } from './filter.js'
+import includeFilter from './includeFilter.js'
 import { marked } from "marked";
-import applyTemplate from './applyTemplate.js'
+import { applyTemplate } from './applyTemplate.js'
 
 const render = async (templateName, data) => {
   let template = await applyTemplate(templateName)
@@ -13,11 +13,15 @@ const render = async (templateName, data) => {
   template = await replaceScriptFilter(template, data)
 
   let markdown = data.markdown
-  markdown = await includeFilter(markdown)
+  markdown = includeFilter(markdown)
   markdown = await replaceIfFilter(markdown, data)
   markdown = await replaceScriptFilter(markdown, data)
   markdown = replaceVariablesFilter(markdown, data)
   data.markdown = data.__filetype === 'md' ? marked.parse(markdown) : markdown
+  if (!data.description) {
+    data.description = data.markdown.replaceAll("\n", '').replace(/(<([^>]+)>)/gi, '').slice(0, 150) + '...'
+    data.og_description = data.description
+  }
 
   return replaceVariablesFilter(template, data)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenjuu99/blog",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "blog template",
   "main": "index.js",
   "scripts": {

package/src-sample/pages/post/1.md

@@ -0,0 +1 @@
+top > [post](/post/) > /post/1

package/src-sample/pages/post/2.md

@@ -0,0 +1 @@
+top > [post](/post/) > /post/2

package/src-sample/pages/post/3.md

@@ -0,0 +1 @@
+top > [post](/post/) > /post/3

package/src-sample/pages/post/index.md

@@ -0,0 +1,7 @@
+---
+title: 投稿一覧
+---
+<script type="ssg">
+  variables.postPages = helper.readIndex().filter(v => v.url.indexOf('/post/') === 0)
+</script>
+{{ renderIndex(postPages) }}