280 lines
8.6 KiB
JavaScript
280 lines
8.6 KiB
JavaScript
import { Node } from './node'
|
|
import { Transformer } from './transformer'
|
|
import { unified } from 'unified'
|
|
import markdown from 'remark-parse'
|
|
import { toString } from 'mdast-util-to-string'
|
|
import path from 'path'
|
|
import fs from 'fs'
|
|
|
|
import * as dirTree from 'directory-tree'
|
|
|
|
class Util {
|
|
_counter
|
|
cachedSlugMap
|
|
|
|
constructor() {
|
|
this._counter = 0
|
|
this.cachedSlugMap = this.getSlugHashMap()
|
|
}
|
|
|
|
/**
|
|
* @returns {string | null}
|
|
* */
|
|
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
|
|
getContent(slug) {
|
|
const currentFilePath = this.toFilePath(slug)
|
|
if (currentFilePath === undefined || currentFilePath == null) return null
|
|
return Node.readFileSync(currentFilePath)
|
|
}
|
|
|
|
getShortSummary(slug) {
|
|
const content = this.getContent(slug)
|
|
if (content === undefined || content === null) {
|
|
return
|
|
}
|
|
|
|
const tree = unified().use(markdown)
|
|
.parse(content)
|
|
const plainText = toString(tree)
|
|
return plainText.split(' ').splice(0, 40).join(' ')
|
|
}
|
|
|
|
getAllMarkdownFiles() {
|
|
return Node.getFiles(Node.getMarkdownFolder())
|
|
}
|
|
|
|
getSinglePost(slug) {
|
|
// List of filenames that will provide existing links to wikilink
|
|
const currentFilePath = this.toFilePath(slug)
|
|
// console.log("currentFilePath: ", currentFilePath)
|
|
|
|
const fileContent = Node.readFileSync(currentFilePath)
|
|
|
|
// const currentFileFrontMatter = Transformer.getFrontMatterData(fileContent)
|
|
// console.log("===============\n\nFile is scanning: ", slug)
|
|
const [htmlContent] = Transformer.getHtmlContent(fileContent)
|
|
// console.log("==================================")
|
|
// console.log("hrmlcontents and backlinks")
|
|
return {
|
|
id: slug,
|
|
// ...currentFileFrontMatter,
|
|
data: htmlContent
|
|
}
|
|
}
|
|
|
|
toFilePath(slug) {
|
|
return this.cachedSlugMap[slug]
|
|
}
|
|
|
|
getSlugHashMap() {
|
|
// This is to solve problem of converting between slug and filepath,
|
|
// where previously if I convert a slug to a file path sometime
|
|
// it does not always resolve to correct filepath, converting function is not bi-directional
|
|
// and not conflict-free, other solution was considered (hash file name into a hash, but this
|
|
// is not SEO-friendly and make url look ugly ==> I chose this
|
|
|
|
const slugMap = new Map()
|
|
this.getAllMarkdownFiles().forEach(aFile => {
|
|
const aSlug = this.toSlug(aFile)
|
|
// if (slugMap.has(aSlug)) {
|
|
// slugMap[aSlug].push(aFile)
|
|
// } else {
|
|
// slugMap[aSlug] = [aFile]
|
|
// }
|
|
// Note: [Future improvement] Resolve conflict
|
|
slugMap[aSlug] = aFile
|
|
})
|
|
|
|
const indexFile = '/🌎 Home.md'
|
|
slugMap.index = Node.getMarkdownFolder() + indexFile
|
|
slugMap['/'] = Node.getMarkdownFolder() + indexFile
|
|
|
|
return slugMap
|
|
}
|
|
|
|
toSlug(filePath) {
|
|
const markdownFolder = Node.getMarkdownFolder()
|
|
const isFile = Node.isFile(filePath)
|
|
const isMarkdownFolder = filePath.includes(markdownFolder)
|
|
|
|
if (isFile && Boolean(isMarkdownFolder)) {
|
|
return filePath.replace(markdownFolder, '')
|
|
.replaceAll('/', '_')
|
|
.replaceAll(' ', '+')
|
|
.replaceAll('&', '-')
|
|
.replace('.md', '')
|
|
} else {
|
|
// TODO handle this properly
|
|
return '/'
|
|
}
|
|
}
|
|
|
|
constructGraphData() {
|
|
const filepath = path.join(process.cwd(), 'graph-data.json')
|
|
if (Node.isFile(filepath)) {
|
|
const data = fs.readFileSync(filepath)
|
|
return JSON.parse(String(data))
|
|
} else {
|
|
const filePaths = this.getAllMarkdownFiles()
|
|
const edges = []
|
|
const nodes = []
|
|
filePaths
|
|
.forEach(aFilePath => {
|
|
// const {currentFilePath} = getFileNames(filename)
|
|
const aNode = {
|
|
title: Transformer.parseFileNameFromPath(aFilePath),
|
|
slug: this.toSlug(aFilePath),
|
|
shortSummary: this.getShortSummary(this.toSlug(aFilePath))
|
|
}
|
|
nodes.push(aNode)
|
|
|
|
// console.log("Constructing graph for node: " + aFilePath )
|
|
const internalLinks = Transformer.getInternalLinks(aFilePath)
|
|
internalLinks.forEach(aLink => {
|
|
if (aLink.slug === null || aLink.slug.length === 0) return
|
|
|
|
const anEdge = {
|
|
source: this.toSlug(aFilePath),
|
|
target: aLink.slug
|
|
}
|
|
edges.push(anEdge)
|
|
// console.log("Source: " + anEdge.source)
|
|
// console.log("Target: " + anEdge.target)
|
|
})
|
|
// console.log("==============Constructing graph" )
|
|
}
|
|
)
|
|
const data = { nodes, edges }
|
|
fs.writeFileSync(filepath, JSON.stringify(data), 'utf-8')
|
|
return data
|
|
}
|
|
}
|
|
|
|
getLocalGraphData(currentNodeId) {
|
|
const { nodes, edges } = constructGraphData()
|
|
|
|
const newNodes = nodes.map(aNode => (
|
|
{
|
|
data: {
|
|
id: aNode.slug.toString(),
|
|
label: Transformer.parseFileNameFromPath(this.toFilePath(aNode.slug))
|
|
}
|
|
}
|
|
))
|
|
|
|
const newEdges = edges.map(anEdge => ({
|
|
data: {
|
|
source: anEdge.source,
|
|
target: anEdge.target
|
|
}
|
|
}))
|
|
|
|
const existingNodeIDs = newNodes.map(aNode => aNode.data.id)
|
|
currentNodeId = currentNodeId === 'index' ? '__index' : currentNodeId
|
|
if (currentNodeId != null && Boolean(existingNodeIDs.includes(currentNodeId))) {
|
|
const outGoingNodeIds = newEdges
|
|
.filter(anEdge => anEdge.data.source === currentNodeId)
|
|
.map(anEdge => anEdge.data.target)
|
|
|
|
const incomingNodeIds = newEdges
|
|
.filter(anEdge => anEdge.data.target === currentNodeId)
|
|
.map(anEdge => anEdge.data.source)
|
|
|
|
outGoingNodeIds.push(currentNodeId)
|
|
|
|
const localNodeIds = incomingNodeIds.concat(outGoingNodeIds.filter(item => incomingNodeIds.indexOf(item) < 0))
|
|
if (localNodeIds.indexOf(currentNodeId) < 0) {
|
|
localNodeIds.push(currentNodeId)
|
|
}
|
|
|
|
const localNodes = newNodes.filter(aNode => localNodeIds.includes(aNode.data.id))
|
|
let localEdges = newEdges.filter(edge => localNodeIds.includes(edge.data.source)).filter(edge => localNodeIds.includes(edge.data.target))
|
|
|
|
// Filter self-reference edges
|
|
localEdges = localEdges.filter(edge => edge.data.source !== edge.data.target)
|
|
|
|
// TODO: Find out why target ==='/' in some case
|
|
localEdges = localEdges.filter(edge => edge.data.target !== '/')
|
|
return {
|
|
nodes: localNodes,
|
|
edges: localEdges
|
|
}
|
|
} else {
|
|
const filteredEdges = newEdges
|
|
.filter(edge => existingNodeIDs.includes(edge.data.source))
|
|
.filter(edge => existingNodeIDs.includes(edge.data.target))
|
|
|
|
return {
|
|
nodes: newNodes,
|
|
edges: filteredEdges
|
|
}
|
|
}
|
|
}
|
|
|
|
getAllSlugs() {
|
|
// console.log("\n\nAll Posts are scanning")
|
|
// Get file names under /posts
|
|
const markdownFolder = Node.getMarkdownFolder()
|
|
const markdownFiles = Node.getFiles(markdownFolder)
|
|
const filePaths = markdownFiles.filter(file => !(Boolean(file.endsWith('index')) || Boolean(file.endsWith('sidebar'))))
|
|
return filePaths.map(f => this.toSlug(f))
|
|
}
|
|
|
|
getDirectoryData() {
|
|
const filteredDirectory = dirTree(Node.getMarkdownFolder(), { extensions: /\.md/, exclude: [/\.git/, /\.obsidian/] })
|
|
return this.convertObject(filteredDirectory)
|
|
}
|
|
|
|
convertObject(thisObject) {
|
|
const children = []
|
|
const slugs = this.getAllSlugs()
|
|
|
|
function findFunc(slug) {
|
|
const fileName = Transformer.parseFileNameFromPath(this.toFilePath(slug))
|
|
return Transformer.normalizeFileName(fileName) === Transformer.normalizeFileName(thisObject.name)
|
|
}
|
|
|
|
const foundSlugs = slugs.find(slug => findFunc(slug))
|
|
|
|
let routerPath = foundSlugs !== (null | undefined) ? foundSlugs : null
|
|
|
|
routerPath = routerPath !== (null | undefined) ? '/notes/' + routerPath : null
|
|
const newObject = {
|
|
name: thisObject.name,
|
|
children,
|
|
id: (this._counter++).toString(),
|
|
routePath: routerPath !== (null | undefined) ? routerPath : null
|
|
}
|
|
|
|
if (thisObject.children != null && thisObject.children.length > 0) {
|
|
thisObject.children.forEach(aChild => {
|
|
const newChild = this.convertObject(aChild)
|
|
children.push(newChild)
|
|
})
|
|
return newObject
|
|
} else {
|
|
return newObject
|
|
}
|
|
}
|
|
|
|
flat = (array) => {
|
|
let result = []
|
|
const outerThis = this
|
|
// eslint-disable-next-line @typescript-eslint/space-before-function-paren
|
|
array.forEach(function(a) {
|
|
result.push(a)
|
|
if (Array.isArray(a.children)) {
|
|
result = result.concat(outerThis.flat(a.children))
|
|
}
|
|
})
|
|
return result
|
|
}
|
|
|
|
getFlattenArray(thisObject) {
|
|
return this.flat(thisObject.children)
|
|
}
|
|
}
|
|
|
|
const util = new Util()
|
|
export default util
|