@farm.js/core 0.1.0-beta.13 → 0.1.0-beta.16

package/dist/{chunk-Z3YG4OZT.mjs → chunk-OSWV5IJB.mjs}

@@ -59,7 +59,7 @@ import {
 } from "./chunk-GY2STC2S.mjs";
 import {
   resolveServerActionsConfig
-} from "./chunk-UB5UOSHB.mjs";
+} from "./chunk-ZVMV3THA.mjs";
 import {
   createFarmMarkdownRouteModuleFromFile,
   createFarmMarkdownSourceResponse,
@@ -109,7 +109,7 @@ import {
   discoverProgrammaticRoutePaths,
   findProgrammaticRouteFiles,
   loadProgrammaticRouteManifests
-} from "./chunk-Z5CQMP54.mjs";
+} from "./chunk-ARRYKOI5.mjs";
 import {
   _runWithFarmI18nRequest,
   _setDefaultFarmI18nRuntime,
@@ -160,13 +160,13 @@ import {
 } from "./chunk-RHIFZZUI.mjs";
 import {
   FARM_VERSION
-} from "./chunk-3WIRO3N7.mjs";
+} from "./chunk-BWJC5ZOD.mjs";
 import {
   FARM_DEPLOYMENT_ID_HEADER,
   createFarmDeploymentCookie,
   createFarmDeploymentMismatchResponse,
   getFarmDeploymentMismatch
-} from "./chunk-B232I2GP.mjs";
+} from "./chunk-3HIVDX7J.mjs";
 import {
   createDeferredDataResponse,
   prepareDeferredData,
@@ -5131,7 +5131,7 @@ var HMRManager = _HMRManager;
 
 // src/type-artifacts.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync2, unlinkSync } from "fs";
-import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, resolve as resolve3 } from "path";
 
 // src/routing/generate-route-types.ts
 import * as path7 from "path";
@@ -5165,6 +5165,15 @@ function routePatternToRouteLiteral(pattern) {
   return JSON.stringify(pattern);
 }
 __name(routePatternToRouteLiteral, "routePatternToRouteLiteral");
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+__name(renderTypeUnion, "renderTypeUnion");
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
+__name(renderTypeAlias, "renderTypeAlias");
 function createRoutePattern(route) {
   if (route.segments.length === 0) return "/";
   return "/" + route.segments.map((seg) => {
@@ -5190,39 +5199,48 @@ async function createRouteTypeDeclarations(options, outPath) {
   const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
   const patterns = /* @__PURE__ */ new Set();
+  const routeModulePatterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
     const appDir = path7.join(source.root, source.srcDir, "app");
     if (fs3.existsSync(appDir)) {
-      const pageFiles = await glob.default("**/page.{ts,tsx,js,jsx,md,mdx}", {
-        cwd: appDir,
-        absolute: false
-      });
-      for (const file of pageFiles) {
+      const routeModuleFiles = await glob.default(
+        "**/{page,layout,loading,error}.{ts,tsx,js,jsx,md,mdx}",
+        {
+          cwd: appDir,
+          absolute: false
+        }
+      );
+      for (const file of routeModuleFiles) {
         if (parseRouteSlotFile(file)) continue;
         const route = parseRoutePath(file);
+        const pattern = createRoutePattern(route);
+        routeModulePatterns.add(pattern);
         if (route.type === "page") {
-          const pattern = createRoutePattern(route);
           patterns.add(pattern);
         }
       }
     }
     for (const route of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
       patterns.add(route);
+      routeModulePatterns.add(route);
     }
   }
   for (const route of extraRoutes) {
     if (route.startsWith("/")) {
       patterns.add(route);
+      routeModulePatterns.add(route);
     }
   }
   const sortedPatterns = Array.from(patterns).sort();
   const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
-  const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
-  const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
+  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
   const routeTypesImportPath = `./${path7.basename(outPath).replace(/\.d\.ts$/, "")}`;
-  const augmentationBlock = suppressLintOnLink ? "" : `
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
     _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
@@ -5246,14 +5264,25 @@ declare module "@farm.js/core/dist/client.js" {
     pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
+`;
+  const routeModuleAugmentationBlock = `
+declare global {
+  namespace FarmJS {
+    interface RouteRegistry {
+      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
+    }
+  }
+}
 `;
   const content = `/**
  * Auto-generated route types from src/app.
- * Link href is typed automatically via module augmentation. Regenerated on dev start and when routes change.
+ * Link href and route component props are typed automatically from generated declarations.
+ * Regenerated on dev start and when routes change.
  * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
  */
-export type RoutePath = ${routePathType};
-export type RoutePattern = ${routePatternType};${augmentationBlock}
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
 `;
   return content;
 }
@@ -5358,7 +5387,8 @@ async function generateFarmTypeArtifacts(options) {
   const sourceRoots = getFarmSourceRoots({ root, srcDir, layers: options.layers });
   const appDirs = getFarmAppDirectories({ root, srcDir, layers: options.layers });
   const result = {
-    apiRoutes: []
+    apiRoutes: [],
+    stalePaths: []
   };
   const unifiedTypesPath = join4(root, srcDir, "farm.d.ts");
   const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
@@ -5374,22 +5404,29 @@ async function generateFarmTypeArtifacts(options) {
     unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
     result.routeTypesPath = unifiedTypesPath;
   } else if (shouldGenerateRoutes) {
-    result.routeTypesPath = await generateRouteTypes({
+    const routeOptions = {
       root,
       srcDir,
       outFile: options.routeTypesOutFile,
       extraRoutes: options.extraRoutes || [],
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
-    });
+    };
+    if (options.check) {
+      const routeTypesPath = resolveGeneratedPath(root, srcDir, options.routeTypesOutFile);
+      const content = await createRouteTypeDeclarations(routeOptions, routeTypesPath);
+      checkGeneratedFile(routeTypesPath, content, result.stalePaths);
+      result.routeTypesPath = routeTypesPath;
+    } else {
+      result.routeTypesPath = await generateRouteTypes(routeOptions);
+    }
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
     const apiTypesPath = options.apiTypesOutFile ? resolve3(root, options.apiTypesOutFile) : join4(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
-    mkdirSync4(dirname3(apiTypesPath), { recursive: true });
-    writeFileIfChanged(apiTypesPath, content);
+    writeOrCheckGeneratedFile(apiTypesPath, content, options.check, result.stalePaths);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
@@ -5407,36 +5444,63 @@ async function generateFarmTypeArtifacts(options) {
     );
     result.envTypesPath = unifiedTypesPath;
   } else if (shouldGenerateEnv) {
-    result.envTypesPath = await generateEnvTypes({
+    const envOptions = {
       root,
       srcDir,
       outFile: options.envTypesOutFile,
       configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-    });
+    };
+    if (options.check) {
+      const envTypesPath = resolveGeneratedPath(root, srcDir, options.envTypesOutFile);
+      checkGeneratedFile(
+        envTypesPath,
+        createEnvTypeDeclarations(envOptions, envTypesPath),
+        result.stalePaths
+      );
+      result.envTypesPath = envTypesPath;
+    } else {
+      result.envTypesPath = await generateEnvTypes(envOptions);
+    }
   }
   if (shouldGenerateImages && options.imageTypesOutFile) {
-    result.imageTypesPath = generateFarmImageTypes({
-      root,
-      srcDir,
-      outFile: options.imageTypesOutFile
-    });
+    const imageTypesPath = resolveGeneratedPath(root, srcDir, options.imageTypesOutFile, false);
+    if (options.check) {
+      checkGeneratedFile(imageTypesPath, createFarmImageTypeDeclarations(), result.stalePaths);
+      result.imageTypesPath = imageTypesPath;
+    } else {
+      result.imageTypesPath = generateFarmImageTypes({
+        root,
+        srcDir,
+        outFile: options.imageTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
     const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
     unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
     result.i18nTypesPath = unifiedTypesPath;
   } else if (shouldGenerateI18n && options.i18nConfig) {
-    result.i18nTypesPath = await generateFarmI18nTypes({
-      root,
-      srcDir,
-      config: options.i18nConfig,
-      outFile: options.i18nTypesOutFile
-    });
+    if (options.check) {
+      const i18nTypesPath = resolveGeneratedPath(root, srcDir, options.i18nTypesOutFile, false);
+      const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+      checkGeneratedFile(
+        i18nTypesPath,
+        renderFarmI18nTypes(options.i18nConfig.locales, signatures),
+        result.stalePaths
+      );
+      result.i18nTypesPath = i18nTypesPath;
+    } else {
+      result.i18nTypesPath = await generateFarmI18nTypes({
+        root,
+        srcDir,
+        config: options.i18nConfig,
+        outFile: options.i18nTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes) {
-    mkdirSync4(dirname3(unifiedTypesPath), { recursive: true });
-    writeFileIfChanged(
+    writeOrCheckGeneratedFile(
       unifiedTypesPath,
       `/**
  * Generated by Farm.js. Do not edit.
@@ -5445,14 +5509,41 @@ async function generateFarmTypeArtifacts(options) {
 
 import "@farm.js/core/image";
 
-${unifiedSections.join("\n")}`
+${unifiedSections.map((section) => section.trimEnd()).join("\n\n")}
+`,
+      options.check,
+      result.stalePaths
     );
     result.typesPath = unifiedTypesPath;
-    removeLegacyTypeArtifacts(root, srcDir);
+    if (options.check) {
+      collectLegacyTypeArtifacts(root, srcDir, result.stalePaths);
+    } else {
+      removeLegacyTypeArtifacts(root, srcDir);
+    }
   }
   return result;
 }
 __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
+  if (isAbsolute2(outFile)) return resolve3(outFile);
+  return resolve3(root, relativeToSrc ? join4(srcDir, outFile) : outFile);
+}
+__name(resolveGeneratedPath, "resolveGeneratedPath");
+function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
+  if (check) {
+    checkGeneratedFile(filePath, content, stalePaths);
+    return;
+  }
+  mkdirSync4(dirname3(filePath), { recursive: true });
+  writeFileIfChanged(filePath, content);
+}
+__name(writeOrCheckGeneratedFile, "writeOrCheckGeneratedFile");
+function checkGeneratedFile(filePath, content, stalePaths) {
+  if (!existsSync4(filePath) || readFileSync2(filePath, "utf8") !== content) {
+    stalePaths.push(filePath);
+  }
+}
+__name(checkGeneratedFile, "checkGeneratedFile");
 var LEGACY_TYPE_ARTIFACTS = [
   ["farm-routes.d.ts", "Auto-generated route types"],
   ["farm-env.d.ts", "Auto-generated env types"],
@@ -5470,6 +5561,14 @@ function removeLegacyTypeArtifacts(root, srcDir) {
   }
 }
 __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
+function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = join4(root, srcDir, fileName);
+    if (!existsSync4(filePath)) continue;
+    if (readFileSync2(filePath, "utf8").includes(marker)) stalePaths.push(filePath);
+  }
+}
+__name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
 
 // src/vite.ts
 import * as fs4 from "fs";
@@ -5680,7 +5779,7 @@ function loadFarmWorkflowsDevRuntime() {
 }
 __name(loadFarmWorkflowsDevRuntime, "loadFarmWorkflowsDevRuntime");
 function loadFarmDevtoolsSnapshotRuntime() {
-  return import("./devtools-GAZ7F3KL.mjs");
+  return import("./devtools-E4YNCY5J.mjs");
 }
 __name(loadFarmDevtoolsSnapshotRuntime, "loadFarmDevtoolsSnapshotRuntime");
 function loadFarmDevtoolsUIRuntime() {
@@ -9447,4 +9546,4 @@ export {
   farmPlugin,
   defineConfig
 };
-//# sourceMappingURL=chunk-Z3YG4OZT.mjs.map
+//# sourceMappingURL=chunk-OSWV5IJB.mjs.map