nattoppet 4.0.1 → 4.1.0

package/GUIDE.md

@@ -34,8 +34,8 @@ This guide covers writing `.ymd` files from the perspective of an end user.
 
 ### Prerequisites
 
-- [Bun](https://bun.sh) (≥1.0)
-- Clone this repository and run `bun install` in the project root.
+- [Node.js](https://nodejs.org/) 22.18 or newer.
+- Install Nattoppet with `npm install -g nattoppet`.
 
 ### Your first document
 
@@ -56,13 +56,13 @@ This line is not indented, so it passes through as raw HTML.
 Compile it:
 
 ```bash
-bun run nattoppet.ts input.ymd > output.html
+nattoppet input.ymd > output.html
 ```
 
 Preview with live reload:
 
 ```bash
-bun run nattoppet-dev.ts input.ymd
+nattoppet-dev input.ymd
 ```
 
 The `--dev` flag disables minification and is useful for debugging. Both compilation modes write to stdout.
@@ -651,9 +651,9 @@ The delimiter passed to `capture_until` is consumed from `remaining` but is **no
 You can turn a `.ymd` file into a desktop application:
 
 ```bash
-bun run nattoppet-native.ts init        # create native/ Rust scaffold
-bun run nattoppet-native.ts bundle file.ymd  # compile HTML into native/
-bun run nattoppet-native.ts build file.ymd   # compile HTML and run cargo build --release
+nattoppet-native init        # create native/ Rust scaffold
+nattoppet-native bundle file.ymd  # compile HTML into native/
+nattoppet-native build file.ymd   # compile HTML and run cargo build --release
 ```
 
 The result is a single native binary (Linux/macOS/Windows) that embeds the HTML and renders it with a web-view.
@@ -661,7 +661,7 @@ The result is a single native binary (Linux/macOS/Windows) that embeds the HTML
 ### Project scaffolding
 
 ```bash
-bun run nattoppet-init.ts form
+nattoppet-init form
 ```
 
 This generates a starter `main.ymd`, `main.js`, and optionally Rust/WASM boilerplate plus a GitHub Pages deployment workflow.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shiwei Zhang
+
+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/dist/nattoppet-dev.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// nattoppet-dev.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as http from "node:http";
+import * as cp from "node:child_process";
+import { fileURLToPath } from "node:url";
+var file = process.argv[2];
+if (process.argv.length < 3 || file == "--help") {
+  console.log("Usage: nattoppet-dev [file] [hook cmd]...");
+  process.exit(0);
+}
+var runtimeExt = path.extname(fileURLToPath(import.meta.url)) === ".js" ? ".js" : ".ts";
+var nattoppetPath = fileURLToPath(new URL(`nattoppet${runtimeExt}`, import.meta.url));
+var mimeTypes = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".wasm": "application/wasm",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml"
+};
+http.createServer(async (req, res) => {
+  try {
+    const url = new URL(req.url, "http://localhost");
+    if (url.pathname !== "/") {
+      const filePath = path.join(process.cwd(), decodeURIComponent(url.pathname));
+      await fs.promises.access(filePath);
+      const ext = path.extname(filePath);
+      const contentType = mimeTypes[ext] || "application/octet-stream";
+      res.writeHead(200, { "Content-Type": contentType });
+      fs.createReadStream(filePath).pipe(res);
+      return;
+    }
+    if (process.argv.length > 3) {
+      const exitCode = await new Promise((resolve) => {
+        const hookProc = cp.spawn(process.argv[3], process.argv.slice(4), {
+          stdio: "inherit"
+        });
+        hookProc.on("close", resolve);
+      });
+      if (exitCode !== 0) {
+        console.warn("!!! hook command exit with non-0 status");
+        res.writeHead(500);
+        res.end("Hook command failed");
+        return;
+      }
+    }
+    const { stdout, stderr } = await new Promise((resolve, reject) => {
+      const proc = cp.spawn(process.execPath, [nattoppetPath, file, "--dev"]);
+      let stdout2 = "";
+      let stderr2 = "";
+      proc.stdout.on("data", (d) => stdout2 += d);
+      proc.stderr.on("data", (d) => stderr2 += d);
+      proc.on("close", (code) => {
+        if (code !== 0) reject(new Error(`compilation failed with code ${code}`));
+        else resolve({ stdout: stdout2, stderr: stderr2 });
+      });
+      proc.on("error", reject);
+    });
+    if (stderr)
+      console.error(stderr);
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(stdout);
+  } catch (e) {
+    if (e instanceof Error && "code" in e && e.code !== "ENOENT") {
+      console.error(e);
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  }
+}).listen(3939, () => {
+  console.log("Server running at http://127.0.0.1:3939");
+});
+var platform = process.platform;
+var browser = process.env.BROWSER ?? (platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open");
+var browserArgs = browser.includes("chrom") ? [browser, "--app=http://127.0.0.1:3939"] : [browser, "http://127.0.0.1:3939"];
+cp.spawn(browserArgs[0], browserArgs.slice(1), {
+  stdio: "ignore",
+  detached: true
+}).unref();

package/{nattoppet-init.ts → dist/nattoppet-init.js}

@@ -1,16 +1,16 @@
-import * as fs from "node:fs"
-
-const type = process.argv[2]
-
-const avaliable_templates = ["form"]
-
+#!/usr/bin/env node
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// nattoppet-init.ts
+import * as fs from "node:fs";
+import * as readline from "node:readline";
+var type = process.argv[2];
+var avaliable_templates = ["form"];
 if (process.argv.length < 3 || !avaliable_templates.includes(type)) {
-    console.log("Usage: nattoppet-init form")
-    process.exit(0)
+  console.log("Usage: nattoppet-init form");
+  process.exit(0);
 }
-
-fs.writeFileSync("main.ymd", `\
-[mixin] ${type}
+fs.writeFileSync("main.ymd", `[mixin] ${type}
 
 [title]: Page Title
 
@@ -23,22 +23,23 @@ fs.writeFileSync("main.ymd", `\
 [checkbox].female Female
 
 [require](main.js)
-`)
-
-fs.writeFileSync("main.js", `\
-async function run(args) {
+`);
+fs.writeFileSync("main.js", `async function run(args) {
     return JSON.stringify(args)
 }
 
 if (typeof Deno != 'undefined')
     run({}).then(console.log)
-`)
-
-const gen_wasm = prompt("Generate wasm? (give lib name or empty to cancel): ")
-
+`);
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+var question = (q) => new Promise((resolve) => rl.question(q, resolve));
+var gen_wasm = await question("Generate wasm? (give lib name or empty to cancel): ");
+rl.close();
 if (gen_wasm) {
-    fs.writeFileSync(`${gen_wasm}.rs`, `\
-#[no_mangle]
+  fs.writeFileSync(`${gen_wasm}.rs`, `#[no_mangle]
 pub unsafe extern fn sum(data: *const u32, len: usize) -> u32 {
     let mut sum = 0;
     for i in 0..len {
@@ -58,10 +59,8 @@ pub unsafe extern "C" fn free_memory(ptr: *mut u8, byte_size: usize, alignment:
     let layout = std::alloc::Layout::from_size_align_unchecked(byte_size, alignment);
     std::alloc::dealloc(ptr, layout)
 }
-`)
-
-    fs.writeFileSync("Cargo.toml", `\
-[package]
+`);
+  fs.writeFileSync("Cargo.toml", `[package]
 name = "${gen_wasm}"
 version = "0.1.0"
 authors = ["Shiwei Zhang <ylxdzsw@gmail.com>"]
@@ -78,9 +77,8 @@ strip = true
 
 [dependencies]
 absurd = { git = "https://github.com/ylxdzsw/absurd" }
-`)
-
-    fs.appendFileSync("main.js", `
+`);
+  fs.appendFileSync("main.js", `
 
 async function call_wasm() {
     await window.wasm_ready
@@ -91,21 +89,21 @@ async function call_wasm() {
     ${gen_wasm}.free_memory(buffer_ptr, 4 * 8, 4)
     console.log(sum)
 }
-`)
-
-    fs.appendFileSync("main.ymd", `
+`);
+  fs.appendFileSync("main.ymd", `
 [require](target/wasm32-unknown-unknown/release/${gen_wasm}.wasm)
-`)
+`);
 }
-
-
-const gen_workflow = prompt("Generate github workflow? (y/n): ")
-
+var rl2 = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+var gen_workflow = await new Promise((resolve) => rl2.question("Generate github workflow? (y/n): ", resolve));
+rl2.close();
 if (gen_workflow == "y") {
-    fs.mkdirSync(".github", { recursive: true })
-    fs.mkdirSync(".github/workflows", { recursive: true })
-    fs.writeFileSync(".github/workflows/pages.yml", `\
-name: Build and deploy to pages
+  fs.mkdirSync(".github", { recursive: true });
+  fs.mkdirSync(".github/workflows", { recursive: true });
+  fs.writeFileSync(".github/workflows/pages.yml", `name: Build and deploy to pages
 on: [push]
 
 jobs:
@@ -115,10 +113,11 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Install Bun
-        uses: oven-sh/setup-bun@v2
+      - name: Install Node.js
+        uses: actions/setup-node@v4
         with:
-          bun-version: latest
+          node-version: 22
+
 ${gen_wasm ? `
       - name: Install Rust
         uses: dtolnay/rust-toolchain@nightly
@@ -127,16 +126,15 @@ ${gen_wasm ? `
 
       - name: Compile WASM
         run: cargo build --release --target wasm32-unknown-unknown
-` : ''}
+` : ""}
       - name: Build HTML
-        run: bun run nattoppet.ts main.ymd > index.html
+        run: npx --yes nattoppet main.ymd > index.html
 
       - name: Deploy
         uses: JamesIves/github-pages-deploy-action@v4
         with:
           branch: gh-pages
           folder: "."
-`)
+`);
 }
-
-console.info("Finished")
+console.info("Finished");

package/dist/nattoppet-native.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// nattoppet-native.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as cp from "node:child_process";
+import { fileURLToPath } from "node:url";
+var main_source = `#![windows_subsystem = "windows"]
+
+use web_view::*;
+
+fn main() {
+    static HTML_CONTENT: &str = include_str!("../target/bundle.html");
+
+    web_view::builder()
+        .title("Nattoppet Native")
+        .content(Content::Html(HTML_CONTENT))
+        .size(600, 480)
+        .resizable(false)
+        .debug(cfg!(debug_assertions))
+        .user_data(())
+        .invoke_handler(handler)
+        .run()
+        .unwrap();
+}
+
+fn handler(webview: &mut WebView<()>, arg: &str) -> WVResult {
+    Ok(())
+}
+`;
+var build_source = `#[cfg(windows)]
+extern crate winres;
+
+#[cfg(windows)]
+fn main() {
+    let mut res = winres::WindowsResource::new();
+    res.set_icon("../icon.ico");
+    res.compile().unwrap();
+}
+
+#[cfg(not(windows))]
+fn main() {}
+`;
+var cargo_source = `[package]
+name = "nattoppet_native"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+web-view = { version = "0.7", features = ["edge"] }
+
+[target.'cfg(windows)'.build-dependencies]
+winres = "0.1"
+
+[package.metadata.winres]
+ProductName = "A nattoppet native app"
+`;
+var init = () => {
+  fs.mkdirSync("native", { recursive: true });
+  fs.mkdirSync("native/src", { recursive: true });
+  fs.mkdirSync("native/target", { recursive: true });
+  fs.writeFileSync("native/src/main.rs", main_source);
+  fs.writeFileSync("native/build.rs", build_source);
+  fs.writeFileSync("native/Cargo.toml", cargo_source);
+};
+var spawn2 = (cmd, args, opts) => {
+  return new Promise((resolve, reject) => {
+    const proc = cp.spawn(cmd, args, opts);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => stdout += d);
+    proc.stderr.on("data", (d) => stderr += d);
+    proc.on("close", (code) => {
+      if (code !== 0) reject(new Error(stderr));
+      else resolve(stdout);
+    });
+    proc.on("error", reject);
+  });
+};
+var bundle = async () => {
+  const runtimeExt = path.extname(fileURLToPath(import.meta.url)) === ".js" ? ".js" : ".ts";
+  const nattoppetPath = fileURLToPath(new URL(`nattoppet${runtimeExt}`, import.meta.url));
+  const stdout = await spawn2(process.execPath, [nattoppetPath, process.argv[3]]);
+  fs.writeFileSync("native/target/bundle.html", stdout);
+};
+var build = async () => {
+  await bundle();
+  await spawn2("cargo", ["build", "--release"], {
+    cwd: "native"
+  });
+  console.log("building finished. Check native/target/release/");
+};
+var help = () => {
+  console.log("Usage: nattoppet-native [init|bundle|build] <file.ymd>");
+};
+switch (process.argv[2]) {
+  case "init":
+    init();
+    break;
+  case "bundle":
+    bundle().catch((e) => {
+      console.error(e.message);
+      process.exit(1);
+    });
+    break;
+  case "build":
+    build().catch((e) => {
+      console.error(e.message);
+      process.exit(1);
+    });
+    break;
+  default:
+    help();
+    break;
+}