@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-BMQAPZXD.mjs

@@ -0,0 +1,31 @@
+// src/route-context.ts
+var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
+async function resolveFarmRouteContext(config, input) {
+  if (typeof config.context !== "function") {
+    return void 0;
+  }
+  return config.context(input);
+}
+function withFarmRouteContext(props, context) {
+  if (context === void 0) {
+    return props;
+  }
+  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
+    value: context,
+    enumerable: false,
+    configurable: true
+  });
+  return props;
+}
+function getFarmRouteContext(props) {
+  if (!props || typeof props !== "object") {
+    return void 0;
+  }
+  return props[FARM_ROUTE_CONTEXT_SYMBOL];
+}
+
+export {
+  resolveFarmRouteContext,
+  withFarmRouteContext,
+  getFarmRouteContext
+};

package/dist/chunk-BNH53KOT.cjs

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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; }// src/api/dev-dispatch.ts
+var _http = require('http'); var _http2 = _interopRequireDefault(_http);
+var _https = require('https'); var _https2 = _interopRequireDefault(_https);
+var _stream = require('stream');
+function createFarmDevServerDispatch(server) {
+  return (request) => new Promise((resolve, reject) => {
+    const address = _optionalChain([server, 'access', _ => _.httpServer, 'optionalAccess', _2 => _2.address, 'call', _3 => _3()]);
+    if (!address || typeof address === "string") {
+      throw new Error(
+        "Farm cannot dispatch an app endpoint request: the Vite dev server has no listening HTTP server."
+      );
+    }
+    const url = new URL(request.url);
+    const headers = {};
+    request.headers.forEach((value, name) => {
+      headers[name] = value;
+    });
+    headers.host = url.host;
+    const secure = Boolean(server.config.server.https);
+    const outgoing = (secure ? _https2.default : _http2.default).request(
+      {
+        host: loopbackAddress(address),
+        port: address.port,
+        method: request.method,
+        path: `${url.pathname}${url.search}`,
+        headers,
+        signal: request.signal,
+        // The listener is this process's own dev server, often with a self-signed certificate.
+        ...secure ? { rejectUnauthorized: false } : {}
+      },
+      (incoming) => {
+        const responseHeaders = new Headers();
+        for (const [name, value] of Object.entries(incoming.headers)) {
+          if (value === void 0) continue;
+          for (const entry of Array.isArray(value) ? value : [value]) {
+            responseHeaders.append(name, entry);
+          }
+        }
+        const status = _nullishCoalesce(incoming.statusCode, () => ( 502));
+        const hasBody = request.method !== "HEAD" && status !== 204 && status !== 205 && status !== 304;
+        if (!hasBody) incoming.resume();
+        try {
+          resolve(
+            new Response(
+              hasBody ? _stream.Readable.toWeb(incoming) : null,
+              { status, statusText: incoming.statusMessage, headers: responseHeaders }
+            )
+          );
+        } catch (error) {
+          incoming.destroy();
+          reject(error);
+        }
+      }
+    );
+    outgoing.on("error", reject);
+    if (request.body) {
+      _stream.Readable.fromWeb(request.body).on("error", (error) => outgoing.destroy(error)).pipe(outgoing);
+    } else {
+      outgoing.end();
+    }
+  });
+}
+function loopbackAddress({ address }) {
+  return address === "0.0.0.0" ? "127.0.0.1" : address === "::" ? "::1" : address;
+}
+
+
+
+exports.createFarmDevServerDispatch = createFarmDevServerDispatch;

package/dist/chunk-BNMHXVLL.mjs

@@ -0,0 +1,239 @@
+import {
+  getFarmClientDataCache,
+  trackFarmClientCacheInvalidations
+} from "./chunk-C64XOPBZ.mjs";
+import {
+  isFarmServerQueryResult
+} from "./chunk-N7XWC6BN.mjs";
+import {
+  createFarmCacheKey
+} from "./chunk-GLOICKDO.mjs";
+
+// src/client-revalidation.ts
+function attachRevalidationListeners(refresh, options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
+  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
+  if (onFocus) window.addEventListener("focus", onFocus);
+  if (onOnline) window.addEventListener("online", onOnline);
+  return () => {
+    if (onFocus) window.removeEventListener("focus", onFocus);
+    if (onOnline) window.removeEventListener("online", onOnline);
+  };
+}
+
+// src/server-query-runtime.ts
+var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
+var serverQueryClientGlobal = globalThis;
+var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ?? (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
+  functionIds: /* @__PURE__ */ new WeakMap(),
+  nextFunctionId: 0,
+  active: [],
+  latestOwners: /* @__PURE__ */ new Map(),
+  owners: /* @__PURE__ */ new Set()
+});
+serverQueryClientState.latestOwners ?? (serverQueryClientState.latestOwners = /* @__PURE__ */ new Map());
+serverQueryClientState.owners ?? (serverQueryClientState.owners = /* @__PURE__ */ new Set());
+function isServerQueryOwnerSuperseded(owner, key) {
+  const cache = getFarmClientDataCache();
+  const resolved = cache.resolveKey(key);
+  for (const superseded of owner.supersededKeys ?? []) {
+    if (cache.resolveKey(superseded) === resolved) return true;
+  }
+  return false;
+}
+function claimServerQueryKey(owner, key) {
+  if (isServerQueryOwnerSuperseded(owner, key)) return false;
+  const resolved = getFarmClientDataCache().resolveKey(key);
+  for (const older of serverQueryClientState.owners) {
+    if (older === owner) break;
+    older.supersededKeys.add(resolved);
+  }
+  return true;
+}
+var RAW_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
+function isFarmServerQueryBrowserRuntime() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function assertNotRawServerQueryInBrowser(query) {
+  if (!isFarmServerQueryBrowserRuntime()) return;
+  if (!query?.[RAW_SERVER_QUERY_SYMBOL]) return;
+  throw new Error(
+    [
+      "useServerQuery received a raw server query implementation in the browser.",
+      "Server query handlers run only on the server. Enable the server-function transform (add @farm.js/plugin/rsc and set experimental.serverActions: true in farm.config.ts) so client imports become server references,",
+      "or call the query from server code / an API route (createAPIClient) instead."
+    ].join("\n")
+  );
+}
+function beginFarmServerQueryAction(actionId, args) {
+  const active = serverQueryClientState.active.at(-1);
+  return {
+    actionId,
+    args,
+    provisionalKey: active?.provisionalKey,
+    owner: active?.owner
+  };
+}
+function completeFarmServerQueryAction(invocation, value) {
+  if (!isFarmServerQueryResult(value)) return value;
+  const cache = getFarmClientDataCache();
+  const metadata = value.__farmServerQuery;
+  if (!shouldApplyFarmServerQueryActionResult(invocation)) {
+    return value.data;
+  }
+  if (invocation.provisionalKey) {
+    cache.alias(invocation.provisionalKey, metadata.key);
+  }
+  const owner = invocation.owner;
+  if (owner && serverQueryClientState.owners.has(owner) && !claimServerQueryKey(owner, metadata.key)) {
+    return value.data;
+  }
+  const invalidated = invocation.owner?.invalidations?.has(
+    metadata.key
+  );
+  cache.set(metadata.key, {
+    data: value.data,
+    updatedAt: metadata.updatedAt,
+    staleAt: invalidated ? 0 : metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
+    status: "success",
+    error: null,
+    fetching: false,
+    persist: metadata.persist === true ? true : void 0
+  });
+  return value.data;
+}
+function shouldApplyFarmServerQueryActionResult(invocation) {
+  if (!invocation.provisionalKey || !invocation.owner) return true;
+  return isCurrentServerQueryOwner(invocation.provisionalKey, invocation.owner);
+}
+function isCurrentServerQueryOwner(provisionalKey, owner) {
+  return serverQueryClientState.latestOwners.get(provisionalKey) === owner && !isServerQueryOwnerSuperseded(owner, provisionalKey);
+}
+function createServerQueryCallKey(query, input) {
+  let id = serverQueryClientState.functionIds.get(query);
+  if (!id) {
+    id = ++serverQueryClientState.nextFunctionId;
+    serverQueryClientState.functionIds.set(query, id);
+  }
+  return createFarmCacheKey(["server-query-call", id, input]);
+}
+async function fetchServerQuery(query, input, options = {}) {
+  if (!isFarmServerQueryBrowserRuntime()) return query(input);
+  const cache = getFarmClientDataCache();
+  const provisionalKey = createServerQueryCallKey(query, input);
+  const entry = cache.get(provisionalKey);
+  const stale = cache.isStale(provisionalKey);
+  const inflight = cache.getInflight(provisionalKey);
+  if (!options.force && entry && stale && (entry.status !== "pending" || entry.updatedAt !== 0) && entry.status !== "error" && (options.swr ?? true)) {
+    if (!inflight) {
+      void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+    }
+    return entry.data;
+  }
+  if (inflight && !options.force) return inflight;
+  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
+  return executeServerQuery(query, input, provisionalKey, options);
+}
+function prefetchServerQuery(query, input, options = {}) {
+  return fetchServerQuery(query, input, options);
+}
+async function executeServerQuery(query, input, provisionalKey, options) {
+  assertNotRawServerQueryInBrowser(query);
+  const cache = getFarmClientDataCache();
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight && !options.force) return inflight;
+  const owner = {
+    invalidations: trackFarmClientCacheInvalidations(cache),
+    supersededKeys: /* @__PURE__ */ new Set()
+  };
+  serverQueryClientState.latestOwners.set(provisionalKey, owner);
+  serverQueryClientState.owners.add(owner);
+  claimServerQueryKey(owner, provisionalKey);
+  const previous = cache.get(provisionalKey);
+  cache.set(provisionalKey, {
+    data: previous?.data,
+    updatedAt: previous?.updatedAt ?? 0,
+    staleAt: previous?.staleAt ?? 0,
+    gcAt: previous?.gcAt,
+    invalidatedAt: previous?.invalidatedAt,
+    status: "pending",
+    error: null,
+    fetching: true
+  });
+  let promise;
+  promise = (async () => {
+    await Promise.resolve();
+    try {
+      serverQueryClientState.active.push({ provisionalKey, owner });
+      let pending;
+      try {
+        pending = query(input);
+      } finally {
+        serverQueryClientState.active.pop();
+      }
+      const data = await pending;
+      const transported = cache.get(provisionalKey);
+      if (isCurrentServerQueryOwner(provisionalKey, owner) && (!transported || transported.fetching)) {
+        const updatedAt = Date.now();
+        cache.set(provisionalKey, {
+          data,
+          updatedAt,
+          staleAt: owner.invalidations.has(provisionalKey) ? 0 : options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
+          status: "success",
+          error: null,
+          fetching: false
+        });
+      }
+      return data;
+    } catch (cause) {
+      const error = normalizeServerQueryError(cause);
+      if (isCurrentServerQueryOwner(provisionalKey, owner)) {
+        const current = cache.get(provisionalKey);
+        cache.set(provisionalKey, {
+          data: current?.data,
+          updatedAt: current?.updatedAt ?? 0,
+          staleAt: current?.staleAt ?? 0,
+          gcAt: current?.gcAt,
+          invalidatedAt: current?.invalidatedAt,
+          status: "error",
+          error,
+          fetching: false
+        });
+      }
+      throw error;
+    } finally {
+      const invalidated = isCurrentServerQueryOwner(provisionalKey, owner) && owner.invalidations.has(provisionalKey);
+      owner.invalidations.dispose();
+      serverQueryClientState.owners.delete(owner);
+      owner.supersededKeys.clear();
+      if (cache.getInflight(provisionalKey) === promise) {
+        cache.deleteInflight(provisionalKey);
+      }
+      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
+        serverQueryClientState.latestOwners.delete(provisionalKey);
+      }
+      if (invalidated) cache.invalidate(provisionalKey);
+    }
+  })();
+  cache.setInflight(provisionalKey, promise);
+  return promise;
+}
+function normalizeServerQueryError(cause) {
+  if (cause instanceof Error) return cause;
+  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
+  error.cause = cause;
+  return error;
+}
+
+export {
+  attachRevalidationListeners,
+  isFarmServerQueryBrowserRuntime,
+  beginFarmServerQueryAction,
+  completeFarmServerQueryAction,
+  shouldApplyFarmServerQueryActionResult,
+  createServerQueryCallKey,
+  fetchServerQuery,
+  prefetchServerQuery
+};

package/dist/chunk-BOVGCUDZ.cjs

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkJATTVAHAcjs = require('./chunk-JATTVAHA.cjs');
+
+// src/app-markdown.ts
+var _promises = require('fs/promises');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
+  const source = await _promises.readFile.call(void 0, filePath, "utf8");
+  return _chunkJATTVAHAcjs.createFarmMarkdownRouteModule.call(void 0, {
+    source,
+    filePath,
+    components: options.components,
+    config: options.config
+  });
+}
+async function loadFarmMdxComponents(config, options) {
+  const configured = _optionalChain([config, 'optionalAccess', _ => _.components]);
+  if (!configured) {
+    return {};
+  }
+  if (typeof configured !== "string") {
+    return configured;
+  }
+  const modulePath = _path2.default.isAbsolute(configured) ? configured : _path2.default.join(options.root, configured);
+  const mod = options.loadModule ? await options.loadModule(modulePath) : await import(_url.pathToFileURL.call(void 0, modulePath).href);
+  const maybeModule = mod;
+  return maybeModule.components || maybeModule.default || {};
+}
+
+
+
+
+exports.createFarmMarkdownRouteModuleFromFile = createFarmMarkdownRouteModuleFromFile; exports.loadFarmMdxComponents = loadFarmMdxComponents;

package/dist/chunk-BPAXGCKX.mjs

@@ -0,0 +1,166 @@
+import {
+  matchSegmentParts,
+  normalizePathname,
+  normalizeRoutePattern,
+  parseRoutePattern,
+  splitNormalizedPathname,
+  splitPathname
+} from "./chunk-MFQGU5CC.mjs";
+import {
+  AmbiguousRouteError,
+  compareRouteSpecificity,
+  getRoutePatternShape
+} from "./chunk-AYP2YFVN.mjs";
+
+// src/router.ts
+function createFarmRouter(routes) {
+  const normalizedRoutes = routes.map(normalizeRouteInput);
+  const patternsByShape = /* @__PURE__ */ new Map();
+  for (const entry of normalizedRoutes) {
+    const shape = getRoutePatternShape(entry.route.path, "router");
+    const existingPattern = patternsByShape.get(shape);
+    if (existingPattern) {
+      throw new AmbiguousRouteError(
+        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
+      );
+    }
+    patternsByShape.set(shape, entry.route.path);
+  }
+  normalizedRoutes.sort(compareRoutes);
+  const exactRoutes = /* @__PURE__ */ new Map();
+  for (const entry of normalizedRoutes) {
+    if (entry.segments.every((segment) => segment.type === "static")) {
+      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
+      exactRoutes.set(pathname, entry);
+    }
+  }
+  return {
+    routes: normalizedRoutes.map((entry) => entry.route),
+    match(pathname) {
+      const normalizedPathname = normalizePathname(pathname);
+      const exactRoute = exactRoutes.get(normalizedPathname);
+      if (exactRoute) {
+        return {
+          route: exactRoute.route,
+          pathname: normalizedPathname,
+          params: {}
+        };
+      }
+      const parts = splitNormalizedPathname(normalizedPathname);
+      for (const entry of normalizedRoutes) {
+        const params = matchSegmentParts(entry.segments, parts);
+        if (params) {
+          return {
+            route: entry.route,
+            pathname: normalizedPathname,
+            params
+          };
+        }
+      }
+      return null;
+    },
+    build: buildFarmRoutePath,
+    isActive: isFarmRouteActive
+  };
+}
+function matchFarmRoute(pattern, pathname) {
+  return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));
+}
+function buildFarmRoutePath(pattern, params = {}, options = {}) {
+  const parts = [];
+  for (const segment of parseRoutePattern(pattern)) {
+    if (segment.type === "static") {
+      parts.push(encodePathSegment(segment.value));
+      continue;
+    }
+    const value = params[segment.name];
+    const values = Array.isArray(value) ? value : value == null ? [] : [value];
+    if (values.length === 0) {
+      if (segment.optional) continue;
+      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
+    }
+    if (!segment.catchAll && values.length > 1) {
+      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
+    }
+    const encodedValues = values.map((item) => {
+      const value2 = String(item);
+      if (!value2) {
+        throw new Error(
+          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
+        );
+      }
+      return encodePathSegment(value2);
+    });
+    parts.push(...encodedValues);
+  }
+  let pathname = parts.length ? `/${parts.join("/")}` : "/";
+  if (options.trailingSlash && pathname !== "/") {
+    pathname = `${pathname}/`;
+  }
+  return appendQueryAndHash(pathname, options);
+}
+function isFarmRouteActive(pattern, pathname, options = {}) {
+  const normalizedPathname = normalizePathname(pathname);
+  const segments = parseRoutePattern(pattern);
+  const parts = splitNormalizedPathname(normalizedPathname);
+  if (matchSegmentParts(segments, parts)) return true;
+  if (options.exact !== false) return false;
+  if (segments.length === 0) return normalizedPathname === "/";
+  return matchSegmentParts(segments, parts, true) !== null;
+}
+function normalizeRouteInput(input, index) {
+  const route = typeof input === "string" ? { path: input } : input;
+  const segments = parseRoutePattern(route.path);
+  const path = normalizeRoutePattern(route.path);
+  return {
+    route: {
+      ...route,
+      path
+    },
+    segments,
+    specificity: segments.map(getRouterSegmentSpecificity),
+    index
+  };
+}
+function matchSegments(segments, pathname, allowTrailingSegments = false) {
+  return matchSegmentParts(segments, splitPathname(pathname), allowTrailingSegments);
+}
+function compareRoutes(left, right) {
+  const specificity = compareRouteSpecificity(left.specificity, right.specificity);
+  if (specificity !== 0) return specificity;
+  return left.index - right.index;
+}
+function getRouterSegmentSpecificity(segment) {
+  if (segment.type === "static") return "static";
+  if (!segment.catchAll) return "dynamic";
+  return segment.optional ? "optional-catch-all" : "catch-all";
+}
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function appendQueryAndHash(pathname, options) {
+  const search = createSearchParams(options.query);
+  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
+  const query = search.toString();
+  return `${pathname}${query ? `?${query}` : ""}${hash}`;
+}
+function createSearchParams(query) {
+  if (query instanceof URLSearchParams) return query;
+  const search = new URLSearchParams();
+  if (!query) return search;
+  for (const [key, value] of Object.entries(query)) {
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item == null) continue;
+      search.append(key, String(item));
+    }
+  }
+  return search;
+}
+
+export {
+  createFarmRouter,
+  matchFarmRoute,
+  buildFarmRoutePath,
+  isFarmRouteActive
+};