@hashrock/ono 0.1.2 → 0.2.0

package/src/bundler.js

@@ -1,81 +1,232 @@
+// @ts-nocheck — consumes the parser's anonymous-tuple combinator results;
+// checkJs adds noise here without catching real bugs (see parser.js).
 /**
- * Bundler - Bundle JSX files into a single executable module
+ * Mini bundler - browser-compatible.
+ *
+ * Each module is wrapped in a factory function and linked with a tiny
+ * lazy require(), so no topological sort is needed and import cycles
+ * behave like CommonJS. Module syntax is parsed with the parser
+ * combinators in parser.js — no regular expressions over source code.
+ *
+ * The host environment supplies I/O:
+ *   - load(id): return the module's JavaScript source (JSX already transformed)
+ *   - resolve(specifier, fromId): turn a relative specifier into a module id
+ *
+ * Known limitations (deliberate, for simplicity): no top-level await,
+ * no destructuring in exported declarations, `export *` copies a
+ * snapshot of the source module.
  */
+import { parseModule, isIdentifierName } from "./parser.js";
 
-import fs from "node:fs/promises";
-import { collectDependencies } from "./resolver.js";
-import { transformJSX } from "./transformer.js";
+const isRelative = (specifier) =>
+  specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
 
-/**
- * Bundle a JSX file and all its dependencies
- * @param {string} entryFile - Absolute path to entry file
- * @returns {Promise<string>} Bundled JavaScript code
- */
-export async function bundle(entryFile) {
-  // Collect all dependencies
-  const { order } = await collectDependencies(entryFile);
-
-  const modules = [];
-
-  // Process each module in dependency order
-  for (let i = 0; i < order.length; i++) {
-    const filePath = order[i];
-    const isEntry = i === order.length - 1; // Last file is entry
-
-    // Read the file
-    const source = await fs.readFile(filePath, "utf-8");
-
-    // Transform JSX to JS
-    const transformed = transformJSX(source, filePath);
-
-    // Remove import statements (they're already resolved)
-    const withoutImports = removeImports(transformed);
-
-    // Remove export default from non-entry files
-    const withoutExports = isEntry ? withoutImports : removeExportDefault(withoutImports);
+/** Apply text replacements (non-overlapping) to a source string */
+function applyEdits(source, edits) {
+  let result = source;
+  for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return result;
+}
 
-    modules.push({
-      path: filePath,
-      code: withoutExports,
-      isEntry
-    });
+/** Generate the require/destructuring lines that replace an import statement */
+function importReplacement(imp, requireCall) {
+  const parts = [];
+  if (imp.defaultBinding) parts.push(`const ${imp.defaultBinding} = ${requireCall}.default;`);
+  if (imp.namespace) parts.push(`const ${imp.namespace} = ${requireCall};`);
+  if (imp.named && imp.named.length > 0) {
+    const bindings = imp.named
+      .map(({ imported, local }) =>
+        imported === local ? imported : `${JSON.stringify(imported)}: ${local}`,
+      )
+      .join(", ");
+    parts.push(`const { ${bindings} } = ${requireCall};`);
   }
+  if (parts.length === 0) parts.push(`${requireCall};`); // side-effect only
+  return parts.join(" ");
+}
 
-  // Combine all modules into one
-  const bundledCode = modules.map(m => m.code).join("\n\n");
+/** Record the top-level names an import statement binds */
+function collectBindings(imp, bindings) {
+  if (imp.defaultBinding) bindings.add(imp.defaultBinding);
+  if (imp.namespace) bindings.add(imp.namespace);
+  for (const { local } of imp.named ?? []) bindings.add(local);
+}
 
-  return bundledCode;
+const LINKER_RUNTIME = `const __ono_cache = new Map();
+function __ono_require(id) {
+  let record = __ono_cache.get(id);
+  if (!record) {
+    record = { exports: {} };
+    __ono_cache.set(id, record);
+    __ono_modules[id](record.exports, __ono_require);
+  }
+  return record.exports;
 }
+function __ono_export_star(target, source) {
+  for (const key of Object.keys(source)) {
+    if (key !== "default") target[key] = source[key];
+  }
+}`;
 
 /**
- * Remove import statements from code (but keep package imports)
- * @param {string} code - JavaScript code
- * @returns {string} Code with relative imports removed, package imports kept
+ * Bundle an entry module and its local imports into one script.
+ *
+ * @param {Object} options
+ * @param {string} options.entry - Module id of the entry point
+ * @param {(id: string) => string | Promise<string>} options.load - Return a module's JS source
+ * @param {(specifier: string, fromId: string) => string} options.resolve - Resolve a relative specifier
+ * @param {"hoist"|"error"} [options.onExternal] - Bare (package) imports: hoist to the
+ *   bundle top (needs an ESM host, e.g. Node) or throw (e.g. the browser REPL)
+ * @param {boolean} [options.exposeEntryFunctions] - Also export the entry's top-level
+ *   function declarations (REPL convenience for code without exports)
+ * @returns {Promise<{code: string, entryId: string, entryExports: string[], externalBindings: Set<string>}>}
+ *   `code` defines __ono_modules/__ono_require and ends by evaluating the
+ *   entry into `__ono_entry`. The caller decides how to expose it.
  */
-function removeImports(code) {
-  // Remove only relative import statements, keep package imports
-  const lines = code.split("\n");
-  const filteredLines = lines.filter(line => {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("import ")) return true;
-
-    // Keep package imports (not starting with . or /)
-    const importMatch = trimmed.match(/from\s+['"]([^'"]+)['"]/);
-    if (importMatch && !importMatch[1].startsWith('.') && !importMatch[1].startsWith('/')) {
-      return true; // Keep package import
+export async function bundle(options) {
+  const { entry, load, resolve, onExternal = "hoist", exposeEntryFunctions = false } = options;
+
+  const moduleCodes = new Map();
+  const externalImports = [];
+  const externalBindings = new Set();
+  const entryExports = [];
+  const addEntryExport = (name) => {
+    if (!entryExports.includes(name)) entryExports.push(name);
+  };
+
+  const queue = [entry];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (moduleCodes.has(id)) continue;
+
+    const source = await load(id);
+    let parsed;
+    try {
+      parsed = parseModule(source);
+    } catch (error) {
+      throw new Error(`${error.message} (in ${id})`);
     }
 
-    return false; // Remove relative import
-  });
+    const isEntry = id === entry;
+    const edits = [];
+    // Function declarations are hoisted, so their export assignments go at
+    // the top of the factory — this keeps them visible across import cycles,
+    // mirroring ESM hoisting. Everything else is assigned at the end.
+    const head = [];
+    const tail = [];
+
+    for (const imp of parsed.imports) {
+      if (isRelative(imp.specifier)) {
+        const depId = resolve(imp.specifier, id);
+        queue.push(depId);
+        const requireCall = `__ono_require(${JSON.stringify(depId)})`;
+        edits.push({ start: imp.start, end: imp.end, text: importReplacement(imp, requireCall) });
+      } else if (onExternal === "hoist") {
+        // Package import: move it to the top of the bundle, outside the factories
+        const statement = source.slice(imp.start, imp.end).trim();
+        if (!externalImports.includes(statement)) externalImports.push(statement);
+        collectBindings(imp, externalBindings);
+        edits.push({ start: imp.start, end: imp.end, text: "" });
+      } else {
+        throw new Error(`Cannot bundle package import "${imp.specifier}" (in ${id})`);
+      }
+    }
 
-  return filteredLines.join("\n");
-}
+    for (const exp of parsed.exports) {
+      switch (exp.type) {
+        case "exportStarFrom": {
+          if (!isRelative(exp.specifier)) {
+            throw new Error(`"export * from" a package is not supported (in ${id})`);
+          }
+          const depId = resolve(exp.specifier, id);
+          queue.push(depId);
+          const requireCall = `__ono_require(${JSON.stringify(depId)})`;
+          const text = exp.alias
+            ? `__ono_exports[${JSON.stringify(exp.alias)}] = ${requireCall};`
+            : `__ono_export_star(__ono_exports, ${requireCall});`;
+          edits.push({ start: exp.start, end: exp.end, text });
+          if (isEntry && exp.alias) addEntryExport(exp.alias);
+          break;
+        }
+        case "exportNamedFrom": {
+          if (!isRelative(exp.specifier)) {
+            throw new Error(`Re-exporting from a package is not supported (in ${id})`);
+          }
+          const depId = resolve(exp.specifier, id);
+          queue.push(depId);
+          const requireCall = `__ono_require(${JSON.stringify(depId)})`;
+          const text = exp.named
+            .map(
+              ({ local, exported }) =>
+                `__ono_exports[${JSON.stringify(exported)}] = ${requireCall}[${JSON.stringify(local)}];`,
+            )
+            .join(" ");
+          edits.push({ start: exp.start, end: exp.end, text });
+          if (isEntry) exp.named.forEach(({ exported }) => addEntryExport(exported));
+          break;
+        }
+        case "exportNamed": {
+          edits.push({ start: exp.start, end: exp.end, text: "" });
+          for (const { local, exported } of exp.named) {
+            tail.push(`__ono_exports[${JSON.stringify(exported)}] = ${local};`);
+            if (isEntry) addEntryExport(exported);
+          }
+          break;
+        }
+        case "exportDefaultDeclaration": {
+          edits.push({ start: exp.start, end: exp.headerEnd, text: "" });
+          const target = exp.declarationKind === "function" ? head : tail;
+          target.push(`__ono_exports.default = ${exp.name};`);
+          if (isEntry) addEntryExport("default");
+          break;
+        }
+        case "exportDefaultExpression": {
+          edits.push({ start: exp.start, end: exp.headerEnd, text: "__ono_exports.default =" });
+          if (isEntry) addEntryExport("default");
+          break;
+        }
+        case "exportDeclaration": {
+          edits.push({ start: exp.start, end: exp.headerEnd, text: "" });
+          const target = exp.declarationKind === "function" ? head : tail;
+          for (const name of exp.names) {
+            target.push(`__ono_exports[${JSON.stringify(name)}] = ${name};`);
+            if (isEntry) addEntryExport(name);
+          }
+          break;
+        }
+      }
+    }
 
-/**
- * Remove export default from code
- * @param {string} code - JavaScript code
- * @returns {string} Code without export default
- */
-function removeExportDefault(code) {
-  return code.replace(/export\s+default\s+/g, "");
+    if (exposeEntryFunctions && isEntry) {
+      for (const name of parsed.topLevelFunctions) {
+        if (!entryExports.includes(name)) {
+          tail.push(`__ono_exports[${JSON.stringify(name)}] = ${name};`);
+          addEntryExport(name);
+        }
+      }
+    }
+
+    let code = applyEdits(source, edits);
+    if (head.length > 0) code = `${head.join("\n")}\n${code}`;
+    if (tail.length > 0) code += `\n${tail.join("\n")}`;
+    moduleCodes.set(id, code);
+  }
+
+  const parts = [];
+  if (externalImports.length > 0) parts.push(externalImports.join("\n"));
+  parts.push("const __ono_modules = {};");
+  for (const [id, code] of moduleCodes) {
+    parts.push(`__ono_modules[${JSON.stringify(id)}] = function (__ono_exports, __ono_require) {\n${code}\n};`);
+  }
+  parts.push(LINKER_RUNTIME);
+  parts.push(`const __ono_entry = __ono_require(${JSON.stringify(entry)});`);
+
+  return {
+    code: parts.join("\n\n"),
+    entryId: entry,
+    entryExports: entryExports.filter((name) => name === "default" || isIdentifierName(name)),
+    externalBindings,
+  };
 }

package/src/cli.js

@@ -3,191 +3,16 @@
 /**
  * Ono CLI - Minimalist SSG framework
  */
-import { resolve } from "node:path";
-import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join, relative } from "node:path";
-import { loadUnoConfig } from "./unocss.js";
-import { createDevServer } from "./server.js";
-import { buildFile, buildFiles, generateUnoCSS } from "./builder.js";
-import { watchFile, watchFiles, createWebSocketServer } from "./watcher.js";
+import { runBuildCommand } from "./commands/build.js";
+import { runDevCommand } from "./commands/dev.js";
+import { DIRS, PORTS } from "./constants.js";
 
 const args = process.argv.slice(2);
 const command = args[0];
 
-async function copyPublicFiles(outputDir = "dist") {
-  const publicDir = resolve(process.cwd(), "public");
-  const outDir = resolve(process.cwd(), outputDir);
-
-  if (!existsSync(publicDir)) {
-    return;
-  }
-
-  async function copyRecursive(src, dest) {
-    const entries = await readdir(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = join(src, entry.name);
-      const destPath = join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        await mkdir(destPath, { recursive: true });
-        await copyRecursive(srcPath, destPath);
-      } else {
-        await mkdir(dest, { recursive: true });
-        await copyFile(srcPath, destPath);
-      }
-    }
-  }
-
-  await copyRecursive(publicDir, outDir);
-}
-
-async function runBuildCommand() {
-  // Check for help flag
-  if (args.includes("--help") || args.includes("-h")) {
-    console.log(`
-Usage: ono build [input] [options]
-
-Build JSX files to static HTML
-
-Arguments:
-  input                  File or directory to build (default: pages)
-
-Options:
-  --output <dir>         Output directory (default: dist)
-  --help                 Show this help message
-
-Examples:
-  ono build              Build all pages in pages/ directory
-  ono build pages/index.jsx   Build a single file
-  ono build --output build   Build to build/ directory
-`);
-    process.exit(0);
-  }
-
-  // Filter out options to get the input argument
-  const nonOptionArgs = args.slice(1).filter(arg => !arg.startsWith("--"));
-  const input = nonOptionArgs[0] || "pages";
-  const outputDir = args.includes("--output")
-    ? args[args.indexOf("--output") + 1]
-    : "dist";
-
-  const unocssConfig = await loadUnoConfig();
-
-  // Check if input is a directory or a file
-  const inputPath = resolve(process.cwd(), input);
-  const inputStat = await stat(inputPath);
-
-  if (inputStat.isDirectory()) {
-    // Build all files in directory
-    await buildFiles(input, { outputDir, unocssConfig });
-  } else {
-    // Build single file
-    await buildFile(input, { outputDir, unocssConfig });
-  }
-
-  // Copy public files
-  await copyPublicFiles(outputDir);
-
-  // Generate UnoCSS
-  await generateUnoCSS({ outputDir, unocssConfig });
-
-  console.log("\n✨ Build complete!");
-}
-
-
-
-async function runDevCommand() {
-  const input = args[1] || "pages";
-  const port = args.includes("--port")
-    ? parseInt(args[args.indexOf("--port") + 1])
-    : 3000;
-  const outputDir = args.includes("--output")
-    ? args[args.indexOf("--output") + 1]
-    : "dist";
-
-  const unocssConfig = await loadUnoConfig();
-
-  // Initial build
-  const inputPath = resolve(process.cwd(), input);
-  const inputStat = await stat(inputPath);
-
-  if (inputStat.isDirectory()) {
-    await buildFiles(input, { outputDir, unocssConfig });
-  } else {
-    await buildFile(input, { outputDir, unocssConfig });
-  }
-
-  await copyPublicFiles(outputDir);
-  await generateUnoCSS({ outputDir, unocssConfig });
-
-  // Create WebSocket server for live reload
-  const { wss, port: wsPort } = createWebSocketServer();
-
-  // Start dev server
-  const mode = inputStat.isDirectory() ? "pages" : "single";
-  const indexFile = inputStat.isFile()
-    ? relative(
-        outputDir,
-        (await buildFile(input, { outputDir, unocssConfig, silent: true }))
-          .outputPath
-      )
-    : "index.html";
-
-  let serverPort = port;
-  try {
-    const { server, app, port: actualPort } = await createDevServer({
-      outputDir,
-      port,
-      mode,
-      indexFile,
-    });
-    serverPort = actualPort;
-  } catch (error) {
-    if (error.code === "EADDRINUSE") {
-      serverPort = port + 1;
-      console.log(
-        `ℹ️  Port ${port} is busy, using port ${serverPort} instead`
-      );
-      await createDevServer({
-        outputDir,
-        port: serverPort,
-        mode,
-        indexFile,
-      });
-    } else {
-      throw error;
-    }
-  }
-
-  // Watch for changes
-  if (inputStat.isDirectory()) {
-    await watchFiles(input, {
-      outputDir,
-      unocssConfig,
-      wss,
-      onRebuild: async () => {
-        await copyPublicFiles(outputDir);
-      },
-    });
-  } else {
-    await watchFile(input, {
-      outputDir,
-      unocssConfig,
-      wss,
-      onRebuild: async () => {
-        await copyPublicFiles(outputDir);
-      },
-    });
-  }
-
-  console.log(`\n🚀 Server running at http://localhost:${serverPort}`);
-  console.log(`📝 Serving: ${input}/ → ${outputDir}/`);
-}
-
-
-
+/**
+ * Show main help message
+ */
 function showHelp() {
   console.log(`
 Ono - Minimalist SSG Framework
@@ -197,39 +22,43 @@ Usage:
 
 Commands:
   build [input]          Build JSX files to static HTML
-                         input: file or directory (default: pages)
+                         input: file or directory (default: ${DIRS.PAGES})
 
   dev [input]            Build, watch, and serve with live reload
-                         input: file or directory (default: pages)
+                         input: file or directory (default: ${DIRS.PAGES})
 
 Options:
-  --output <dir>         Output directory (default: dist)
-  --port <number>        Server port (default: 3000)
+  --output <dir>         Output directory (default: ${DIRS.OUTPUT})
+  --port <number>        Server port (default: ${PORTS.SERVER})
   --help                 Show this help message
 
 Examples:
-  ono build              Build all pages in pages/ directory
+  ono build              Build all pages in ${DIRS.PAGES}/ directory
   ono build pages/index.jsx   Build a single file
   ono dev                Start dev server with live reload
   ono dev --port 8080    Start dev server on port 8080
 `);
 }
 
-// Main CLI handler
-(async () => {
+/**
+ * Main CLI entry point
+ */
+async function main() {
   try {
     if (!command || command === "--help" || command === "-h") {
       showHelp();
       process.exit(0);
     }
 
+    const commandArgs = args.slice(1);
+
     switch (command) {
       case "build":
-        await runBuildCommand();
+        await runBuildCommand(commandArgs);
         break;
 
       case "dev":
-        await runDevCommand();
+        await runDevCommand(commandArgs);
         break;
 
       default:
@@ -244,4 +73,6 @@ Examples:
     }
     process.exit(1);
   }
-})();
+}
+
+main();

package/src/commands/build.js

@@ -0,0 +1,141 @@
+/**
+ * Build command for Ono CLI
+ */
+import { resolve, join } from "node:path";
+import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { buildFile, buildFiles, generateUnoCSS } from "../builder.js";
+import { generateBarrels } from "../barrels.js";
+import { DIRS, PORTS } from "../constants.js";
+
+/**
+ * Parse arguments shared by the build and dev commands
+ * @param {string[]} args - Command line arguments
+ * @returns {{ input: string, outputDir: string, port: number, showHelp: boolean }}
+ */
+export function parseCommandArgs(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      output: { type: "string", default: DIRS.OUTPUT },
+      port: { type: "string", default: String(PORTS.SERVER) },
+      help: { type: "boolean", short: "h", default: false },
+    },
+    allowPositionals: true,
+  });
+
+  return {
+    input: positionals[0] || DIRS.PAGES,
+    outputDir: values.output,
+    port: Number.parseInt(values.port, 10),
+    showHelp: values.help,
+  };
+}
+
+/**
+ * Show build command help
+ */
+export function showBuildHelp() {
+  console.log(`
+Usage: ono build [input] [options]
+
+Build JSX files to static HTML
+
+Arguments:
+  input                  File or directory to build (default: ${DIRS.PAGES})
+
+Options:
+  --output <dir>         Output directory (default: ${DIRS.OUTPUT})
+  --help                 Show this help message
+
+Examples:
+  ono build              Build all pages in ${DIRS.PAGES}/ directory
+  ono build pages/index.jsx   Build a single file
+  ono build --output build   Build to build/ directory
+`);
+}
+
+/**
+ * Copy public files to output directory
+ * @param {string} outputDir - Output directory path
+ * @returns {Promise<void>}
+ */
+export async function copyPublicFiles(outputDir = DIRS.OUTPUT) {
+  const publicDir = resolve(process.cwd(), DIRS.PUBLIC);
+  const outDir = resolve(process.cwd(), outputDir);
+
+  if (!existsSync(publicDir)) {
+    return;
+  }
+
+  /**
+   * @param {string} src
+   * @param {string} dest
+   */
+  async function copyRecursive(src, dest) {
+    const entries = await readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = join(src, entry.name);
+      const destPath = join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await mkdir(destPath, { recursive: true });
+        await copyRecursive(srcPath, destPath);
+      } else {
+        await mkdir(dest, { recursive: true });
+        await copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  await copyRecursive(publicDir, outDir);
+}
+
+/**
+ * Initialize barrels if barrels directory exists
+ * @returns {Promise<void>}
+ */
+export async function initializeBarrels() {
+  const barrelsDir = resolve(process.cwd(), DIRS.BARRELS);
+  if (existsSync(barrelsDir)) {
+    console.log("Generating barrel files...");
+    await generateBarrels(barrelsDir);
+  }
+}
+
+/**
+ * Run the build command
+ * @param {string[]} args - Command line arguments (after 'build')
+ * @returns {Promise<void>}
+ */
+export async function runBuildCommand(args) {
+  const { input, outputDir, showHelp } = parseCommandArgs(args);
+
+  if (showHelp) {
+    showBuildHelp();
+    process.exit(0);
+  }
+
+  // Generate barrel files if barrels directory exists
+  await initializeBarrels();
+
+  // Check if input is a directory or a file
+  const inputPath = resolve(process.cwd(), input);
+  const inputStat = await stat(inputPath);
+
+  if (inputStat.isDirectory()) {
+    await buildFiles(input, { outputDir });
+  } else {
+    await buildFile(input, { outputDir });
+  }
+
+  // Copy public files
+  await copyPublicFiles(outputDir);
+
+  // Generate UnoCSS
+  await generateUnoCSS({ outputDir });
+
+  console.log("\n✨ Build complete!");
+}