@farm.js/core 0.1.42 → 0.1.44

package/dist/chunk-LRJRXXQZ.cjs

@@ -0,0 +1,109 @@
+"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 _chunkLYLEZIG3cjs = require('./chunk-LYLEZIG3.cjs');
+
+
+var _chunk5QIKR7RRcjs = require('./chunk-5QIKR7RR.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, adaptTailwindVitePlugin, "adaptTailwindVitePlugin");
+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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, adaptPluginOption, "adaptPluginOption");
+function isVitePluginHook(value) {
+  return typeof value === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isVitePluginHook, "isVitePluginHook");
+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);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withVite5TransformContext, "withVite5TransformContext");
+
+// src/build/tailwind.ts
+var TAILWIND_CSS_IMPORT = /@import\s+["']tailwindcss["']/;
+var TAILWIND_VITE_INSTALL_HINT = _chunkLYLEZIG3cjs.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) _chunk5QIKR7RRcjs.logger.info("\u{1F4E6} Enabled built-in Tailwind support (@tailwindcss/vite)");
+    return plugin;
+  } catch (error) {
+    if (_chunkLYLEZIG3cjs.isMissingPackageError.call(void 0, error, "@tailwindcss/vite")) return createMissingTailwindPlugin();
+    _chunk5QIKR7RRcjs.logger.warn(
+      `Tailwind plugin auto-enable failed${options.label ? ` ${options.label}` : ""}; continuing without it: ${error.message}`
+    );
+    return void 0;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadTailwindVitePlugin, "loadTailwindVitePlugin");
+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, "/");
+      _chunk5QIKR7RRcjs.logger.warn(
+        `${file} imports Tailwind CSS, but @tailwindcss/vite is not installed; continuing without Tailwind. ${TAILWIND_VITE_INSTALL_HINT}`
+      );
+      return null;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createMissingTailwindPlugin, "createMissingTailwindPlugin");
+
+
+
+exports.loadTailwindVitePlugin = loadTailwindVitePlugin;

package/dist/{chunk-HCSVR4YZ.mjs → chunk-M3BXTWJM.mjs}

@@ -2,6 +2,22 @@ import {
   __name
 } from "./chunk-LPEX4YW6.mjs";
 
+// 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" }.'
+  );
+}
+__name(resolveFarmServerComponentsMode, "resolveFarmServerComponentsMode");
+function isExplicitFarmServerComponentsMode(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isExplicitFarmServerComponentsMode, "isExplicitFarmServerComponentsMode");
+
 // src/dev-indicators.ts
 function resolveFarmDevIndicatorsConfig(config, mode = "development") {
   return {
@@ -440,6 +456,8 @@ function validateFarmAuthConfig(config) {
 __name(validateFarmAuthConfig, "validateFarmAuthConfig");
 
 export {
+  resolveFarmServerComponentsMode,
+  isExplicitFarmServerComponentsMode,
   setFarmProjectSourceDir,
   getFarmProjectSourceDir,
   resolveFarmDevIndicatorsConfig,

package/dist/{chunk-2JZHQDUY.mjs → chunk-OYZGFRPA.mjs}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-2VQKKQ6D.mjs";
 import {
   resolveDocsConfig
-} from "./chunk-NU25TRIO.mjs";
+} from "./chunk-WWYXIECF.mjs";
 import {
   getFarmDocsAdapterConfigModule,
   isSecretDocsConfigKey

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
+};