methanol 0.0.20 → 0.0.22

package/src/feed.js

@@ -63,15 +63,6 @@ const wrapCdata = (value) => {
 	return `<![CDATA[${text.replace(/]]>/g, ']]]]><![CDATA[>')}]]>`
 }
 
-const escapeXml = (value) => {
-	const text = value == null ? '' : String(value)
-	if (!text) return ''
-	return text
-		.replace(/&/g, '&amp;')
-		.replace(/</g, '&lt;')
-		.replace(/>/g, '&gt;')
-}
-
 const resolveSiteUrl = (options, site) => {
 	if (options?.siteUrl) return options.siteUrl
 	if (state.SITE_BASE) return state.SITE_BASE
@@ -86,10 +77,10 @@ const buildItem = (page, siteUrl, htmlContent = null, isAtom = false, siteOwner
 	const link = new URL(href, siteUrl).href
 	const title = page.title || page.name || page.routePath || link
 	const description = extractExcerpt(page)
-	const contentSource = htmlContent || page.content || ''
+	const contentSource = htmlContent ?? page.content ?? ''
 	const content = contentSource
 		? (isAtom
-			? HTMLRenderer.rawHTML(escapeXml(contentSource))
+			? contentSource
 			: HTMLRenderer.rawHTML(wrapCdata(contentSource)))
 		: null
 	const authorValue = page.frontmatter?.author
@@ -183,7 +174,7 @@ export const generateRssFeed = async (pagesContext, rssContent = null) => {
 	const items = pages
 		.map((page) => ({
 			page,
-			content: rssContent?.get(page.path) || rssContent?.get(page.routePath) || null
+			content: rssContent?.get(page.path) ?? rssContent?.get(page.routePath) ?? null
 		}))
 		.map((entry) => buildItem(entry.page, siteUrl, entry.content, isAtom, siteOwner))
 		.filter(Boolean)

package/src/html/build-html.js

@@ -0,0 +1,221 @@
+/* Copyright Yukino Song, SudoMaker Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { writeFile, mkdir, rm } from 'fs/promises'
+import { resolve, dirname, relative, posix } from 'path'
+import { normalizePath } from 'vite'
+import { state } from '../state.js'
+import { hashMd5 } from './utils.js'
+
+const ensureDir = async (dir) => {
+	await mkdir(dir, { recursive: true })
+}
+
+const METHANOL_DIR = '.methanol'
+const ENTRY_DIR = 'entries'
+
+const resolveMethanolDir = () => resolve(state.PAGES_DIR, METHANOL_DIR)
+
+export async function scanHtmlEntries(entries, preScan = null, options = null) {
+	const methanolDir = resolveMethanolDir()
+	const entriesDir = resolve(methanolDir, ENTRY_DIR)
+	const assetsEntryPath = resolve(methanolDir, 'assets-entry.js')
+	await rm(entriesDir, { recursive: true, force: true })
+	await ensureDir(entriesDir)
+	const assetUrls = new Set()
+	const entryModules = []
+	const scriptCounts = new Map()
+	const scriptOrder = new Map()
+	let scriptIndex = 0
+	const stylePaths = new Set()
+	let commonScriptEntry = null
+	const commonScripts = new Set()
+	let pagesWithScripts = 0
+
+	const createEntryModule = async (kind, publicPath, contentOverride = null, extraImports = null) => {
+		const hash = hashMd5(`${kind}:${publicPath || contentOverride || ''}`)
+		const filename = `${kind}-${hash}.js`
+		const fsPath = resolve(entriesDir, filename)
+		const manifestKey = normalizePath(relative(state.PAGES_DIR, fsPath))
+		const lines = []
+		if (contentOverride) {
+			lines.push(contentOverride)
+		} else if (publicPath) {
+			lines.push(`import ${JSON.stringify(publicPath)}`)
+		}
+		if (Array.isArray(extraImports) && extraImports.length) {
+			for (const entry of extraImports) {
+				if (!entry) continue
+				lines.push(`import ${JSON.stringify(entry)}`)
+			}
+		}
+		const content = lines.join('\n')
+		await writeFile(fsPath, content)
+		const entryInfo = {
+			kind,
+			publicPath,
+			fsPath,
+			manifestKey,
+			publicUrl: `/${METHANOL_DIR}/${ENTRY_DIR}/${filename}`
+		}
+		entryModules.push(entryInfo)
+		return entryInfo
+	}
+
+	// assetUrls are collected from worker scan results
+
+	const parseSrcset = (value = '') =>
+		value
+			.split(',')
+			.map((entry) => entry.trim())
+			.filter(Boolean)
+			.map((entry) => {
+				const [url, ...rest] = entry.split(/\s+/)
+				return { url, descriptor: rest.join(' ') }
+			})
+
+	const reportProgress = typeof options?.onProgress === 'function'
+		? options.onProgress
+		: null
+	const totalEntries = entries.filter((entry) => entry.source !== 'static').length
+	let processedEntries = 0
+
+	const sortedEntries = [...entries].sort((a, b) => {
+		const left = a?.stagePath || a?.name || ''
+		const right = b?.stagePath || b?.name || ''
+		return left.localeCompare(right)
+	})
+	for (const entry of sortedEntries) {
+		if (entry.source === 'static') {
+			continue
+		}
+		if (preScan && preScan.has(entry.stagePath)) {
+			const scanned = preScan.get(entry.stagePath)
+			const scripts = Array.isArray(scanned?.scripts) ? scanned.scripts : []
+			const styles = Array.isArray(scanned?.styles) ? scanned.styles : []
+			const assets = Array.isArray(scanned?.assets) ? scanned.assets : []
+			if (scripts.length > 0) {
+				pagesWithScripts++
+			}
+			for (const script of scripts) {
+				if (!scriptOrder.has(script)) {
+					scriptOrder.set(script, scriptIndex++)
+				}
+				scriptCounts.set(script, (scriptCounts.get(script) || 0) + 1)
+			}
+			for (const style of styles) {
+				stylePaths.add(style)
+			}
+			for (const asset of assets) {
+				assetUrls.add(asset)
+			}
+		}
+
+		processedEntries += 1
+		if (reportProgress) {
+			reportProgress(processedEntries, totalEntries)
+		}
+	}
+
+	if (pagesWithScripts === 0) {
+		return { entryModules: [], assetsEntryPath: null, commonScriptEntry: null, commonScripts: [] }
+	}
+
+	const commonScriptCandidates = Array.from(scriptCounts.entries())
+		.filter(([, count]) => count === pagesWithScripts)
+		.map(([script]) => script)
+		.sort((a, b) => (scriptOrder.get(a) || 0) - (scriptOrder.get(b) || 0))
+
+	const assetsEntryPublicUrl = assetUrls.size ? `/${METHANOL_DIR}/assets-entry.js` : null
+	const extraImports = []
+
+	for (const style of stylePaths) {
+		const styleEntry = await createEntryModule('style', style)
+		extraImports.push(styleEntry.publicUrl)
+	}
+	if (assetsEntryPublicUrl) {
+		extraImports.push(assetsEntryPublicUrl)
+	}
+
+	if (commonScriptCandidates.length) {
+		const commonImports = commonScriptCandidates
+			.map((script) => `import ${JSON.stringify(script)}`)
+			.join('\n')
+		commonScriptEntry = await createEntryModule('script-common', null, commonImports, extraImports)
+		for (const script of commonScriptCandidates) {
+			commonScripts.add(script)
+		}
+	}
+
+	for (const [script] of scriptCounts) {
+		if (commonScripts.has(script)) continue
+		if (!commonScriptEntry && extraImports.length) {
+			await createEntryModule('script', script, null, extraImports)
+			extraImports.length = 0
+			continue
+		}
+		await createEntryModule('script', script)
+	}
+
+	await ensureDir(dirname(assetsEntryPath))
+	const assetLines = Array.from(assetUrls)
+		.sort()
+		.map((url) => `import ${JSON.stringify(url)};`)
+	if (assetLines.length) {
+		const assetEntry = `${assetLines.join('\n')}`
+		await writeFile(assetsEntryPath, assetEntry)
+	} else {
+		await rm(assetsEntryPath, { force: true })
+	}
+
+	return {
+		entryModules,
+		commonScripts: Array.from(commonScripts),
+		commonScriptEntry,
+		assetsEntryPath: assetLines.length ? assetsEntryPath : null
+	}
+}
+
+const resolveManifestEntry = (manifest, key) => {
+	if (!manifest || !key) return null
+	if (manifest[key]) return manifest[key]
+	if (manifest[`/${key}`]) return manifest[`/${key}`]
+	const normalized = posix.normalize(key)
+	if (manifest[normalized]) return manifest[normalized]
+	if (manifest[`/${normalized}`]) return manifest[`/${normalized}`]
+	return null
+}
+
+export async function rewriteHtmlEntries(entries, manifest, scanResult = null, options = null) {
+	const reportProgress = typeof options?.onProgress === 'function'
+		? options.onProgress
+		: null
+	const totalEntries = entries.filter((entry) => entry.source !== 'static').length
+	let processedEntries = 0
+	for (const entry of entries) {
+		if (entry.source === 'static') {
+			continue
+		}
+		processedEntries += 1
+		if (reportProgress) {
+			reportProgress(processedEntries, totalEntries)
+		}
+	}
+}

package/src/html/utils.js

@@ -0,0 +1,125 @@
+/* Copyright Yukino Song, SudoMaker Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { createHash } from 'crypto'
+
+export const hashMd5 = (value) =>
+	createHash('md5').update(value).digest('hex')
+
+export const splitUrlParts = (value) => {
+	if (!value) return { path: '', suffix: '' }
+	const hashIndex = value.indexOf('#')
+	const queryIndex = value.indexOf('?')
+	let end = value.length
+	if (hashIndex >= 0) end = Math.min(end, hashIndex)
+	if (queryIndex >= 0) end = Math.min(end, queryIndex)
+	const path = value.slice(0, end)
+	const suffix = value.slice(end)
+	return { path, suffix }
+}
+
+export const isExternalUrl = (value) => {
+	if (!value) return false
+	const trimmed = value.trim().toLowerCase()
+	if (!trimmed) return false
+	return (
+		trimmed.startsWith('http://') ||
+		trimmed.startsWith('https://') ||
+		trimmed.startsWith('//') ||
+		trimmed.startsWith('data:') ||
+		trimmed.startsWith('mailto:') ||
+		trimmed.startsWith('tel:') ||
+		trimmed.startsWith('javascript:')
+	)
+}
+
+export const resolvePageBase = (routePath) => {
+	if (!routePath || routePath === '/') return '/'
+	if (routePath.endsWith('/')) return routePath
+	const index = routePath.lastIndexOf('/')
+	if (index <= 0) return '/'
+	return `${routePath.slice(0, index)}/`
+}
+
+export const stripBasePrefix = (value, basePrefix) => {
+	if (!value || !basePrefix || basePrefix === '/') return value
+	const trimmedBase = basePrefix.endsWith('/') ? basePrefix.slice(0, -1) : basePrefix
+	if (!trimmedBase) return value
+	if (value === trimmedBase) return '/'
+	if (value.startsWith(`${trimmedBase}/`)) {
+		const next = value.slice(trimmedBase.length)
+		return next.startsWith('/') ? next : `/${next}`
+	}
+	return value
+}
+
+export const joinBasePrefix = (basePrefix, value) => {
+	if (!value) return value
+	if (!basePrefix || basePrefix === '/') {
+		return value.startsWith('/') ? value : `/${value}`
+	}
+	const trimmedBase = basePrefix.endsWith('/') ? basePrefix.slice(0, -1) : basePrefix
+	const normalized = value.startsWith('/') ? value : `/${value}`
+	return `${trimmedBase}${normalized}`
+}
+
+export const resolveManifestKey = (value, basePrefix, pageRoutePath) => {
+	if (!value || isExternalUrl(value)) return null
+	const { path } = splitUrlParts(value)
+	if (!path) return null
+	const withoutBase = stripBasePrefix(path, basePrefix)
+	const resolvedPath = withoutBase.startsWith('/')
+		? withoutBase
+		: new URL(withoutBase, `http://methanol${resolvePageBase(pageRoutePath)}`).pathname
+	const key = resolvedPath.startsWith('/') ? resolvedPath.slice(1) : resolvedPath
+	return { key, resolvedPath }
+}
+
+export const getAttr = (node, name) => {
+	const attrs = node.attrs || []
+	const attr = attrs.find((item) => item.name === name)
+	return attr ? attr.value : null
+}
+
+export const setAttr = (node, name, value) => {
+	const attrs = node.attrs || []
+	const existing = attrs.find((item) => item.name === name)
+	if (existing) {
+		existing.value = value
+	} else {
+		attrs.push({ name, value })
+	}
+	node.attrs = attrs
+}
+
+export const getTextContent = (node) => {
+	if (!node.childNodes) return ''
+	return node.childNodes
+		.map((child) => (child.nodeName === '#text' ? child.value : ''))
+		.join('')
+}
+
+export const walkNodes = async (node, visitor) => {
+	await visitor(node)
+	if (!node.childNodes) return
+	for (const child of node.childNodes) {
+		await walkNodes(child, visitor)
+	}
+}