orga-build 0.1.0

package/LICENSE.org

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 gatsbyjs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import { argv } from 'node:process'
+import { parseArgs } from 'node:util'
+import { watch } from './lib/watch.js'
+import { loadConfig, clean } from './lib/build.js'
+import { build } from './lib/esbuild/index.js'
+import { serve } from './lib/serve.js'
+
+const { values, positionals } = parseArgs({
+	args: argv.slice(2),
+	options: {
+		watch: { type: 'boolean', short: 'w' },
+		outDir: { type: 'string', short: 'o', default: 'out' }
+	},
+	tokens: true,
+	allowPositionals: true
+})
+
+const config = await loadConfig()
+
+await build(config)
+
+if (positionals.includes('dev')) {
+	serve(values.outDir)
+	watch('.', new RegExp(`^${config.outDir}`), async () => {
+		console.log('rebuilding')
+		await clean(config.outDir)
+		await build(config)
+	})
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+export { build } from "./lib/build.js";
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":""}

package/index.js

@@ -0,0 +1 @@
+export { build } from './lib/build.js'

package/lib/build.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @param {typeof defaultConfig} options
+ */
+export function build({ outDir, preBuild, postBuild }: typeof defaultConfig): Promise<void>;
+/**
+ * @param {import("fs").PathLike} dir
+ */
+export function clean(dir: import("fs").PathLike): Promise<void>;
+/**
+ * @returns {Promise<typeof defaultConfig>}
+ */
+export function loadConfig(): Promise<typeof defaultConfig>;
+export type Page = {
+    Content: import("@orgajs/orgx").OrgContent;
+    /**
+     * - The metadata from the org file export, will be passed to the Layout component
+     */
+    metadata: Record<string, any>;
+    /**
+     * - The absolute path to the org file
+     */
+    src: string;
+    /**
+     * - The slug for the page
+     */
+    slug: string;
+};
+export type Layout = import("react").ComponentType<any>;
+export type Pattern = string | RegExp;
+export type BuildContext = {
+    /**
+     * - The components from the org file
+     */
+    components?: import("@orgajs/orgx").OrgComponents;
+    /**
+     * - The layout component
+     */
+    Layout?: Layout | undefined;
+    /**
+     * - The ignore pattern
+     */
+    ignore?: Pattern | Pattern[];
+    /**
+     * - The build function
+     */
+    build: (page: Page & {
+        Layout?: Layout | undefined;
+        components: Record<string, any>;
+    }) => Promise<void>;
+    /**
+     * - The build function
+     */
+    buildHref: (filePath: string, metadata: Record<string, any>) => string;
+};
+declare namespace defaultConfig {
+    let outDir: string;
+    let preBuild: string[];
+    let postBuild: string[];
+}
+export {};
+//# sourceMappingURL=build.d.ts.map

package/lib/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["build.js"],"names":[],"mappings":"AAwJA;;GAEG;AACH,uDAFW,OAAO,aAAa,iBAwC9B;AAwBD;;GAEG;AACH,2BAFW,OAAO,IAAI,EAAE,QAAQ,iBAI/B;AAED;;GAEG;AACH,8BAFa,OAAO,CAAC,OAAO,aAAa,CAAC,CAKzC;;aAzMa,OAAO,cAAc,EAAE,UAAU;;;;cACjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;SACnB,MAAM;;;;UACN,MAAM;;qBAIP,OAAO,OAAO,EAAE,aAAa,CAAC,GAAG,CAAC;sBAIlC,MAAM,GAAG,MAAM;;;;;iBAKd,OAAO,cAAc,EAAE,aAAa;;;;aACpC,MAAM,GAAG,SAAS;;;;aAClB,OAAO,GAAG,OAAO,EAAE;;;;WACnB,CAAC,IAAI,EAAE,IAAI,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC;;;;eAChG,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,MAAM;;;;kBA5B7D,MAAM,EAAE;mBAER,MAAM,EAAE"}

package/lib/build.js

@@ -0,0 +1,231 @@
+import { globby } from 'globby'
+import fs from 'node:fs/promises'
+import { register } from 'node:module'
+import path from 'path'
+import { createElement } from 'react'
+import { renderToString } from 'react-dom/server'
+import assert from 'node:assert'
+import { match } from './util.js'
+import { evaluate, build as _build } from './esbuild.js'
+import { $, DefaultLayout } from './util.js'
+
+const USE_NODE = false
+
+if (USE_NODE) {
+	register('./jsx-loader.js', import.meta.url)
+	register('./orga-loader.js', import.meta.url)
+	register('./raw-loader.js', import.meta.url)
+}
+
+const defaultConfig = {
+	outDir: 'out',
+	/** @type {string[]} */
+	preBuild: [],
+	/** @type {string[]} */
+	postBuild: []
+}
+
+/**
+ * @typedef {Object} Page
+ * @property {import('@orgajs/orgx').OrgContent} Content
+ * @property {Record<string, any>} metadata - The metadata from the org file export, will be passed to the Layout component
+ * @property {string} src - The absolute path to the org file
+ * @property {string} slug - The slug for the page
+ */
+
+/**
+ * @typedef {import('react').ComponentType<any>} Layout
+ */
+
+/**
+ * @typedef {string | RegExp} Pattern
+ */
+
+/**
+ * @typedef {Object} BuildContext
+ * @property {import('@orgajs/orgx').OrgComponents} [components] - The components from the org file
+ * @property {Layout | undefined} [Layout] - The layout component
+ * @property {Pattern | Pattern[]} [ignore] - The ignore pattern
+ * @property {(page: Page & { Layout?: Layout | undefined, components: Record<string, any> }) => Promise<void>} build - The build function
+ * @property {(filePath: string, metadata: Record<string, any>) => string} buildHref - The build function
+ */
+
+/**
+ * Recursively processes a directory to build pages from .org files
+ * @param {string} dirPath - The directory path to process
+ * @param {BuildContext} context - Build context containing components, layout, and build function
+ * @returns {Promise<void>}
+ */
+async function iter(dirPath, context) {
+	/** @type {Page[]} */
+	const pages = []
+	const subdirs = []
+
+	let components = { ...context.components }
+	let Layout = context.Layout
+	let ignore = context.ignore || /node_modules/
+	if (!Array.isArray(ignore)) {
+		ignore = [ignore]
+	}
+
+	const files = await fs.readdir(dirPath)
+
+	for (const file of files) {
+		if (match(file, ...ignore)) {
+			continue
+		}
+		const filePath = path.join(dirPath, file)
+		const stat = await fs.stat(filePath)
+
+		if (stat.isDirectory()) {
+			subdirs.push(filePath)
+			continue
+		}
+
+		if (match(file, /(.|_)layout.(j|t)sx/)) {
+			const InnerLayout = (await _import(filePath)).default
+			if (!InnerLayout) continue
+			if (Layout !== undefined) {
+				const OuterLayout = Layout
+				Layout = function Layout(/** @type {any} */ props) {
+					return createElement(
+						OuterLayout,
+						props,
+						createElement(InnerLayout, props)
+					)
+				}
+			} else {
+				Layout = InnerLayout
+			}
+			continue
+		}
+		if (match(file, /(.|_)components.(j|t)sx$/)) {
+			const localComponents = await _import(filePath)
+			if (localComponents) {
+				components = { ...components, ...localComponents }
+			}
+			continue
+		}
+
+		if (file.startsWith('.')) continue
+
+		// write regex to match .org and .tsx, .jsx files, javascript code only
+
+		if (match(file, /\.(org)$/, /\.(j|t)sx$/)) {
+			const module = await _import(filePath)
+			const {
+				default: /** @type import('@orgajs/orgx').OrgContent */ Content,
+				...metadata
+			} = module
+			pages.push({
+				Content,
+				metadata,
+				slug: context.buildHref(filePath, metadata),
+				src: filePath
+			})
+		}
+	}
+
+	await Promise.all(
+		pages.map((page) =>
+			context.build({
+				...page,
+				metadata: {
+					...page.metadata,
+					pages: pages.map((p) => ({ ...p.metadata, slug: p.slug }))
+				},
+				Layout: Layout,
+				components
+			})
+		)
+	)
+
+	// TODO: parallelize
+	for (const subdir of subdirs) {
+		await iter(subdir, {
+			...context,
+			Layout,
+			components
+		})
+	}
+}
+
+/**
+ * @param {typeof defaultConfig} options
+ */
+export async function build({ outDir, preBuild, postBuild }) {
+	for (const cmd of preBuild) {
+		console.log(`Running pre-build command: ${cmd}`)
+		await $(cmd)
+	}
+	const start = performance.now()
+	const cwd = process.cwd()
+	const outFullPath = path.join(cwd, outDir)
+	console.log(`Building to ${outFullPath}`)
+
+	await iter(cwd, {
+		buildHref: (filePath) => {
+			return `/${path.relative(cwd, filePath).replace(/\.\w+$/, '.html')}`
+		},
+		ignore: [/node_modules/, 'out'],
+		build: async ({ Layout, Content, metadata, src, components }) => {
+			assert(Content, 'Content component is required')
+			const e = createElement(
+				Layout ?? DefaultLayout,
+				metadata,
+				createElement(Content, { components })
+			)
+			const code = renderToString(e)
+			const filePath = path.relative(cwd, src).replace(/\.\w+$/, '.html')
+			const outPath = path.resolve(outFullPath, filePath)
+			await fs.mkdir(path.dirname(outPath), { recursive: true })
+			const filesize = new Intl.NumberFormat().format(code.length)
+			console.log(`${filePath} (${filesize} bytes)`)
+			await fs.writeFile(outPath, code, { encoding: 'utf-8', flush: true })
+		}
+	})
+	const end = performance.now()
+	console.log(`Built in ${(end - start).toFixed(2)}ms`)
+
+	for (const cmd of postBuild) {
+		console.log(`Running post-build command: ${cmd}`)
+		await $(cmd)
+	}
+}
+
+/**
+ * @param {string[]} files
+ */
+async function _import(...files) {
+	const found = await globby(files, {
+		cwd: process.cwd(),
+		onlyFiles: true
+	})
+	if (found.length === 0) {
+		return null
+	}
+
+	const file = found[0]
+	const fullPath = path.isAbsolute(file) ? file : path.join(process.cwd(), file)
+	const { mtime } = await fs.stat(fullPath)
+	if (USE_NODE) {
+		return await import(`${fullPath}?version=${mtime.getTime()}`)
+	} else {
+		return await evaluate(fullPath)
+	}
+}
+
+/**
+ * @param {import("fs").PathLike} dir
+ */
+export async function clean(dir) {
+	await fs.rm(dir, { recursive: true })
+}
+
+/**
+ * @returns {Promise<typeof defaultConfig>}
+ */
+export async function loadConfig() {
+	const config = await _import('orga.config.(j|t)s')
+	return { ...defaultConfig, ...config }
+}

package/lib/esbuild/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @typedef {Object} Options
+ * @property {string} [outDir]
+ * @property {string[]} [preBuild]
+ * @property {string[]} [postBuild]
+ */
+/**
+ * @param {Options} options
+ */
+export function build({ outDir, preBuild, postBuild }: Options): Promise<void>;
+export type Options = {
+    outDir?: string;
+    preBuild?: string[];
+    postBuild?: string[];
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/esbuild/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AAEH;;GAEG;AACH,uDAFW,OAAO,iBAuKjB;;aA7Ka,MAAM;eACN,MAAM,EAAE;gBACR,MAAM,EAAE"}

package/lib/esbuild/index.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs/promises'
+import * as esbuild from 'esbuild'
+import esbuildOrga from '@orgajs/esbuild'
+import path from 'node:path'
+import { createElement } from 'react'
+import { renderToString } from 'react-dom/server'
+import assert from 'node:assert'
+import { DefaultLayout, $, match } from '../util.js'
+import rawLoader from './raw-loader.js'
+
+/**
+ * @typedef {Object} Options
+ * @property {string} [outDir]
+ * @property {string[]} [preBuild]
+ * @property {string[]} [postBuild]
+ */
+
+/**
+ * @param {Options} options
+ */
+export async function build({ outDir = 'dir', preBuild = [], postBuild = [] }) {
+	for (const cmd of preBuild) {
+		console.log(`Running pre-build command: ${cmd}`)
+		await $(cmd)
+	}
+	const cwd = process.cwd()
+	const start = performance.now()
+
+	const src = {
+		/** @type {string[]} */
+		layouts: [],
+		/** @type {string[]} */
+		components: [],
+		/** @type {string[]} */
+		pages: []
+	}
+
+	await walk(cwd, (file) => {
+		const fileName = path.basename(file)
+		if (match(fileName, /(.|_)layout.(j|t)sx$/)) {
+			src.layouts.push(file)
+			return
+		}
+		if (match(fileName, /(.|_)components.(j|t)sx$/)) {
+			src.components.push(file)
+			return
+		}
+		if (match(fileName, /\.(org)$/, /\.(j|t)sx$/)) {
+			src.pages.push(file)
+			return
+		}
+	})
+
+	const result = await esbuild.build({
+		entryPoints: [
+			...Object.values(src.layouts),
+			...src.components,
+			...src.pages
+		],
+		// entryNames: '[dir]/_/[name]',
+		bundle: true,
+		format: 'esm',
+		platform: 'node',
+		target: 'esnext',
+		jsx: 'automatic',
+		// write: false,
+		outdir: '.orga-build/js',
+		// splitting: true,
+		metafile: true,
+		plugins: [esbuildOrga(), rawLoader],
+		// external: ['react/jsx-runtime'],
+		loader: {
+			'.jsx': 'jsx',
+			'.tsx': 'tsx'
+		}
+	})
+
+	assert(result.metafile, 'metafile not found')
+
+	let components = {}
+
+	/**
+	 * @typedef {Object} DirInfo
+	 * @property {string|undefined} layout
+	 * @property {PageInfo[]} pages
+
+	 * @typedef {Object} PageInfo
+	 * @property {Record<string, any>} metadata
+	 * @property {import('react').ComponentType<any>} Content
+	 * @property {string} src
+	 * @property {string} file
+	 */
+
+	/** @type {Record<string, DirInfo>} */
+	let map = {}
+	// iterate over results to get layout and components
+	for (const [file, meta] of Object.entries(result.metafile.outputs)) {
+		if (!meta.entryPoint) continue
+		const fullSrc = path.join(cwd, meta.entryPoint)
+		// get components
+		if (src.components.includes(fullSrc)) {
+			const module = await import(path.join(cwd, file))
+			components = { ...components, ...module }
+			continue
+		}
+
+		const dirPath = path.dirname(fullSrc)
+		map[dirPath] = map[dirPath] ?? {
+			layout: undefined,
+			pages: []
+		}
+		const dir = map[dirPath]
+
+		// get layouts
+		if (src.layouts.includes(fullSrc)) {
+			dir.layout = path.join(cwd, file)
+			continue
+		}
+		if (src.pages.includes(fullSrc)) {
+			const fullPath = path.join(cwd, file)
+			const { default: Content, ...metadata } = await import(fullPath)
+			dir.pages.push({
+				metadata: {
+					...metadata,
+					slug: `/${meta.entryPoint.replace(/\.\w+$/, '.html')}`
+				},
+				Content,
+				src: fullSrc,
+				file: fullPath
+			})
+		}
+	}
+
+	for (const [, content] of Object.entries(map)) {
+		for (const page of content.pages) {
+			const Layout = await getLayout(page.src)
+			const e = createElement(
+				Layout ?? DefaultLayout,
+				{ ...page.metadata, pages: content.pages.map((p) => p.metadata) },
+				createElement(page.Content, { components })
+			)
+			const html = renderToString(e)
+			// write to outDir/file
+			const relPath = path.relative(cwd, page.src)
+			const outPath = path.join(outDir, relPath)
+			const outDirPath = path.dirname(outPath)
+			await fs.mkdir(outDirPath, { recursive: true })
+			await fs
+				.writeFile(outPath.replace(/\.(org|jsx|tsx)$/, '.html'), html)
+				.catch(console.error)
+		}
+	}
+
+	for (const cmd of postBuild) {
+		console.log(`Running post-build command: ${cmd}`)
+		await $(cmd)
+	}
+
+	const end = performance.now()
+	console.log(`Built in ${(end - start).toFixed(2)}ms`)
+
+	/**
+	 * @param {string} file
+	 * @returns {Promise<import('react').ComponentType<any>|undefined>}
+	 */
+	async function getLayout(file) {
+		if (file === cwd) return
+		const dir = path.dirname(file)
+		const ParentLayout = await getLayout(dir)
+		const { layout } = map[dir]
+		if (layout) {
+			const Layout = (await import(layout)).default
+			if (ParentLayout) {
+				return function (props) {
+					return createElement(
+						ParentLayout,
+						props,
+						createElement(Layout, props)
+					)
+				}
+			}
+			return Layout
+		}
+		return ParentLayout
+	}
+}
+
+/**
+ * Iterates over files in a directory recursively in a breadth-first manner.
+ * @param {string} dirPath - The path to the directory.
+ * @param {(file: string) => void} callback - The callback function to be called for each file.
+ */
+async function walk(dirPath, callback) {
+	const queue = [dirPath]
+
+	const ignore = [/^\./, /node_modules/]
+
+	while (queue.length > 0) {
+		const currentPath = queue.shift()
+		if (!currentPath) break
+		const files = await fs.readdir(currentPath)
+
+		for (const file of files) {
+			if (match(file, ...ignore)) {
+				continue
+			}
+			const filePath = path.join(currentPath, file)
+			const stats = await fs.stat(filePath)
+
+			if (stats.isDirectory()) {
+				queue.push(filePath)
+			} else {
+				callback(filePath)
+			}
+		}
+	}
+}

package/lib/esbuild/raw-loader.d.ts

@@ -0,0 +1,13 @@
+export default rawLoader;
+declare namespace rawLoader {
+    let name: string;
+    /**
+     * @param {PluginBuild} build
+     *   Build.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    function setup(build: PluginBuild): undefined;
+}
+import type { PluginBuild } from 'esbuild';
+//# sourceMappingURL=raw-loader.d.ts.map

package/lib/esbuild/raw-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-loader.d.ts","sourceRoot":"","sources":["raw-loader.js"],"names":[],"mappings":";;;IASC;;;;;OAKG;IACH,sBALW,WAAW,GAET,SAAS,CA+BrB;;iCA1C4B,SAAS"}

package/lib/esbuild/raw-loader.js

@@ -0,0 +1,47 @@
+/**
+ * @import {PluginBuild} from 'esbuild'
+ */
+
+import path from 'path'
+import { promises as fs } from 'fs'
+
+const rawLoader = {
+	name: 'raw',
+	/**
+	 * @param {PluginBuild} build
+	 *   Build.
+	 * @returns {undefined}
+	 *   Nothing.
+	 */
+	setup(build) {
+		build.onResolve({ filter: /.*\?raw$/ }, (args) => {
+			return {
+				path: args.path,
+				pluginData: {
+					isAbsolute: path.isAbsolute(args.path),
+					resolveDir: args.resolveDir
+				},
+				namespace: 'raw-loader'
+			}
+		})
+
+		build.onLoad(
+			{ filter: /.*\?raw$/, namespace: 'raw-loader' },
+			async (args) => {
+				const fullPath = args.pluginData.isAbsolute
+					? args.path
+					: path.join(args.pluginData.resolveDir, args.path)
+				const contents = await fs.readFile(
+					fullPath.replace(/\?raw$/, ''),
+					'utf8'
+				)
+				return {
+					contents,
+					loader: 'text'
+				}
+			}
+		)
+	}
+}
+
+export default rawLoader

package/lib/esbuild.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Evaluate an org/jsx/tsx/ts file. Returns as a module.
+ * It's like a dynamic import, but without relying on nodejs.
+ * @param {string} filePath
+ * @returns {Promise<any>}
+ */
+export function evaluate(filePath: string): Promise<any>;
+/**
+ * @param {string} pattern
+ */
+export function build(pattern: string): Promise<esbuild.BuildResult<{
+    entryPoints: string[];
+    entryNames: string;
+    bundle: true;
+    format: "esm";
+    platform: "node";
+    target: string;
+    jsx: "automatic";
+    outdir: string;
+    plugins: {
+        name: string;
+        setup: (build: esbuild.PluginBuild) => undefined;
+    }[];
+    loader: {
+        '.jsx': "jsx";
+        '.tsx': "tsx";
+    };
+}>>;
+export function b(): Promise<void>;
+import * as esbuild from 'esbuild';
+//# sourceMappingURL=esbuild.d.ts.map

package/lib/esbuild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.d.ts","sourceRoot":"","sources":["esbuild.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAwBxB;AAED;;GAEG;AACH,+BAFW,MAAM;;;;;;;;;;;;;;;;;IAmBhB;AAED,mCAA4B;yBAvDH,SAAS"}

package/lib/esbuild.js

@@ -0,0 +1,57 @@
+import assert from 'assert'
+import * as esbuild from 'esbuild'
+import esbuildOrga from '@orgajs/esbuild'
+
+/**
+ * Evaluate an org/jsx/tsx/ts file. Returns as a module.
+ * It's like a dynamic import, but without relying on nodejs.
+ * @param {string} filePath
+ * @returns {Promise<any>}
+ */
+export async function evaluate(filePath) {
+	const result = await esbuild.build({
+		entryPoints: [filePath],
+		bundle: true,
+		format: 'esm',
+		platform: 'node',
+		target: 'esnext',
+		jsx: 'automatic',
+		write: false,
+		plugins: [esbuildOrga()],
+		loader: {
+			'.jsx': 'jsx',
+			'.tsx': 'tsx'
+		}
+	})
+
+	const files = result.outputFiles
+	assert(files.length === 1, 'Expected only one output file')
+	const code = files[0].text
+	return await new Function(
+		`return import("data:application/javascript,${encodeURIComponent(code)}")`
+	)()
+}
+
+/**
+ * @param {string} pattern
+ */
+export async function build(pattern) {
+	return await esbuild.build({
+		entryPoints: [pattern],
+		entryNames: '[dir]/_/[name]',
+		bundle: true,
+		format: 'esm',
+		platform: 'node',
+		target: 'esnext',
+		jsx: 'automatic',
+		// write: false,
+		outdir: '.build',
+		plugins: [esbuildOrga()],
+		loader: {
+			'.jsx': 'jsx',
+			'.tsx': 'tsx'
+		}
+	})
+}
+
+export async function b() {}

package/lib/jsx-loader.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {string} href
+ *   URL.
+ * @param {unknown} context
+ *   Context.
+ * @param {Function} defaultLoad
+ *   Default `load`.
+ * @returns
+ *   Result.
+ */
+export function load(href: string, context: unknown, defaultLoad: Function): Promise<any>;
+//# sourceMappingURL=jsx-loader.d.ts.map

package/lib/jsx-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-loader.d.ts","sourceRoot":"","sources":["jsx-loader.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,2BATW,MAAM,WAEN,OAAO,uCAgCjB"}

package/lib/jsx-loader.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { transform } from 'esbuild'
+
+/**
+ * @param {string} href
+ *   URL.
+ * @param {unknown} context
+ *   Context.
+ * @param {Function} defaultLoad
+ *   Default `load`.
+ * @returns
+ *   Result.
+ */
+export async function load(href, context, defaultLoad) {
+	const url = new URL(href)
+
+	const loader = getLoader(url.pathname)
+	if (!loader) {
+		return defaultLoad(href, context, defaultLoad)
+	}
+
+	const { code, warnings } = await transform(String(await fs.readFile(url)), {
+		format: 'esm',
+		loader,
+		sourcefile: fileURLToPath(url),
+		sourcemap: 'both',
+		target: 'esnext',
+		jsx: 'automatic',
+	})
+
+	if (warnings) {
+		for (const warning of warnings) {
+			console.log(warning.location)
+			console.log(warning.text)
+		}
+	}
+
+	return { format: 'module', shortCircuit: true, source: code }
+}
+
+/**
+ * @param {string} filename
+ * @returns {import('esbuild').Loader | null}
+ */
+function getLoader(filename) {
+	const ext = filename.split('.').pop()
+	switch (ext) {
+		case 'jsx':
+			return 'jsx'
+		case 'tsx':
+			return 'tsx'
+		case 'ts':
+			return 'ts'
+		default:
+			return null
+	}
+}

package/lib/orga-loader.d.ts

@@ -0,0 +1,3 @@
+export const initialize: (options: Readonly<Options> | null | undefined) => Promise<void>;
+export const load: (href: string, context: import("module").LoadHookContext, nextLoad: NextLoad) => Promise<import("module").LoadFnOutput>;
+//# sourceMappingURL=orga-loader.d.ts.map

package/lib/orga-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orga-loader.d.ts","sourceRoot":"","sources":["orga-loader.js"],"names":[],"mappings":"AAOA,0FAA2C;AAC3C,2IAA+B"}

package/lib/orga-loader.js

@@ -0,0 +1,9 @@
+import { createLoader } from '@orgajs/node-loader'
+import latex from 'rehype-katex'
+
+let loader = createLoader({
+	rehypePlugins: [latex],
+})
+
+export const initialize = loader.initialize
+export const load = loader.load

package/lib/raw-loader.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {string} href
+ *   URL.
+ * @param {unknown} context
+ *   Context.
+ * @param {Function} defaultLoad
+ *   Default `load`.
+ * @returns
+ *   Result.
+ */
+export function load(href: string, context: unknown, defaultLoad: Function): Promise<any>;
+//# sourceMappingURL=raw-loader.d.ts.map

package/lib/raw-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-loader.d.ts","sourceRoot":"","sources":["raw-loader.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,2BATW,MAAM,WAEN,OAAO,uCAsBjB"}

package/lib/raw-loader.js

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * @param {string} href
+ *   URL.
+ * @param {unknown} context
+ *   Context.
+ * @param {Function} defaultLoad
+ *   Default `load`.
+ * @returns
+ *   Result.
+ */
+const rawLoader = async (href, context, defaultLoad) => {
+	const url = new URL(href)
+	const { searchParams } = url
+	const raw = searchParams.get('raw')
+	if (raw === null || raw === undefined || raw.toLowerCase() === 'false') {
+		return defaultLoad(href, context, defaultLoad)
+	}
+
+	const filePath = fileURLToPath(href)
+	const fileContent = readFileSync(filePath, 'utf8')
+	return {
+		format: 'module',
+		shortCircuit: true,
+		source: `export default ${JSON.stringify(fileContent)}`
+	}
+}
+
+export const load = rawLoader

package/lib/serve.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {string} dir
+ */
+export function serve(dir: string, port?: number): {
+    start: () => void;
+    stop: () => void;
+};
+//# sourceMappingURL=serve.d.ts.map

package/lib/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["serve.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,2BAFW,MAAM;;;EA2BhB"}

package/lib/serve.js

@@ -0,0 +1,32 @@
+import handler from 'serve-handler'
+import http from 'http'
+
+/**
+ * @param {string} dir
+ */
+export function serve(dir, port = 3000) {
+	/** @type {import('http').Server | null} */
+	let server = null
+
+	function start() {
+		server = http
+			.createServer((req, res) => {
+				return handler(req, res, {
+					public: dir,
+				})
+			})
+			.listen(port)
+		console.log(`Server running at http://localhost:${port}/`)
+	}
+
+	function stop() {
+		server?.close()
+		server?.on('close', () => {
+			server = null
+			return Promise.resolve()
+		})
+	}
+
+	start()
+	return { start, stop }
+}

package/lib/util.d.ts

@@ -0,0 +1,23 @@
+export function buildNav(): void;
+/**
+ * @param {string} file
+ * @param {...RegExp|string} patterns
+ * @returns {boolean}
+ */
+export function match(file: string, ...patterns: (RegExp | string)[]): boolean;
+/**
+ * Default layout
+ * @param {Object} props
+ * @param {string|undefined} props.title
+ * @param {import('react').ReactNode} props.children
+ * @returns {React.JSX.Element}
+ */
+export function DefaultLayout({ title, children }: {
+    title: string | undefined;
+    children: import("react").ReactNode;
+}): React.JSX.Element;
+/**
+ * @param {string} cmd
+ */
+export function $(cmd: string): Promise<any>;
+//# sourceMappingURL=util.d.ts.map

package/lib/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["util.js"],"names":[],"mappings":"AAGA,iCAA6B;AAE7B;;;;GAIG;AACH,4BAJW,MAAM,eACN,CAAG,MAAM,GAAC,MAAM,GAAA,GACd,OAAO,CASnB;AAED;;;;;;GAMG;AACH,mDAJG;IAAgC,KAAK,EAA7B,MAAM,GAAC,SAAS;IACiB,QAAQ,EAAzC,OAAO,OAAO,EAAE,SAAS;CACjC,GAAU,KAAK,CAAC,GAAG,CAAC,OAAO,CAkB7B;AAED;;GAEG;AACH,uBAFW,MAAM,gBAehB"}

package/lib/util.js

@@ -0,0 +1,61 @@
+import { exec } from 'node:child_process'
+import { createElement } from 'react'
+
+export function buildNav() {}
+
+/**
+ * @param {string} file
+ * @param {...RegExp|string} patterns
+ * @returns {boolean}
+ */
+export function match(file, ...patterns) {
+	return patterns.some((p) => {
+		if (p instanceof RegExp) {
+			return p.test(file)
+		}
+		return file === p
+	})
+}
+
+/**
+ * Default layout
+ * @param {Object} props
+ * @param {string|undefined} props.title
+ * @param {import('react').ReactNode} props.children
+ * @returns {React.JSX.Element}
+ */
+export function DefaultLayout({ title, children }) {
+	return createElement(
+		'html',
+		{ lang: 'en' },
+		createElement(
+			'head',
+			{},
+			createElement('meta', { charSet: 'utf-8' }),
+			createElement('meta', {
+				name: 'viewport',
+				content: 'width=device-width, initial-scale=1'
+			}),
+			title && createElement('title', {}, title)
+		),
+		createElement('body', {}, children)
+	)
+}
+
+/**
+ * @param {string} cmd
+ */
+export async function $(cmd) {
+	return new Promise((resolve, reject) => {
+		exec(cmd, (err, stdout, stderr) => {
+			if (err) {
+				reject(err)
+			}
+			if (stderr) {
+				console.error(stderr)
+			}
+			console.log(stdout)
+			resolve(stdout)
+		})
+	})
+}

package/lib/watch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {import("fs").PathLike} dir
+ * @param {RegExp} ignore
+ * @param {{(event: fs.FileChangeInfo<string>): Promise<void> | void}} onChange
+ */
+export function watch(dir: import("fs").PathLike, ignore: RegExp, onChange: {
+    (event: fs.FileChangeInfo<string>): Promise<void> | void;
+}): Promise<void>;
+import fs from 'node:fs/promises';
+//# sourceMappingURL=watch.d.ts.map

package/lib/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["watch.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,2BAJW,OAAO,IAAI,EAAE,QAAQ,UACrB,MAAM,YACN;IAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAAC,iBA+CpE;eApDc,kBAAkB"}

package/lib/watch.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises'
+
+/**
+ * @param {import("fs").PathLike} dir
+ * @param {RegExp} ignore
+ * @param {{(event: fs.FileChangeInfo<string>): Promise<void> | void}} onChange
+ */
+export async function watch(dir, ignore, onChange) {
+	let busy = false
+	let dirty = false
+	/** @type {ReturnType<typeof setTimeout> | null} */
+	let timeout = null
+	const delay = 1000
+	const defaultIgnorePattern = /node_modules|\.git|\.DS_Store/
+
+	const watcher = fs.watch(dir, { recursive: true })
+	for await (const event of watcher) {
+		if (
+			event.eventType !== 'change' ||
+			event.filename === null ||
+			shouldIgnore(event.filename)
+		) {
+			continue
+		}
+		console.log(`file changed: ${event.filename}`)
+		dirty = true
+		if (busy) {
+			continue
+		}
+		if (timeout !== null) clearTimeout(timeout)
+		timeout = setTimeout(processEvent, delay, event)
+	}
+
+	/**
+	 * @param {any} event
+	 */
+	async function processEvent(event) {
+		busy = true
+		dirty = false
+		await onChange(event)
+		busy = false
+		if (dirty) {
+			processEvent(event)
+		}
+	}
+
+	/**
+	 * @param {string} filename
+	 */
+	function shouldIgnore(filename) {
+		return defaultIgnorePattern.test(filename) || ignore.test(filename)
+	}
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "orga-build",
+  "version": "0.1.0",
+  "description": "A simple tool that builds org-mode files into a website",
+  "type": "module",
+  "bin": {
+    "orga-build": "cli.js"
+  },
+  "files": [
+    "lib/",
+    "cli.js",
+    "index.js",
+    "index.d.ts",
+    "index.d.ts.map"
+  ],
+  "exports": "./index.js",
+  "keywords": [
+    "orgajs",
+    "org-mode",
+    "build",
+    "website",
+    "react"
+  ],
+  "author": "Xiaoxing Hu <hi@xiaoxing.dev>",
+  "license": "MIT",
+  "dependencies": {
+    "@orgajs/esbuild": "^1.1.1",
+    "esbuild": "^0.24.2",
+    "globby": "^14.0.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "rehype-katex": "^7.0.1",
+    "serve-handler": "^6.1.6",
+    "@orgajs/node-loader": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "@types/serve-handler": "^6.1.4",
+    "@orgajs/orgx": "^2.5.0"
+  },
+  "scripts": {}
+}