@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-VEKFLAQM.cjs

@@ -0,0 +1,300 @@
+"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 _chunkCMGMGHUZcjs = require('./chunk-CMGMGHUZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/env.ts
+var FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+var FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
+var farmEnvGlobal = globalThis;
+var currentEnv = getInitialEnv();
+function resolveEnv(config, source = getProcessEnv()) {
+  const resolved = {
+    server: resolveEnvScope(_optionalChain([config, 'optionalAccess', _ => _.server]), source, "server"),
+    public: resolveEnvScope(_optionalChain([config, 'optionalAccess', _2 => _2.public]), source, "public")
+  };
+  return resolved;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveEnv, "resolveEnv");
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(_nullishCoalesce(env2, () => ( {})));
+  const server = {};
+  const runtime = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    const raw = source[key];
+    const type = getRuntimeEnvType(value);
+    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
+      runtime[key] = type;
+    } else {
+      server[key] = value;
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime).length > 0 ? { runtime: { server: runtime } } : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createBundledEnv, "createBundledEnv");
+function setEnv(env2) {
+  currentEnv = prepareEnv(env2);
+  if (typeof window === "undefined") {
+    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setEnv, "setEnv");
+function getResolvedEnv() {
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getResolvedEnv, "getResolvedEnv");
+function getEnv(key) {
+  const server = getEnvScope("server");
+  if (key === void 0) {
+    return server;
+  }
+  return readServerEnvKey(server, key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getEnv, "getEnv");
+function getPublicEnv(key) {
+  if (key === void 0) {
+    return getCurrentEnv().public;
+  }
+  return getCurrentEnv().public[key];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPublicEnv, "getPublicEnv");
+var env = createEnvProxy("server");
+var serverEnv = env;
+var publicEnv = createEnvProxy("public");
+function resolveEnvScope(shape, source, scope) {
+  if (!shape) {
+    return {};
+  }
+  const resolved = {};
+  for (const [key, parser] of Object.entries(shape)) {
+    try {
+      resolved[key] = parseEnvValue(parser, source[key], key, scope);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
+    }
+  }
+  return resolved;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveEnvScope, "resolveEnvScope");
+function parseEnvValue(parser, value, key, scope) {
+  if (typeof parser === "function") {
+    return parser(value, { key, scope });
+  }
+  if (parser && typeof parser.parse === "function") {
+    return parser.parse(value);
+  }
+  throw new Error("expected a parser function or schema with parse()");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseEnvValue, "parseEnvValue");
+function createEnvProxy(scope) {
+  return new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") {
+          return void 0;
+        }
+        const env2 = getEnvScope(scope);
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
+      },
+      ownKeys() {
+        return Reflect.ownKeys(getEnvScope(scope));
+      },
+      getOwnPropertyDescriptor(_target, property) {
+        const env2 = getEnvScope(scope);
+        if (!(property in env2)) {
+          return void 0;
+        }
+        return {
+          enumerable: true,
+          configurable: true,
+          value: env2[property]
+        };
+      },
+      has(_target, property) {
+        return property in getEnvScope(scope);
+      }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEnvProxy, "createEnvProxy");
+function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
+  if (scope === "server") {
+    assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getEnvScope, "getEnvScope");
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readServerEnvKey, "readServerEnvKey");
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = _chunkCMGMGHUZcjs.readFarmEnvironmentValue.call(void 0, key);
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readRuntimeServerEnv, "readRuntimeServerEnv");
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRuntimeEnvType, "getRuntimeEnvType");
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch (e) {
+      return raw;
+    }
+  }
+  return raw;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+function isSameEnvValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
+  }
+  if (!isPlainObject(left) || !isPlainObject(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSameEnvValue, "isSameEnvValue");
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainObject, "isPlainObject");
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime = _optionalChain([env2, 'access', _3 => _3.runtime, 'optionalAccess', _4 => _4.server]);
+  if (!isRecord(runtime) || Object.keys(runtime).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, prepareEnv, "prepareEnv");
+function assertServerEnvAccess() {
+  if (typeof window !== "undefined") {
+    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertServerEnvAccess, "assertServerEnvAccess");
+function getInitialEnv() {
+  const injectedEnv = getInjectedEnv();
+  if (injectedEnv) {
+    return injectedEnv;
+  }
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
+  }
+  return {
+    server: {},
+    public: getInjectedPublicEnv()
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getInitialEnv, "getInitialEnv");
+function getCurrentEnv() {
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return farmEnvGlobal[FARM_ENV_SYMBOL];
+  }
+  return currentEnv;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getCurrentEnv, "getCurrentEnv");
+function getInjectedEnv() {
+  try {
+    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
+      return prepareEnv(__FARM_ENV__);
+    }
+  } catch (e2) {
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getInjectedEnv, "getInjectedEnv");
+function getInjectedPublicEnv() {
+  try {
+    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
+      return __FARM_PUBLIC_ENV__;
+    }
+  } catch (e3) {
+  }
+  return {};
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getInjectedPublicEnv, "getInjectedPublicEnv");
+function normalizeResolvedEnv(env2) {
+  return {
+    server: isRecord(env2.server) ? env2.server : {},
+    public: isRecord(env2.public) ? env2.public : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeResolvedEnv, "normalizeResolvedEnv");
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isRecord, "isRecord");
+function getProcessEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getProcessEnv, "getProcessEnv");
+
+
+
+
+
+
+
+
+
+
+
+exports.resolveEnv = resolveEnv; exports.createBundledEnv = createBundledEnv; exports.setEnv = setEnv; exports.getResolvedEnv = getResolvedEnv; exports.getEnv = getEnv; exports.getPublicEnv = getPublicEnv; exports.env = env; exports.serverEnv = serverEnv; exports.publicEnv = publicEnv;

package/dist/chunk-VQDBNVOO.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/utils/file-module.ts
+var _url = require('url');
+function toFileModuleUrl(filePath) {
+  return _url.pathToFileURL.call(void 0, filePath).href;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toFileModuleUrl, "toFileModuleUrl");
+
+
+
+exports.toFileModuleUrl = toFileModuleUrl;

package/dist/chunk-W4E7WMXE.cjs

@@ -0,0 +1,71 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/environment.ts
+var _FarmEnvironmentError = class _FarmEnvironmentError extends Error {
+  constructor(api, expected, actual) {
+    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);
+    this.api = api;
+    this.expected = expected;
+    this.actual = actual;
+    this.code = "FARM_ENVIRONMENT_MISMATCH";
+    this.name = "FarmEnvironmentError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmEnvironmentError, "FarmEnvironmentError");
+var FarmEnvironmentError = _FarmEnvironmentError;
+function createServerOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createServerOnlyFn", "server", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "server") {
+    return createMismatchFunction("createServerOnlyFn", "server");
+  }
+  assertFunction(implementation, "createServerOnlyFn");
+  return implementation;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createServerOnlyFn, "createServerOnlyFn");
+function createClientOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createClientOnlyFn", "client", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "client") {
+    return createMismatchFunction("createClientOnlyFn", "client");
+  }
+  assertFunction(implementation, "createClientOnlyFn");
+  return implementation;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createClientOnlyFn, "createClientOnlyFn");
+function createIsomorphicFn(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("createIsomorphicFn requires server and client functions");
+  }
+  assertFunction(options.server, "createIsomorphicFn server");
+  assertFunction(options.client, "createIsomorphicFn client");
+  return getRuntimeEnvironment() === "server" ? options.server : options.client;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createIsomorphicFn, "createIsomorphicFn");
+function getRuntimeEnvironment() {
+  return typeof window === "undefined" ? "server" : "client";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRuntimeEnvironment, "getRuntimeEnvironment");
+function createMismatchFunction(api, expected, actual = expected === "server" ? "client" : "server") {
+  return /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, function farmEnvironmentBoundary() {
+    throw new FarmEnvironmentError(api, expected, actual);
+  }, "farmEnvironmentBoundary");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createMismatchFunction, "createMismatchFunction");
+function assertFunction(value, label) {
+  if (typeof value !== "function") {
+    throw new TypeError(`${label} must be a function`);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertFunction, "assertFunction");
+
+
+
+
+
+
+exports.FarmEnvironmentError = FarmEnvironmentError; exports.createServerOnlyFn = createServerOnlyFn; exports.createClientOnlyFn = createClientOnlyFn; exports.createIsomorphicFn = createIsomorphicFn;