@anaemia/bundler 0.0.1

package/src/router/generate-entry.ts

@@ -0,0 +1,306 @@
+import fs from "fs";
+import path from "path";
+import type { RouteManifestEntry } from "./scan.js";
+
+type LayoutNode = {
+  kind: "layout";
+  layoutFile: string;
+  layoutIdx: number;
+  relativePath: string;
+  prefixPath: string;
+  children: TreeNode[];
+};
+
+type PageNode = {
+  kind: "page";
+  route: RouteManifestEntry;
+  routeIdx: number;
+  relativePath: string;
+};
+
+type TreeNode = LayoutNode | PageNode;
+
+function buildTree(routes: RouteManifestEntry[], strippedLayouts: string[][], routeIndices: number[], routesDir: string, allLayouts: Map<string, number>, parentPrefix: string): TreeNode[] {
+  const nodes: TreeNode[] = [];
+  const leafIndices = strippedLayouts.map((l, i) => (l.length === 0 ? i : -1)).filter((i) => i !== -1);
+
+  for (const i of leafIndices) {
+    const route = routes[routeIndices[i]];
+    const relativePath = toRelativePath(route.urlPattern, parentPrefix);
+    nodes.push({
+      kind: "page",
+      route,
+      routeIdx: routeIndices[i],
+      relativePath,
+    });
+  }
+
+  const byLayout = new Map<string, { ri: number[]; sl: string[][] }>();
+  for (let i = 0; i < strippedLayouts.length; i++) {
+    if (strippedLayouts[i].length === 0) continue;
+    const nextLayout = strippedLayouts[i][0];
+    if (!byLayout.has(nextLayout)) byLayout.set(nextLayout, { ri: [], sl: [] });
+    byLayout.get(nextLayout)!.ri.push(routeIndices[i]);
+    byLayout.get(nextLayout)!.sl.push(strippedLayouts[i].slice(1));
+  }
+
+  for (const [layoutFile, { ri, sl }] of byLayout) {
+    const layoutIdx = allLayouts.get(layoutFile)!;
+    const layoutDir = path.dirname(path.relative(routesDir, layoutFile));
+    const prefixPath = layoutDir === "." ? "/" : `/${layoutDir.replace(/\\/g, "/")}`;
+    const relativePath = toRelativePath(prefixPath, parentPrefix);
+
+    const children = buildTree(routes, sl, ri, routesDir, allLayouts, prefixPath);
+    nodes.push({ kind: "layout", layoutFile, layoutIdx, prefixPath, children, relativePath });
+  }
+
+  return nodes;
+}
+
+function toRelativePath(absolute: string, parentPrefix: string): string {
+  if (parentPrefix === "/" || parentPrefix === "") return absolute;
+  if (absolute.startsWith(parentPrefix)) {
+    const rel = absolute.slice(parentPrefix.length) || "/";
+    return rel.startsWith("/") ? rel : `/${rel}`;
+  }
+  return absolute;
+}
+
+function renderTree(nodes: TreeNode[], indent = 6): string {
+  const pad = " ".repeat(indent);
+  return nodes
+    .map((node) => {
+      if (node.kind === "page") {
+        let routePath = node.relativePath;
+
+        if (node.route.type === "catch-all") {
+          const paramName = node.route.params[0] || "any";
+          if (routePath.endsWith("*")) {
+            routePath = routePath.slice(0, -1) + `*${paramName}`;
+          }
+        }
+
+        if (indent > 6 && routePath === "/") {
+          routePath = "";
+        } else if (indent > 6 && routePath.startsWith("/") && routePath !== "/") {
+          routePath = routePath.slice(1);
+        }
+
+        if (routePath === "") {
+          return `${pad}<Route component={Route${node.routeIdx}Wrapped} />`;
+        }
+        
+        return `${pad}<Route path="${routePath}" component={Route${node.routeIdx}Wrapped} />`;
+      }
+
+      let layoutPath = (node as any).relativePath;
+      const inner = renderTree(node.children, indent + 2);
+
+      return [`${pad}<Route path="${layoutPath}" component={Layout${node.layoutIdx}}>`, inner, `${pad}</Route>`].join("\n");
+    })
+    .join("\n");
+}
+
+function buildPreloadMapString(routes: RouteManifestEntry[], allLayouts: Map<string, number>): string {
+  const mapLines = routes.map((r, i) => {
+    const layoutTokens = r.layouts.map((l) => `Layout${allLayouts.get(l.filePath)}`);
+    const pageToken = `Route${i}`;
+    const tokensArrayString = `[${[...layoutTokens, pageToken].join(", ")}]`;
+    return `  "${r.urlPattern}": ${tokensArrayString}`;
+  });
+
+  return `const chunkPreloadRegistry = {\n${mapLines.join(",\n")}\n};`;
+}
+
+export function generateRouterEntry(appRoot: string, routes: RouteManifestEntry[]): string {
+  const routesDir = path.resolve(appRoot, "./src/routes");
+  const outDir = path.resolve(appRoot, "./.anaemia");
+  const outPath = path.resolve(outDir, "./__anaemia_entry__.tsx");
+
+  const conventionalRoutes = routes.filter((r) => !r.filePath.endsWith("404.tsx") && !r.filePath.endsWith("500.tsx"));
+  const errorRoutes = routes.filter((r) => r.filePath.endsWith("404.tsx") || r.filePath.endsWith("500.tsx"));
+
+  const allLayouts = new Map<string, number>();
+
+  let layoutIndex = 0;
+  for (const entry of conventionalRoutes) {
+    for (const layout of entry.layouts) {
+      if (!allLayouts.has(layout.filePath)) {
+        allLayouts.set(layout.filePath, layoutIndex++);
+      }
+    }
+  }
+
+  const routeImports = conventionalRoutes
+    .map((r, i) => {
+      const relativeToRoutes = path.relative(routesDir, r.filePath);
+      const chunkName = relativeToRoutes
+        .replace(/\.[jt]sx?$/, "")
+        .replace(/[^a-zA-Z0-9-_\[\]]/g, "-")
+        .toLowerCase();
+
+      const guardSources = [...r.layouts.map((l) => l.filePath), r.filePath]
+        .map((fp) => {
+          const configPath = fp.replace(/\.(tsx|jsx)$/, ".config.ts");
+          const guardPath = fs.existsSync(configPath) ? configPath : fp.replace(/\.(jsx)$/, ".config.js");
+          const resolvedGuardPath = fs.existsSync(guardPath) ? guardPath : fp;
+          return `() => import("${resolvedGuardPath.replace(/\\/g, "/")}").then(m => m?.config?.guards ?? [])`;
+        })
+        .join(",\n    ");
+
+      return `
+const Route${i} = lazy(() => import(/* webpackChunkName: "${chunkName}" */ "${r.filePath.replace(/\\/g, "/")}"));
+const Route${i}Loader = async (args) => {
+  const _guardSources = [
+    ${guardSources}
+  ];
+  for (const loadGuards of _guardSources) {
+    const guards = await loadGuards();
+    for (const guard of guards) {
+      const result = await guard({ params: args.params, request: args.request, url: args.location?.pathname ?? "" });
+      if (result?.redirect) {
+        throw Object.assign(new Error("guard:redirect"), { redirect: result.redirect, status: result.status ?? 302 });
+      }
+      if (result?.status) {
+        throw Object.assign(new Error("guard:error"), { status: result.status });
+      }
+    }
+  }
+  return import(/* webpackChunkName: "${chunkName}" */ "${r.filePath.replace(/\\/g, "/")}").then(mod => {
+    return mod.loader ? mod.loader(args) : null;
+  });
+};
+const Route${i}Wrapped = (props) => (
+  <RouteDataController loader={Route${i}Loader}>
+    <Route${i} {...props} />
+  </RouteDataController>
+);`.trim();
+    })
+    .join("\n");
+
+  const layoutImports = [...allLayouts.entries()]
+    .map(([file, i]) => {
+      const relativeToRoutes = path.relative(routesDir, file);
+      const chunkName = ("layout-" + relativeToRoutes.replace(/\.[jt]sx?$/, "").replace(/[^a-zA-Z0-9-_\[\]]/g, "-")).toLowerCase();
+
+      return `import Layout${i} from "${file.replace(/\\/g, "/")}";`;
+    })
+    .join("\n");
+
+  const tree = buildTree(
+    conventionalRoutes,
+    conventionalRoutes.map((r) => r.layouts.map((l) => l.filePath)),
+    conventionalRoutes.map((_, i) => i),
+    routesDir,
+    allLayouts,
+    "/"
+  );
+
+  let routeJsx = renderTree(tree, 6);
+
+  const has404 = errorRoutes.some((r) => r.filePath.endsWith("404.tsx"));
+  if (has404) {
+    const idx = routes.findIndex((r) => r.filePath.endsWith("404.tsx"));
+    routeJsx += `\n      <Route path="*any" component={Route${idx}} />`;
+  }
+
+  const rootWrapperPath = path.resolve(appRoot, "./src/root.tsx");
+  const hasRootWrapper = fs.existsSync(rootWrapperPath);
+
+  const rootImport = hasRootWrapper ? `import RootWrapper from "../src/root.tsx";` : ``;
+
+  const rootWrapperCode = hasRootWrapper
+    ? `const RootWrapperComponent = (props) => (
+  <RootWrapper {...props} />
+);`
+    : ``;
+
+  const finalJsx = hasRootWrapper
+    ? `    <Route component={RootWrapperComponent}>
+${routeJsx}
+    </Route>`
+    : routeJsx;
+
+  const registryEntries = routes
+    .map((r) => {
+      return `  ["${r.urlPattern}", async (args) => {
+    const mod = await import("${r.filePath.replace(/\\/g, "/")}");
+    return mod.loader ? mod.loader(args) : null;
+  }]`;
+    })
+    .join(",\n");
+
+  const guardRegistryEntries = conventionalRoutes
+    .map((r) => {
+      const sources = [...r.layouts.map((l) => l.filePath), r.filePath];
+
+      const loaders = sources
+        .map((fp) => {
+          const configPath = fp.replace(/\.(tsx|jsx)$/, ".config.ts");
+          const guardPath = fs.existsSync(configPath) ? configPath : fp.replace(/\.jsx$/, ".config.js");
+          const resolvedGuardPath = fs.existsSync(guardPath) ? guardPath : fp;
+          return `async () => { const m = await import("${resolvedGuardPath.replace(/\\/g, "/")}"); return m?.config?.guards ?? []; }`;
+        })
+        .join(",\n    ");
+
+      return `  ["${r.urlPattern}", [\n    ${loaders}\n  ]]`;
+    })
+    .join(",\n");
+
+  const chunkPreloadRegistryCode = buildPreloadMapString(conventionalRoutes, allLayouts);
+
+  const preloadFnCode = `
+export async function preloadActiveClientRoute(pathname: string) {
+  // Simple match logic against parameters or route patterns
+  const pattern = Object.keys(chunkPreloadRegistry).find(p => {
+    if (p === pathname) return true;
+    const regexStr = p.replace(/:([a-zA-Z0-9_-]+)/g, "([^/]+)").replace(/\\*([a-zA-Z0-9_-]*)/g, "(.*)");
+    return new RegExp("^" + regexStr + "$").test(pathname);
+  });
+  
+  const componentsToPreload = pattern ? chunkPreloadRegistry[pattern] : [];
+  const preloads = componentsToPreload
+    .filter(c => typeof c.preload === "function")
+    .map(c => c.preload());
+  
+  await Promise.all(preloads);
+}
+`.trim();
+
+  const code = `
+// @ts-nocheck
+// auto-generated by anaemia - do not edit!!
+import { lazy } from "solid-js";
+import { Route } from "@solidjs/router";
+import { RouteDataController } from "@anaemia/core";
+
+${rootImport}
+
+${rootWrapperCode}
+
+${routeImports}
+
+${layoutImports}
+
+${chunkPreloadRegistryCode}
+
+${preloadFnCode}
+
+export const serverLoaderRegistry = new Map([\n${registryEntries}\n]);
+
+export const serverGuardRegistry = new Map([\n${guardRegistryEntries}\n]);
+
+export default function AnaemiaRoutes() {
+  return (
+${finalJsx}
+  );
+}
+`.trimStart();
+
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outPath, code);
+  return outPath;
+}

package/src/router/generate-server-routes.ts

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import type { ServerRouteEntry } from "./scan.js";
+
+export function generateServerRoutes(appRoot: string, routes: ServerRouteEntry[]): string {
+  const outDir = path.resolve(appRoot, "./.anaemia");
+  const outPath = path.resolve(outDir, "./__anaemia_server_routes__.ts");
+
+  const imports = routes.map((r, i) => `import * as ServerRoute${i} from "${r.filePath}";`).join("\n");
+
+  const registrations = routes.map((r, i) => `  registerRoute(app, "${r.urlPattern}", ServerRoute${i});`).join("\n");
+
+  const code = `
+// @ts-nocheck
+// auto-generated by anaemia - do not edit!!
+import type { Hono } from "hono";
+
+${imports}
+
+function registerRoute(app: any, pattern: string, mod: any) {
+  const methods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+  for (const m of methods) {
+    if (m in mod && typeof mod[m] === "function") {
+      app[m.toLowerCase()](pattern, mod[m]);
+    }
+  }
+}
+
+export function registerServerRoutes(app: Hono) {
+${registrations}
+}
+`.trimStart();
+
+  fs.writeFileSync(outPath, code);
+  return outPath;
+}

package/src/router/manifest.ts

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "path";
+import type { RouteManifestEntry } from "./scan.js";
+
+export interface BuildManifest {
+  routes: RouteManifestEntry[];
+  // filled in after rspack build - maps chunkName to hashed filename
+  chunks: Record<string, { js: string; css?: string }>;
+  errors: Record<string, string>;
+  buildTime: string;
+}
+
+export function writeManifest(appRoot: string, routes: RouteManifestEntry[]): void {
+  const errors: Record<string, string> = {};
+
+  for (const route of routes) {
+    if (route.filePath.endsWith("404.tsx")) {
+      errors["404"] = route.urlPattern;
+    }
+    if (route.filePath.endsWith("500.tsx")) {
+      errors["500"] = route.urlPattern;
+    }
+  }
+
+  const conventionalRoutes = routes.filter(
+    (r) => !r.filePath.endsWith("404.tsx") && !r.filePath.endsWith("500.tsx")
+  );
+
+  const manifest: BuildManifest = {
+    routes: conventionalRoutes,
+    errors,
+    chunks: {}, // rspack fills this in via ManifestPlugin
+    buildTime: new Date().toISOString(),
+  };
+
+  const outDir = path.resolve(appRoot, "./dist");
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(
+    path.resolve(outDir, "route-manifest.json"),
+    JSON.stringify(manifest, null, 2)
+  );
+}

package/src/router/scan.ts

@@ -0,0 +1,228 @@
+import { glob } from "glob";
+import path from "path";
+import { createJiti } from "jiti";
+import fs from "node:fs";
+import { getAliases } from "../aliases.js";
+
+export function createScanJiti(appRoot: string) {
+  return createJiti(import.meta.url, {
+    interopDefault: true,
+    alias: getAliases(appRoot),
+  });
+}
+
+export type RouteType = "page" | "layout" | "catch-all";
+
+export interface LayoutManifestEntry {
+  filePath: string;
+  guards: any[];
+}
+
+export interface RouteManifestEntry {
+  // the URL pattern this route matches
+  // e.g. /blog/:slug, /dashboard, /
+  urlPattern: string;
+
+  // absolute path to the route file
+  filePath: string;
+
+  // rspack chunk name derived from the path
+  chunkName: string;
+
+  // ordered list of layout files that wrap this route
+  // e.g. [root layout, dashboard layout]
+  layouts: LayoutManifestEntry[];
+
+  // holds page level guards
+  guards: any[];
+  // what type of file this is
+  type: RouteType;
+
+  // the dynamic params this route exposes
+  // e.g. /blog/[slug] -> ["slug"]
+  params: string[];
+}
+
+export interface ServerRouteEntry {
+  urlPattern: string;
+  filePath: string;
+}
+
+const LAYOUT_FILE = /^_layout\.(tsx|jsx)$/;
+const CATCH_ALL_FILE = /^\[\.\.\.(.+?)\]\.(tsx|jsx)$/;
+const DYNAMIC_SEGMENT = /^\[(.+?)\]\.(tsx|jsx)$/;
+
+export function scanServerRoutes(appRoot: string): ServerRouteEntry[] {
+  const routesDir = path.resolve(appRoot, "./src/routes");
+  const files = glob.sync("**/_route.{ts,tsx}", { cwd: routesDir, posix: true });
+
+  return files.map((file) => {
+    const dir = path.dirname(file);
+    const urlPattern = dir === "." ? "/" : `/${dir}`;
+    return {
+      urlPattern,
+      filePath: path.resolve(routesDir, file),
+    };
+  });
+}
+
+export async function scanRoutes(appRoot: string): Promise<RouteManifestEntry[]> {
+  const jiti = createScanJiti(appRoot);
+  const routesDir = path.resolve(appRoot, "./src/routes");
+  const files = glob.sync("**/*.{tsx,jsx}", { cwd: routesDir, posix: true });
+
+  const layoutMap = new Map<string, LayoutManifestEntry>();
+  for (const file of files) {
+    const filename = path.basename(file);
+    if (LAYOUT_FILE.test(filename)) {
+      const dir = path.dirname(file);
+      const absolutePath = path.resolve(routesDir, file);
+
+      let layoutGuards: any[] = [];
+      const configPath = absolutePath
+        .replace(/\.(tsx|jsx)$/, ".config.$1")
+        .replace(".config.tsx", ".config.ts")
+        .replace(".config.jsx", ".config.js");
+
+      const moduleToScan = fs.existsSync(configPath) ? configPath : absolutePath;
+
+      try {
+        const layoutModule = jiti.import(moduleToScan) as any;
+        if (layoutModule?.config?.guards) {
+          layoutGuards = layoutModule.config.guards;
+        }
+      } catch (err) {
+        console.warn(`[anaemia bundler warning]: Failed parsing config flags on layout: ${file}`);
+      }
+
+      layoutMap.set(dir, {
+        filePath: absolutePath,
+        guards: layoutGuards,
+      });
+    }
+  }
+
+  const entries: RouteManifestEntry[] = [];
+
+  for (const file of files) {
+    const filename = path.basename(file);
+    const dir = path.dirname(file);
+
+    if (LAYOUT_FILE.test(filename)) continue;
+    if (filename.includes(".config.")) continue;
+
+    const absolutePagePath = path.resolve(routesDir, file);
+    const { urlPattern, chunkName, params, type } = parseFilePath(file);
+
+    let pageGuards: any[] = [];
+
+    const pageConfigPath = absolutePagePath
+      .replace(/\.(tsx|jsx)$/, ".config.$1")
+      .replace(".config.tsx", ".config.ts")
+      .replace(".config.jsx", ".config.js");
+
+    const pageModuleToScan = fs.existsSync(pageConfigPath) ? pageConfigPath : absolutePagePath;
+
+    try {
+      const pageModule = (await jiti.import(pageModuleToScan)) as any;
+      if (pageModule?.config?.guards) {
+        pageGuards = pageModule.config.guards;
+      }
+    } catch (err) {
+      // quietly ignore parsing problems for pure components lacking a config wrapper
+    }
+
+    const layouts = resolveLayoutChain(dir, layoutMap);
+
+    entries.push({
+      urlPattern,
+      filePath: absolutePagePath,
+      chunkName,
+      layouts,
+      guards: pageGuards,
+      type,
+      params,
+    });
+  }
+
+  return entries;
+}
+
+function parseFilePath(file: string): {
+  urlPattern: string;
+  chunkName: string;
+  params: string[];
+  type: RouteType;
+} {
+  const segments = file.split("/");
+  const urlParts: string[] = [];
+  const params: string[] = [];
+  let type: RouteType = "page";
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+
+    if (isLast) {
+      const cleanName = segment.replace(/\.(tsx|jsx)$/, "");
+
+      if (CATCH_ALL_FILE.test(segment)) {
+        const match = segment.match(CATCH_ALL_FILE)!;
+        params.push(match[1]);
+        urlParts.push(`*`);
+        type = "catch-all";
+      } else if (DYNAMIC_SEGMENT.test(segment)) {
+        const match = segment.match(DYNAMIC_SEGMENT)!;
+        params.push(match[1]);
+        urlParts.push(`:${match[1]}`);
+      } else if (cleanName !== "index") {
+        urlParts.push(cleanName);
+      }
+    } else {
+      if (segment.startsWith("[...") && segment.endsWith("]")) {
+        const param = segment.slice(4, -1);
+        params.push(param);
+        urlParts.push(`*`);
+        type = "catch-all";
+      } else if (segment.startsWith("[") && segment.endsWith("]")) {
+        const param = segment.slice(1, -1);
+        params.push(param);
+        urlParts.push(`:${param}`);
+      } else {
+        urlParts.push(segment);
+      }
+    }
+  }
+
+  const filteredParts = urlParts.filter((part) => part !== "" && part !== ".");
+  let urlPattern = "/" + filteredParts.join("/");
+
+  if (urlPattern === "") {
+    urlPattern = "/";
+  }
+
+  const chunkName = file
+    .replace(/\.(tsx|jsx)$/, "")
+    .replace(/\[\.\.\.(.+?)\]/g, "catchall-$1")
+    .replace(/\[(.+?)\]/g, "param-$1")
+    .replace(/\//g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+
+  return { urlPattern, chunkName, params, type };
+}
+
+function resolveLayoutChain(dir: string, layoutMap: Map<string, LayoutManifestEntry>): LayoutManifestEntry[] {
+  const layouts: LayoutManifestEntry[] = [];
+  let current = dir;
+
+  while (true) {
+    const layoutEntry = layoutMap.get(current);
+    if (layoutEntry) layouts.unshift(layoutEntry);
+
+    if (current === "." || current === "") break;
+    current = path.dirname(current);
+  }
+
+  return layouts;
+}

package/src/rules.ts

@@ -0,0 +1,58 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import type { AnaemiaConfig } from "@anaemia/core";
+
+const require = createRequire(import.meta.url);
+
+export function createStyleRules(config: AnaemiaConfig) {
+  const useSass = config.styles?.sass !== false;
+  const useModules = config.styles?.modules ?? true;
+
+  const baseLoaders = useSass ? [{ loader: require.resolve("sass-loader"), options: { api: "modern" } }] : [];
+
+  return {
+    client: {
+      test: /\.(c|sc|sa)ss$/,
+      type: useModules ? "css/auto" : ("css" as const),
+      use: baseLoaders,
+    },
+    server: {
+      test: /\.(c|sc|sa)ss$/,
+      type: useModules ? "css/auto" : ("css" as const),
+      generator: {
+        css: {
+          exportOnlyLocals: true,
+        },
+      },
+      use: baseLoaders,
+    },
+  };
+}
+
+export function createBabelRule({
+  isServer,
+  isDev,
+  plugins = [],
+}: {
+  isServer: boolean;
+  isDev: boolean;
+  plugins: any[];
+}) {
+  const generateMode = isServer ? "ssr" : "dom";
+
+  return {
+    test: /\.[jt]sx?$/,
+    use: [
+      {
+        loader: require.resolve("babel-loader"),
+        options: {
+          presets: [
+            [require.resolve("babel-preset-solid"), { generate: generateMode, hydratable: true, dev: isDev }],
+            require.resolve("@babel/preset-typescript"),
+          ],
+          plugins: plugins,
+        },
+      },
+    ],
+  };
+}

package/src/runtime/empty-module.cjs

@@ -0,0 +1,10 @@
+const createInfiniteProxy = () => {
+  return new Proxy(() => {}, {
+    get(target, prop) {
+      if (prop === "__esModule") return true;
+      return createInfiniteProxy();
+    },
+  });
+};
+
+module.exports = createInfiniteProxy();

package/src/server-function-id.ts

@@ -0,0 +1,3 @@
+export function createServerFunctionId(filename: string, start: number | null | undefined) {
+  return Buffer.from(`${filename}:${start ?? 0}`).toString("base64url");
+}