@farm.js/core 0.1.41 → 0.1.43

package/dist/{chunk-JR4QCLJY.cjs → chunk-PDU4P2IC.cjs}

@@ -2,6 +2,22 @@
 
 var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
+// src/server-components-mode.ts
+function resolveFarmServerComponentsMode(value) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true) return "rsc";
+  const mode = typeof value === "object" ? value.mode : void 0;
+  if (mode === "rsc" || mode === "islands") return mode;
+  throw new TypeError(
+    'experimental.serverComponents must be true, false, { mode: "rsc" } or { mode: "islands" }.'
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmServerComponentsMode, "resolveFarmServerComponentsMode");
+function isExplicitFarmServerComponentsMode(value) {
+  return typeof value === "object" && value !== null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isExplicitFarmServerComponentsMode, "isExplicitFarmServerComponentsMode");
+
 // src/dev-indicators.ts
 function resolveFarmDevIndicatorsConfig(config, mode = "development") {
   return {
@@ -446,4 +462,6 @@ _chunkS3JO3N4Hcjs.__name.call(void 0, validateFarmAuthConfig, "validateFarmAuthC
 
 
 
-exports.setFarmProjectSourceDir = setFarmProjectSourceDir; exports.getFarmProjectSourceDir = getFarmProjectSourceDir; exports.resolveFarmDevIndicatorsConfig = resolveFarmDevIndicatorsConfig; exports.generateFarmDevIndicatorsClientRuntime = generateFarmDevIndicatorsClientRuntime; exports.resolveFarmAuthConfig = resolveFarmAuthConfig; exports.resolveFarmAuthIntegration = resolveFarmAuthIntegration;
+
+
+exports.resolveFarmServerComponentsMode = resolveFarmServerComponentsMode; exports.isExplicitFarmServerComponentsMode = isExplicitFarmServerComponentsMode; exports.setFarmProjectSourceDir = setFarmProjectSourceDir; exports.getFarmProjectSourceDir = getFarmProjectSourceDir; exports.resolveFarmDevIndicatorsConfig = resolveFarmDevIndicatorsConfig; exports.generateFarmDevIndicatorsClientRuntime = generateFarmDevIndicatorsClientRuntime; exports.resolveFarmAuthConfig = resolveFarmAuthConfig; exports.resolveFarmAuthIntegration = resolveFarmAuthIntegration;

package/dist/chunk-PJEHUSHA.mjs

@@ -0,0 +1,229 @@
+import {
+  FARM_ACTION_TAG,
+  FARM_OBJECT_TAG,
+  FARM_REFERENCE_TAG,
+  FARM_SLOT_TAG,
+  FARM_TAG,
+  FARM_TAG_VALUE,
+  getFarmTag
+} from "./chunk-2NXO5SBY.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/client/island-codec.ts
+var TYPED_ARRAYS = {
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+};
+function toBase64(bytes) {
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+  }
+  return btoa(binary);
+}
+__name(toBase64, "toBase64");
+function fromBase64(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+__name(fromBase64, "fromBase64");
+function farmTagged(tag, value) {
+  return value === void 0 ? { [FARM_TAG]: tag } : { [FARM_TAG]: tag, [FARM_TAG_VALUE]: value };
+}
+__name(farmTagged, "farmTagged");
+function needsFarmObjectTag(object) {
+  return Object.prototype.hasOwnProperty.call(object, FARM_TAG);
+}
+__name(needsFarmObjectTag, "needsFarmObjectTag");
+function encodeFarmLeaf(value) {
+  switch (typeof value) {
+    case "undefined":
+      return farmTagged("u");
+    case "bigint":
+      return farmTagged("B", value.toString());
+    case "number":
+      if (Number.isNaN(value)) return farmTagged("n", "NaN");
+      if (value === Infinity) return farmTagged("n", "Infinity");
+      if (value === -Infinity) return farmTagged("n", "-Infinity");
+      if (Object.is(value, -0)) return farmTagged("n", "-0");
+      return void 0;
+    case "object":
+      break;
+    default:
+      return void 0;
+  }
+  if (value === null) return void 0;
+  if (value instanceof Date) {
+    return farmTagged("D", Number.isNaN(value.getTime()) ? null : value.toISOString());
+  }
+  if (typeof URL === "function" && value instanceof URL) return farmTagged("U", value.href);
+  if (value instanceof RegExp) return farmTagged("R", [value.source, value.flags]);
+  if (value instanceof ArrayBuffer) {
+    return farmTagged("Y", ["ArrayBuffer", toBase64(new Uint8Array(value))]);
+  }
+  if (ArrayBuffer.isView(value)) {
+    const name = value instanceof DataView ? "DataView" : value.constructor.name;
+    if (name !== "DataView" && !(name in TYPED_ARRAYS)) return void 0;
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return farmTagged("Y", [name, toBase64(bytes)]);
+  }
+  return void 0;
+}
+__name(encodeFarmLeaf, "encodeFarmLeaf");
+var NOT_A_FARM_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
+function farmPlainObject(entries) {
+  const object = {};
+  for (const [key, value] of entries) {
+    Object.defineProperty(object, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return object;
+}
+__name(farmPlainObject, "farmPlainObject");
+function decodeFarmTagged(object, decodeChild) {
+  const tag = object[FARM_TAG];
+  const data = object[FARM_TAG_VALUE];
+  switch (tag) {
+    case FARM_REFERENCE_TAG:
+    case FARM_SLOT_TAG:
+    case FARM_ACTION_TAG:
+      return NOT_A_FARM_MARKER;
+    case FARM_OBJECT_TAG:
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        return farmPlainObject(
+          Object.entries(data).map(([key, value]) => [key, decodeChild(value)])
+        );
+      }
+      break;
+    case "u":
+      return void 0;
+    case "n":
+      if (data === "NaN") return Number.NaN;
+      if (data === "Infinity") return Infinity;
+      if (data === "-Infinity") return -Infinity;
+      if (data === "-0") return -0;
+      break;
+    case "B":
+      if (typeof data === "string" && /^-?\d+$/.test(data)) return BigInt(data);
+      break;
+    case "D":
+      if (data === null) return new Date(Number.NaN);
+      if (typeof data === "string") return new Date(data);
+      break;
+    case "U":
+      if (typeof data === "string") return new URL(data);
+      break;
+    case "R":
+      if (Array.isArray(data) && typeof data[0] === "string" && typeof data[1] === "string") {
+        return new RegExp(data[0], data[1]);
+      }
+      break;
+    case "Y": {
+      if (!Array.isArray(data) || typeof data[0] !== "string" || typeof data[1] !== "string") break;
+      const bytes = fromBase64(data[1]);
+      if (data[0] === "ArrayBuffer") return bytes.buffer;
+      if (data[0] === "DataView") return new DataView(bytes.buffer);
+      const TypedArray = Object.prototype.hasOwnProperty.call(TYPED_ARRAYS, data[0]) ? TYPED_ARRAYS[data[0]] : void 0;
+      if (!TypedArray || bytes.byteLength % TypedArray.BYTES_PER_ELEMENT !== 0) break;
+      return new TypedArray(
+        bytes.buffer,
+        0,
+        bytes.byteLength / TypedArray.BYTES_PER_ELEMENT
+      );
+    }
+    case "M":
+      if (Array.isArray(data) && data.every((entry) => Array.isArray(entry) && entry.length === 2)) {
+        return new Map(data.map(([key, value]) => [decodeChild(key), decodeChild(value)]));
+      }
+      break;
+    case "S":
+      if (Array.isArray(data)) return new Set(data.map(decodeChild));
+      break;
+    default:
+      throw new TypeError(`unknown ${JSON.stringify(tag)} tag`);
+  }
+  throw new TypeError(`malformed ${JSON.stringify(tag)} tag`);
+}
+__name(decodeFarmTagged, "decodeFarmTagged");
+function encodeFarmJson(value, seen = /* @__PURE__ */ new Set()) {
+  const leaf = encodeFarmLeaf(value);
+  if (leaf) return leaf;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return value;
+  if (typeof value !== "object") throw new TypeError(`${typeof value} values are not serializable`);
+  if (seen.has(value)) throw new TypeError("circular values are not serializable");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((entry) => encodeFarmJson(entry, seen));
+    if (value instanceof Map) {
+      return farmTagged(
+        "M",
+        Array.from(value, ([key, entry]) => [
+          encodeFarmJson(key, seen),
+          encodeFarmJson(entry, seen)
+        ])
+      );
+    }
+    if (value instanceof Set) {
+      return farmTagged(
+        "S",
+        Array.from(value, (entry) => encodeFarmJson(entry, seen))
+      );
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("class instances are not serializable");
+    }
+    const encoded = Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, encodeFarmJson(entry, seen)])
+    );
+    return needsFarmObjectTag(value) ? farmTagged(FARM_OBJECT_TAG, encoded) : encoded;
+  } finally {
+    seen.delete(value);
+  }
+}
+__name(encodeFarmJson, "encodeFarmJson");
+function decodeFarmJson(value) {
+  if (Array.isArray(value)) return value.map(decodeFarmJson);
+  if (!value || typeof value !== "object") return value;
+  if (getFarmTag(value) !== void 0) {
+    const decoded = decodeFarmTagged(value, decodeFarmJson);
+    if (decoded === NOT_A_FARM_MARKER) {
+      throw new TypeError(
+        `a ${JSON.stringify(value[FARM_TAG])} reference is not allowed here`
+      );
+    }
+    return decoded;
+  }
+  if (needsFarmObjectTag(value)) throw new TypeError('malformed "$" tag');
+  return farmPlainObject(Object.entries(value).map(([key, entry]) => [key, decodeFarmJson(entry)]));
+}
+__name(decodeFarmJson, "decodeFarmJson");
+
+export {
+  farmTagged,
+  needsFarmObjectTag,
+  encodeFarmLeaf,
+  NOT_A_FARM_MARKER,
+  farmPlainObject,
+  decodeFarmTagged,
+  encodeFarmJson,
+  decodeFarmJson
+};

package/dist/chunk-QGH2RQVF.mjs

@@ -0,0 +1,132 @@
+import {
+  isExplicitFarmServerComponentsMode,
+  resolveFarmServerComponentsMode
+} from "./chunk-M3BXTWJM.mjs";
+import {
+  logger
+} from "./chunk-KI3MESHB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/server-components-status.ts
+import { existsSync, realpathSync } from "fs";
+import path from "path";
+var FARM_RSC_PACKAGES = [
+  "@farm.js/plugin",
+  "@vitejs/plugin-rsc",
+  "react-server-dom-webpack"
+];
+var FARM_RSC_INSTALL_HINT = `pnpm add ${FARM_RSC_PACKAGES.join(" ")}`;
+var FARM_RSC_BLOCKING_KEYS = [
+  "auth",
+  "integrations",
+  "headers",
+  "redirects",
+  "rewrites",
+  "routeRules",
+  "context"
+];
+var FARM_RSC_IGNORED_KEYS = [
+  "plugins",
+  "storage",
+  "schema",
+  "cron",
+  "workflows",
+  "docs",
+  "theme",
+  "observability"
+];
+function farmConfigUsesServerComponents(config) {
+  return resolveFarmServerComponentsMode(config?.experimental?.serverComponents) === "rsc";
+}
+__name(farmConfigUsesServerComponents, "farmConfigUsesServerComponents");
+function findFarmAppPackageDir(root, packageName) {
+  for (let dir = path.resolve(root); ; dir = path.dirname(dir)) {
+    const candidate = path.join(dir, "node_modules", packageName);
+    if (existsSync(path.join(candidate, "package.json"))) return realpathSync(candidate);
+    if (path.dirname(dir) === dir) return void 0;
+  }
+}
+__name(findFarmAppPackageDir, "findFarmAppPackageDir");
+function isSet(value) {
+  if (value === void 0 || value === false || value === null) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value !== "object" || Object.keys(value).length > 0;
+}
+__name(isSet, "isSet");
+function inspectFarmServerComponents(config, root) {
+  const value = config?.experimental?.serverComponents;
+  const mode = resolveFarmServerComponentsMode(value);
+  const enabled = mode === "rsc";
+  const explicit = enabled && isExplicitFarmServerComponentsMode(value);
+  const missingPackages = enabled ? FARM_RSC_PACKAGES.filter((name) => !findFarmAppPackageDir(root, name)) : [];
+  return {
+    mode,
+    enabled,
+    explicit,
+    missingPackages,
+    // `true` predates the pipeline; `{ mode: "rsc" }` is new and fails with the install command.
+    fallback: enabled && !explicit && missingPackages.length > 0,
+    blockingKeys: enabled ? FARM_RSC_BLOCKING_KEYS.filter((key) => isSet(config?.[key])) : [],
+    ignoredKeys: enabled ? FARM_RSC_IGNORED_KEYS.filter((key) => isSet(config?.[key])) : []
+  };
+}
+__name(inspectFarmServerComponents, "inspectFarmServerComponents");
+function formatKeys(keys) {
+  return keys.map((key) => `\`${key}\``).join(", ");
+}
+__name(formatKeys, "formatKeys");
+function formatFarmRscFallbackMessage(missingPackages, blockingKeys = []) {
+  if (blockingKeys.length > 0) {
+    return `experimental.serverComponents is true, but this app uses ${formatKeys(
+      blockingKeys
+    )}, which the RSC pipeline does not run yet, so it runs without React Server Components. Remove the flag, or move ${blockingKeys.length === 1 ? "that feature" : "those features"} out of farm.config to turn RSC on.`;
+  }
+  return `experimental.serverComponents is true, but ${missingPackages.join(", ")} ${missingPackages.length === 1 ? "is" : "are"} not installed, so the app runs without React Server Components. \`farm dev\` and \`farm build\` install them outside CI; in CI or with another tool, run ${FARM_RSC_INSTALL_HINT}.`;
+}
+__name(formatFarmRscFallbackMessage, "formatFarmRscFallbackMessage");
+function formatFarmRscBlockingMessage(blockingKeys) {
+  return `experimental.serverComponents runs on the RSC pipeline, which does not run ${formatKeys(
+    blockingKeys
+  )} yet. Serving the app without ${blockingKeys.length === 1 ? "it" : "them"} could expose what ${blockingKeys.length === 1 ? "it protects" : "they protect"}, so RSC does not start. Remove experimental.serverComponents to keep ${blockingKeys.length === 1 ? "it" : "them"}.`;
+}
+__name(formatFarmRscBlockingMessage, "formatFarmRscBlockingMessage");
+var warnedFallback = false;
+function farmAppUsesRscPipeline(config, root) {
+  const status = inspectFarmServerComponents(config, root);
+  if (status.mode === "islands") return false;
+  if (!status.enabled) return false;
+  if (status.fallback) {
+    if (!warnedFallback) {
+      warnedFallback = true;
+      logger.warn(
+        `[Farm.js] ${formatFarmRscFallbackMessage(status.missingPackages, status.blockingKeys)}`
+      );
+    }
+    return false;
+  }
+  if (status.blockingKeys.length > 0) {
+    throw new Error(`[Farm.js] ${formatFarmRscBlockingMessage(status.blockingKeys)}`);
+  }
+  if (status.ignoredKeys.length > 0) {
+    logger.warn(
+      `[Farm.js] experimental.serverComponents runs on the RSC pipeline, which does not run ${formatKeys(
+        status.ignoredKeys
+      )} yet. ${status.ignoredKeys.length === 1 ? "It is" : "They are"} ignored.`
+    );
+  }
+  return true;
+}
+__name(farmAppUsesRscPipeline, "farmAppUsesRscPipeline");
+
+export {
+  FARM_RSC_PACKAGES,
+  FARM_RSC_INSTALL_HINT,
+  farmConfigUsesServerComponents,
+  findFarmAppPackageDir,
+  inspectFarmServerComponents,
+  formatFarmRscFallbackMessage,
+  formatFarmRscBlockingMessage,
+  farmAppUsesRscPipeline
+};