hadars 0.1.1

package/dist/ssr-watch.js

@@ -0,0 +1,345 @@
+// src/ssr-watch.ts
+import pathMod2 from "node:path";
+
+// src/utils/rspack.ts
+import rspack from "@rspack/core";
+import ReactRefreshPlugin from "@rspack/plugin-react-refresh";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import pathMod from "node:path";
+import { existsSync } from "node:fs";
+var __dirname = process.cwd();
+var packageDir = pathMod.dirname(fileURLToPath(import.meta.url));
+var clientScriptPath = pathMod.resolve(packageDir, "template.html");
+var loaderPath = existsSync(pathMod.resolve(packageDir, "loader.cjs")) ? pathMod.resolve(packageDir, "loader.cjs") : pathMod.resolve(packageDir, "loader.ts");
+var getConfigBase = (mode) => {
+  const isDev = mode === "development";
+  return {
+    experiments: {
+      css: true,
+      outputModule: true
+    },
+    resolve: {
+      modules: [
+        path.resolve(__dirname, "node_modules"),
+        // 'node_modules' (relative) enables the standard upward-traversal
+        // resolution so rspack can find transitive deps (e.g. webpack-dev-server)
+        // that live in a parent node_modules when running from a sub-project.
+        "node_modules"
+      ],
+      tsConfig: path.resolve(__dirname, "tsconfig.json"),
+      extensions: [".tsx", ".ts", ".js", ".jsx"]
+    },
+    module: {
+      rules: [
+        {
+          test: /\.mdx?$/,
+          use: [
+            {
+              loader: "@mdx-js/loader",
+              options: {}
+            }
+          ]
+        },
+        {
+          test: /\.css$/,
+          use: ["postcss-loader"],
+          type: "css"
+        },
+        {
+          test: /\.svg$/i,
+          issuer: /\.[jt]sx?$/,
+          use: ["@svgr/webpack"]
+        },
+        {
+          test: /\.m?jsx?$/,
+          resolve: {
+            fullySpecified: false
+          },
+          exclude: [loaderPath],
+          use: [
+            // Transforms loadModule('./path') based on build target.
+            // Runs before swc-loader (loaders execute right-to-left).
+            {
+              loader: loaderPath
+            },
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "ecmascript",
+                    jsx: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic",
+                      development: isDev,
+                      refresh: isDev
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          type: "javascript/auto"
+        },
+        {
+          test: /\.tsx?$/,
+          resolve: {
+            fullySpecified: false
+          },
+          exclude: [loaderPath],
+          use: [
+            {
+              loader: loaderPath
+            },
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "typescript",
+                    tsx: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic",
+                      development: isDev,
+                      refresh: isDev
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          type: "javascript/auto"
+        }
+      ]
+    }
+  };
+};
+var buildCompilerConfig = (entry2, opts, includeHotPlugin) => {
+  const Config = getConfigBase(opts.mode);
+  const { base: base2 } = opts;
+  const isDev = opts.mode === "development";
+  const localConfig = {
+    ...Config,
+    module: {
+      ...Config.module,
+      rules: (Config.module && Array.isArray(Config.module.rules) ? Config.module.rules : []).map((r) => {
+        const nr = { ...r };
+        if (r && Array.isArray(r.use)) {
+          nr.use = r.use.map((u) => ({ ...typeof u === "object" ? u : { loader: u } }));
+        }
+        return nr;
+      })
+    }
+  };
+  if (opts.swcPlugins && Array.isArray(opts.swcPlugins) && opts.swcPlugins.length > 0) {
+    const rules = localConfig.module && localConfig.module.rules;
+    if (Array.isArray(rules)) {
+      for (const rule of rules) {
+        const ruleUse = rule;
+        if (ruleUse.use && Array.isArray(ruleUse.use)) {
+          for (const entry3 of ruleUse.use) {
+            const useEntry = entry3;
+            if (useEntry && useEntry.loader && typeof useEntry.loader === "string" && useEntry.loader.includes("swc-loader")) {
+              const options = useEntry.options || {};
+              useEntry.options = options;
+              useEntry.options.jsc = useEntry.options.jsc || {};
+              useEntry.options.jsc.experimental = useEntry.options.jsc.experimental || {};
+              useEntry.options.jsc.experimental.runPluginFirst = true;
+              const existingPlugins = Array.isArray(useEntry.options.jsc.experimental.plugins) ? useEntry.options.jsc.experimental.plugins : [];
+              const incomingPlugins = Array.isArray(opts.swcPlugins) ? opts.swcPlugins : [];
+              const seen = /* @__PURE__ */ new Set();
+              const merged = [];
+              for (const p of existingPlugins.concat(incomingPlugins)) {
+                const name = Array.isArray(p) && p.length > 0 ? String(p[0]) : String(p);
+                if (!seen.has(name)) {
+                  seen.add(name);
+                  merged.push(p);
+                }
+              }
+              useEntry.options.jsc.experimental.plugins = merged;
+            }
+          }
+        }
+      }
+    }
+  }
+  const isServerBuild = Boolean(
+    opts.output && typeof opts.output === "object" && (opts.output.library || String(opts.output.filename || "").includes("ssr"))
+  );
+  const resolveAliases = isServerBuild ? {
+    // force all react imports to resolve to this project's react
+    react: path.resolve(process.cwd(), "node_modules", "react"),
+    "react-dom": path.resolve(process.cwd(), "node_modules", "react-dom"),
+    // also map react/jsx-runtime to avoid duplicates when automatic runtime is used
+    "react/jsx-runtime": path.resolve(process.cwd(), "node_modules", "react", "jsx-runtime.js"),
+    "react/jsx-dev-runtime": path.resolve(process.cwd(), "node_modules", "react", "jsx-dev-runtime.js"),
+    // ensure emotion packages resolve to the project's node_modules so we don't pick up a browser-specific entry
+    "@emotion/react": path.resolve(process.cwd(), "node_modules", "@emotion", "react"),
+    "@emotion/server": path.resolve(process.cwd(), "node_modules", "@emotion", "server"),
+    "@emotion/cache": path.resolve(process.cwd(), "node_modules", "@emotion", "cache"),
+    "@emotion/styled": path.resolve(process.cwd(), "node_modules", "@emotion", "styled")
+  } : void 0;
+  const externals = isServerBuild ? [
+    "react",
+    "react-dom",
+    // keep common aliases external as well
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    // emotion should be external on server builds to avoid client/browser code
+    "@emotion/react",
+    "@emotion/server",
+    "@emotion/cache",
+    "@emotion/styled"
+  ] : void 0;
+  const extraPlugins = [];
+  if (opts.define && typeof opts.define === "object") {
+    const DefinePlugin = rspack.DefinePlugin || rspack.plugins?.DefinePlugin;
+    if (DefinePlugin) {
+      extraPlugins.push(new DefinePlugin(opts.define));
+    } else {
+      extraPlugins.push({ name: "DefinePlugin", value: opts.define });
+    }
+  }
+  const resolveConfig = {
+    extensions: [".tsx", ".ts", ".js", ".jsx"],
+    alias: resolveAliases,
+    // for server builds prefer the package "main"/"module" fields and avoid "browser" so we don't pick browser-specific entrypoints
+    mainFields: isServerBuild ? ["main", "module"] : ["browser", "module", "main"]
+  };
+  return {
+    entry: entry2,
+    resolve: resolveConfig,
+    output: {
+      ...opts.output,
+      clean: false
+    },
+    mode: opts.mode,
+    externals,
+    plugins: [
+      new rspack.HtmlRspackPlugin({
+        publicPath: base2 || "/",
+        template: clientScriptPath,
+        scriptLoading: "module",
+        filename: "out.html",
+        inject: "body"
+      }),
+      isDev && new ReactRefreshPlugin(),
+      includeHotPlugin && isDev && new rspack.HotModuleReplacementPlugin(),
+      ...extraPlugins
+    ],
+    ...localConfig,
+    // HMR is not implemented for module chunk format, so disable outputModule
+    // for client builds. SSR builds still need it for dynamic import() of exports.
+    experiments: {
+      ...localConfig.experiments || {},
+      outputModule: isServerBuild
+    }
+  };
+};
+var compileEntry = async (entry2, opts) => {
+  const compiler = rspack(buildCompilerConfig(entry2, opts, true));
+  if (opts.watch) {
+    await new Promise((resolve, reject) => {
+      let first = true;
+      compiler.watch({}, (err, stats) => {
+        if (err) {
+          if (first) {
+            first = false;
+            reject(err);
+          } else {
+            console.error("rspack watch error", err);
+          }
+          return;
+        }
+        console.log(stats?.toString({
+          colors: true,
+          modules: true,
+          children: true,
+          chunks: true,
+          chunkModules: true
+        }));
+        if (first) {
+          first = false;
+          resolve(stats);
+        } else {
+          try {
+            opts.onChange && opts.onChange(stats);
+          } catch (e) {
+            console.error("onChange handler error", e);
+          }
+        }
+      });
+    });
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    compiler.run((err, stats) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      console.log(stats?.toString({
+        colors: true,
+        modules: true,
+        children: true,
+        chunks: true,
+        chunkModules: true
+      }));
+      resolve(stats);
+    });
+  });
+};
+
+// src/ssr-watch.ts
+var args = process.argv.slice(2);
+var argv = {};
+for (const a of args) {
+  if (!a.startsWith("--"))
+    continue;
+  const idx = a.indexOf("=");
+  if (idx === -1)
+    continue;
+  const key = a.slice(2, idx);
+  const val = a.slice(idx + 1);
+  argv[key] = val;
+}
+var entry = argv["entry"];
+var outDir = argv["outDir"] || ".hadars";
+var outFile = argv["outFile"] || "index.ssr.js";
+var base = argv["base"] || "";
+if (!entry) {
+  console.error("ssr-watch: missing --entry argument");
+  process.exit(1);
+}
+(async () => {
+  try {
+    console.log("ssr-watch: starting SSR watcher for", entry);
+    await compileEntry(entry, {
+      target: "node",
+      output: {
+        iife: false,
+        filename: outFile,
+        path: pathMod2.resolve(process.cwd(), outDir),
+        publicPath: "",
+        library: { type: "module" }
+      },
+      base,
+      mode: "development",
+      watch: true,
+      onChange: () => {
+        console.log("ssr-watch: SSR rebuilt");
+      }
+    });
+    console.log("ssr-watch: initial-build-complete");
+    await new Promise(() => {
+    });
+  } catch (err) {
+    console.error("ssr-watch: error", err);
+    process.exit(1);
+  }
+})();

package/dist/template.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="NINETY_HEAD">
+</head>
+<body>
+    <meta name="NINETY_BODY">
+</body>
+</html>

package/dist/utils/clientScript.tsx

@@ -0,0 +1,58 @@
+import React from 'react';
+import { hydrateRoot, createRoot } from 'react-dom/client';
+import type { HadarsEntryModule } from '../types/ninety';
+import { initServerDataCache } from '$_HEAD_PATH$';
+import * as _appMod from '$_MOD_PATH$';
+
+const appMod = _appMod as HadarsEntryModule<{}>;
+
+const getProps = () => {
+    const script = document.getElementById('hadars');
+    if (script) {
+        try {
+            const data = JSON.parse(script.textContent || '{}');
+            return data.hadars?.props || {};
+        } catch (e) {
+            return {};
+        }
+    }
+    return {};
+}
+
+const main = async () => {
+    let props = getProps();
+
+    // Seed the useServerData client cache from server-resolved values before
+    // hydration so that hooks return the same data on the first render.
+    if (props.__serverData && typeof props.__serverData === 'object') {
+        initServerDataCache(props.__serverData as Record<string, unknown>);
+        const { __serverData: _, ...rest } = props;
+        props = rest;
+    }
+
+    const { location } = props;
+
+    if ( appMod.getClientProps ) {
+        props = await appMod.getClientProps(props);
+    }
+
+    props = {
+        ...props,
+        location,
+    }
+
+    const Component = appMod.default;
+
+    const appEl = document.getElementById("app");
+    if (appEl) {
+        // In HMR mode the client component may have already changed since SSR,
+        // so skip hydration to avoid mismatch warnings and do a fresh render.
+        if ((module as any).hot) {
+            createRoot(appEl).render(<Component {...props} />);
+        } else {
+            hydrateRoot(appEl, <Component {...props} />);
+        }
+    }
+}
+
+main();

package/index.ts

@@ -0,0 +1,15 @@
+// Bun entry point — re-exports the full public API from source so that
+// `ninety-bun` (which runs TypeScript directly) gets the same exports as
+// the compiled `dist/index.js` used by Node.js / Deno.
+export type {
+    NinetyOptions,
+    NinetyProps,
+    NinetyRequest,
+    NinetyGetAfterRenderProps,
+    NinetyGetFinalProps,
+    NinetyGetInitialProps,
+    NinetyGetClientProps,
+    NinetyEntryModule,
+    NinetyApp,
+} from "./src/types/ninety";
+export { NinetyHead, NinetyContext, loadModule } from "./src/index";

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "hadars",
+  "version": "0.1.1",
+  "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
+  "module": "./dist/index.js",
+  "type": "module",
+  "bin": {
+    "hadars": "dist/cli.js",
+    "hadars-bun": "cli-bun.ts"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "cli-lib.ts",
+    "cli.ts",
+    "cli-bun.ts",
+    "index.ts",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli.js",
+      "require": "./dist/cli.js"
+    }
+  },
+  "scripts": {
+    "build:lib": "tsup src/index.tsx --format esm,cjs --dts --out-dir dist --clean --external '@rspack/*' --external '@rspack/binding'",
+    "build:cli": "node build-scripts/build-cli.mjs",
+    "build:all": "npm run build:lib && npm run build:cli",
+    "prepare": "npm run build:all",
+    "prepublishOnly": "npm run build:all"
+  },
+  "keywords": [
+    "react",
+    "ssr",
+    "server-side-rendering",
+    "rspack",
+    "typescript",
+    "bun",
+    "deno",
+    "hmr",
+    "framework",
+    "streaming"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@rspack/core": "1.4.9",
+    "@rspack/dev-server": "^1.1.4",
+    "@rspack/plugin-react-refresh": "^1.5.0",
+    "@types/bun": "latest",
+    "@types/react-dom": "^19.1.9",
+    "react-refresh": "^0.17.0",
+    "typescript": "^5"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "esbuild": "^0.19.0",
+    "tsup": "^6.6.0",
+    "@swc/core": "^1.4.0"
+  },
+  "dependencies": {
+    "@mdx-js/loader": "^3.1.1",
+    "@mdx-js/react": "^3.1.1",
+    "@svgr/webpack": "^8.1.0",
+    "@tailwindcss/postcss": "^4.1.12",
+    "postcss": "^8.5.6",
+    "postcss-loader": "^8.2.0",
+    "tailwindcss": "^4.1.12"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dumistoklus/ninety.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dumistoklus/ninety/issues"
+  },
+  "homepage": "https://github.com/dumistoklus/ninety#readme"
+}