defuss-ssg 0.0.1

package/dist/serve-COHw7ASj.mjs

@@ -0,0 +1,366 @@
+import chokidar from 'chokidar';
+import express from 'express';
+import serveStatic from 'serve-static';
+import { join, resolve, dirname, sep } from 'node:path';
+import { existsSync, rmdirSync, mkdirSync } from 'node:fs';
+import esbuild from 'esbuild';
+import remarkFrontmatter from 'remark-frontmatter';
+import rehypeKatex from 'rehype-katex';
+import remarkMath from 'remark-math';
+import remarkMdxFrontmatter from 'remark-mdx-frontmatter';
+import { t as tailwindPlugin } from './tailwind-DV23JSh-.mjs';
+import mdx from '@mdx-js/esbuild';
+import glob from 'fast-glob';
+import { getBrowserGlobals, getDocument, renderSync, renderToString } from 'defuss/server';
+import { cp, readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const remarkPlugins = [
+  // Parse both YAML and TOML (or omit options to default to YAML)
+  [remarkFrontmatter, ["yaml", "toml"]],
+  // Export each key as an ESM binding: export const title = "…"
+  [remarkMdxFrontmatter, { name: "meta" }],
+  // Convert $…$ and $$…$$ into math nodes for KaTeX
+  remarkMath
+];
+const rehypePlugins = [
+  //rehypeMdxTitle,
+  rehypeKatex
+];
+
+const readConfig = async (projectDir, debug) => {
+  const configPath = join(projectDir, "config.ts");
+  let config = {};
+  if (existsSync(configPath)) {
+    if (debug) {
+      console.log(`Using config from ${configPath}`);
+    }
+    const result = await esbuild.build({
+      entryPoints: [configPath],
+      format: "esm",
+      bundle: true,
+      target: ["esnext"],
+      write: false
+    });
+    const code = result.outputFiles[0].text;
+    const encoded = Buffer.from(code).toString("base64");
+    const dataUrl = `data:text/javascript;base64,${encoded}`;
+    const module = await import(dataUrl);
+    config = module.default;
+  }
+  config.pages = config.pages || configDefaults.pages;
+  config.output = config.output || configDefaults.output;
+  config.components = config.components || configDefaults.components;
+  config.assets = config.assets || configDefaults.assets;
+  config.plugins = config.plugins || configDefaults.plugins;
+  config.tmp = config.tmp || configDefaults.tmp;
+  config.remarkPlugins = config.remarkPlugins || configDefaults.remarkPlugins;
+  config.rehypePlugins = config.rehypePlugins || configDefaults.rehypePlugins;
+  return config;
+};
+const configDefaults = {
+  pages: "pages",
+  output: "dist",
+  components: "components",
+  assets: "assets",
+  tmp: ".ssg-temp",
+  plugins: [tailwindPlugin],
+  remarkPlugins,
+  rehypePlugins
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const build = async ({
+  projectDir,
+  debug = false,
+  mode = "build"
+}) => {
+  const startTime = performance.now();
+  const config = await readConfig(projectDir, debug);
+  if (debug) {
+    console.log("PRE config", config);
+  }
+  if (debug) {
+    console.log("Using config:", config);
+  }
+  const inputPagesDir = join(projectDir, config.pages);
+  const inputComponentsDir = join(projectDir, config.components);
+  const inputAssetsDir = join(projectDir, config.assets);
+  const tmpPagesDir = join(config.tmp, config.pages);
+  const tmpComponentsDir = join(config.tmp, config.components);
+  const outputProjectDir = join(projectDir, config.output);
+  const outputPagesDir = join(projectDir, config.output, config.pages);
+  const outputComponentsDir = join(
+    projectDir,
+    config.output,
+    config.components
+  );
+  const outputAssetsDir = join(projectDir, config.output, config.assets);
+  if (debug) {
+    console.log("Input pages dir:", inputPagesDir);
+    console.log("Input components dir:", inputComponentsDir);
+    console.log("Input assets dir:", inputAssetsDir);
+    console.log("Temp pages dir:", tmpPagesDir);
+    console.log("Temp components dir:", tmpComponentsDir);
+    console.log("Output pages dir:", outputPagesDir);
+    console.log("Output components dir:", outputComponentsDir);
+    console.log("Output assets dir:", outputAssetsDir);
+  }
+  if (!existsSync(inputPagesDir)) {
+    throw new Error(`Input pages directory does not exist: ${inputPagesDir}`);
+  } else if (debug) {
+    console.log(`Input pages directory exists: ${inputPagesDir}`);
+  }
+  if (!existsSync(inputComponentsDir)) {
+    console.warn(
+      `There is no components directory: ${inputComponentsDir}. You may not be able to use any custom components.`
+    );
+  }
+  if (!existsSync(inputAssetsDir)) {
+    console.warn(
+      `There is no assets directory: ${inputAssetsDir}. You may not be able to serve any custom assets.`
+    );
+  }
+  for (const plugin of config.plugins || []) {
+    if (plugin.phase === "pre" && (plugin.mode === mode || plugin.mode === "both")) {
+      if (debug) {
+        console.log(`Running pre-plugin: ${plugin.name}`);
+      }
+      await plugin.fn(projectDir, config);
+    }
+  }
+  if (existsSync(config.tmp)) {
+    if (debug) {
+      console.log(`Removing existing temp folder: ${config.tmp}`);
+    }
+    rmdirSync(config.tmp, { recursive: true });
+  }
+  await cp(projectDir, config.tmp, {
+    recursive: true,
+    filter: (src) => {
+      const relative = src.replace(join(projectDir, ""), "");
+      if (relative.startsWith(join("assets", "")) || relative.startsWith(join("node_modules", ""))) {
+        return false;
+      }
+      return true;
+    }
+  });
+  await cp(
+    // because of this the packaging of defuss-ssg must be done with "files" including the "components" folder
+    // in a built situation, __dirname is the dist folder of defuss-ssg
+    resolve(join(__dirname, "components", "index.mjs")),
+    // dist folder
+    join(tmpComponentsDir, "hydrate.tsx")
+    // a valid JS is always a valid TS file
+  );
+  await cp(
+    // because of this the packaging of defuss-ssg must be done with "files" including the "runtime" file
+    // in a built situation, __dirname is the dist folder of defuss-ssg
+    resolve(join(__dirname, "runtime.mjs")),
+    // dist folder
+    join(tmpComponentsDir, "runtime.ts")
+    // a valid JS is always a valid TS file
+  );
+  await esbuild.build({
+    entryPoints: [join(tmpPagesDir, "**/*.mdx")],
+    format: "esm",
+    bundle: true,
+    sourcemap: true,
+    target: ["esnext"],
+    outdir: tmpPagesDir,
+    plugins: [
+      mdx({
+        // using the defuss jsxImportSource so that the output code contains JSX runtime calls
+        // and can be rendered to HTML here on the server (in Node.js).
+        jsxImportSource: "defuss",
+        // We also use any remark/rehype plugins specified in the config file.
+        remarkPlugins: config.remarkPlugins,
+        rehypePlugins: config.rehypePlugins
+      })
+    ]
+  });
+  await esbuild.build({
+    entryPoints: [
+      join(tmpComponentsDir, "**/*.tsx"),
+      join(tmpComponentsDir, "**/*.ts")
+    ],
+    format: "esm",
+    bundle: true,
+    // making sure we can do code splitting for shared dependencies (e.g. defuss lib)
+    splitting: true,
+    target: ["esnext"],
+    outdir: tmpComponentsDir
+  });
+  const outputFiles = await glob.async(join(tmpPagesDir, "**/*.js"));
+  if (!existsSync(outputProjectDir)) {
+    mkdirSync(outputProjectDir, { recursive: true });
+  }
+  for (const outputFile of outputFiles) {
+    const outputHtmlFilePath = outputFile.replace(".js", ".html");
+    const relativeOutputHtmlFilePath = outputHtmlFilePath.replace(
+      `${tmpPagesDir}${sep}`,
+      ""
+    );
+    if (debug) {
+      console.log("Processing output file (JS):", outputFile);
+      console.log("Output HTML file path:", outputHtmlFilePath);
+      console.log("Relative output HTML path:", relativeOutputHtmlFilePath);
+    }
+    const code = await readFile(outputFile, "utf-8");
+    const encoded = Buffer.from(code).toString("base64");
+    const dataUrl = `data:text/javascript;base64,${encoded}`;
+    const exports = await import(dataUrl);
+    if (debug) {
+      console.log("exports", exports);
+    }
+    let vdom = exports.default(exports);
+    for (const plugin of config.plugins || []) {
+      if (plugin.phase === "page-vdom" && (plugin.mode === mode || plugin.mode === "both")) {
+        if (debug) {
+          console.log(`Running page-vdom plugin: ${plugin.name}`);
+        }
+        vdom = await plugin.fn(
+          vdom,
+          relativeOutputHtmlFilePath,
+          projectDir,
+          config
+        );
+      }
+    }
+    const browserGlobals = getBrowserGlobals();
+    const document = getDocument(false, browserGlobals);
+    browserGlobals.document = document;
+    let el = renderSync(vdom, document.documentElement, {
+      browserGlobals
+    });
+    for (const plugin of config.plugins || []) {
+      if (plugin.phase === "page-dom" && (plugin.mode === mode || plugin.mode === "both")) {
+        if (debug) {
+          console.log(`Running page-dom plugin: ${plugin.name}`);
+        }
+        el = await plugin.fn(
+          el,
+          relativeOutputHtmlFilePath,
+          projectDir,
+          config
+        );
+      }
+    }
+    let html = renderToString(el);
+    for (const plugin of config.plugins || []) {
+      if (plugin.phase === "page-html" && (plugin.mode === mode || plugin.mode === "both")) {
+        if (debug) {
+          console.log(`Running page-html plugin: ${plugin.name}`);
+        }
+        html = await plugin.fn(
+          html,
+          relativeOutputHtmlFilePath,
+          projectDir,
+          config
+        );
+      }
+    }
+    if (debug) {
+      console.log("Writing HTML file", outputHtmlFilePath);
+    }
+    if (debug) {
+      console.log("Relative HTML path:", relativeOutputHtmlFilePath);
+    }
+    const finalOutputFile = join(
+      projectDir,
+      config.output,
+      relativeOutputHtmlFilePath
+    );
+    if (debug) {
+      console.log("Full HTML output path:", finalOutputFile);
+    }
+    const finalOutputDir = dirname(finalOutputFile);
+    if (!existsSync(finalOutputDir)) {
+      mkdirSync(finalOutputDir, { recursive: true });
+    }
+    await writeFile(finalOutputFile, html);
+  }
+  await cp(tmpComponentsDir, outputComponentsDir, { recursive: true });
+  await cp(inputAssetsDir, outputAssetsDir, { recursive: true });
+  for (const plugin of config.plugins || []) {
+    if (plugin.phase === "post" && (plugin.mode === mode || plugin.mode === "both")) {
+      if (debug) {
+        console.log(`Running post-plugin: ${plugin.name}`);
+      }
+      await plugin.fn(projectDir, config);
+    }
+  }
+  if (!debug) {
+    rmdirSync(config.tmp, { recursive: true });
+  }
+  const endTime = performance.now();
+  const totalTime = (endTime - startTime) / 1e3;
+  console.log(`Build completed in ${totalTime.toFixed(2)} seconds.`);
+};
+
+const serve = async ({ projectDir, debug = false }) => {
+  const config = await readConfig(projectDir, debug);
+  const outputDir = join(projectDir, config.output);
+  const pagesDir = join(projectDir, config.pages);
+  const componentsDir = join(projectDir, config.components);
+  const assetsDir = join(projectDir, config.assets);
+  await build({ projectDir, debug, mode: "serve" });
+  const app = express();
+  const port = 3e3;
+  app.use(serveStatic(outputDir));
+  app.listen(port, () => {
+    console.log(`Server running at http://localhost:${port}`);
+  });
+  let isBuilding = false;
+  let pendingBuild = false;
+  const triggerBuild = async () => {
+    if (isBuilding) {
+      pendingBuild = true;
+      if (debug) {
+        console.log("Build scheduled after current one completes");
+      }
+      return;
+    }
+    isBuilding = true;
+    try {
+      await build({ projectDir, debug, mode: "serve" });
+    } finally {
+      isBuilding = false;
+      if (pendingBuild) {
+        pendingBuild = false;
+        if (debug) {
+          console.log("Running pending build");
+        }
+        await triggerBuild();
+      }
+    }
+  };
+  const watcher = chokidar.watch([pagesDir, componentsDir, assetsDir], {
+    ignored: /(^|[\/\\])\../,
+    // Ignore dotfiles
+    persistent: true,
+    ignoreInitial: true
+    // Ignore initial add events
+  });
+  watcher.on("change", async (path) => {
+    if (debug) {
+      console.log(`File changed: ${path}`);
+    }
+    await triggerBuild();
+  });
+  watcher.on("add", async (path) => {
+    if (debug) {
+      console.log(`File added: ${path}`);
+    }
+    await triggerBuild();
+  });
+  watcher.on("unlink", async (path) => {
+    if (debug) {
+      console.log(`File removed: ${path}`);
+    }
+    await triggerBuild();
+  });
+};
+
+export { rehypePlugins as a, readConfig as b, configDefaults as c, build as d, remarkPlugins as r, serve as s };

package/dist/tailwind-C4AuHybm.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var node_path = require('node:path');
+
+const tailwindPlugin = {
+  name: "tailwind",
+  mode: "both",
+  phase: "post",
+  fn: async (projectDir, { tmp }) => {
+    console.log("Tailwind CSS plugin running... 1 DIR:", node_path.join(projectDir));
+  }
+};
+
+exports.tailwindPlugin = tailwindPlugin;

package/dist/tailwind-DV23JSh-.mjs

@@ -0,0 +1,12 @@
+import { join } from 'node:path';
+
+const tailwindPlugin = {
+  name: "tailwind",
+  mode: "both",
+  phase: "post",
+  fn: async (projectDir, { tmp }) => {
+    console.log("Tailwind CSS plugin running... 1 DIR:", join(projectDir));
+  }
+};
+
+export { tailwindPlugin as t };

package/dist/types-D1n7GtYH.d.ts

@@ -0,0 +1,101 @@
+import { Options } from '@mdx-js/esbuild';
+import { VNode } from 'defuss/server';
+
+type RemarkPlugins = Options["remarkPlugins"];
+type RehypePlugins = Options["rehypePlugins"];
+type PluginFnPageHtml = (html: string, relativeOutputHtmlFilePath: string, projectDir: string, config: SsgConfig) => Promise<string> | string;
+type PluginFnPageVdom = (vdom: VNode, relativeOutputHtmlFilePath: string, projectDir: string, config: SsgConfig) => Promise<VNode> | VNode;
+type PluginFnPageDom = (dom: HTMLElement, relativeOutputHtmlFilePath: string, projectDir: string, config: SsgConfig) => Promise<HTMLElement> | HTMLElement;
+type PluginFnPrePost = (projectDir: string, config: SsgConfig) => Promise<void> | void;
+type BuildMode = "serve" | "build" | "both";
+interface BuildOptions {
+    /**
+     * Enable debug logging during the build process
+     * Defaults to false
+     */
+    debug?: boolean;
+    /**
+     * The root directory of the project to build
+     * No default - this must be provided
+     */
+    projectDir: string;
+    /**
+     * The mode in which to run the build: "serve" for development server mode,
+     * "build" for static site generation mode;
+     * Defaults to "build"
+     */
+    mode: Omit<BuildMode, "both">;
+}
+type PluginFn = PluginFnPageHtml | PluginFnPageVdom | PluginFnPageDom | PluginFnPrePost;
+/**
+ * Plugin interface for extending the SSG build process
+ */
+interface SsgPlugin<T = PluginFn> {
+    /**
+     * The name of the plugin
+     */
+    name: string;
+    /**
+     * When to run the plugin: "pre" before the build starts, "post" after the build completes
+     * "page-vdom" after the VDOM for each page is created, before rendering to DOM
+     * "page-dom" after the DOM for each page is created, before serializing to HTML
+     * "page-html" after the HTML for each page is created, before writing to disk
+     */
+    phase: "pre" | "page-vdom" | "page-dom" | "page-html" | "post";
+    /**
+     * The mode(s) in which the plugin should run: "serve" for development server mode,
+     * "build" for static site generation mode, or "both" for both modes
+     * Defaults to "both"
+     */
+    mode: BuildMode;
+    /**
+     * The plugin function to execute
+     * @param config The current SsgConfig object
+     */
+    fn: T;
+}
+interface SsgConfig {
+    /**
+     * Input directory containing page files (e.g., MDX files)
+     * Defaults to "pages"
+     */
+    pages: string;
+    /**
+     * Output directory for generated static site files
+     * Defaults to "dist"
+     */
+    output: string;
+    /**
+     * Directory containing reusable components (e.g., defuss components)
+     * Defaults to "components"
+     */
+    components: string;
+    /**
+     * Directory containing static assets (e.g., images, fonts)
+     * Defaults to "assets"
+     */
+    assets: string;
+    /**
+     * Temporary working directory for build process
+     * Defaults to ".ssg-temp"
+     */
+    tmp: string;
+    /**
+     * Optional list of plugins to extend the build process
+     */
+    plugins: Array<SsgPlugin>;
+    /**
+     * Remark plugins to use for MDX processing
+     * You can import the default set from "defuss-ssg" and extend it
+     * like this: import { remarkPlugins as defaultRemarkPlugins } from "defuss-ssg"
+     */
+    remarkPlugins: Options["remarkPlugins"];
+    /**
+     * Rehype plugins to use for MDX processing
+     * You can import the default set from "defuss-ssg" and extend it
+     * like this: import { rehypePlugins as defaultRehypePlugins } from "defuss-ssg"
+     */
+    rehypePlugins: Options["rehypePlugins"];
+}
+
+export type { BuildOptions as B, PluginFnPageHtml as P, RemarkPlugins as R, SsgConfig as S, RehypePlugins as a, PluginFnPageVdom as b, PluginFnPageDom as c, PluginFnPrePost as d, BuildMode as e, PluginFn as f, SsgPlugin as g };

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "defuss-ssg",
+  "version": "0.0.1",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": "./dist/cli.mjs",
+  "license": "MIT",
+  "description": "A simple static site generator (SSG) built with defuss.",
+  "keywords": ["ssg", "static", "site", "generator", "defuss"],
+  "repository": {
+    "url": "git+https://github.com/kyr0/defuss.git",
+    "type": "git"
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist && rm -rf ./node_modules/.pnpm",
+    "pretest": "pnpm run build",
+    "prebuild": "pnpm run clean",
+    "build": "pkgroll",
+    "cli-build": "node ./dist/cli.mjs build",
+    "cli-serve": "node ./dist/cli.mjs serve",
+    "test": "vitest --run  --coverage"
+  },
+  "author": "Aron Homberg <info@aron-homberg.de>",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./components": {
+      "require": {
+        "types": "./dist/components/index.d.cts",
+        "default": "./dist/components/index.cjs"
+      },
+      "import": {
+        "types": "./dist/components/index.d.mts",
+        "default": "./dist/components/index.mjs"
+      }
+    },
+    "./runtime": {
+      "require": {
+        "types": "./dist/runtime.d.cts",
+        "default": "./dist/runtime.cjs"
+      },
+      "import": {
+        "types": "./dist/runtime.d.mts",
+        "default": "./dist/runtime.mjs"
+      }
+    },
+    "./plugins": {
+      "require": {
+        "types": "./dist/plugins/index.d.cts",
+        "default": "./dist/plugins/index.cjs"
+      },
+      "import": {
+        "types": "./dist/plugins/index.d.mts",
+        "default": "./dist/plugins/index.mjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": ["dist"],
+  "engines": {
+    "node": "^18.17.1 || ^20.3.0 || >=21.0.0"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "serve-static": "^2.2.0",
+    "chokidar": "^4.0.3",
+    "@mdx-js/esbuild": "^3.1.1",
+    "esbuild": "^0.25.9",
+    "rehype-mdx-title": "^3.2.0",
+    "rehype-katex": "^7.0.1",
+    "remark-math": "^6.0.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-mdx-frontmatter": "^5.2.0",
+    "fast-glob": "^3.3.3",
+    "@types/express": "^5.0.3",
+    "@types/serve-static": "^1.15.8",
+    "defuss": "^2.1.1",
+    "defuss-runtime": "^1.2.0"
+  },
+  "devDependencies": {
+    "pkgroll": "^2.5.1",
+    "typescript": "^5.6.3",
+    "happy-dom": "^15.11.7"
+  }
+}