methanol 0.0.0 → 0.0.2

package/src/main.js

@@ -0,0 +1,133 @@
+/* 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 { loadUserConfig, applyConfig } from './config.js'
+import { runViteDev } from './dev-server.js'
+import { buildHtmlEntries, runViteBuild } from './build-system.js'
+import { runPagefind } from './pagefind.js'
+import { runVitePreview } from './preview-server.js'
+import { cli, state } from './state.js'
+import { HTMLRenderer } from './renderer.js'
+import { readFile } from 'fs/promises'
+
+const printBanner = async () => {
+	try {
+		const pkgUrl = new URL('../package.json', import.meta.url)
+		const raw = await readFile(pkgUrl, 'utf-8')
+		const pkg = JSON.parse(raw)
+		const version = pkg?.version ? `v${pkg.version}` : ''
+		const isTty = Boolean(process.stdout && process.stdout.isTTY)
+		const label = `Methanol ${version}`.trim()
+		if (isTty) {
+			const bannerUrl = new URL('../banner.txt', import.meta.url)
+			const banner = await readFile(bannerUrl, 'utf-8')
+			console.log(banner.trimEnd())
+			console.log(`\n\t${label}\n`)
+		} else {
+			console.log(label)
+		}
+	} catch {
+		console.log('Methanol')
+	}
+}
+
+const main = async () => {
+	await printBanner()
+	const command = cli.command
+	if (!command) {
+		cli.showHelp()
+		process.exit(1)
+	}
+	const normalizedCommand = command === 'preview' ? 'serve' : command
+	const isDev = normalizedCommand === 'dev'
+	const isPreview = normalizedCommand === 'serve'
+	const isBuild = normalizedCommand === 'build'
+	const mode = isDev ? 'development' : 'production'
+	const config = await loadUserConfig(mode, cli.CLI_CONFIG_PATH)
+	await applyConfig(config, mode)
+	const hookContext = {
+		mode,
+		root: state.ROOT_DIR,
+		command: normalizedCommand,
+		isDev,
+		isBuild,
+		isPreview,
+		HTMLRenderer,
+		site: {
+			name: state.SITE_NAME,
+			root: state.ROOT_DIR,
+			pagesDir: state.PAGES_DIR,
+			componentsDir: state.COMPONENTS_DIR,
+			publicDir: state.STATIC_DIR,
+			distDir: state.DIST_DIR,
+			mode: state.CURRENT_MODE,
+			pagefind: {
+				enabled: state.PAGEFIND_ENABLED,
+				options: state.PAGEFIND_OPTIONS || null,
+				build: state.PAGEFIND_BUILD || null
+			}
+		},
+		data: {}
+	}
+	const runHooks = async (hooks = [], extra = null) => {
+		const context = extra ? { ...hookContext, ...extra } : hookContext
+		for (const hook of hooks) {
+			await hook(context)
+		}
+	}
+	if (isDev) {
+		await runHooks(state.USER_PRE_BUILD_HOOKS)
+		await runHooks(state.THEME_PRE_BUILD_HOOKS)
+		await runViteDev()
+		return
+	}
+	if (isPreview) {
+		await runVitePreview()
+		return
+	}
+	if (isBuild) {
+		await runHooks(state.USER_PRE_BUILD_HOOKS)
+		await runHooks(state.THEME_PRE_BUILD_HOOKS)
+		const { entry, htmlCache, pagesContext } = await buildHtmlEntries()
+		await runViteBuild(entry, htmlCache)
+		if (state.PAGEFIND_ENABLED) {
+			await runPagefind()
+		}
+		const postBuildContext = pagesContext
+			? {
+					pagesContext,
+					pages: pagesContext.pages,
+					pagesTree: pagesContext.pagesTree,
+					pagesByRoute: pagesContext.pagesByRoute,
+					site: pagesContext.site
+				}
+			: null
+		await runHooks(state.THEME_POST_BUILD_HOOKS, postBuildContext)
+		await runHooks(state.USER_POST_BUILD_HOOKS, postBuildContext)
+		return
+	}
+	cli.showHelp()
+	process.exit(1)
+}
+
+main().catch((err) => {
+	console.error(err)
+	process.exit(1)
+})

package/src/mdx.js

@@ -0,0 +1,406 @@
+/* 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 { compile, run } from '@mdx-js/mdx'
+import * as JSXFactory from 'refui/jsx-runtime'
+import * as JSXDevFactory from 'refui/jsx-dev-runtime'
+import rehypeSlug from 'rehype-slug'
+import extractToc from '@stefanprobst/rehype-extract-toc'
+import withTocExport from '@stefanprobst/rehype-extract-toc/mdx'
+import rehypeStarryNight from 'rehype-starry-night'
+import { HTMLRenderer } from './renderer.js'
+import { signal, computed, read, Suspense, nextTick } from 'refui'
+import { createPortal } from 'refui/extras'
+import { pathToFileURL } from 'url'
+import { existsSync } from 'fs'
+import { resolve, dirname, basename, relative } from 'path'
+import { state } from './state.js'
+import { resolveUserMdxConfig } from './config.js'
+import { methanolCtx } from './rehype-plugins/methanol-ctx.js'
+import { linkResolve } from './rehype-plugins/link-resolve.js'
+
+// Workaround for Vite: it doesn't support resolving module/virtual modules in script src in dev mode
+const RWND_INJECT = HTMLRenderer.rawHTML`<script type="module" src="/.methanol_virtual_module/inject.js"></script>`
+const RWND_FALLBACK = HTMLRenderer.rawHTML`<script>
+	if (!window.$$rwnd) {
+		const l = []
+		const r = function(k,i,p) {
+			l.push([k,i,p,document.currentScript])
+		}
+		r.$$loaded = l
+		window.$$rwnd = r
+	}
+</script>`
+
+let cachedHeadAssets = null
+
+const resolveUserHeadAssets = () => {
+	if (cachedHeadAssets) {
+		return cachedHeadAssets
+	}
+	const assets = []
+	const pagesDir = state.PAGES_DIR
+	if (!pagesDir) return assets
+	if (existsSync(resolve(pagesDir, 'style.css'))) {
+		assets.push(HTMLRenderer.c('link', { rel: 'stylesheet', href: '/style.css' }))
+	}
+	if (existsSync(resolve(pagesDir, 'index.js'))) {
+		assets.push(HTMLRenderer.c('script', { type: 'module', src: '/index.js' }))
+	} else if (existsSync(resolve(pagesDir, 'index.ts'))) {
+		assets.push(HTMLRenderer.c('script', { type: 'module', src: '/index.ts' }))
+	}
+	if (state.CURRENT_MODE === 'production') {
+		cachedHeadAssets = assets
+	}
+	return assets
+}
+
+const resolvePageAssetUrl = (page, filePath) => {
+	const root = page?.source === 'theme' && state.THEME_PAGES_DIR
+		? state.THEME_PAGES_DIR
+		: state.PAGES_DIR
+	if (!root) return null
+	const relPath = relative(root, filePath).replace(/\\/g, '/')
+	if (!relPath || relPath.startsWith('..')) return null
+	return `/${relPath}`
+}
+
+const resolvePageHeadAssets = (page) => {
+	if (!page?.filePath) return []
+	const baseDir = dirname(page.filePath)
+	const baseName = basename(page.filePath).replace(/\.(mdx|md)$/, '')
+	const pagesRoot = state.PAGES_DIR ? resolve(state.PAGES_DIR) : null
+	const isRootIndex =
+		pagesRoot && baseName === 'index' && resolve(baseDir) === pagesRoot && page.source !== 'theme'
+	const isRootStylePage =
+		pagesRoot && baseName === 'style' && resolve(baseDir) === pagesRoot && page.source !== 'theme'
+	const assets = []
+	const cssPath = resolve(baseDir, `${baseName}.css`)
+	if (existsSync(cssPath)) {
+		if (isRootStylePage) {
+			const rootStyle = resolve(pagesRoot, 'style.css')
+			if (cssPath === rootStyle) {
+				return assets
+			}
+		}
+		const href = resolvePageAssetUrl(page, cssPath)
+		if (href) {
+			assets.push(HTMLRenderer.c('link', { rel: 'stylesheet', href }))
+		}
+	}
+	const scriptExtensions = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts']
+	let scriptPath = null
+	for (const ext of scriptExtensions) {
+		const candidate = resolve(baseDir, `${baseName}${ext}`)
+		if (existsSync(candidate)) {
+			scriptPath = candidate
+			break
+		}
+	}
+	if (scriptPath) {
+		if (isRootIndex) {
+			const rootIndexJs = resolve(pagesRoot, 'index.js')
+			const rootIndexTs = resolve(pagesRoot, 'index.ts')
+			if (scriptPath === rootIndexJs || scriptPath === rootIndexTs) {
+				return assets
+			}
+		}
+		const src = resolvePageAssetUrl(page, scriptPath)
+		if (src) {
+			assets.push(HTMLRenderer.c('script', { type: 'module', src }))
+		}
+	}
+	return assets
+}
+
+export const buildPageContext = ({
+	routePath,
+	filePath,
+	pageMeta,
+	pagesContext,
+	lazyPagesTree = false
+}) => {
+	const page = pageMeta
+	const language = pagesContext?.getLanguageForRoute ? pagesContext.getLanguageForRoute(routePath) : null
+	const getSiblings = pagesContext?.getSiblings
+		? () => pagesContext.getSiblings(routePath, page?.filePath || filePath)
+		: null
+	if (page && getSiblings && page.getSiblings !== getSiblings) {
+		page.getSiblings = getSiblings
+	}
+	const ctx = {
+		routePath,
+		filePath,
+		page,
+		pages: pagesContext?.pages || [],
+		pagesByRoute: pagesContext?.pagesByRoute || new Map(),
+		languages: pagesContext?.languages || [],
+		language,
+		site: pagesContext?.site || null,
+		getSiblings
+	}
+	const resolvePagesTree = () =>
+		pagesContext?.getPagesTree ? pagesContext.getPagesTree(routePath) : pagesContext?.pagesTree || []
+	if (lazyPagesTree) {
+		let cachedTree = null
+		let hasTree = false
+		Object.defineProperty(ctx, 'pagesTree', {
+			enumerable: true,
+			get() {
+				if (!hasTree) {
+					cachedTree = resolvePagesTree()
+					hasTree = true
+				}
+				return cachedTree
+			},
+			set(value) {
+				cachedTree = value
+				hasTree = true
+			}
+		})
+	} else {
+		ctx.pagesTree = resolvePagesTree()
+	}
+	return ctx
+}
+
+const findTitleFromToc = (toc = []) => {
+	let minDepth = Infinity
+	const scanDepth = (items) => {
+		for (const item of items) {
+			if (typeof item?.depth === 'number') {
+				minDepth = Math.min(minDepth, item.depth)
+			}
+			if (item?.children?.length) {
+				scanDepth(item.children)
+			}
+		}
+	}
+	scanDepth(toc)
+	if (!Number.isFinite(minDepth)) return null
+	let result = null
+	const findFirst = (items) => {
+		for (const item of items) {
+			if (item?.depth === minDepth && item?.value) {
+				result = item.value
+				return true
+			}
+			if (item?.children?.length && findFirst(item.children)) {
+				return true
+			}
+		}
+		return false
+	}
+	findFirst(toc)
+	return result
+}
+
+let cachedMdxConfig = null
+
+const normalizeStarryNightConfig = (value) => {
+	if (value == null) return null
+	if (typeof value === 'boolean') {
+		return { enabled: value, options: null }
+	}
+	if (typeof value !== 'object') return null
+	const { enabled, options, ...rest } = value
+	if (enabled === false) return { enabled: false, options: null }
+	if (options && typeof options === 'object') {
+		return { enabled: true, options: { ...options } }
+	}
+	if (Object.keys(rest).length) {
+		return { enabled: true, options: { ...rest } }
+	}
+	return { enabled: true, options: null }
+}
+
+const resolveStarryNightForPage = (frontmatter) => {
+	const base = {
+		enabled: state.STARRY_NIGHT_ENABLED === true,
+		options: state.STARRY_NIGHT_OPTIONS || null
+	}
+	if (!frontmatter || !Object.prototype.hasOwnProperty.call(frontmatter, 'starryNight')) {
+		return base
+	}
+	const override = normalizeStarryNightConfig(frontmatter.starryNight)
+	if (!override) return base
+	if (override.enabled === false) return { enabled: false, options: null }
+	const options = override.options != null ? override.options : base.options
+	return { enabled: true, options }
+}
+
+const resolveBaseMdxConfig = async () => {
+	const userMdxConfig = await resolveUserMdxConfig()
+	if (cachedMdxConfig) {
+		return cachedMdxConfig
+	}
+	const baseMdxConfig = {
+		outputFormat: 'function-body',
+		jsxRuntime: 'automatic',
+		jsxImportSource: 'refui',
+		development: state.CURRENT_MODE !== 'production',
+		elementAttributeNameCase: 'html',
+		rehypePlugins: [rehypeSlug, extractToc, [withTocExport, { name: 'toc' }]]
+	}
+	const mdxConfig = { ...baseMdxConfig, ...userMdxConfig }
+	const userRehypePlugins = Array.isArray(userMdxConfig.rehypePlugins) ? userMdxConfig.rehypePlugins : []
+	mdxConfig.rehypePlugins = [...baseMdxConfig.rehypePlugins, ...userRehypePlugins]
+	mdxConfig.rehypePlugins.push(linkResolve)
+	mdxConfig.rehypePlugins.push(methanolCtx)
+	return (cachedMdxConfig = mdxConfig)
+}
+
+const resolveMdxConfigForPage = async (frontmatter) => {
+	const baseConfig = await resolveBaseMdxConfig()
+	const mdxConfig = {
+		...baseConfig,
+		rehypePlugins: [...baseConfig.rehypePlugins]
+	}
+	const starryNightConfig = resolveStarryNightForPage(frontmatter)
+	if (!starryNightConfig.enabled) return mdxConfig
+	const plugin = starryNightConfig.options ? [rehypeStarryNight, starryNightConfig.options] : [rehypeStarryNight]
+	const insertIndex = mdxConfig.rehypePlugins.indexOf(linkResolve)
+	if (insertIndex >= 0) {
+		mdxConfig.rehypePlugins.splice(insertIndex, 0, plugin)
+	} else {
+		mdxConfig.rehypePlugins.push(plugin)
+	}
+	return mdxConfig
+}
+
+export const compileMdx = async ({ content, filePath, ctx }) => {
+	const mdxConfig = await resolveMdxConfigForPage(ctx?.page?.frontmatter)
+	const runtimeFactory = mdxConfig.development ? JSXDevFactory : JSXFactory
+	const compiled = await compile({ value: content, path: filePath }, mdxConfig)
+
+	return await run(compiled, {
+		...runtimeFactory,
+		baseUrl: pathToFileURL(filePath).href,
+		ctx,
+		rawHTML: HTMLRenderer.rawHTML
+	})
+}
+
+export const compilePageMdx = async (page, pagesContext, options = {}) => {
+	if (!page || page.content == null || page.mdxComponent) return
+	const { ctx = null, lazyPagesTree = false, refreshPagesTree = true } = options || {}
+	const activeCtx =
+		ctx ||
+		buildPageContext({
+			routePath: page.routePath,
+			filePath: page.filePath,
+			pageMeta: page,
+			pagesContext,
+			lazyPagesTree
+		})
+	const mdxModule = await compileMdx({
+		content: page.content,
+		filePath: page.filePath,
+		ctx: activeCtx
+	})
+	page.mdxComponent = mdxModule.default
+	page.toc = mdxModule.toc
+	const shouldUseTocTitle = page.frontmatter?.title == null
+	if (shouldUseTocTitle) {
+		const nextTitle = findTitleFromToc(page.toc) || page.title
+		if (nextTitle !== page.title) {
+			page.title = nextTitle
+			if (typeof pagesContext?.refreshPagesTree === 'function') {
+				pagesContext.refreshPagesTree()
+			}
+		}
+	}
+	if (typeof pagesContext?.setDerivedTitle === 'function') {
+		pagesContext.setDerivedTitle(page.filePath, shouldUseTocTitle ? page.title : null, page.toc)
+	}
+	if (ctx && refreshPagesTree && pagesContext?.getPagesTree) {
+		ctx.pagesTree = pagesContext.getPagesTree(activeCtx.routePath)
+	}
+}
+
+export const renderHtml = async ({
+	routePath,
+	filePath,
+	components,
+	pagesContext,
+	pageMeta: explicitPageMeta = null
+}) => {
+	const pageMeta =
+		explicitPageMeta ||
+		(pagesContext.getPageByRoute
+			? pagesContext.getPageByRoute(routePath, { filePath })
+			: pagesContext.pagesByRoute.get(routePath))
+
+	const ctx = buildPageContext({
+		routePath,
+		filePath,
+		pageMeta,
+		pagesContext
+	})
+	await compilePageMdx(pageMeta, pagesContext, { ctx })
+
+	const [Head, Outlet] = createPortal()
+	const ExtraHead = () => {
+		return [
+			RWND_INJECT,
+			...resolveUserHeadAssets(),
+			...resolvePageHeadAssets(pageMeta),
+			Outlet(),
+			RWND_FALLBACK
+		]
+	}
+
+	const mdxComponent = pageMeta?.mdxComponent
+
+	const Page = ({ components: extraComponents, ...props }, ...children) =>
+		mdxComponent({
+			children,
+			...props,
+			components: {
+				...components,
+				...extraComponents,
+				head: Head,
+				Head
+			}
+		})
+
+	const template = state.USER_THEME.template
+
+	const renderResult = await new Promise((r) => {
+		const result = HTMLRenderer.c(
+			Suspense,
+			{
+				onLoad() {
+					nextTick(() => r(result))
+				}
+			},
+			() =>
+				template({
+					ctx,
+					Page,
+					ExtraHead,
+					HTMLRenderer,
+					components
+				})
+		)
+	})
+
+	return HTMLRenderer.serialize(renderResult)
+}

package/src/node-loader.js

@@ -0,0 +1,88 @@
+/* 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 { readFile } from 'node:fs/promises'
+import { dirname, extname, join, resolve as pathResolve, relative } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import { transform } from 'esbuild'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const projectRoot = pathResolve('.', '__virtual__.js')
+const projectRootURL = pathToFileURL(projectRoot)
+export const projectRequire = createRequire(projectRootURL)
+
+const require = createRequire(import.meta.url)
+
+const EXTS = new Set(['.jsx', '.tsx', '.ts', '.mts', '.cts'])
+
+export async function load(url, context, nextLoad) {
+	if (url.startsWith('node:') || url.startsWith('data:')) {
+		return nextLoad(url, context, nextLoad)
+	}
+
+	const pathname = new URL(url).pathname
+	const ext = extname(pathname).toLowerCase()
+	if (!EXTS.has(ext)) {
+		return nextLoad(url, context, nextLoad)
+	}
+
+	const source = await readFile(fileURLToPath(url), 'utf-8')
+	const loader = ext === '.tsx' ? 'tsx' : ext === '.jsx' ? 'jsx' : 'ts'
+	const result = await transform(source, {
+		loader,
+		format: 'esm',
+		jsx: 'automatic',
+		jsxImportSource: 'refui',
+		sourcemap: 'inline',
+		sourcefile: fileURLToPath(url)
+	})
+
+	return {
+		format: 'module',
+		shortCircuit: true,
+		source: result.code
+	}
+}
+
+const startPos = 'methanol'.length
+export async function resolve(specifier, context, nextResolve) {
+	if (specifier === 'refui' || specifier.startsWith('refui/')) {
+		try {
+			// Use user installed rEFui when possible
+			return await nextResolve(specifier, { ...context, parentURL: projectRootURL })
+		} catch (e) {
+			return await nextResolve(specifier, { ...context, parentURL: import.meta.url })
+		}
+	} else if (specifier === 'methanol' || specifier.startsWith('methanol/')) {
+		// Force only one Metnanol instance
+		const filePath = require.resolve('..' + specifier.slice(startPos))
+		return {
+			__proto__: null,
+			shortCircuit: true,
+			format: 'module',
+			url: pathToFileURL(filePath).href
+		}
+	} else {
+		return await nextResolve(specifier, context)
+	}
+}