@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-GL3ZDHKI.mjs

@@ -0,0 +1,274 @@
+import {
+  notifyClientObserver,
+  resolveClientRetryCount,
+  resolveClientRetryDelay
+} from "./chunk-IAPTECEB.mjs";
+
+// src/server-fn-client.ts
+import {
+  createElement,
+  useCallback,
+  useMemo,
+  useRef,
+  useState
+} from "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 = error?.status;
+  return typeof status === "number" ? status : void 0;
+}
+async function invokeMutationWithRetry(invoke, retry, shouldContinue) {
+  const maxRetries = resolveClientRetryCount(retry?.count);
+  if (typeof retry?.delay !== "function") resolveClientRetryDelay(retry?.delay);
+  const shouldRetryFailure = retry?.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 = resolveClientRetryDelay(
+        typeof retry?.delay === "function" ? retry.delay(attempt) : retry?.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 = useRef({});
+  const requestIdRef = useRef(0);
+  const lastResetIdRef = useRef(0);
+  const initialState = {
+    pendingCount: 0,
+    status: "idle",
+    result: initialResult,
+    error: null
+  };
+  const stateRef = useRef(initialState);
+  const [state, setState] = useState(initialState);
+  const setActionState = useCallback(
+    (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 = useCallback(
+    async (input) => {
+      const requestId = ++requestIdRef.current;
+      const formData = isFormData(input) ? input : void 0;
+      const previousResult = stateRef.current.result;
+      const optimisticResult = options.optimistic?.({
+        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) {
+          notifyClientObserver(callbacksRef.current.onSuccess, [result], "Action onSuccess");
+          if (requestId === requestIdRef.current) {
+            notifyClientObserver(
+              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) {
+          notifyClientObserver(callbacksRef.current.onError, [error], "Action onError");
+          if (requestId === requestIdRef.current) {
+            notifyClientObserver(callbacksRef.current.onSettled, [null, error], "Action onSettled");
+          }
+        }
+        throw error;
+      }
+    },
+    [
+      options.optimistic,
+      options.retry,
+      options.rollbackOnError,
+      resetOnSubmit,
+      serverFn,
+      setActionState
+    ]
+  );
+  const formAction = useCallback(
+    async (formData) => {
+      try {
+        await submit(formData);
+      } catch (error) {
+        if (callbacksRef.current.throwOnFormError) {
+          throw error;
+        }
+      }
+    },
+    [submit]
+  );
+  const reset = useCallback(() => {
+    lastResetIdRef.current = ++requestIdRef.current;
+    setActionState({
+      pendingCount: 0,
+      status: "idle",
+      result: initialResult,
+      error: null
+    });
+  }, [initialResult, setActionState]);
+  return useMemo(
+    () => ({
+      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 = useRef(action.formAction);
+  formActionRef.current = action.formAction;
+  const Form = useMemo(() => {
+    const submitForm = (formData) => formActionRef.current(formData);
+    const ActionForm = (props) => createElement("form", {
+      ...props,
+      action: submitForm
+    });
+    ActionForm.displayName = "FarmActionForm";
+    return ActionForm;
+  }, []);
+  return useMemo(() => {
+    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";
+}
+
+export {
+  invokeMutationWithRetry,
+  useServerFn,
+  useAction
+};

package/dist/chunk-GLOICKDO.mjs

@@ -0,0 +1,142 @@
+// src/cache-key.ts
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+function getFunctionCacheIdentity(fn) {
+  const name = fn.name || "anonymous";
+  return `${name}:${hashFunctionSource(String(fn))}`;
+}
+function hashFunctionSource(source) {
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index++) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function compareCodepoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function serializeBinaryBytes(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function serializeCanonicalStringEntries(entries, seen) {
+  const valuesByKey = /* @__PURE__ */ new Map();
+  for (const [key, item] of entries) {
+    const values = valuesByKey.get(key);
+    if (values) values.push(item);
+    else valuesByKey.set(key, [item]);
+  }
+  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
+    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
+  ).join(",");
+}
+function isPlainCacheKeyObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null) return true;
+  const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
+}
+function getCacheKeyValueType(value) {
+  const prototype = Object.getPrototypeOf(value);
+  const constructor = prototype ? Object.getOwnPropertyDescriptor(prototype, "constructor")?.value : void 0;
+  if (typeof constructor === "function" && constructor.name) {
+    return constructor.name;
+  }
+  return Object.prototype.toString.call(value).slice(8, -1) || "object";
+}
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
+  }
+  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const viewType = Object.prototype.toString.call(value).slice(8, -1);
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const items = [];
+      for (let index = 0; index < value.length; index++) {
+        items.push(
+          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
+        );
+      }
+      seen.delete(value);
+      return `[${items.join(",")}]`;
+    }
+    if (value instanceof Set) {
+      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
+      seen.delete(value);
+      return `set:[${items.join(",")}]`;
+    }
+    if (value instanceof Map) {
+      const items = Array.from(
+        value,
+        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
+      ).sort(compareCodepoint);
+      seen.delete(value);
+      return `map:[${items.join(",")}]`;
+    }
+    if (value instanceof URLSearchParams) {
+      const serialized2 = serializeCanonicalStringEntries(value, seen);
+      seen.delete(value);
+      return `urlsearchparams:[${serialized2}]`;
+    }
+    if (value instanceof Headers) {
+      const serialized2 = serializeCanonicalStringEntries(value, seen);
+      seen.delete(value);
+      return `headers:[${serialized2}]`;
+    }
+    if (!isPlainCacheKeyObject(value)) {
+      throw new TypeError(
+        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
+      );
+    }
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => compareCodepoint(a, b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+
+export {
+  createRouteDataCacheKey,
+  createFarmCacheKey,
+  getFunctionCacheIdentity
+};

package/dist/chunk-GSVJ3IIF.cjs

@@ -0,0 +1,173 @@
+"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(); } }
+
+var _chunk5YPBFMBNcjs = require('./chunk-5YPBFMBN.cjs');
+
+// src/env-types.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var DEFAULT_OUT_FILE = "farm-env.d.ts";
+var CONFIG_FILENAMES = [
+  "farm.config.ts",
+  "farm.config.tsx",
+  "farm.config.mts",
+  "farm.config.cts",
+  "farm.config.js",
+  "farm.config.jsx",
+  "farm.config.mjs",
+  "farm.config.cjs",
+  "config.ts",
+  "config.tsx",
+  "config.mts",
+  "config.cts",
+  "config.js",
+  "config.jsx",
+  "config.mjs",
+  "config.cjs"
+];
+async function generateEnvTypes(options) {
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
+  const content = createEnvTypeDeclarations(options, outPath);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  _chunk5YPBFMBNcjs.writeFileIfChanged.call(void 0, outPath, content);
+  return outPath;
+}
+function createEnvTypeDeclarations(options, outPath) {
+  const root = path.resolve(options.root);
+  const configPath = findConfigPath(root, options.configPath);
+  const configPaths = [
+    ...(_nullishCoalesce(options.layerConfigPaths, () => ( []))).filter((value) => fs.existsSync(value)),
+    ...configPath ? [configPath] : []
+  ];
+  const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
+  return content;
+}
+function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
+  const imports = configPaths.map(
+    (configPath, index) => `import type FarmConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
+  ).join("\n");
+  const resolvedTypes = configPaths.map(
+    (_configPath, index) => `
+type FarmConfigEnv${index} = typeof FarmConfig${index} extends { env?: infer TEnv }
+  ? NonNullable<TEnv>
+  : never;
+type FarmResolvedEnv${index} = [FarmConfigEnv${index}] extends [never]
+  ? { server: {}; public: {} }
+  : InferEnv<FarmConfigEnv${index}>;`
+  ).join("\n");
+  const mergedTypes = configPaths.slice(1).map(
+    (_configPath, index) => `type FarmMergedEnv${index + 1} = MergeFarmEnv<${index === 0 ? "FarmResolvedEnv0" : `FarmMergedEnv${index}`}, FarmResolvedEnv${index + 1}>;`
+  ).join("\n");
+  const finalType = `FarmMergedEnv${configPaths.length - 1}`;
+  return `/**
+ * Auto-generated env types from Farm layers and farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+${imports}
+import type { InferEnv } from "@farm.js/core/env";
+
+type MergeFarmEnv<TBase, TOverride> = {
+  server: Omit<TBase extends { server: infer T } ? T : {}, keyof (TOverride extends { server: infer T } ? T : {})> &
+    (TOverride extends { server: infer T } ? T : {});
+  public: Omit<TBase extends { public: infer T } ? T : {}, keyof (TOverride extends { public: infer T } ? T : {})> &
+    (TOverride extends { public: infer T } ? T : {});
+};
+${resolvedTypes}
+${mergedTypes}
+
+type FarmResolvedEnv = ${finalType};
+
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+export {};
+`;
+}
+function findConfigPath(root, configPath) {
+  if (configPath) {
+    const resolvedPath = path.isAbsolute(configPath) ? configPath : path.join(root, configPath);
+    return fs.existsSync(resolvedPath) ? resolvedPath : null;
+  }
+  for (const filename of CONFIG_FILENAMES) {
+    const resolvedPath = path.join(root, filename);
+    if (fs.existsSync(resolvedPath)) {
+      return resolvedPath;
+    }
+  }
+  return null;
+}
+function createConfigBackedEnvTypes(outPath, configPath) {
+  const configImportPath = toTypeImportPath(outPath, configPath);
+  return `/**
+ * Auto-generated env types from farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+import type FarmConfig from ${JSON.stringify(configImportPath)};
+import type { InferEnv } from "@farm.js/core/env";
+
+type FarmConfigEnv = typeof FarmConfig extends { env?: infer TEnv } ? NonNullable<TEnv> : never;
+type FarmResolvedEnv = [FarmConfigEnv] extends [never]
+  ? { server: {}; public: {} }
+  : InferEnv<FarmConfigEnv>;
+
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+export {};
+`;
+}
+function createEmptyEnvTypes() {
+  return `/**
+ * Auto-generated env types from farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: {};
+    public: {};
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: {};
+    public: {};
+  }
+}
+
+export {};
+`;
+}
+function toTypeImportPath(outPath, targetPath) {
+  const relativePath = path.relative(path.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+
+
+
+
+exports.generateEnvTypes = generateEnvTypes; exports.createEnvTypeDeclarations = createEnvTypeDeclarations;