@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-QTD6EMN2.mjs

@@ -0,0 +1,368 @@
+import {
+  ServerFnFailure,
+  getServerActionExecutionContext,
+  getServerActionSignal,
+  isServerFnFailure,
+  runWithServerActionRequest
+} from "./chunk-E46NXBNJ.mjs";
+import {
+  applyFarmCacheInvalidationTargets
+} from "./chunk-RLEALQEN.mjs";
+import {
+  getFarmRedirectError
+} from "./chunk-JNYFXL7X.mjs";
+import {
+  _resolveCurrentRequestForApp,
+  _toAppRequestView
+} from "./chunk-VIXTAVEA.mjs";
+
+// src/server-fn.ts
+var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var ServerFnInputError = class extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+async function _invokeServerFunction(value, input, request) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await runWithServerActionRequest(request, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (isServerFnFailure(error)) return { ok: false, reason: "failure", failure: error };
+    const redirect = getFarmRedirectError(error);
+    if (redirect) {
+      return { ok: false, reason: "redirect", url: redirect.url, status: redirect.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function createServerMiddleware(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerMiddleware requires a handler function");
+  }
+  const middleware = Object.freeze([...options.middleware ?? []]);
+  for (const entry of middleware) {
+    assertServerFnMiddleware(entry);
+  }
+  return Object.freeze({
+    __farmServerFnMiddleware: true,
+    middleware,
+    handler: options.handler
+  });
+}
+function createServerFn(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerFn requires a handler function");
+  }
+  const middleware = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
+  const run = async (value, labelInputErrors) => {
+    const formData = isFormData(value) ? value : void 0;
+    const rawInput = formData ? formDataToObject(formData) : value;
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors && isSchemaValidationFailure(cause) ? new ServerFnInputError(cause) : cause;
+    }
+    const executionContext = getServerActionExecutionContext();
+    const request = executionContext ? _toAppRequestView(executionContext.request) : _resolveCurrentRequestForApp();
+    const signal = executionContext?.signal ?? request?.signal ?? getServerActionSignal();
+    const handlerContext = {
+      input,
+      rawInput,
+      formData,
+      request,
+      signal
+    };
+    let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
+      resolvedContext = context.context;
+      return options.handler({ ...context, error });
+    });
+    const parsedResult = await _parseServerFnSchema(options.output, result, "output");
+    if (options.invalidates) {
+      const declaration = typeof options.invalidates === "function" ? await options.invalidates({
+        ...handlerContext,
+        context: resolvedContext,
+        result: parsedResult
+      }) : options.invalidates;
+      await applyFarmCacheInvalidationTargets(declaration);
+    }
+    return parsedResult;
+  };
+  const serverFn = (value) => run(value, false);
+  Object.defineProperties(serverFn, {
+    [FARM_SERVER_FN_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFn: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFnInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerFnOutput: {
+      value: options.output,
+      enumerable: false
+    },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
+    __farmServerFnMiddleware: {
+      value: middleware,
+      enumerable: false
+    },
+    __farmServerFnInvalidates: {
+      value: options.invalidates,
+      enumerable: false
+    }
+  });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
+  return serverFn;
+}
+async function runServerFnMiddleware(middleware, handlerContext, handler) {
+  const dispatch = async (index, context) => {
+    const current = middleware[index];
+    if (!current) {
+      return handler({ ...handlerContext, context });
+    }
+    let nextCalled = false;
+    const result = await current.handler({
+      ...handlerContext,
+      context,
+      next: async (nextOptions) => {
+        if (nextCalled) {
+          throw new Error("Server function middleware next() can only be called once");
+        }
+        nextCalled = true;
+        return dispatch(index + 1, mergeServerFnContext(context, nextOptions?.context));
+      }
+    });
+    if (!nextCalled) {
+      throw new Error("Server function middleware must call next()");
+    }
+    return result;
+  };
+  return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
+}
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new ServerFnFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Server function failed"
+    });
+  });
+}
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+function resolveServerFnMiddleware(middleware) {
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (entry) => {
+    assertServerFnMiddleware(entry);
+    if (seen.has(entry)) return;
+    if (visiting.has(entry)) {
+      throw new Error("Server function middleware dependencies cannot contain a cycle");
+    }
+    visiting.add(entry);
+    for (const dependency of entry.middleware) {
+      visit(dependency);
+    }
+    visiting.delete(entry);
+    seen.add(entry);
+    resolved.push(entry);
+  };
+  for (const entry of middleware ?? []) {
+    visit(entry);
+  }
+  return Object.freeze(resolved);
+}
+function assertServerFnMiddleware(value) {
+  if (!value || typeof value !== "object" || value.__farmServerFnMiddleware !== true || typeof value.handler !== "function" || !Array.isArray(value.middleware)) {
+    throw new TypeError("createServerFn middleware must be created with createServerMiddleware");
+  }
+}
+function mergeServerFnContext(current, added) {
+  if (added !== void 0 && (added === null || typeof added !== "object" || Array.isArray(added))) {
+    throw new TypeError("Server function middleware context must be an object");
+  }
+  return Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), current, added));
+}
+async function _parseServerFnSchema(schema, value, contract, owner = "createServerFn") {
+  if (!schema) return value;
+  if (typeof schema.safeParseAsync === "function") {
+    const result = await schema.safeParseAsync(value);
+    return unwrapSafeParseResult(result);
+  }
+  if (typeof schema.safeParse === "function") {
+    const result = schema.safeParse(value);
+    return unwrapSafeParseResult(await result);
+  }
+  if (typeof schema.parseAsync === "function") {
+    return schema.parseAsync(value);
+  }
+  if (typeof schema.parse === "function") {
+    return schema.parse(value);
+  }
+  throw new TypeError(`${owner} ${contract} must provide parse, parseAsync, or safeParse`);
+}
+var schemaValidationFailures = /* @__PURE__ */ new WeakSet();
+function isSchemaValidationFailure(error) {
+  if (!error || typeof error !== "object") return false;
+  return schemaValidationFailures.has(error) || Array.isArray(error.issues);
+}
+function unwrapSafeParseResult(result) {
+  if (result && typeof result === "object" && "success" in result && result.success === false) {
+    const error = result.error;
+    if (error && typeof error === "object") schemaValidationFailures.add(error);
+    throw error;
+  }
+  if (result && typeof result === "object" && "success" in result && result.success === true) {
+    return result.data;
+  }
+  return result;
+}
+function formDataToObject(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.entries()) {
+    if (!isSafeFormKey(key)) continue;
+    const existing = output[key];
+    if (existing === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      output[key] = [existing, value];
+    }
+  }
+  return output;
+}
+function isSafeFormKey(key) {
+  return !key.startsWith("$ACTION_") && !UNSAFE_FORM_KEYS.has(key);
+}
+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 {
+  FARM_SERVER_FN_SYMBOL,
+  createServerFunctionDescriptor,
+  _attachServerFunctionDescriptor,
+  _runServerFunctionForCaller,
+  _describeServerFunction,
+  _invokeServerFunction,
+  createServerMiddleware,
+  createServerFn,
+  _parseServerFnSchema
+};

package/dist/chunk-R53QDV6T.cjs

@@ -0,0 +1,100 @@
+"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 _chunkKORZ6PREcjs = require('./chunk-KORZ6PRE.cjs');
+
+
+var _chunkQMNWKQL4cjs = require('./chunk-QMNWKQL4.cjs');
+
+// src/build/tailwind.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// src/build/vite-plugin-compat.ts
+function adaptTailwindVitePlugin(pluginOption, builder) {
+  if (builder !== "rolldown") return pluginOption;
+  return adaptPluginOption(pluginOption);
+}
+function adaptPluginOption(pluginOption) {
+  if (Array.isArray(pluginOption)) return pluginOption.map(adaptPluginOption);
+  if (!pluginOption || typeof pluginOption !== "object") return pluginOption;
+  const plugin = pluginOption;
+  if (!_optionalChain([plugin, 'access', _ => _.name, 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3("@tailwindcss/vite:generate:")])) return pluginOption;
+  if (isVitePluginHook(plugin.transform)) {
+    return {
+      ...plugin,
+      transform: withVite5TransformContext(plugin.transform)
+    };
+  }
+  if (plugin.transform && typeof plugin.transform === "object" && "handler" in plugin.transform && isVitePluginHook(plugin.transform.handler)) {
+    return {
+      ...plugin,
+      transform: {
+        ...plugin.transform,
+        handler: withVite5TransformContext(plugin.transform.handler)
+      }
+    };
+  }
+  return pluginOption;
+}
+function isVitePluginHook(value) {
+  return typeof value === "function";
+}
+function withVite5TransformContext(handler) {
+  return function(...args) {
+    const context = new Proxy(this, {
+      get(target, property, receiver) {
+        if (property === "environment") return void 0;
+        return Reflect.get(target, property, receiver);
+      }
+    });
+    return handler.apply(context, args);
+  };
+}
+
+// src/build/tailwind.ts
+var TAILWIND_CSS_IMPORT = /@import\s+["']tailwindcss["']/;
+var TAILWIND_VITE_INSTALL_HINT = _chunkKORZ6PREcjs.formatOptionalPeerInstallHint.call(void 0, 
+  "@tailwindcss/vite",
+  "enable built-in Tailwind CSS support",
+  { dev: true }
+);
+var warnedMissingTailwind = false;
+async function loadTailwindVitePlugin(options = {}, importTailwind = () => import("@tailwindcss/vite")) {
+  try {
+    const tailwindVite = (await importTailwind()).default;
+    const plugin = options.builder ? adaptTailwindVitePlugin(tailwindVite(), options.builder) : tailwindVite();
+    if (options.announce) _chunkQMNWKQL4cjs.logger.info("\u{1F4E6} Enabled built-in Tailwind support (@tailwindcss/vite)");
+    return plugin;
+  } catch (error) {
+    if (_chunkKORZ6PREcjs.isMissingPackageError.call(void 0, error, "@tailwindcss/vite")) return createMissingTailwindPlugin();
+    _chunkQMNWKQL4cjs.logger.warn(
+      `Tailwind plugin auto-enable failed${options.label ? ` ${options.label}` : ""}; continuing without it: ${error.message}`
+    );
+    return void 0;
+  }
+}
+function createMissingTailwindPlugin() {
+  let root = process.cwd();
+  return {
+    name: "farm:tailwind-missing",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root;
+    },
+    transform(code, id) {
+      if (warnedMissingTailwind || !/\.css(?:\?.*)?$/.test(id) || !TAILWIND_CSS_IMPORT.test(code)) {
+        return null;
+      }
+      warnedMissingTailwind = true;
+      const file = _path2.default.relative(root, id.split("?", 1)[0]).replace(/\\/g, "/");
+      _chunkQMNWKQL4cjs.logger.warn(
+        `${file} imports Tailwind CSS, but @tailwindcss/vite is not installed; continuing without Tailwind. ${TAILWIND_VITE_INSTALL_HINT}`
+      );
+      return null;
+    }
+  };
+}
+
+
+
+exports.loadTailwindVitePlugin = loadTailwindVitePlugin;

package/dist/chunk-R5U7OIPI.cjs

@@ -0,0 +1,34 @@
+"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/request-cookies.ts
+function parseRequestCookieHeader(header) {
+  if (!_optionalChain([header, 'optionalAccess', _ => _.trim, 'call', _2 => _2()])) return [];
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      return {
+        name: decodeCookieName(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookieName(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+var RESERVED_PREFIX = /^__(host|secure)-/i;
+function decodeCookieName(raw) {
+  const decoded = decodeCookiePart(raw);
+  return RESERVED_PREFIX.test(decoded) && !RESERVED_PREFIX.test(raw) ? raw : decoded;
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch (e) {
+    return value;
+  }
+}
+
+
+
+
+exports.parseRequestCookieHeader = parseRequestCookieHeader; exports.decodeCookieName = decodeCookieName;