@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-PENBZAHJ.cjs

@@ -0,0 +1,88 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/client-cancellation.ts
+function createClientCancellation(signal, timeoutMs = 0, parent) {
+  let timer;
+  let invalid;
+  let timeoutReason;
+  const signals = [signal, parent].filter((value) => !!value);
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647) {
+    invalid = new RangeError(
+      "timeoutMs must be an integer between 0 and 2147483647 (0 disables the deadline)."
+    );
+  } else if (timeoutMs > 0) {
+    const controller = new AbortController();
+    signals.push(controller.signal);
+    timer = setTimeout(() => {
+      timeoutReason = new DOMException("Client request timed out", "TimeoutError");
+      controller.abort(timeoutReason);
+    }, timeoutMs);
+  }
+  const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+  let active = 0;
+  let closed = false;
+  const cleanup = () => {
+    if (closed && active === 0 && timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const check = () => {
+    if (invalid) throw invalid;
+    _optionalChain([combined, 'optionalAccess', _ => _.throwIfAborted, 'call', _2 => _2()]);
+  };
+  return {
+    signal: combined,
+    get timedOut() {
+      return timeoutReason !== void 0 && _optionalChain([combined, 'optionalAccess', _3 => _3.reason]) === timeoutReason;
+    },
+    check,
+    hold() {
+      active++;
+      return () => {
+        active--;
+        cleanup();
+      };
+    },
+    // A race also bounds cooperative local dispatch and custom HTTP implementations.
+    // Late completion is consumed, but cannot turn a cancelled result into success.
+    async run(work) {
+      check();
+      active++;
+      let abort;
+      try {
+        if (!combined) return await work();
+        return await new Promise((resolve, reject) => {
+          abort = () => reject(combined.reason);
+          combined.addEventListener("abort", abort, { once: true });
+          Promise.resolve().then(() => {
+            check();
+            return work();
+          }).then(resolve, reject);
+        });
+      } finally {
+        if (abort) _optionalChain([combined, 'optionalAccess', _4 => _4.removeEventListener, 'call', _5 => _5("abort", abort)]);
+        active--;
+        cleanup();
+      }
+    },
+    async delay(ms) {
+      let retryTimer;
+      try {
+        await this.run(
+          () => new Promise((resolve) => {
+            retryTimer = setTimeout(resolve, ms);
+          })
+        );
+      } finally {
+        if (retryTimer !== void 0) clearTimeout(retryTimer);
+      }
+    },
+    dispose() {
+      closed = true;
+      cleanup();
+    }
+  };
+}
+
+
+
+exports.createClientCancellation = createClientCancellation;

package/dist/chunk-PFV2KPDZ.cjs

@@ -0,0 +1,172 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk5DX3O6TTcjs = require('./chunk-5DX3O6TT.cjs');
+
+
+
+var _chunkB5BBTPJQcjs = require('./chunk-B5BBTPJQ.cjs');
+
+
+
+var _chunk6CTFVBATcjs = require('./chunk-6CTFVBAT.cjs');
+
+
+var _chunkOWQV6MLMcjs = require('./chunk-OWQV6MLM.cjs');
+
+
+var _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
+
+// src/integration-middleware-matcher.ts
+function isFarmIntegration(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-integration";
+}
+var compiledIntegrationGuards = /* @__PURE__ */ new WeakMap();
+var noMiddlewareContext = {};
+function resolveIntegrationMiddlewareParams(entry, pathname, config) {
+  const params = resolveMatcherParams(entry.matcher, pathname);
+  if (params || !entry.matcher) return params;
+  const routePathname = resolveIntegrationRoutePathname(pathname, config);
+  const candidates = [.../* @__PURE__ */ new Set([pathname, ...getIntegrationAPIPathnames(config)(routePathname)])];
+  for (const candidate of candidates) {
+    if (candidate === pathname) continue;
+    const routeParams = resolveMatcherParams(entry.matcher, candidate);
+    if (routeParams) return routeParams;
+  }
+  let compiled = compiledIntegrationGuards.get(entry);
+  if (!compiled) {
+    compiled = _chunk5DX3O6TTcjs.compileMiddlewareConfig.call(void 0, {
+      matcher: typeof entry.matcher === "string" ? entry.matcher : [...entry.matcher]
+    });
+    compiledIntegrationGuards.set(entry, compiled);
+  }
+  for (const candidate of candidates) {
+    const result = _chunk5DX3O6TTcjs.matchesCompiledMiddlewareConfig.call(void 0, candidate, compiled, noMiddlewareContext);
+    if (result.matched) return _nullishCoalesce(result.params, () => ( {}));
+  }
+  return null;
+}
+function integrationMiddlewareMayHandlePath(integrations, pathname, catchAllProbe) {
+  if (!integrations) return false;
+  const covers = (entry) => resolveIntegrationMiddlewareParams(entry, pathname, void 0) !== null;
+  return Object.values(integrations).some(
+    (integration) => isFarmIntegration(integration) && (integration.middleware || []).some((entry) => {
+      if (catchAllProbe === void 0) return covers(entry);
+      if (!entry.matcher) return false;
+      const specific = (Array.isArray(entry.matcher) ? entry.matcher : [entry.matcher]).filter(
+        (matcher) => resolveIntegrationMiddlewareParams({ matcher }, catchAllProbe, void 0) === null
+      );
+      return specific.length > 0 && covers({ matcher: specific });
+    })
+  );
+}
+var FARM_INTEGRATION_API_BASE_PATH_KEY = "__farmAPIServerBasePath";
+var integrationAPIPathnames = /* @__PURE__ */ new WeakMap();
+function getIntegrationAPIPathnames(config) {
+  if (!config) return (pathname) => [pathname];
+  let toPathnames = integrationAPIPathnames.get(config);
+  if (!toPathnames) {
+    const recorded = config[FARM_INTEGRATION_API_BASE_PATH_KEY];
+    const api = config.api;
+    const serverBasePath = typeof recorded === "string" ? recorded : typeof _optionalChain([api, 'optionalAccess', _ => _.baseURL]) === "string" && typeof api.basePath === "string" ? _chunkB5BBTPJQcjs.resolveFarmAPIServerBasePath.call(void 0, api) : void 0;
+    toPathnames = _chunkB5BBTPJQcjs.createFarmAPIMiddlewarePathnames.call(void 0, serverBasePath);
+    integrationAPIPathnames.set(config, toPathnames);
+  }
+  return toPathnames;
+}
+function resolveIntegrationRoutePathname(pathname, config) {
+  const basePath = typeof _optionalChain([config, 'optionalAccess', _2 => _2.basePath]) === "string" ? config.basePath : void 0;
+  let routePathname = basePath ? _chunkD22BUQKWcjs.stripFarmBasePath.call(void 0, pathname, basePath) : pathname;
+  const i18n = _optionalChain([config, 'optionalAccess', _3 => _3.i18n]);
+  if (i18n && Array.isArray(i18n.locales) && i18n.locales.length > 0) {
+    routePathname = _chunkOWQV6MLMcjs.resolveFarmLocalePath.call(void 0, routePathname, {
+      locales: i18n.locales,
+      defaultLocale: i18n.defaultLocale,
+      routing: i18n.routing || "prefix-except-default"
+    }).pathname;
+  }
+  return routePathname;
+}
+function resolveMatcherParams(matcher, pathname) {
+  if (!matcher) {
+    return {};
+  }
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  let canonicalPathname;
+  let canonicalSegments;
+  for (const item of list) {
+    if (item === "/(.*)" || item === "*") {
+      return {};
+    }
+    if (item.endsWith("(.*)")) {
+      _nullishCoalesce(canonicalPathname, () => ( (canonicalPathname = _chunk6CTFVBATcjs.canonicalizeRequestPathname.call(void 0, pathname))));
+      const prefix = item.slice(0, -4);
+      if (canonicalPathname === prefix || canonicalPathname.startsWith(`${prefix}/`)) {
+        return {};
+      }
+      continue;
+    }
+    _nullishCoalesce(canonicalSegments, () => ( (canonicalSegments = _chunk6CTFVBATcjs.canonicalizeRequestPathSegments.call(void 0, pathname))));
+    const params = matchPathSegments(splitPath(item), canonicalSegments);
+    if (params) {
+      return params;
+    }
+  }
+  return null;
+}
+function matchPathSegments(routeSegments, pathSegments) {
+  const params = {};
+  let routeIndex = 0;
+  let pathIndex = 0;
+  while (routeIndex < routeSegments.length && pathIndex < pathSegments.length) {
+    const routeSegment = routeSegments[routeIndex];
+    const pathSegment = pathSegments[pathIndex];
+    if (isCatchAllSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = pathSegments.slice(pathIndex);
+      return params;
+    }
+    if (isDynamicSegment(routeSegment)) {
+      params[getSegmentParamName(routeSegment)] = pathSegment;
+      routeIndex += 1;
+      pathIndex += 1;
+      continue;
+    }
+    if (routeSegment !== pathSegment) {
+      return null;
+    }
+    routeIndex += 1;
+    pathIndex += 1;
+  }
+  if (routeIndex === routeSegments.length && pathIndex === pathSegments.length) {
+    return params;
+  }
+  if (routeIndex === routeSegments.length - 1 && isCatchAllSegment(routeSegments[routeIndex])) {
+    params[getSegmentParamName(routeSegments[routeIndex])] = [];
+    return params;
+  }
+  return null;
+}
+function splitPath(value) {
+  return value.split("/").filter(Boolean);
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") && segment.endsWith("]");
+}
+function isCatchAllSegment(segment) {
+  return segment.startsWith("[...") && segment.endsWith("]");
+}
+function getSegmentParamName(segment) {
+  if (isCatchAllSegment(segment)) {
+    return segment.slice(4, -1);
+  }
+  return segment.slice(1, -1);
+}
+
+
+
+
+
+
+
+
+exports.isFarmIntegration = isFarmIntegration; exports.resolveIntegrationMiddlewareParams = resolveIntegrationMiddlewareParams; exports.integrationMiddlewareMayHandlePath = integrationMiddlewareMayHandlePath; exports.FARM_INTEGRATION_API_BASE_PATH_KEY = FARM_INTEGRATION_API_BASE_PATH_KEY; exports.matchPathSegments = matchPathSegments; exports.splitPath = splitPath;

package/dist/chunk-PO5MXV5X.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/api/server-client-bridge.ts
+var API_RUNTIME_RESOLVER = /* @__PURE__ */ Symbol.for("farm.apiRequestRuntimeResolver");
+function setAPIRequestRuntimeResolver(resolver) {
+  globalThis[API_RUNTIME_RESOLVER] = resolver;
+}
+function resolveAPIRequestRuntime() {
+  return _optionalChain([globalThis, 'access', _ => _[API_RUNTIME_RESOLVER], 'optionalCall', _2 => _2()]);
+}
+
+
+
+
+exports.setAPIRequestRuntimeResolver = setAPIRequestRuntimeResolver; exports.resolveAPIRequestRuntime = resolveAPIRequestRuntime;

package/dist/chunk-PSUYE5HR.mjs

@@ -0,0 +1,25 @@
+// src/build/production-vite.ts
+function assertRequestedProductionViteBuilder() {
+  const requested = process.env.FARM_VITE_BUILDER?.trim().toLowerCase();
+  if (!requested || requested === "rolldown") return;
+  if (requested === "rollup") {
+    throw new Error(
+      "FARM_VITE_BUILDER=rollup is no longer supported: Farm builds with Vite 8, which bundles with Rolldown. Remove FARM_VITE_BUILDER."
+    );
+  }
+  throw new Error('FARM_VITE_BUILDER must be "rolldown" when set');
+}
+async function loadFarmProductionVite() {
+  assertRequestedProductionViteBuilder();
+  const runtime = await import("vite");
+  return {
+    build: runtime.build,
+    createServer: runtime.createServer,
+    loadEnv: runtime.loadEnv,
+    builder: "rolldown"
+  };
+}
+
+export {
+  loadFarmProductionVite
+};

package/dist/chunk-PTLXHRJZ.mjs

@@ -0,0 +1,57 @@
+import {
+  resolveFarmNavigationURL
+} from "./chunk-NCIAP562.mjs";
+import {
+  getActiveFarmI18nSnapshot
+} from "./chunk-M25IONJP.mjs";
+import {
+  localizeFarmHref,
+  resolveFarmLocalePath
+} from "./chunk-7S7AAK2D.mjs";
+
+// src/i18n/client-state.ts
+var listeners = /* @__PURE__ */ new Set();
+var compiledFarmI18nMessages = /* @__PURE__ */ new Map();
+var currentSnapshot;
+function getFarmI18nClientState() {
+  return currentSnapshot || getActiveFarmI18nSnapshot();
+}
+function subscribeFarmI18n(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function _hydrateFarmI18n(snapshot) {
+  if (!snapshot) return;
+  const changed = currentSnapshot?.locale !== snapshot.locale;
+  currentSnapshot = snapshot;
+  if (typeof window !== "undefined") window.__FARM_I18N__ = snapshot;
+  if (typeof document !== "undefined") {
+    document.documentElement.lang = snapshot.locale;
+    document.documentElement.dir = snapshot.direction;
+  }
+  if (changed) compiledFarmI18nMessages.clear();
+  for (const listener of listeners) listener();
+}
+function localizeActiveFarmHref(href, locale) {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) return href;
+  return localizeFarmHref(href, locale || snapshot.locale, snapshot);
+}
+function isFarmLocaleChangeHref(href) {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot || typeof window === "undefined") return false;
+  if (snapshot.routing === "none") return false;
+  const target = resolveFarmNavigationURL(href, window.location.href);
+  const match = resolveFarmLocalePath(target.pathname, snapshot);
+  const targetLocale = match.locale || snapshot.defaultLocale;
+  return targetLocale !== snapshot.locale;
+}
+
+export {
+  compiledFarmI18nMessages,
+  getFarmI18nClientState,
+  subscribeFarmI18n,
+  _hydrateFarmI18n,
+  localizeActiveFarmHref,
+  isFarmLocaleChangeHref
+};

package/dist/chunk-PXEXOQ5R.mjs

@@ -0,0 +1,135 @@
+import {
+  isExplicitFarmServerComponentsMode,
+  resolveFarmServerComponentsMode
+} from "./chunk-PAKCHVUS.mjs";
+import {
+  logger
+} from "./chunk-2SVJGOAX.mjs";
+
+// src/server-components-status.ts
+import { existsSync, realpathSync } from "fs";
+import path from "path";
+var FARM_RSC_PACKAGES = [
+  "@farm.js/plugin",
+  "@vitejs/plugin-rsc",
+  "react-server-dom-webpack"
+];
+var FARM_RSC_INSTALL_HINT = `pnpm add ${FARM_RSC_PACKAGES.join(" ")}`;
+var FARM_RSC_BLOCKING_KEYS = [
+  "auth",
+  "integrations",
+  "headers",
+  "redirects",
+  "rewrites",
+  "routeRules",
+  "context",
+  // A Content Security Policy the RSC pipeline would not send.
+  "security"
+];
+var FARM_RSC_IGNORED_KEYS = [
+  "plugins",
+  "storage",
+  "schema",
+  "cron",
+  "workflows",
+  "docs",
+  "theme",
+  "observability"
+];
+function farmConfigUsesServerComponents(config) {
+  return resolveFarmServerComponentsMode(config?.experimental?.serverComponents) === "rsc";
+}
+function findFarmAppPackageDir(root, packageName) {
+  for (let dir = path.resolve(root); ; dir = path.dirname(dir)) {
+    const candidate = path.join(dir, "node_modules", packageName);
+    if (existsSync(path.join(candidate, "package.json"))) return realpathSync(candidate);
+    if (path.dirname(dir) === dir) return void 0;
+  }
+}
+function isSet(value, key) {
+  if (key === "security") {
+    const csp = value?.csp;
+    return csp !== void 0 && csp !== false && csp !== null;
+  }
+  if (value === void 0 || value === false || value === null) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value !== "object" || Object.keys(value).length > 0;
+}
+function inspectFarmServerComponents(config, root) {
+  const value = config?.experimental?.serverComponents;
+  const mode = resolveFarmServerComponentsMode(value);
+  const enabled = mode === "rsc";
+  const explicit = enabled && isExplicitFarmServerComponentsMode(value);
+  const missingPackages = enabled ? FARM_RSC_PACKAGES.filter((name) => !findFarmAppPackageDir(root, name)) : [];
+  return {
+    mode,
+    enabled,
+    explicit,
+    missingPackages,
+    // `true` predates the pipeline; `{ mode: "rsc" }` is new and fails with the install command.
+    fallback: enabled && !explicit && missingPackages.length > 0,
+    blockingKeys: enabled ? FARM_RSC_BLOCKING_KEYS.filter((key) => isSet(config?.[key], key)).map(
+      (key) => key === "security" ? "security.csp" : key
+    ) : [],
+    ignoredKeys: enabled ? FARM_RSC_IGNORED_KEYS.filter((key) => isSet(config?.[key])) : []
+  };
+}
+function formatKeys(keys) {
+  return keys.map((key) => `\`${key}\``).join(", ");
+}
+function formatFarmRscFallbackMessage(missingPackages, blockingKeys = []) {
+  if (blockingKeys.length > 0) {
+    return `experimental.serverComponents is true, but this app uses ${formatKeys(
+      blockingKeys
+    )}, which the RSC pipeline does not run yet, so it runs without React Server Components. Remove the flag, or move ${blockingKeys.length === 1 ? "that feature" : "those features"} out of farm.config to turn RSC on.`;
+  }
+  return `experimental.serverComponents is true, but ${missingPackages.join(", ")} ${missingPackages.length === 1 ? "is" : "are"} not installed, so the app runs without React Server Components. \`farm dev\` and \`farm build\` install them outside CI; in CI or with another tool, run ${FARM_RSC_INSTALL_HINT}.`;
+}
+function formatFarmRscBlockingMessage(blockingKeys) {
+  return `experimental.serverComponents runs on the RSC pipeline, which does not run ${formatKeys(
+    blockingKeys
+  )} yet. Serving the app without ${blockingKeys.length === 1 ? "it" : "them"} could expose what ${blockingKeys.length === 1 ? "it protects" : "they protect"}, so RSC does not start. Remove experimental.serverComponents to keep ${blockingKeys.length === 1 ? "it" : "them"}.`;
+}
+var warnedFallback = false;
+async function resolveFarmRscCheckConfig(config, root, mode) {
+  if (!config?.extends) return config;
+  const { resolveFarmLayers } = await import("./layers-T55SA47E.mjs");
+  return (await resolveFarmLayers(config, { root, mode })).config;
+}
+function farmAppUsesRscPipeline(config, root) {
+  const status = inspectFarmServerComponents(config, root);
+  if (status.mode === "islands") return false;
+  if (!status.enabled) return false;
+  if (status.fallback) {
+    if (!warnedFallback) {
+      warnedFallback = true;
+      logger.warn(
+        `[Farm.js] ${formatFarmRscFallbackMessage(status.missingPackages, status.blockingKeys)}`
+      );
+    }
+    return false;
+  }
+  if (status.blockingKeys.length > 0) {
+    throw new Error(`[Farm.js] ${formatFarmRscBlockingMessage(status.blockingKeys)}`);
+  }
+  if (status.ignoredKeys.length > 0) {
+    logger.warn(
+      `[Farm.js] experimental.serverComponents runs on the RSC pipeline, which does not run ${formatKeys(
+        status.ignoredKeys
+      )} yet. ${status.ignoredKeys.length === 1 ? "It is" : "They are"} ignored.`
+    );
+  }
+  return true;
+}
+
+export {
+  FARM_RSC_PACKAGES,
+  FARM_RSC_INSTALL_HINT,
+  farmConfigUsesServerComponents,
+  findFarmAppPackageDir,
+  inspectFarmServerComponents,
+  formatFarmRscFallbackMessage,
+  formatFarmRscBlockingMessage,
+  resolveFarmRscCheckConfig,
+  farmAppUsesRscPipeline
+};