@anaemia/bundler 0.4.0 → 0.5.0

package/dist/analyzer/ast-utils.d.ts

@@ -0,0 +1,5 @@
+import type { AstNode } from "./ast-walker.js";
+export declare function prop<T = unknown>(node: AstNode, key: string): T;
+export declare function child(node: AstNode, key: string): AstNode | null;
+export declare function children(node: AstNode, key: string): AstNode[];
+//# sourceMappingURL=ast-utils.d.ts.map

package/dist/analyzer/ast-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../src/analyzer/ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,wBAAgB,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAE/D;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAMhE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAO9D"}

package/dist/analyzer/ast-utils.js

@@ -0,0 +1,16 @@
+export function prop(node, key) {
+    return node[key];
+}
+export function child(node, key) {
+    const value = node[key];
+    if (value && typeof value === "object" && typeof value.type === "string") {
+        return value;
+    }
+    return null;
+}
+export function children(node, key) {
+    const value = node[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => v !== null && v !== undefined && typeof v === "object" && typeof v.type === "string");
+}

package/dist/analyzer/ast-walker.d.ts

@@ -0,0 +1,15 @@
+import type { Program } from "oxc-parser";
+export type AstNode = {
+    type: string;
+    [key: string]: unknown;
+};
+type WalkController = {
+    skip: () => void;
+};
+export type AstWalker = {
+    enter?: (node: AstNode, parent: AstNode | null, controller: WalkController) => void;
+    leave?: (node: AstNode, parent: AstNode | null) => void;
+};
+export declare function walkAst(root: AstNode | Program, walker: AstWalker): void;
+export {};
+//# sourceMappingURL=ast-walker.d.ts.map

package/dist/analyzer/ast-walker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-walker.d.ts","sourceRoot":"","sources":["../../src/analyzer/ast-walker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,UAAU,EAAE,cAAc,KAAK,IAAI,CAAC;IACpF,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,CAAC;CACzD,CAAC;AAkBF,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CA6BxE"}

package/dist/analyzer/ast-walker.js

@@ -0,0 +1,43 @@
+import { visitorKeys } from "oxc-parser";
+function isAstNode(value) {
+    return Boolean(value && typeof value === "object" && typeof value.type === "string");
+}
+function childKeysForNode(node) {
+    const keysByNodeType = visitorKeys;
+    const configuredKeys = keysByNodeType[node.type];
+    if (configuredKeys)
+        return configuredKeys;
+    return Object.keys(node).filter((key) => {
+        if (key === "type" || key === "start" || key === "end" || key === "range" || key === "loc")
+            return false;
+        const value = node[key];
+        return isAstNode(value) || (Array.isArray(value) && value.some(isAstNode));
+    });
+}
+export function walkAst(root, walker) {
+    const visit = (node, parent) => {
+        const state = { skipped: false };
+        const controller = {
+            skip() {
+                state.skipped = true;
+            },
+        };
+        walker.enter?.(node, parent, controller);
+        if (!state.skipped) {
+            for (const key of childKeysForNode(node)) {
+                const value = node[key];
+                if (Array.isArray(value)) {
+                    for (const child of value) {
+                        if (isAstNode(child))
+                            visit(child, node);
+                    }
+                }
+                else if (isAstNode(value)) {
+                    visit(value, node);
+                }
+            }
+        }
+        walker.leave?.(node, parent);
+    };
+    visit(root, null);
+}

package/dist/analyzer/checks/env-access.d.ts

@@ -0,0 +1,3 @@
+import type { AnalyzerDiagnostic, ParsedAnalyzerFile } from "../types.js";
+export declare function checkEnvAccess(file: ParsedAnalyzerFile): AnalyzerDiagnostic[];
+//# sourceMappingURL=env-access.d.ts.map

package/dist/analyzer/checks/env-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-access.d.ts","sourceRoot":"","sources":["../../../src/analyzer/checks/env-access.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAe1E,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB,EAAE,CA0D7E"}

package/dist/analyzer/checks/env-access.js

@@ -0,0 +1,63 @@
+import { walkAst } from "../ast-walker.js";
+import { prop, child } from "../ast-utils.js";
+const SERVER_FILE_PATTERNS = [/\.server\.(ts|tsx|js|jsx)$/, /server\//, /\/api\//, /_route\.(ts|tsx|js|jsx)$/];
+function isClientFile(filePath) {
+    return !SERVER_FILE_PATTERNS.some((p) => p.test(filePath));
+}
+const ALWAYS_SAFE = new Set(["NODE_ENV", "MODE", "DEV", "PROD"]);
+function startLine(node) {
+    const loc = prop(node, "loc");
+    return loc?.start.line;
+}
+export function checkEnvAccess(file) {
+    if (!file.program || !isClientFile(file.relativePath))
+        return [];
+    const diagnostics = [];
+    walkAst(file.program, {
+        enter(node) {
+            if (node.type !== "MemberExpression")
+                return;
+            const obj = child(node, "object");
+            const propNode = child(node, "property");
+            if (!obj || !propNode)
+                return;
+            // process.env
+            if (obj.type === "Identifier" &&
+                prop(obj, "name") === "process" &&
+                propNode.type === "Identifier" &&
+                prop(propNode, "name") === "env") {
+                diagnostics.push({
+                    code: "PROCESS_ENV_ACCESS",
+                    severity: "warning",
+                    message: "using process.env is not recommended in anaemia apps. Use import.meta.env instead.",
+                    filePath: file.relativePath,
+                    line: startLine(node),
+                    help: "replace process.env with import.meta.env and ensure client variables are prefixed with PUBLIC_",
+                });
+                return;
+            }
+            // import.meta.env.KEY
+            if (obj.type === "MemberExpression") {
+                const innerObj = child(obj, "object");
+                const innerProp = child(obj, "property");
+                if (innerObj?.type === "MetaProperty" &&
+                    innerProp?.type === "Identifier" &&
+                    prop(innerProp, "name") === "env" &&
+                    propNode.type === "Identifier") {
+                    const envKey = prop(propNode, "name");
+                    if (!envKey.startsWith("PUBLIC_") && !ALWAYS_SAFE.has(envKey)) {
+                        diagnostics.push({
+                            code: "ENV_NOT_PUBLIC",
+                            severity: "warning",
+                            message: `import.meta.env.${envKey} is not prefixed with PUBLIC_ and will be undefined on the client`,
+                            filePath: file.relativePath,
+                            line: startLine(node),
+                            help: `rename to PUBLIC_${envKey} or move this code to a .server.ts file`,
+                        });
+                    }
+                }
+            }
+        },
+    });
+    return diagnostics;
+}

package/dist/analyzer/checks/route-metadata.d.ts

@@ -0,0 +1,12 @@
+import type { ParsedAnalyzerFile } from "../types.js";
+export interface RouteMetadata {
+    filePath: string;
+    hasServerFunctions: boolean;
+    hasLoader: boolean;
+    hasGuard: boolean;
+    isStatic: boolean;
+    serverFunctionIds: string[];
+    params: string[];
+}
+export declare function extractRouteMetadata(file: ParsedAnalyzerFile): RouteMetadata;
+//# sourceMappingURL=route-metadata.d.ts.map

package/dist/analyzer/checks/route-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-metadata.d.ts","sourceRoot":"","sources":["../../../src/analyzer/checks/route-metadata.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,aAAa,CAuE5E"}

package/dist/analyzer/checks/route-metadata.js

@@ -0,0 +1,74 @@
+import { walkAst } from "../ast-walker.js";
+import { prop, child, children } from "../ast-utils.js";
+export function extractRouteMetadata(file) {
+    if (!file.program) {
+        return {
+            filePath: file.relativePath,
+            hasServerFunctions: false,
+            hasLoader: false,
+            hasGuard: false,
+            isStatic: true,
+            serverFunctionIds: [],
+            params: extractParamsFromPath(file.relativePath),
+        };
+    }
+    let hasServerFunctions = false;
+    let hasLoader = false;
+    let hasGuard = false;
+    const serverFunctionIds = [];
+    walkAst(file.program, {
+        enter(node) {
+            if (node.type === "ImportDeclaration") {
+                const source = child(node, "source");
+                if (source && /\.server/.test(prop(source, "value"))) {
+                    hasServerFunctions = true;
+                }
+                return;
+            }
+            if (node.type === "ExportNamedDeclaration") {
+                const decl = child(node, "declaration");
+                if (decl?.type === "VariableDeclaration") {
+                    for (const d of children(decl, "declarations")) {
+                        const id = child(d, "id");
+                        if (!id)
+                            continue;
+                        const name = prop(id, "name");
+                        if (name === "loader")
+                            hasLoader = true;
+                        if (name === "guard")
+                            hasGuard = true;
+                    }
+                }
+                return;
+            }
+            if (node.type === "CallExpression") {
+                const callee = child(node, "callee");
+                const args = children(node, "arguments");
+                const idArg = args[1];
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (!idArg)
+                    return;
+                if (callee?.type === "Identifier" &&
+                    prop(callee, "name") === "runOnServer" &&
+                    idArg.type === "Literal") {
+                    const value = prop(idArg, "value");
+                    if (typeof value === "string")
+                        serverFunctionIds.push(value);
+                }
+            }
+        },
+    });
+    return {
+        filePath: file.relativePath,
+        hasServerFunctions,
+        hasLoader,
+        hasGuard,
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        isStatic: !hasServerFunctions && !hasLoader && !hasGuard,
+        serverFunctionIds,
+        params: extractParamsFromPath(file.relativePath),
+    };
+}
+function extractParamsFromPath(filePath) {
+    return [...filePath.matchAll(/\[([^\]]+)\]/g)].map((m) => m[1]);
+}

package/dist/analyzer/checks/server-functions.d.ts

@@ -0,0 +1,3 @@
+import type { AnalyzerDiagnostic, ParsedAnalyzerFile } from "../types.js";
+export declare function checkUnusedServerFunctions(files: ParsedAnalyzerFile[]): AnalyzerDiagnostic[];
+//# sourceMappingURL=server-functions.d.ts.map

package/dist/analyzer/checks/server-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-functions.d.ts","sourceRoot":"","sources":["../../../src/analyzer/checks/server-functions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AA8D1E,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,kBAAkB,EAAE,CAmB5F"}

package/dist/analyzer/checks/server-functions.js

@@ -0,0 +1,75 @@
+import { walkAst } from "../ast-walker.js";
+import { prop, child, children } from "../ast-utils.js";
+function collectServerFunctionDefinitions(files) {
+    const definitions = new Map();
+    for (const file of files) {
+        if (!file.program)
+            continue;
+        walkAst(file.program, {
+            enter(node) {
+                if (node.type !== "CallExpression")
+                    return;
+                const callee = child(node, "callee");
+                const args = children(node, "arguments");
+                const idArg = args[1];
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (!idArg)
+                    return;
+                if (callee?.type === "Identifier" &&
+                    prop(callee, "name") === "runOnServer" &&
+                    idArg.type === "Literal") {
+                    const value = prop(idArg, "value");
+                    if (typeof value === "string") {
+                        definitions.set(value, {
+                            filePath: file.relativePath,
+                            line: prop(node, "loc")?.start.line,
+                        });
+                    }
+                }
+            },
+        });
+    }
+    return definitions;
+}
+function collectServerFunctionImports(files) {
+    const imports = new Set();
+    for (const file of files) {
+        if (!file.program)
+            continue;
+        walkAst(file.program, {
+            enter(node) {
+                if (node.type !== "ImportDeclaration")
+                    return;
+                const source = child(node, "source");
+                if (!source || !/\.server/.test(prop(source, "value")))
+                    return;
+                for (const specifier of children(node, "specifiers")) {
+                    if (specifier.type === "ImportSpecifier") {
+                        const local = child(specifier, "local");
+                        if (local)
+                            imports.add(prop(local, "name"));
+                    }
+                }
+            },
+        });
+    }
+    return imports;
+}
+export function checkUnusedServerFunctions(files) {
+    const definitions = collectServerFunctionDefinitions(files);
+    const imports = collectServerFunctionImports(files);
+    const diagnostics = [];
+    for (const [id, { filePath, line }] of definitions) {
+        if (!imports.has(id)) {
+            diagnostics.push({
+                code: "UNUSED_SERVER_FUNCTION",
+                severity: "info",
+                message: `server function "${id}" is defined but never imported`,
+                filePath,
+                line,
+                help: `remove it or check if it's being imported under a different name`,
+            });
+        }
+    }
+    return diagnostics;
+}

package/dist/analyzer/index.d.ts

@@ -0,0 +1,7 @@
+import type { AnalyzeAppOptions, AnalyzerResult } from "./types.js";
+export declare function collectAnalyzerFiles(appRoot: string, include?: string[]): string[];
+export declare function analyzeApp(appRoot: string, options?: AnalyzeAppOptions): Promise<AnalyzerResult>;
+export { parseAnalyzerFile } from "./parser.js";
+export { walkAst } from "./ast-walker.js";
+export type { AnalyzeAppOptions, AnalyzerDiagnostic, AnalyzerFileKind, AnalyzerResult, ParsedAnalyzerFile, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/analyzer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/analyzer/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAgBpE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,WAA4B,GAAG,MAAM,EAAE,CAYnG;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAyB1G;AAED,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/analyzer/index.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { glob } from "glob";
+import { parseAnalyzerFile } from "./parser.js";
+import { checkUnusedServerFunctions } from "./checks/server-functions.js";
+import { extractRouteMetadata } from "./checks/route-metadata.js";
+const DEFAULT_ANALYZER_PATTERNS = [
+    "anaemia.config.{ts,js,mjs,cjs}",
+    "src/root.{tsx,jsx}",
+    "src/routes/**/*.{ts,tsx,js,jsx}",
+    "src/**/*.{ts,tsx,js,jsx}",
+];
+function uniqueFilePaths(filePaths) {
+    return [...new Set(filePaths.map((filePath) => path.resolve(filePath)))].sort();
+}
+export function collectAnalyzerFiles(appRoot, include = DEFAULT_ANALYZER_PATTERNS) {
+    const files = include.flatMap((pattern) => glob.sync(pattern, {
+        cwd: appRoot,
+        absolute: true,
+        nodir: true,
+        posix: true,
+        ignore: ["node_modules/**", "dist/**", ".anaemia/**"],
+    }));
+    return uniqueFilePaths(files).filter((filePath) => fs.existsSync(filePath));
+}
+export async function analyzeApp(appRoot, options = {}) {
+    const normalizedRoot = path.resolve(appRoot);
+    const files = collectAnalyzerFiles(normalizedRoot, options.include);
+    const parsedFiles = files.map((filePath) => parseAnalyzerFile(normalizedRoot, filePath));
+    // per-file diagnostics
+    const diagnostics = parsedFiles.flatMap((file) => file.diagnostics);
+    // cross-file diagnostics
+    const unusedServerFnDiagnostics = checkUnusedServerFunctions(parsedFiles);
+    // route metadata for manifest
+    const routeFiles = parsedFiles.filter((f) => /src\/routes\//.test(f.filePath));
+    const routeMetadata = routeFiles.map(extractRouteMetadata);
+    return {
+        appRoot: normalizedRoot,
+        build: {
+            mode: options.mode ?? process.env.NODE_ENV ?? "development",
+            analyzedAt: new Date().toISOString(),
+        },
+        files: parsedFiles,
+        diagnostics: [...diagnostics, ...unusedServerFnDiagnostics],
+        routeMetadata,
+    };
+}
+export { parseAnalyzerFile } from "./parser.js";
+export { walkAst } from "./ast-walker.js";

package/dist/analyzer/parser.d.ts

@@ -0,0 +1,4 @@
+import type { ParserOptions } from "oxc-parser";
+import type { ParsedAnalyzerFile } from "./types.js";
+export declare function parseAnalyzerFile(appRoot: string, filePath: string, options?: ParserOptions): ParsedAnalyzerFile;
+//# sourceMappingURL=parser.d.ts.map

package/dist/analyzer/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/analyzer/parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAwC,kBAAkB,EAA+B,MAAM,YAAY,CAAC;AA8DxH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,kBAAkB,CAoCpH"}

package/dist/analyzer/parser.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseSync } from "oxc-parser";
+import { checkEnvAccess } from "./checks/env-access.js";
+const DEFAULT_PARSE_OPTIONS = {
+    sourceType: "module",
+    astType: "ts",
+    range: true,
+    preserveParens: false,
+};
+function offsetToLocation(source, offset) {
+    const boundedOffset = Math.max(0, Math.min(offset, source.length));
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < boundedOffset; i++) {
+        if (source.charCodeAt(i) === 10) {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column };
+}
+function severityFromOxc(error) {
+    if (error.severity === "Error")
+        return "error";
+    if (error.severity === "Warning")
+        return "warning";
+    return "info";
+}
+function diagnosticFromOxcError(filePath, source, error) {
+    const label = error.labels[0];
+    const start = label.start;
+    const location = typeof start === "number" ? offsetToLocation(source, start) : undefined;
+    return {
+        code: "parse",
+        severity: severityFromOxc(error),
+        message: label.message ? `${error.message}: ${label.message}` : error.message,
+        filePath,
+        start,
+        end: label.end,
+        line: location?.line,
+        column: location?.column,
+        help: error.helpMessage ?? undefined,
+        codeframe: error.codeframe ?? undefined,
+    };
+}
+function inferAnalyzerFileKind(appRoot, filePath) {
+    const relativePath = path.relative(appRoot, filePath).replace(/\\/g, "/");
+    if (/^anaemia\.config\.[cm]?[jt]s$/.test(relativePath))
+        return "config";
+    if (relativePath === "src/root.tsx" || relativePath === "src/root.jsx")
+        return "root";
+    if (/^src\/routes\/.*\/?_route\.[jt]sx?$/.test(relativePath))
+        return "server-route";
+    if (/^src\/routes\/.*\.[jt]sx$/.test(relativePath))
+        return "route";
+    return "source";
+}
+export function parseAnalyzerFile(appRoot, filePath, options = {}) {
+    const source = fs.readFileSync(filePath, "utf-8");
+    const relativePath = path.relative(appRoot, filePath).replace(/\\/g, "/");
+    const kind = inferAnalyzerFileKind(appRoot, filePath);
+    const parseOptions = { ...DEFAULT_PARSE_OPTIONS, ...options };
+    try {
+        const result = parseSync(filePath, source, parseOptions);
+        const parseDiagnostics = result.errors.map((error) => diagnosticFromOxcError(filePath, source, error));
+        const file = {
+            filePath,
+            relativePath,
+            kind,
+            source,
+            program: result.program,
+            comments: result.comments,
+            module: result.module,
+            diagnostics: [],
+        };
+        const diagnostics = [...parseDiagnostics, ...checkEnvAccess(file)];
+        return { ...file, diagnostics };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            filePath,
+            relativePath,
+            kind,
+            source,
+            program: null,
+            comments: [],
+            module: null,
+            diagnostics: [{ code: "parse:thrown", severity: "error", message, filePath }],
+        };
+    }
+}

package/dist/analyzer/types.d.ts

@@ -0,0 +1,48 @@
+import type { Comment, EcmaScriptModule, OxcError, Program } from "oxc-parser";
+import type { RouteMetadata } from "./checks/route-metadata.js";
+type AnalyzerSeverity = "error" | "warning" | "info";
+export type AnalyzerDiagnostic = {
+    code: string;
+    severity: AnalyzerSeverity;
+    message: string;
+    filePath: string;
+    start?: number;
+    end?: number;
+    line?: number;
+    column?: number;
+    help?: string;
+    codeframe?: string;
+};
+export type AnalyzerFileKind = "config" | "route" | "server-route" | "root" | "source";
+export type SourceLocation = {
+    line: number;
+    column: number;
+};
+export type ParsedAnalyzerFile = {
+    filePath: string;
+    relativePath: string;
+    kind: AnalyzerFileKind;
+    source: string;
+    program: Program | null;
+    comments: Comment[];
+    module: EcmaScriptModule | null;
+    diagnostics: AnalyzerDiagnostic[];
+};
+export type AnalyzeAppOptions = {
+    mode?: string;
+    include?: string[];
+};
+type AnalyzerBuildInfo = {
+    mode: string;
+    analyzedAt: string;
+};
+export type AnalyzerResult = {
+    appRoot: string;
+    build: AnalyzerBuildInfo;
+    files: ParsedAnalyzerFile[];
+    diagnostics: AnalyzerDiagnostic[];
+    routeMetadata: RouteMetadata[];
+};
+export type ParserError = OxcError;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/analyzer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/analyzer/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,KAAK,gBAAgB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEvF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,kBAAkB,EAAE,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,iBAAiB,CAAC;IACzB,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAClC,aAAa,EAAE,aAAa,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC"}

package/dist/analyzer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/env-loader.js

@@ -4,7 +4,7 @@ import path from "node:path";
 export default function loadEnvFiles(appRoot, mode) {
     const files = [`.env`, `.env.local`, `.env.${mode}`, `.env.${mode}.local`];
     for (const file of files) {
-        const result = loadDotenv({ path: path.resolve(appRoot, file), override: true });
+        const result = loadDotenv({ path: path.resolve(appRoot, file), override: true, quiet: true });
         expandDotenv(result);
     }
 }

package/dist/index.d.ts

@@ -3,4 +3,6 @@ import type { AnaemiaConfig } from "@anaemia/core/config";
 export declare function getRspackConfig(appRoot: string, config?: AnaemiaConfig): Promise<[Configuration, Configuration]>;
 export { scanRoutes } from "./router/scan.js";
 export { writeManifest } from "./router/manifest.js";
+export { analyzeApp, collectAnalyzerFiles, parseAnalyzerFile, walkAst } from "./analyzer/index.js";
+export type { AnalyzeAppOptions, AnalyzerDiagnostic, AnalyzerFileKind, AnalyzerResult, ParsedAnalyzerFile, } from "./analyzer/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAIlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAsB1D,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,aAAkB,GACzB,OAAO,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CA4NzC;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAIlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAyB1D,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,aAAkB,GACzB,OAAO,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CA2PzC;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnG,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,GACnB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import pc from "picocolors";
 import clientServerFnTransform from "./plugins/babel-transform-server.js";
 import serverHashInjector from "./plugins/babel-hash-injector-server.js";
 import { AnaemiaManifestHydrationPlugin } from "./plugins/rspack-manifest-hydration.js";
@@ -14,17 +15,43 @@ import { getAliases } from "./aliases.js";
 import { createStyleRules, createBabelRule, createAssetRules } from "./rules.js";
 import { getClientOptimization, getPerformanceProfile } from "./optimization.js";
 import loadEnvFiles from "./env-loader.js";
+import { analyzeApp } from "./analyzer/index.js";
 const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export async function getRspackConfig(appRoot, config = {}) {
     const isDev = process.env.NODE_ENV !== "production";
     loadEnvFiles(appRoot, process.env.NODE_ENV || "development");
+    // run the analyzer to collect route metadata and other information about the app that we can use to optimize the build
+    const analysis = await analyzeApp(appRoot, {
+        mode: isDev ? "development" : "production",
+    });
+    // flush diagnostics to console
+    const tag = pc.dim("[anaemia-analyzer]");
+    for (const diagnostic of analysis.diagnostics) {
+        const prefix = diagnostic.severity === "error"
+            ? pc.red("✖ [error]")
+            : diagnostic.severity === "warning"
+                ? pc.yellow("⚠ [warning]")
+                : pc.cyan("› [info]");
+        const loc = diagnostic.line ? pc.dim(`:${diagnostic.line}`) : "";
+        const file = pc.bold(diagnostic.filePath);
+        const msg = diagnostic.severity === "error"
+            ? pc.red(diagnostic.message)
+            : diagnostic.severity === "warning"
+                ? pc.yellow(diagnostic.message)
+                : diagnostic.message;
+        // eslint-disable-next-line no-console
+        console.log(`${tag} ${prefix} ${file}${loc} - ${msg}`);
+        // eslint-disable-next-line no-console
+        if (diagnostic.help)
+            console.log(`  ${pc.dim(`hint: ${diagnostic.help}`)}`);
+    }
     const coreRuntimeDir = path.dirname(require.resolve("@anaemia/core/package.json"));
     const runtimeDir = path.resolve(coreRuntimeDir, "./dist/runtime");
     const routes = await scanRoutes(appRoot);
     const serverRoutes = scanServerRoutes(appRoot);
-    writeManifest(appRoot, routes);
+    writeManifest(appRoot, routes, analysis.routeMetadata);
     const frameworkInternalDir = path.resolve(appRoot, "./.anaemia");
     if (!fs.existsSync(frameworkInternalDir)) {
         fs.mkdirSync(frameworkInternalDir, { recursive: true });
@@ -225,3 +252,4 @@ export async function getRspackConfig(appRoot, config = {}) {
 }
 export { scanRoutes } from "./router/scan.js";
 export { writeManifest } from "./router/manifest.js";
+export { analyzeApp, collectAnalyzerFiles, parseAnalyzerFile, walkAst } from "./analyzer/index.js";