@anaemia/bundler 0.0.1

package/dist/plugins/rspack-manifest-hydration.d.ts

@@ -0,0 +1,11 @@
+import type { RspackPluginInstance, Compiler } from "@rspack/core";
+interface HydrationPluginOptions {
+    appRoot: string;
+}
+export declare class AnaemiaManifestHydrationPlugin implements RspackPluginInstance {
+    private appRoot;
+    constructor(options: HydrationPluginOptions);
+    apply(compiler: Compiler): void;
+}
+export {};
+//# sourceMappingURL=rspack-manifest-hydration.d.ts.map

package/dist/plugins/rspack-manifest-hydration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rspack-manifest-hydration.d.ts","sourceRoot":"","sources":["../../src/plugins/rspack-manifest-hydration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEnE,UAAU,sBAAsB;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,8BAA+B,YAAW,oBAAoB;IACzE,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,sBAAsB;IAI3C,KAAK,CAAC,QAAQ,EAAE,QAAQ;CAwCzB"}

package/dist/plugins/rspack-manifest-hydration.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+export class AnaemiaManifestHydrationPlugin {
+    appRoot;
+    constructor(options) {
+        this.appRoot = options.appRoot;
+    }
+    apply(compiler) {
+        compiler.hooks.emit.tap("AnaemiaManifestHydrationPlugin", (compilation) => {
+            const manifestPath = path.resolve(this.appRoot, "./dist/route-manifest.json");
+            if (!fs.existsSync(manifestPath))
+                return;
+            try {
+                const currentManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+                if (!currentManifest.chunks) {
+                    currentManifest.chunks = {};
+                }
+                for (const chunk of compilation.chunks) {
+                    if (!chunk.name)
+                        continue;
+                    const files = Array.from(chunk.files);
+                    const jsFiles = files.filter((f) => f.endsWith(".js") && !f.includes(".hot-update.") && !f.endsWith(".js.map"));
+                    const cssFiles = files.filter((f) => f.endsWith(".css") && !f.includes(".hot-update.") && !f.endsWith(".css.map"));
+                    if (jsFiles.length > 0 || cssFiles.length > 0) {
+                        currentManifest.chunks[chunk.name] = {
+                            js: jsFiles.map((f) => `/${f}`),
+                            css: cssFiles.map((f) => `/${f}`),
+                        };
+                    }
+                }
+                fs.writeFileSync(manifestPath, JSON.stringify(currentManifest, null, 2));
+            }
+            catch (e) {
+                console.error("[anaemia compiler] failed updating route-manifest with assets:", e.message);
+            }
+        });
+    }
+}

package/dist/plugins/server-function-id.d.ts

@@ -0,0 +1,2 @@
+export declare function createServerFunctionId(filename: string, start: number | null | undefined): string;
+//# sourceMappingURL=server-function-id.d.ts.map

package/dist/plugins/server-function-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-function-id.d.ts","sourceRoot":"","sources":["../../src/plugins/server-function-id.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,UAExF"}

package/dist/plugins/server-function-id.js

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

package/dist/router/generate-entry.d.ts

@@ -0,0 +1,3 @@
+import type { RouteManifestEntry } from "./scan.js";
+export declare function generateRouterEntry(appRoot: string, routes: RouteManifestEntry[]): string;
+//# sourceMappingURL=generate-entry.d.ts.map

package/dist/router/generate-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-entry.d.ts","sourceRoot":"","sources":["../../src/router/generate-entry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAgHpD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,CA+LzF"}

package/dist/router/generate-entry.js

@@ -0,0 +1,243 @@
+import fs from "fs";
+import path from "path";
+function buildTree(routes, strippedLayouts, routeIndices, routesDir, allLayouts, parentPrefix) {
+    const nodes = [];
+    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();
+    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, parentPrefix) {
+    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, indent = 6) {
+    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.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, allLayouts) {
+    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, routes) {
+    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();
+    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/dist/router/generate-server-routes.d.ts

@@ -0,0 +1,3 @@
+import type { ServerRouteEntry } from "./scan.js";
+export declare function generateServerRoutes(appRoot: string, routes: ServerRouteEntry[]): string;
+//# sourceMappingURL=generate-server-routes.d.ts.map

package/dist/router/generate-server-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-server-routes.d.ts","sourceRoot":"","sources":["../../src/router/generate-server-routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,CA+BxF"}

package/dist/router/generate-server-routes.js

@@ -0,0 +1,30 @@
+import fs from "fs";
+import path from "path";
+export function generateServerRoutes(appRoot, routes) {
+    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/dist/router/manifest.d.ts

@@ -0,0 +1,12 @@
+import type { RouteManifestEntry } from "./scan.js";
+export interface BuildManifest {
+    routes: RouteManifestEntry[];
+    chunks: Record<string, {
+        js: string;
+        css?: string;
+    }>;
+    errors: Record<string, string>;
+    buildTime: string;
+}
+export declare function writeManifest(appRoot: string, routes: RouteManifestEntry[]): void;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/router/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/router/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAE7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,IAAI,CA6BjF"}

package/dist/router/manifest.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+import path from "path";
+export function writeManifest(appRoot, routes) {
+    const errors = {};
+    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 = {
+        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/dist/router/scan.d.ts

@@ -0,0 +1,22 @@
+export declare function createScanJiti(appRoot: string): import("jiti").Jiti;
+export type RouteType = "page" | "layout" | "catch-all";
+export interface LayoutManifestEntry {
+    filePath: string;
+    guards: any[];
+}
+export interface RouteManifestEntry {
+    urlPattern: string;
+    filePath: string;
+    chunkName: string;
+    layouts: LayoutManifestEntry[];
+    guards: any[];
+    type: RouteType;
+    params: string[];
+}
+export interface ServerRouteEntry {
+    urlPattern: string;
+    filePath: string;
+}
+export declare function scanServerRoutes(appRoot: string): ServerRouteEntry[];
+export declare function scanRoutes(appRoot: string): Promise<RouteManifestEntry[]>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/router/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/router/scan.ts"],"names":[],"mappings":"AAMA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,uBAK7C;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,GAAG,EAAE,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IAGjC,UAAU,EAAE,MAAM,CAAC;IAGnB,QAAQ,EAAE,MAAM,CAAC;IAGjB,SAAS,EAAE,MAAM,CAAC;IAIlB,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAG/B,MAAM,EAAE,GAAG,EAAE,CAAC;IAEd,IAAI,EAAE,SAAS,CAAC;IAIhB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAMD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAYpE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAgF/E"}

package/dist/router/scan.js

@@ -0,0 +1,164 @@
+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) {
+    return createJiti(import.meta.url, {
+        interopDefault: true,
+        alias: getAliases(appRoot),
+    });
+}
+const LAYOUT_FILE = /^_layout\.(tsx|jsx)$/;
+const CATCH_ALL_FILE = /^\[\.\.\.(.+?)\]\.(tsx|jsx)$/;
+const DYNAMIC_SEGMENT = /^\[(.+?)\]\.(tsx|jsx)$/;
+export function scanServerRoutes(appRoot) {
+    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) {
+    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();
+    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 = [];
+            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);
+                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 = [];
+    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 = [];
+        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));
+            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) {
+    const segments = file.split("/");
+    const urlParts = [];
+    const params = [];
+    let type = "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, layoutMap) {
+    const layouts = [];
+    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/dist/rules.d.ts

@@ -0,0 +1,47 @@
+import type { AnaemiaConfig } from "@anaemia/core";
+export declare function createStyleRules(config: AnaemiaConfig): {
+    client: {
+        test: RegExp;
+        type: string;
+        use: {
+            loader: string;
+            options: {
+                api: string;
+            };
+        }[];
+    };
+    server: {
+        test: RegExp;
+        type: string;
+        generator: {
+            css: {
+                exportOnlyLocals: boolean;
+            };
+        };
+        use: {
+            loader: string;
+            options: {
+                api: string;
+            };
+        }[];
+    };
+};
+export declare function createBabelRule({ isServer, isDev, plugins, }: {
+    isServer: boolean;
+    isDev: boolean;
+    plugins: any[];
+}): {
+    test: RegExp;
+    use: {
+        loader: string;
+        options: {
+            presets: (string | (string | {
+                generate: string;
+                hydratable: boolean;
+                dev: boolean;
+            })[])[];
+            plugins: any[];
+        };
+    }[];
+};
+//# sourceMappingURL=rules.d.ts.map

package/dist/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../src/rules.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAInD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBrD;AAED,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,KAAK,EACL,OAAY,GACb,EAAE;IACD,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,CAAC;CAChB;;;;;;;;;;;;;EAkBA"}