nukejs 0.0.17 → 0.0.19

package/dist/config.js

@@ -0,0 +1,29 @@
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+import { log } from "./logger.js";
+async function loadConfig() {
+  const configPath = path.join(process.cwd(), "nuke.config.ts");
+  if (!fs.existsSync(configPath)) {
+    return {
+      serverDir: "./server",
+      port: 3e3,
+      debug: false
+    };
+  }
+  try {
+    const mod = await import(pathToFileURL(configPath).href);
+    const config = mod.default;
+    return {
+      serverDir: config.serverDir || "./server",
+      port: config.port || 3e3,
+      debug: config.debug ?? false
+    };
+  } catch (error) {
+    log.error("Error loading config:", error);
+    throw error;
+  }
+}
+export {
+  loadConfig
+};

package/dist/hmr-bundle.js

@@ -0,0 +1,120 @@
+import { log } from "./logger.js";
+function hmr() {
+  const es = new EventSource("/__hmr");
+  let reconnecting = false;
+  es.onopen = () => {
+    reconnecting = false;
+    log.info("[HMR] Connected");
+  };
+  es.onerror = () => {
+    if (reconnecting) return;
+    reconnecting = true;
+    es.close();
+    waitForReconnect();
+  };
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState !== "visible") return;
+    if (es.readyState === EventSource.OPEN) return;
+    if (reconnecting) return;
+    reconnecting = true;
+    es.close();
+    waitForReconnect(500, 20);
+  });
+  es.onmessage = async (event) => {
+    try {
+      const msg = JSON.parse(event.data);
+      if (msg.type === "restart") {
+        log.info("[HMR] Server restarting \u2014 waiting to reconnect...");
+        es.close();
+        waitForReconnect();
+        return;
+      }
+      if (msg.type === "reload") {
+        if (msg.url === "*") {
+          reloadStylesheets();
+          return;
+        }
+        if (patternMatchesPathname(msg.url, window.location.pathname)) {
+          log.info("[HMR] Page changed:", msg.url);
+          navigate(window.location.pathname + window.location.search);
+        }
+        return;
+      }
+      if (msg.type === "layout-reload") {
+        const base = msg.base === "/" ? "" : msg.base;
+        const pathname = window.location.pathname;
+        const isUnder = pathname === (base || "/") || pathname.startsWith(base + "/");
+        if (isUnder) {
+          log.info("[HMR] Layout changed:", msg.base);
+          navigate(pathname + window.location.search);
+        }
+        return;
+      }
+      if (msg.type === "replace") {
+        log.info("[HMR] Component changed:", msg.component);
+        navigate(window.location.pathname + window.location.search);
+        return;
+      }
+    } catch (err) {
+      log.error("[HMR] Message parse error:", err);
+    }
+  };
+}
+let _navTimer = null;
+let _navHref = null;
+function navigate(href) {
+  _navHref = href;
+  if (_navTimer) clearTimeout(_navTimer);
+  _navTimer = setTimeout(() => {
+    _navTimer = null;
+    if (_navHref !== null) {
+      window.dispatchEvent(new CustomEvent("locationchange", { detail: { href: _navHref, hmr: true } }));
+      _navHref = null;
+    }
+  }, 50);
+}
+function patternMatchesPathname(pattern, pathname) {
+  const normPattern = pattern.length > 1 ? pattern.replace(/\/+$/, "") : pattern;
+  const normPathname = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+  const segments = normPattern.replace(/^\//, "").split("/");
+  const regexParts = segments.map((seg) => {
+    if (/^\[\[\.\.\..+\]\]$/.test(seg)) return "(?:/.*)?";
+    if (/^\[\.\.\./.test(seg)) return "(?:/.+)";
+    if (/^\[\[/.test(seg)) return "(?:/[^/]*)?";
+    if (/^\[/.test(seg)) return "/[^/]+";
+    return "/" + seg.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  });
+  return new RegExp("^" + regexParts.join("") + "$").test(normPathname);
+}
+function waitForReconnect(intervalMs = 3e3, maxAttempts = 10) {
+  let attempts = 0;
+  const id = setInterval(async () => {
+    attempts++;
+    try {
+      const res = await fetch("/__hmr_ping", { cache: "no-store" });
+      if (res.ok) {
+        clearInterval(id);
+        log.info("[HMR] Server back \u2014 reloading");
+        window.location.reload();
+      }
+    } catch {
+    }
+    if (attempts >= maxAttempts) {
+      clearInterval(id);
+      log.error("[HMR] Server did not come back after restart");
+    }
+  }, intervalMs);
+}
+function reloadStylesheets() {
+  const links = document.querySelectorAll('link[rel="stylesheet"]');
+  log.info(`[HMR] CSS changed \u2014 reloading ${links.length} stylesheet(s)`);
+  links.forEach((link) => {
+    const url = new URL(link.href);
+    url.searchParams.set("t", String(Date.now()));
+    link.href = url.toString();
+  });
+}
+hmr();
+export {
+  hmr as default
+};

package/dist/hmr.js

@@ -0,0 +1,70 @@
+import { existsSync, watch } from "fs";
+import path from "path";
+import { log } from "./logger.js";
+import { invalidateComponentCache } from "./component-analyzer.js";
+import { invalidateSplitBundle } from "./bundler.js";
+const hmrClients = /* @__PURE__ */ new Set();
+function broadcastHmr(payload) {
+  const data = `data: ${JSON.stringify(payload)}
+
+`;
+  for (const client of hmrClients) {
+    try {
+      client.write(data);
+    } catch {
+      hmrClients.delete(client);
+    }
+  }
+}
+function pageFileToUrl(filename) {
+  const withoutPages = filename.slice("pages/".length);
+  const withoutExt = withoutPages.replace(/\.(tsx|ts)$/, "");
+  const url = withoutExt === "index" || withoutExt === "layout" ? "/" : "/" + withoutExt.replace(/\/index$/, "").replace(/\/layout$/, "").replace(/\\/g, "/");
+  return url;
+}
+function buildPayload(filename) {
+  const normalized = filename.replace(/\\/g, "/");
+  if (normalized.startsWith("pages/")) {
+    const stem = path.basename(normalized, path.extname(normalized));
+    if (stem === "_404" || stem === "_500") {
+      return { type: "replace", component: stem };
+    }
+    const url = pageFileToUrl(normalized);
+    if (stem === "layout") {
+      return { type: "layout-reload", base: url };
+    }
+    return { type: "reload", url };
+  }
+  const ext = path.extname(filename).toLowerCase();
+  if (ext === ".css" || ext === ".scss" || ext === ".sass" || ext === ".less") {
+    return { type: "reload", url: "*" };
+  }
+  const componentName = path.basename(filename, path.extname(filename));
+  return { type: "replace", component: componentName };
+}
+const pending = /* @__PURE__ */ new Map();
+function watchDir(dir, label) {
+  if (!existsSync(dir)) return;
+  watch(dir, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    if (pending.has(filename)) clearTimeout(pending.get(filename));
+    const timeout = setTimeout(() => {
+      const payload = buildPayload(filename);
+      log.info(`[HMR] ${label} changed: ${filename}`, JSON.stringify(payload));
+      if (dir) invalidateComponentCache(path.resolve(dir, filename));
+      invalidateSplitBundle();
+      broadcastHmr(payload);
+      pending.delete(filename);
+    }, 100);
+    pending.set(filename, timeout);
+  });
+}
+function broadcastRestart() {
+  broadcastHmr({ type: "restart" });
+  return new Promise((resolve) => setTimeout(resolve, 120));
+}
+export {
+  broadcastRestart,
+  hmrClients,
+  watchDir
+};

package/dist/html-store.d.ts

@@ -0,0 +1,128 @@
+/**
+ * html-store.ts — Per-Request HTML Head Store
+ *
+ * Provides a request-scoped store that server components can write to via
+ * `useHtml()` during SSR.  The accumulated values are flushed into the
+ * rendered HTML document after the component tree is fully rendered.
+ *
+ * Why globalThis?
+ *   Node's module system may import this file multiple times if the page
+ *   module and the nukejs package resolve to different copies (e.g. when
+ *   running from source in dev with tsx).  Using a well-known Symbol on
+ *   globalThis guarantees all copies share the same store instance.
+ *
+ * Request isolation:
+ *   runWithHtmlStore() creates a fresh store before rendering and clears it
+ *   in the `finally` block, so concurrent requests cannot bleed into each other.
+ *
+ * Title resolution:
+ *   Layouts and pages can both call useHtml({ title: … }).  Layouts typically
+ *   pass a template function:
+ *
+ *     useHtml({ title: (prev) => `${prev} | Acme` })
+ *
+ *   Operations are collected in render order (outermost layout first, page
+ *   last) then resolved *in reverse* so the page's string value is the base
+ *   and layout template functions wrap outward.
+ */
+/** A page sets a literal string; a layout wraps with a template function. */
+export type TitleValue = string | ((prev: string) => string);
+export interface HtmlAttrs {
+    lang?: string;
+    class?: string;
+    style?: string;
+    dir?: string;
+    [attr: string]: string | undefined;
+}
+export interface BodyAttrs {
+    class?: string;
+    style?: string;
+    [attr: string]: string | undefined;
+}
+export interface MetaTag {
+    name?: string;
+    property?: string;
+    httpEquiv?: string;
+    charset?: string;
+    content?: string;
+    [attr: string]: string | undefined;
+}
+export interface LinkTag {
+    rel?: string;
+    href?: string;
+    type?: string;
+    media?: string;
+    as?: string;
+    crossOrigin?: string;
+    integrity?: string;
+    hrefLang?: string;
+    sizes?: string;
+    [attr: string]: string | undefined;
+}
+export interface ScriptTag {
+    src?: string;
+    content?: string;
+    type?: string;
+    defer?: boolean;
+    async?: boolean;
+    crossOrigin?: string;
+    integrity?: string;
+    noModule?: boolean;
+    /**
+     * Where to inject the script in the document.
+     *   'head'  (default) — placed inside <head>, inside the <!--n-head--> block.
+     *   'body'            — placed at the very end of <body>, inside the
+     *                       <!--n-body-scripts--> block, just before </body>.
+     */
+    position?: 'head' | 'body';
+}
+export interface StyleTag {
+    content?: string;
+    media?: string;
+}
+export interface HtmlStore {
+    /** Collected in render order; resolved in reverse so the page title wins. */
+    titleOps: TitleValue[];
+    /** Attributes merged onto <html>; last write wins per attribute. */
+    htmlAttrs: HtmlAttrs;
+    /** Attributes merged onto <body>; last write wins per attribute. */
+    bodyAttrs: BodyAttrs;
+    /** Accumulated in render order: layouts first, page last. */
+    meta: MetaTag[];
+    link: LinkTag[];
+    script: ScriptTag[];
+    style: StyleTag[];
+}
+/**
+ * Runs `fn` inside a fresh HTML store and returns the collected values.
+ *
+ * Usage in SSR:
+ * ```ts
+ * const store = await runWithHtmlStore(async () => {
+ *   appHtml = await renderElementToHtml(element, ctx);
+ * });
+ * // store.titleOps, store.meta, etc. are now populated
+ * ```
+ */
+export declare function runWithHtmlStore(fn: () => Promise<void>): Promise<HtmlStore>;
+/**
+ * Returns the current request's store, or `undefined` if called outside of
+ * a `runWithHtmlStore` context (e.g. in the browser or in a test).
+ */
+export declare function getHtmlStore(): HtmlStore | undefined;
+/**
+ * Resolves the final page title from a list of title operations.
+ *
+ * Operations are walked in *reverse* so the page's value is the starting
+ * point and layout template functions wrap it outward:
+ *
+ * ```
+ * ops = [ (p) => `${p} | Acme`, 'About' ]   ← layout pushed first, page last
+ * Walk in reverse:
+ *   i=1: op = 'About'          → title = 'About'
+ *   i=0: op = (p) => …         → title = 'About | Acme'
+ * ```
+ *
+ * @param fallback  Used when ops is empty (e.g. a page that didn't call useHtml).
+ */
+export declare function resolveTitle(ops: TitleValue[], fallback?: string): string;

package/dist/html-store.js

@@ -0,0 +1,41 @@
+const KEY = /* @__PURE__ */ Symbol.for("__nukejs_html_store__");
+const getGlobal = () => globalThis[KEY] ?? null;
+const setGlobal = (store) => {
+  globalThis[KEY] = store;
+};
+function emptyStore() {
+  return {
+    titleOps: [],
+    htmlAttrs: {},
+    bodyAttrs: {},
+    meta: [],
+    link: [],
+    script: [],
+    style: []
+  };
+}
+async function runWithHtmlStore(fn) {
+  setGlobal(emptyStore());
+  try {
+    await fn();
+    return { ...getGlobal() ?? emptyStore() };
+  } finally {
+    setGlobal(null);
+  }
+}
+function getHtmlStore() {
+  return getGlobal() ?? void 0;
+}
+function resolveTitle(ops, fallback = "") {
+  let title = fallback;
+  for (let i = ops.length - 1; i >= 0; i--) {
+    const op = ops[i];
+    title = typeof op === "string" ? op : op(title);
+  }
+  return title;
+}
+export {
+  getHtmlStore,
+  resolveTitle,
+  runWithHtmlStore
+};

package/dist/http-server.js

@@ -0,0 +1,172 @@
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+import { log } from "./logger.js";
+import { matchRoute } from "./router.js";
+function discoverApiPrefixes(serverDir) {
+  if (!fs.existsSync(serverDir)) {
+    log.warn("Server directory not found:", serverDir);
+    return [];
+  }
+  const entries = fs.readdirSync(serverDir, { withFileTypes: true });
+  const prefixes = [];
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      prefixes.push({ prefix: `/${e.name}`, directory: path.join(serverDir, e.name) });
+    }
+  }
+  for (const e of entries) {
+    if (e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx")) && e.name !== "index.ts" && e.name !== "index.tsx") {
+      const stem = e.name.replace(/\.tsx?$/, "");
+      prefixes.push({
+        prefix: `/${stem}`,
+        directory: serverDir,
+        filePath: path.join(serverDir, e.name)
+      });
+    }
+  }
+  if (fs.existsSync(path.join(serverDir, "index.ts"))) {
+    prefixes.push({ prefix: "", directory: serverDir });
+  }
+  return prefixes;
+}
+const MAX_BODY_BYTES = 10 * 1024 * 1024;
+async function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let bytes = 0;
+    req.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_BODY_BYTES) {
+        req.destroy();
+        return reject(new Error("Request body too large"));
+      }
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        if (body && req.headers["content-type"]?.includes("application/json")) {
+          const parsed = JSON.parse(body);
+          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            delete parsed.__proto__;
+            delete parsed.constructor;
+          }
+          resolve(parsed);
+        } else {
+          resolve(body);
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function parseQuery(url, port) {
+  const query = {};
+  new URL(url, `http://localhost:${port}`).searchParams.forEach((v, k) => {
+    query[k] = v;
+  });
+  return query;
+}
+function enhanceResponse(res) {
+  const apiRes = res;
+  apiRes.json = function(data, statusCode = 200) {
+    this.statusCode = statusCode;
+    this.setHeader("Content-Type", "application/json");
+    this.end(JSON.stringify(data));
+  };
+  apiRes.status = function(code) {
+    this.statusCode = code;
+    return this;
+  };
+  return apiRes;
+}
+function respondOptions(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  res.statusCode = 204;
+  res.end();
+}
+function matchApiPrefix(url, apiPrefixes) {
+  for (const prefix of apiPrefixes) {
+    if (prefix.prefix === "") {
+      const claimedByOther = apiPrefixes.some(
+        (p) => p.prefix !== "" && url.startsWith(p.prefix)
+      );
+      if (!claimedByOther) return { prefix, apiPath: url || "/" };
+    } else if (url.startsWith(prefix.prefix)) {
+      return { prefix, apiPath: url.slice(prefix.prefix.length) || "/" };
+    }
+  }
+  return null;
+}
+async function importFreshInDev(filePath) {
+  const { tsImport } = await import("tsx/esm/api");
+  return await tsImport(
+    pathToFileURL(filePath).href,
+    { parentURL: import.meta.url }
+  );
+}
+function createApiHandler({ apiPrefixes, port, isDev }) {
+  return async function handleApiRoute(url, req, res) {
+    const apiRes = enhanceResponse(res);
+    const apiMatch = matchApiPrefix(url, apiPrefixes);
+    if (!apiMatch) {
+      apiRes.json({ error: "API endpoint not found" }, 404);
+      return;
+    }
+    const { prefix, apiPath } = apiMatch;
+    let filePath = null;
+    let params = {};
+    if (prefix.filePath) {
+      filePath = prefix.filePath;
+    }
+    if (!filePath && prefix.prefix === "" && apiPath === "/") {
+      const indexPath = path.join(prefix.directory, "index.ts");
+      if (fs.existsSync(indexPath)) filePath = indexPath;
+    }
+    if (!filePath) {
+      const routeMatch = matchRoute(apiPath, prefix.directory, ".ts") ?? matchRoute(apiPath, prefix.directory, ".tsx");
+      if (routeMatch) {
+        filePath = routeMatch.filePath;
+        params = routeMatch.params;
+      }
+    }
+    if (!filePath) {
+      apiRes.json({ error: "API endpoint not found" }, 404);
+      return;
+    }
+    try {
+      const method = (req.method || "GET").toUpperCase();
+      log.verbose(`API ${method} ${url} -> ${path.relative(process.cwd(), filePath)}`);
+      if (method === "OPTIONS") {
+        respondOptions(apiRes);
+        return;
+      }
+      const apiReq = req;
+      apiReq.body = await parseBody(req);
+      apiReq.params = params;
+      apiReq.query = parseQuery(url, port);
+      const apiModule = isDev ? await importFreshInDev(filePath) : await import(pathToFileURL(filePath).href);
+      const handler = apiModule[method] ?? apiModule.default;
+      if (!handler) {
+        apiRes.json({ error: `Method ${method} not allowed` }, 405);
+        return;
+      }
+      await handler(apiReq, apiRes);
+    } catch (error) {
+      log.error("API Error:", error);
+      apiRes.json({ error: "Internal server error" }, 500);
+    }
+  };
+}
+export {
+  createApiHandler,
+  discoverApiPrefixes,
+  enhanceResponse,
+  matchApiPrefix,
+  parseBody,
+  parseQuery
+};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { createStore, useStore } from './store';
+export type { Store } from './store';
+export { useHtml } from './use-html';
+export type { HtmlOptions } from './use-html';
+export type { TitleValue, HtmlAttrs, BodyAttrs, MetaTag, LinkTag, ScriptTag, StyleTag, } from './html-store';
+export { default as useRouter } from './use-router';
+export { useRequest } from './use-request';
+export type { RequestContext } from './use-request';
+export { normaliseHeaders, sanitiseHeaders, getRequestStore } from './request-store';
+export { default as Link } from './Link';
+export { setupLocationChangeMonitor, initRuntime } from './bundle';
+export type { RuntimeData } from './bundle';
+export { escapeHtml } from './utils';
+export { ansi, c, log, setDebugLevel, getDebugLevel } from './logger';
+export type { DebugLevel } from './logger';

package/dist/index.js

@@ -0,0 +1,28 @@
+import { createStore, useStore } from "./store.js";
+import { useHtml } from "./use-html.js";
+import { default as default2 } from "./use-router.js";
+import { useRequest } from "./use-request.js";
+import { normaliseHeaders, sanitiseHeaders, getRequestStore } from "./request-store.js";
+import { default as default3 } from "./Link.js";
+import { setupLocationChangeMonitor, initRuntime } from "./bundle.js";
+import { escapeHtml } from "./utils.js";
+import { ansi, c, log, setDebugLevel, getDebugLevel } from "./logger.js";
+export {
+  default3 as Link,
+  ansi,
+  c,
+  createStore,
+  escapeHtml,
+  getDebugLevel,
+  getRequestStore,
+  initRuntime,
+  log,
+  normaliseHeaders,
+  sanitiseHeaders,
+  setDebugLevel,
+  setupLocationChangeMonitor,
+  useHtml,
+  useRequest,
+  default2 as useRouter,
+  useStore
+};

package/dist/logger.d.ts

@@ -0,0 +1,59 @@
+/**
+ * logger.ts — ANSI-Coloured Levelled Logger
+ *
+ * Provides a small set of server-side logging utilities used throughout NukeJS.
+ *
+ * Debug levels (set via nuke.config.ts `debug` field):
+ *   false      — silent, nothing printed
+ *   'error'    — error() only
+ *   'info'     — info(), warn(), error()
+ *   true       — verbose: all of the above plus verbose()
+ *
+ * The level can be read back with `getDebugLevel()` and is also forwarded to
+ * the browser client (as a string) so server and client log at the same level.
+ */
+/** Map of named ANSI colour/style escape codes. */
+export declare const ansi: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+    readonly orange: "\u001B[38;5;208m";
+    readonly bgBlue: "\u001B[44m";
+    readonly bgGreen: "\u001B[42m";
+    readonly bgMagenta: "\u001B[45m";
+};
+/**
+ * Wraps `text` in the ANSI sequence for `color`, optionally bold.
+ * Always appends the reset sequence so colour does not bleed into surrounding
+ * terminal output.
+ */
+export declare function c(color: keyof typeof ansi, text: string, bold?: boolean): string;
+/** false = silent | 'error' = errors only | 'info' = startup + errors | true = verbose */
+export type DebugLevel = false | 'error' | 'info' | true;
+/** Sets the active log level.  Called once after the config is loaded. */
+export declare function setDebugLevel(level: DebugLevel): void;
+/** Returns the currently active log level. */
+export declare function getDebugLevel(): DebugLevel;
+/**
+ * Structured log object with four severity methods.
+ * Each method is a no-op unless the current `_level` allows it.
+ */
+export declare const log: {
+    /** Trace-level detail: component IDs, route matching, bundle paths. */
+    verbose(...args: any[]): void;
+    /** Startup messages, route tables, config summary. */
+    info(...args: any[]): void;
+    /** Non-fatal issues: missing middleware, unrecognised config keys. */
+    warn(...args: any[]): void;
+    /** Errors that produce a 500 response or crash the build. */
+    error(...args: any[]): void;
+};