@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-D7JTOLFK.cjs

@@ -1,285 +0,0 @@
-"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 _chunkLTNGXMQ6cjs = require('./chunk-LTNGXMQ6.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isTransientMutationFailure, "isTransientMutationFailure");
-function readErrorStatus(error) {
-  const status = _optionalChain([error, 'optionalAccess', _ => _.status]);
-  return typeof status === "number" ? status : void 0;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readErrorStatus, "readErrorStatus");
-async function invokeMutationWithRetry(invoke, retry, shouldContinue) {
-  const maxRetries = _chunkLTNGXMQ6cjs.resolveClientRetryCount.call(void 0, _optionalChain([retry, 'optionalAccess', _2 => _2.count]));
-  if (typeof _optionalChain([retry, 'optionalAccess', _3 => _3.delay]) !== "function") _chunkLTNGXMQ6cjs.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 = _chunkLTNGXMQ6cjs.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;
-      }
-    }
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, invokeMutationWithRetry, "invokeMutationWithRetry");
-
-// 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) {
-          _chunkLTNGXMQ6cjs.notifyClientObserver.call(void 0, callbacksRef.current.onSuccess, [result], "Action onSuccess");
-          if (requestId === requestIdRef.current) {
-            _chunkLTNGXMQ6cjs.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) {
-          _chunkLTNGXMQ6cjs.notifyClientObserver.call(void 0, callbacksRef.current.onError, [error], "Action onError");
-          if (requestId === requestIdRef.current) {
-            _chunkLTNGXMQ6cjs.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]
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, useServerFn, "useServerFn");
-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 = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (formData) => formActionRef.current(formData), "submitForm");
-    const ActionForm = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (props) => _react.createElement.call(void 0, "form", {
-      ...props,
-      action: submitForm
-    }), "ActionForm");
-    ActionForm.displayName = "FarmActionForm";
-    return ActionForm;
-  }, []);
-  return _react.useMemo.call(void 0, () => {
-    const call = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, ((input) => action.submit(input)), "call");
-    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
-  ]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, useAction, "useAction");
-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"
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveServerFnTarget, "resolveServerFnTarget");
-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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeServerFnError, "normalizeServerFnError");
-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";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isFormData, "isFormData");
-
-
-
-
-
-exports.invokeMutationWithRetry = invokeMutationWithRetry; exports.useServerFn = useServerFn; exports.useAction = useAction;

package/dist/chunk-DAATZTKJ.mjs

@@ -1,220 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/renderer.ts
-import fs from "fs";
-import { createRequire } from "module";
-import path from "path";
-import { pathToFileURL } from "url";
-var DEFAULT_RENDERER_CAPABILITIES = Object.freeze({
-  streaming: Object.freeze({ node: false, web: false }),
-  // Conservative default: assume a re-render rebuilds until a renderer states
-  // otherwise, so callers do not silently rely on reconciliation.
-  reconcilesRerenders: false,
-  functionComponents: false
-});
-function getFarmRendererCapabilities(renderer) {
-  const defaultStreaming = {
-    node: renderer?.capabilities?.streaming?.node ?? DEFAULT_RENDERER_CAPABILITIES.streaming.node,
-    web: renderer?.capabilities?.streaming?.web ?? DEFAULT_RENDERER_CAPABILITIES.streaming.web
-  };
-  const runtimes = Object.fromEntries(
-    ["node", "edge"].flatMap((runtime) => {
-      const override = renderer?.capabilities?.streaming?.runtimes?.[runtime];
-      if (!override) return [];
-      return [
-        [
-          runtime,
-          {
-            node: override.node ?? defaultStreaming.node,
-            web: override.web ?? defaultStreaming.web
-          }
-        ]
-      ];
-    })
-  );
-  return {
-    streaming: {
-      ...defaultStreaming,
-      ...Object.keys(runtimes).length > 0 ? { runtimes } : {}
-    },
-    reconcilesRerenders: renderer?.capabilities?.reconcilesRerenders ?? DEFAULT_RENDERER_CAPABILITIES.reconcilesRerenders,
-    functionComponents: renderer?.capabilities?.functionComponents ?? DEFAULT_RENDERER_CAPABILITIES.functionComponents
-  };
-}
-__name(getFarmRendererCapabilities, "getFarmRendererCapabilities");
-function getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime) {
-  const streaming = getFarmRendererCapabilities(renderer).streaming;
-  if (runtime === "unknown") return { node: streaming.node, web: streaming.web };
-  return streaming.runtimes?.[runtime] ?? { node: streaming.node, web: streaming.web };
-}
-__name(getFarmRendererStreamingCapabilitiesForRuntime, "getFarmRendererStreamingCapabilitiesForRuntime");
-function assertFarmRendererStreamingRuntime(name, renderer, runtimeModule, runtime) {
-  const declared = getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime);
-  const runtimeDeclaration = runtimeModule.capabilities?.streaming;
-  if (runtimeDeclaration) {
-    const advertised = getFarmRendererStreamingCapabilitiesForRuntime(
-      { capabilities: { streaming: runtimeDeclaration } },
-      runtime
-    );
-    if (declared.node && !advertised.node || declared.web && !advertised.web) {
-      throw new Error(
-        `Renderer \`${name}\` server module advertises ${JSON.stringify(advertised)} streaming for the ${runtime} runtime, which does not satisfy its descriptor ${JSON.stringify(declared)}.`
-      );
-    }
-  }
-  if (declared.node && typeof runtimeModule.renderToPipeableStream !== "function") {
-    throw new Error(
-      `Renderer \`${name}\` advertises Node streaming for the ${runtime} runtime but its server module does not export renderToPipeableStream().`
-    );
-  }
-  if (declared.web && typeof runtimeModule.renderToReadableStream !== "function") {
-    throw new Error(
-      `Renderer \`${name}\` advertises Web streaming for the ${runtime} runtime but its server module does not export renderToReadableStream().`
-    );
-  }
-  return declared;
-}
-__name(assertFarmRendererStreamingRuntime, "assertFarmRendererStreamingRuntime");
-var FARM_COMPONENT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
-function resolveFarmComponentExtensions(extensions = []) {
-  return Array.from(
-    new Set(
-      [...FARM_COMPONENT_EXTENSIONS, ...extensions].map((extension) => {
-        const normalized = extension.trim().toLowerCase();
-        return normalized.startsWith(".") ? normalized : `.${normalized}`;
-      })
-    )
-  ).filter((extension) => extension.length > 1);
-}
-__name(resolveFarmComponentExtensions, "resolveFarmComponentExtensions");
-function getFarmRendererComponentExtensions(renderer) {
-  return resolveFarmComponentExtensions(renderer?.componentExtensions);
-}
-__name(getFarmRendererComponentExtensions, "getFarmRendererComponentExtensions");
-var REACT_RENDERER = Object.freeze({
-  name: "react",
-  vite: "@farm.js/core/renderer/react/vite",
-  server: "@farm.js/core/renderer/react/server",
-  client: "@farm.js/core/renderer/react/client",
-  jsxImportSource: "react",
-  dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
-  optimizeDeps: [
-    "react",
-    "react-dom",
-    "react-dom/client",
-    "react/jsx-runtime",
-    "react/jsx-dev-runtime"
-  ],
-  capabilities: {
-    streaming: {
-      node: true,
-      web: false,
-      runtimes: { edge: { node: false, web: true } }
-    },
-    reconcilesRerenders: true,
-    functionComponents: true
-  }
-});
-function defineRenderer(renderer) {
-  return renderer;
-}
-__name(defineRenderer, "defineRenderer");
-function resolveFarmRenderer(renderer) {
-  const resolved = renderer || REACT_RENDERER;
-  const fields = ["name", "vite", "server", "client"];
-  for (const field of fields) {
-    if (typeof resolved[field] !== "string" || resolved[field].trim().length === 0) {
-      throw new TypeError(`Farm renderer \`${field}\` must be a non-empty string.`);
-    }
-  }
-  if (resolved.appSetup !== void 0 && (typeof resolved.appSetup !== "string" || resolved.appSetup.trim().length === 0)) {
-    throw new TypeError("Farm renderer `appSetup` must be a non-empty module path.");
-  }
-  return {
-    ...resolved,
-    componentExtensions: [...resolved.componentExtensions || []],
-    dedupe: [...resolved.dedupe || []],
-    optimizeDeps: [...resolved.optimizeDeps || []],
-    buildConcurrency: resolved.buildConcurrency || "parallel",
-    capabilities: getFarmRendererCapabilities(resolved),
-    options: resolved.options ? { ...resolved.options } : void 0
-  };
-}
-__name(resolveFarmRenderer, "resolveFarmRenderer");
-async function readFarmRendererWebStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let html = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    html += typeof value === "string" ? value : decoder.decode(value, { stream: true });
-  }
-  return html + decoder.decode();
-}
-__name(readFarmRendererWebStream, "readFarmRendererWebStream");
-function isReactRenderer(renderer) {
-  return !renderer || renderer.name === "react";
-}
-__name(isReactRenderer, "isReactRenderer");
-function resolveFarmRendererAppSetup(root, renderer) {
-  if (!renderer.appSetup) return null;
-  const filePath = path.resolve(root, renderer.appSetup);
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Renderer \`${renderer.name}\` app setup module was not found: ${filePath}`);
-  }
-  return filePath;
-}
-__name(resolveFarmRendererAppSetup, "resolveFarmRendererAppSetup");
-function resolveFarmRendererModule(root, specifier) {
-  const requireFromApp = createRequire(path.join(path.resolve(root), "package.json"));
-  return requireFromApp.resolve(specifier);
-}
-__name(resolveFarmRendererModule, "resolveFarmRendererModule");
-function createFarmReactJsxPlugin() {
-  return {
-    name: "farm:react-jsx",
-    config(config) {
-      if (this && this.meta?.rolldownVersion) return;
-      if (config.esbuild === false || config.esbuild?.jsx !== void 0) return;
-      return { esbuild: { jsx: "automatic" } };
-    }
-  };
-}
-__name(createFarmReactJsxPlugin, "createFarmReactJsxPlugin");
-async function loadFarmRendererVitePlugins(renderer, root, options = {}) {
-  if (renderer.vite === REACT_RENDERER.vite) return [createFarmReactJsxPlugin()];
-  const modulePath = resolveFarmRendererModule(root, renderer.vite);
-  const rendererModule = await import(pathToFileURL(modulePath).href);
-  if (typeof rendererModule.createFarmRendererPlugin !== "function") {
-    throw new Error(
-      `Renderer \`${renderer.name}\` module ${renderer.vite} must export createFarmRendererPlugin().`
-    );
-  }
-  const created = await rendererModule.createFarmRendererPlugin({
-    ...options,
-    rendererOptions: renderer.options
-  });
-  if (!created) return [];
-  return Array.isArray(created) ? [...created] : [created];
-}
-__name(loadFarmRendererVitePlugins, "loadFarmRendererVitePlugins");
-
-export {
-  getFarmRendererCapabilities,
-  getFarmRendererStreamingCapabilitiesForRuntime,
-  assertFarmRendererStreamingRuntime,
-  FARM_COMPONENT_EXTENSIONS,
-  resolveFarmComponentExtensions,
-  getFarmRendererComponentExtensions,
-  REACT_RENDERER,
-  defineRenderer,
-  resolveFarmRenderer,
-  readFarmRendererWebStream,
-  isReactRenderer,
-  resolveFarmRendererAppSetup,
-  resolveFarmRendererModule,
-  loadFarmRendererVitePlugins
-};