@farm.js/core 0.1.0-beta.43 → 0.1.0-beta.44

package/dist/internal/client-runtime.mjs

@@ -1,12 +1,12 @@
 import {
   createClientPluginManager,
   installChunkErrorRecovery
-} from "../chunk-7U6Q7NLJ.mjs";
+} from "../chunk-BQWTEZSS.mjs";
 import {
   searchParamsToObject
 } from "../chunk-4DCGM2BW.mjs";
 import "../chunk-FXG2PS27.mjs";
-import "../chunk-MPY5IS76.mjs";
+import "../chunk-FY34HLY7.mjs";
 import {
   __name
 } from "../chunk-CGILA3WO.mjs";

package/dist/internal/config-runtime.cjs

@@ -3450,11 +3450,65 @@ async function resolveFarmLayers(projectConfig, options) {
   };
 }
 __name(resolveFarmLayers, "resolveFarmLayers");
+var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\)/;
+function createFarmConfigResolutionPlugin(options) {
+  const configEntryChecks = /* @__PURE__ */ new Map();
+  return {
+    name: "farm-config-package-resolution",
+    setup(pluginBuild) {
+      pluginBuild.onResolve({ filter: /^@farm\.js\/core$/ }, async (args) => {
+        if (args.pluginData?.farmConfigExternal || args.kind !== "import-statement" || !args.importer) {
+          return;
+        }
+        let configEntryCheck = configEntryChecks.get(args.importer);
+        if (!configEntryCheck) {
+          configEntryCheck = onlyImportsFarmConfigHelpers(args.importer, options.transform);
+          configEntryChecks.set(args.importer, configEntryCheck);
+        }
+        if (!await configEntryCheck) return;
+        const resolved = await pluginBuild.resolve(FARM_CONFIG_ENTRY, {
+          importer: args.importer,
+          kind: args.kind,
+          namespace: args.namespace,
+          resolveDir: args.resolveDir,
+          pluginData: { farmConfigExternal: true }
+        });
+        if (resolved.errors.length > 0 || !resolved.path) return;
+        return {
+          path: resolved.path,
+          external: true,
+          warnings: resolved.warnings
+        };
+      });
+      pluginBuild.onResolve({ filter: /^[^./]/ }, async (args) => {
+        if (args.kind === "entry-point" || import_node_path.default.isAbsolute(args.path) || WINDOWS_ABSOLUTE_PATH_RE.test(args.path)) {
+          return;
+        }
+        if (args.pluginData?.farmConfigExternal) return;
+        const resolved = await pluginBuild.resolve(args.path, {
+          importer: args.importer,
+          kind: args.kind,
+          namespace: args.namespace,
+          resolveDir: args.resolveDir,
+          pluginData: { farmConfigExternal: true }
+        });
+        if (resolved.errors.length > 0 || !resolved.path) {
+          return { path: args.path, external: true };
+        }
+        return {
+          path: resolved.path,
+          external: true,
+          warnings: resolved.warnings
+        };
+      });
+    }
+  };
+}
+__name(createFarmConfigResolutionPlugin, "createFarmConfigResolutionPlugin");
 async function loadFarmConfigFile(configPath, options) {
   const { build, transform } = await import("esbuild");
   const cacheRoot = import_node_path.default.resolve(options.cacheRoot || options.root);
   const configCacheDir = import_node_path.default.join(cacheRoot, ".farm", ".config-loader");
-  const configEntryChecks = /* @__PURE__ */ new Map();
   await (0, import_promises.mkdir)(configCacheDir, { recursive: true });
   const modulePath = import_node_path.default.join(
     configCacheDir,
@@ -3468,55 +3522,7 @@ async function loadFarmConfigFile(configPath, options) {
     format: "esm",
     platform: "node",
     target: `node${process.versions.node.split(".")[0]}`,
-    plugins: [
-      {
-        name: "farm-config-package-resolution",
-        setup(pluginBuild) {
-          pluginBuild.onResolve({ filter: /^@farm.js\/core$/ }, async (args) => {
-            if (args.pluginData?.farmConfigExternal || args.kind !== "import-statement" || !args.importer) {
-              return;
-            }
-            let configEntryCheck = configEntryChecks.get(args.importer);
-            if (!configEntryCheck) {
-              configEntryCheck = onlyImportsFarmConfigHelpers(args.importer, transform);
-              configEntryChecks.set(args.importer, configEntryCheck);
-            }
-            if (!await configEntryCheck) return;
-            const resolved = await pluginBuild.resolve(FARM_CONFIG_ENTRY, {
-              importer: args.importer,
-              kind: args.kind,
-              namespace: args.namespace,
-              resolveDir: args.resolveDir,
-              pluginData: { farmConfigExternal: true }
-            });
-            if (resolved.errors.length > 0 || !resolved.path) return;
-            return {
-              path: resolved.path,
-              external: true,
-              warnings: resolved.warnings
-            };
-          });
-          pluginBuild.onResolve({ filter: /^[^./]/ }, async (args) => {
-            if (args.pluginData?.farmConfigExternal) return;
-            const resolved = await pluginBuild.resolve(args.path, {
-              importer: args.importer,
-              kind: args.kind,
-              namespace: args.namespace,
-              resolveDir: args.resolveDir,
-              pluginData: { farmConfigExternal: true }
-            });
-            if (resolved.errors.length > 0 || !resolved.path) {
-              return { path: args.path, external: true };
-            }
-            return {
-              path: resolved.path,
-              external: true,
-              warnings: resolved.warnings
-            };
-          });
-        }
-      }
-    ],
+    plugins: [createFarmConfigResolutionPlugin({ transform })],
     jsx: "automatic",
     logLevel: "silent",
     sourcemap: "inline"
@@ -4887,7 +4893,7 @@ async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "
   ].filter(Boolean);
   for (const relativePath of searchPaths) {
     try {
-      const absolutePath = relativePath.startsWith("/") ? relativePath : import_path.default.join(root, relativePath);
+      const absolutePath = import_path.default.isAbsolute(relativePath) ? relativePath : import_path.default.join(root, relativePath);
       const normalizedPath = import_path.default.resolve(absolutePath);
       if (!existsSync2(normalizedPath)) {
         continue;