@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-PRFNLQSP.cjs

@@ -0,0 +1,277 @@
+"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 _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 _chunkUNJZGVPUcjs = require('./chunk-UNJZGVPU.cjs');
+
+
+
+
+
+var _chunkLT4VAF5Zcjs = require('./chunk-LT4VAF5Z.cjs');
+
+// src/app-markdown-runtime.ts
+var _url = require('url');
+function isFarmMarkdownPageFile(filePath) {
+  return /(^|[/\\])page\.mdx?$/i.test(filePath);
+}
+function normalizeFarmMarkdownRoutePath(pathname) {
+  const withoutExtension = pathname.replace(/\.md$/i, "");
+  const normalized = withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
+  return normalized === "/index" ? "/" : normalized.replace(/\/+$/g, "") || "/";
+}
+function parseMarkdownFrontmatter(source) {
+  if (!source.startsWith("---")) {
+    return { frontmatter: {}, body: source };
+  }
+  const endIndex = source.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: {}, body: source };
+  }
+  const frontmatterSource = source.slice(3, endIndex).trim();
+  const closingFenceEnd = endIndex + "\n---".length;
+  const bodyStart = source.slice(closingFenceEnd, closingFenceEnd + 2) === "\r\n" ? closingFenceEnd + 2 : source[closingFenceEnd] === "\n" ? closingFenceEnd + 1 : closingFenceEnd;
+  const body = source.slice(bodyStart);
+  const frontmatter = {};
+  for (const line of frontmatterSource.split(/\r?\n/)) {
+    const separator = line.indexOf(":");
+    if (separator === -1) continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
+    if (key && value) frontmatter[key] = value;
+  }
+  return { frontmatter, body };
+}
+function titleFromMarkdown(body, fallback) {
+  return _optionalChain([body, 'access', _ => _.match, 'call', _2 => _2(/^#\s+(.+)$/m), 'optionalAccess', _3 => _3[1], 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]) || fallback;
+}
+function createMarkdownMetadata(source, filePath) {
+  const { frontmatter, body } = parseMarkdownFrontmatter(source);
+  const routeTitle = titleFromMarkdown(body);
+  const title = frontmatter.title || routeTitle;
+  const description = frontmatter.description;
+  if (!title && !description) {
+    return void 0;
+  }
+  return {
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    source: filePath
+  };
+}
+async function evaluateMdxSource(source, filePath) {
+  const [{ evaluate }, runtime, remarkGfmModule] = await Promise.all([
+    import("@mdx-js/mdx"),
+    import("react/jsx-runtime"),
+    import("remark-gfm")
+  ]);
+  const remarkGfm = remarkGfmModule.default;
+  return evaluate(source, {
+    ...runtime,
+    baseUrl: _url.pathToFileURL.call(void 0, filePath),
+    remarkPlugins: [remarkGfm]
+  });
+}
+function createFarmMarkdownRouteModule(input) {
+  const { body } = parseMarkdownFrontmatter(input.source);
+  const components = input.components || {};
+  const className = _optionalChain([input, 'access', _6 => _6.config, 'optionalAccess', _7 => _7.className]) || "farm-markdown";
+  let evaluatedPromise;
+  const loadContent = async () => {
+    _nullishCoalesce(evaluatedPromise, () => ( (evaluatedPromise = evaluateMdxSource(body, input.filePath))));
+    return evaluatedPromise;
+  };
+  async function FarmMarkdownPage(props) {
+    const { createElement } = await import("react");
+    const evaluated = await loadContent();
+    const MDXContent = evaluated.default;
+    return createElement(
+      "article",
+      { className, "data-farm-markdown-page": "" },
+      createElement(MDXContent, {
+        ...props,
+        components: {
+          ...components,
+          ..._optionalChain([props, 'optionalAccess', _8 => _8.components])
+        }
+      })
+    );
+  }
+  return {
+    default: FarmMarkdownPage,
+    metadata: createMarkdownMetadata(input.source, input.filePath),
+    source: input.source
+  };
+}
+var publicSourceResponses = /* @__PURE__ */ new WeakSet();
+function isFarmMarkdownPublicSourceResponse(response) {
+  return publicSourceResponses.has(response);
+}
+var ANONYMOUS_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-encoding",
+  "accept-language",
+  "cache-control",
+  "connection",
+  "dnt",
+  "host",
+  "if-match",
+  "if-modified-since",
+  "if-none-match",
+  "if-range",
+  "if-unmodified-since",
+  "keep-alive",
+  "origin",
+  "pragma",
+  "priority",
+  "purpose",
+  "range",
+  "referer",
+  "save-data",
+  "sec-gpc",
+  "sec-purpose",
+  "te",
+  "traceparent",
+  "tracestate",
+  "upgrade-insecure-requests",
+  "user-agent",
+  "x-forwarded-host",
+  "x-forwarded-port",
+  "x-forwarded-proto",
+  "x-request-id"
+]);
+function isAnonymousRequestHeader(name) {
+  const lower = name.toLowerCase();
+  return ANONYMOUS_REQUEST_HEADERS.has(lower) || lower.startsWith("sec-fetch-") || lower.startsWith("sec-ch-");
+}
+var PAGE_CHECK_DROPPED_HEADERS = /* @__PURE__ */ new Set([
+  "accept-encoding",
+  "if-match",
+  "if-modified-since",
+  "if-none-match",
+  "if-range",
+  "if-unmodified-since",
+  "range"
+]);
+var PAGE_SEGMENT_MARKER = /<div\s[^>]*\bid=["']?__farm_page__["'\s>]/i;
+async function anonymousVisitorOpensPage(options, url, targetPathname) {
+  const pageUrl = new URL(url);
+  pageUrl.pathname = targetPathname;
+  const headers = new Headers();
+  for (const [name, value] of options.request.headers) {
+    if (!PAGE_CHECK_DROPPED_HEADERS.has(name.toLowerCase())) headers.append(name, value);
+  }
+  headers.set("accept", "text/html");
+  headers.set(_chunkLT4VAF5Zcjs.FARM_MARKDOWN_PAGE_CHECK_HEADER, _chunkLT4VAF5Zcjs._getFarmMarkdownPageCheckToken.call(void 0, ));
+  const response = await options.renderPage(
+    new Request(pageUrl, {
+      method: "GET",
+      headers,
+      redirect: "manual",
+      signal: options.request.signal
+    })
+  );
+  if (response.status < 200 || response.status >= 300 || !_optionalChain([response, 'access', _9 => _9.headers, 'access', _10 => _10.get, 'call', _11 => _11("content-type"), 'optionalAccess', _12 => _12.toLowerCase, 'call', _13 => _13(), 'access', _14 => _14.includes, 'call', _15 => _15("text/html")])) {
+    void _optionalChain([response, 'access', _16 => _16.body, 'optionalAccess', _17 => _17.cancel, 'call', _18 => _18(), 'access', _19 => _19.catch, 'call', _20 => _20(() => {
+    })]);
+    return false;
+  }
+  return PAGE_SEGMENT_MARKER.test(await response.text());
+}
+function hasOnlyAnonymousHeaders(headers) {
+  for (const name of headers.keys()) {
+    if (!isAnonymousRequestHeader(name)) return false;
+  }
+  return true;
+}
+var FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS = _chunkUNJZGVPUcjs.FARM_ANONYMOUS_CLIENT_ADDRESS;
+async function createFarmMarkdownSourceResponse(options) {
+  if (options.request.method !== "GET" && options.request.method !== "HEAD") {
+    return null;
+  }
+  if (_optionalChain([options, 'access', _21 => _21.config, 'optionalAccess', _22 => _22.markdownRoutes]) === false) {
+    return null;
+  }
+  const url = new URL(options.request.url);
+  const hasMarkdownExtension = url.pathname.toLowerCase().endsWith(".md");
+  if (!hasMarkdownExtension && !_chunkLT4VAF5Zcjs.requestAcceptsMarkdown.call(void 0, options.request.headers.get("accept"))) {
+    return null;
+  }
+  const targetPathname = normalizeFarmMarkdownRoutePath(url.pathname);
+  const source = await options.resolveSource(targetPathname);
+  if (!source) {
+    return null;
+  }
+  const anonymous = hasOnlyAnonymousHeaders(options.request.headers) && (!options.clientAddress || options.clientAddress === FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS);
+  if (options.renderPage && (hasMarkdownExtension || !anonymous)) {
+    const publicUrl = new URL(url);
+    publicUrl.pathname = targetPathname;
+    const publicHeaders = new Headers();
+    for (const [name, value] of options.request.headers) {
+      if (isAnonymousRequestHeader(name)) publicHeaders.append(name, value);
+    }
+    publicHeaders.set("accept", "text/markdown");
+    const publicResponse = await options.renderPage(
+      new Request(publicUrl, {
+        method: options.request.method,
+        headers: publicHeaders,
+        signal: options.request.signal
+      })
+    );
+    if (publicResponse.headers.get("X-Farm-Markdown-Route") === targetPathname && publicResponse.headers.has("X-Farm-Markdown-Source")) {
+      let response = publicResponse;
+      if (options.request.headers.has("cookie") || options.request.headers.has("authorization")) {
+        const headers2 = new Headers(publicResponse.headers);
+        headers2.set("Cache-Control", "private, no-store");
+        response = new Response(publicResponse.body, {
+          status: publicResponse.status,
+          statusText: publicResponse.statusText,
+          headers: headers2
+        });
+      }
+      publicSourceResponses.add(response);
+      return response;
+    }
+    await _optionalChain([publicResponse, 'access', _23 => _23.body, 'optionalAccess', _24 => _24.cancel, 'call', _25 => _25()]);
+    if (!hasMarkdownExtension) return null;
+    return new Response(`No public Markdown version of ${targetPathname}.
+`, {
+      status: 404,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "private, no-store"
+      }
+    });
+  }
+  if (options.renderPage && !await anonymousVisitorOpensPage(options, url, targetPathname)) {
+    return null;
+  }
+  const headers = new Headers({
+    "Content-Type": "text/markdown; charset=utf-8",
+    "Content-Location": targetPathname === "/" ? "/index.md" : `${targetPathname}.md`,
+    "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
+    "X-Farm-Markdown-Route": targetPathname,
+    "X-Farm-Markdown-Source": source.filePath
+  });
+  if (!hasMarkdownExtension) {
+    headers.set("Vary", "Accept");
+  }
+  return _chunkLT4VAF5Zcjs.createFarmMarkdownViewResponse.call(void 0, {
+    request: options.request,
+    requestUrl: url,
+    markdown: source.source,
+    status: 200,
+    headers,
+    markdownPath: headers.get("Content-Location")
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.isFarmMarkdownPageFile = isFarmMarkdownPageFile; exports.normalizeFarmMarkdownRoutePath = normalizeFarmMarkdownRoutePath; exports.parseMarkdownFrontmatter = parseMarkdownFrontmatter; exports.titleFromMarkdown = titleFromMarkdown; exports.createMarkdownMetadata = createMarkdownMetadata; exports.createFarmMarkdownRouteModule = createFarmMarkdownRouteModule; exports.isFarmMarkdownPublicSourceResponse = isFarmMarkdownPublicSourceResponse; exports.FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS = FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS; exports.createFarmMarkdownSourceResponse = createFarmMarkdownSourceResponse;

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-PZXYAWYG.cjs

@@ -0,0 +1,274 @@
+"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 _chunkEOXPRC2Ccjs = require('./chunk-EOXPRC2C.cjs');
+
+// src/server-fn-client.ts
+
+
+
+
+
+
+var _react = require('react');
+
+// src/mutation-retry.ts
+var TRANSIENT_STATUSES = /* @__PURE__ */ new Set([408, 425, 429]);
+function isTransientMutationFailure(context) {
+  if (context.status === void 0) return true;
+  return context.status >= 500 || TRANSIENT_STATUSES.has(context.status);
+}
+function readErrorStatus(error) {
+  const status = _optionalChain([error, 'optionalAccess', _ => _.status]);
+  return typeof status === "number" ? status : void 0;
+}
+async function invokeMutationWithRetry(invoke, retry, shouldContinue) {
+  const maxRetries = _chunkEOXPRC2Ccjs.resolveClientRetryCount.call(void 0, _optionalChain([retry, 'optionalAccess', _2 => _2.count]));
+  if (typeof _optionalChain([retry, 'optionalAccess', _3 => _3.delay]) !== "function") _chunkEOXPRC2Ccjs.resolveClientRetryDelay.call(void 0, _optionalChain([retry, 'optionalAccess', _4 => _4.delay]));
+  const shouldRetryFailure = _nullishCoalesce(_optionalChain([retry, 'optionalAccess', _5 => _5.shouldRetry]), () => ( isTransientMutationFailure));
+  let attempt = 0;
+  while (true) {
+    try {
+      return await invoke();
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= maxRetries || !shouldContinue() || !shouldRetryFailure({
+        attempt,
+        method: "POST",
+        status: readErrorStatus(error),
+        error: failure
+      })) {
+        throw error;
+      }
+      attempt += 1;
+      const delay = _chunkEOXPRC2Ccjs.resolveClientRetryDelay.call(void 0, 
+        typeof _optionalChain([retry, 'optionalAccess', _6 => _6.delay]) === "function" ? retry.delay(attempt) : _optionalChain([retry, 'optionalAccess', _7 => _7.delay])
+      );
+      if (delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (!shouldContinue()) throw error;
+      }
+    }
+  }
+}
+
+// src/server-fn-client.ts
+function useServerFn(serverFn, options = {}) {
+  const { initialResult = null, resetOnSubmit = true } = options;
+  const callbacksRef = _react.useRef.call(void 0, {});
+  const requestIdRef = _react.useRef.call(void 0, 0);
+  const lastResetIdRef = _react.useRef.call(void 0, 0);
+  const initialState = {
+    pendingCount: 0,
+    status: "idle",
+    result: initialResult,
+    error: null
+  };
+  const stateRef = _react.useRef.call(void 0, initialState);
+  const [state, setState] = _react.useState.call(void 0, initialState);
+  const setActionState = _react.useCallback.call(void 0, 
+    (value) => {
+      const next = typeof value === "function" ? value(stateRef.current) : value;
+      stateRef.current = next;
+      setState(next);
+    },
+    []
+  );
+  callbacksRef.current = {
+    onError: options.onError,
+    onSettled: options.onSettled,
+    onSuccess: options.onSuccess,
+    throwOnFormError: options.throwOnFormError
+  };
+  const submit = _react.useCallback.call(void 0, 
+    async (input) => {
+      const requestId = ++requestIdRef.current;
+      const formData = isFormData(input) ? input : void 0;
+      const previousResult = stateRef.current.result;
+      const optimisticResult = _optionalChain([options, 'access', _8 => _8.optimistic, 'optionalCall', _9 => _9({
+        input,
+        formData,
+        current: previousResult
+      })]);
+      const hasOptimisticResult = optimisticResult !== void 0;
+      setActionState((current) => {
+        if (requestId < lastResetIdRef.current) return current;
+        const pendingCount = current.pendingCount + 1;
+        if (requestId !== requestIdRef.current) return { ...current, pendingCount };
+        return {
+          pendingCount,
+          status: "pending",
+          result: hasOptimisticResult ? optimisticResult : resetOnSubmit ? null : current.result,
+          error: null
+        };
+      });
+      try {
+        const result = await invokeMutationWithRetry(
+          () => serverFn(input),
+          options.retry,
+          // A reset disowns this submission; stop scheduling retries then.
+          () => requestId >= lastResetIdRef.current
+        );
+        const isLatestRequest = requestId === requestIdRef.current;
+        setActionState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount
+            };
+          }
+          return {
+            pendingCount,
+            status: "success",
+            result,
+            error: null
+          };
+        });
+        if (isLatestRequest) {
+          _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, callbacksRef.current.onSuccess, [result], "Action onSuccess");
+          if (requestId === requestIdRef.current) {
+            _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, 
+              callbacksRef.current.onSettled,
+              [result, null],
+              "Action onSettled"
+            );
+          }
+        }
+        return result;
+      } catch (cause) {
+        const error = normalizeServerFnError(cause);
+        const isLatestRequest = requestId === requestIdRef.current;
+        setActionState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount
+            };
+          }
+          return {
+            pendingCount,
+            status: "error",
+            result: hasOptimisticResult && options.rollbackOnError ? previousResult : resetOnSubmit ? null : current.result,
+            error
+          };
+        });
+        if (isLatestRequest) {
+          _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, callbacksRef.current.onError, [error], "Action onError");
+          if (requestId === requestIdRef.current) {
+            _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, callbacksRef.current.onSettled, [null, error], "Action onSettled");
+          }
+        }
+        throw error;
+      }
+    },
+    [
+      options.optimistic,
+      options.retry,
+      options.rollbackOnError,
+      resetOnSubmit,
+      serverFn,
+      setActionState
+    ]
+  );
+  const formAction = _react.useCallback.call(void 0, 
+    async (formData) => {
+      try {
+        await submit(formData);
+      } catch (error) {
+        if (callbacksRef.current.throwOnFormError) {
+          throw error;
+        }
+      }
+    },
+    [submit]
+  );
+  const reset = _react.useCallback.call(void 0, () => {
+    lastResetIdRef.current = ++requestIdRef.current;
+    setActionState({
+      pendingCount: 0,
+      status: "idle",
+      result: initialResult,
+      error: null
+    });
+  }, [initialResult, setActionState]);
+  return _react.useMemo.call(void 0, 
+    () => ({
+      pending: state.pendingCount > 0,
+      status: state.status,
+      result: state.result,
+      error: state.error,
+      submit,
+      formAction,
+      reset
+    }),
+    [formAction, reset, state.error, state.pendingCount, state.result, state.status, submit]
+  );
+}
+function useAction(target, options = {}) {
+  const serverFn = resolveServerFnTarget(target);
+  const action = useServerFn(serverFn, options);
+  const formActionRef = _react.useRef.call(void 0, action.formAction);
+  formActionRef.current = action.formAction;
+  const Form = _react.useMemo.call(void 0, () => {
+    const submitForm = (formData) => formActionRef.current(formData);
+    const ActionForm = (props) => _react.createElement.call(void 0, "form", {
+      ...props,
+      action: submitForm
+    });
+    ActionForm.displayName = "FarmActionForm";
+    return ActionForm;
+  }, []);
+  return _react.useMemo.call(void 0, () => {
+    const call = ((input) => action.submit(input));
+    return Object.assign(call, {
+      pending: action.pending,
+      status: action.status,
+      data: action.result,
+      result: action.result,
+      error: action.error,
+      formAction: action.formAction,
+      Form,
+      reset: action.reset
+    });
+  }, [
+    Form,
+    action.error,
+    action.formAction,
+    action.pending,
+    action.reset,
+    action.result,
+    action.status,
+    action.submit
+  ]);
+}
+function resolveServerFnTarget(target) {
+  if (typeof target === "function") return target;
+  if (target && typeof target.action === "function") return target.action;
+  throw new TypeError(
+    "useAction requires a server function or a route with at least one declared action"
+  );
+}
+function normalizeServerFnError(error) {
+  if (error instanceof Error) return error;
+  const normalized = new Error(typeof error === "string" ? error : "Server function failed");
+  normalized.cause = error;
+  return normalized;
+}
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return true;
+  }
+  return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+
+
+
+
+
+exports.invokeMutationWithRetry = invokeMutationWithRetry; exports.useServerFn = useServerFn; exports.useAction = useAction;

package/dist/chunk-Q5B4LNON.mjs

@@ -0,0 +1,19 @@
+// src/write-file-if-changed.ts
+import { readFileSync, writeFileSync } from "fs";
+function writeFileIfChanged(filePath, content) {
+  try {
+    if (readFileSync(filePath, "utf8") === content) {
+      return false;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  writeFileSync(filePath, content, "utf8");
+  return true;
+}
+
+export {
+  writeFileIfChanged
+};