@farm.js/core 0.1.17 → 0.1.18

package/dist/env-types.cjs

@@ -1,231 +1,10 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/env-types.ts
-var env_types_exports = {};
-__export(env_types_exports, {
-  createEnvTypeDeclarations: () => createEnvTypeDeclarations,
-  generateEnvTypes: () => generateEnvTypes
-});
-module.exports = __toCommonJS(env_types_exports);
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
 
-// src/write-file-if-changed.ts
-var import_node_fs = require("fs");
-function writeFileIfChanged(filePath, content) {
-  try {
-    if ((0, import_node_fs.readFileSync)(filePath, "utf8") === content) {
-      return false;
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  (0, import_node_fs.writeFileSync)(filePath, content, "utf8");
-  return true;
-}
-__name(writeFileIfChanged, "writeFileIfChanged");
+var _chunk6EODJYCXcjs = require('./chunk-6EODJYCX.cjs');
+require('./chunk-TIWHTW3Q.cjs');
+require('./chunk-S3JO3N4H.cjs');
 
-// src/env-types.ts
-var DEFAULT_OUT_FILE = "farm-env.d.ts";
-var CONFIG_FILENAMES = [
-  "farm.config.ts",
-  "farm.config.tsx",
-  "farm.config.mts",
-  "farm.config.cts",
-  "farm.config.js",
-  "farm.config.jsx",
-  "farm.config.mjs",
-  "farm.config.cjs",
-  "config.ts",
-  "config.tsx",
-  "config.mts",
-  "config.cts",
-  "config.js",
-  "config.jsx",
-  "config.mjs",
-  "config.cjs"
-];
-async function generateEnvTypes(options) {
-  const root = path.resolve(options.root);
-  const srcDir = options.srcDir || "src";
-  const outFile = options.outFile || DEFAULT_OUT_FILE;
-  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
-  const content = createEnvTypeDeclarations(options, outPath);
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
-}
-__name(generateEnvTypes, "generateEnvTypes");
-function createEnvTypeDeclarations(options, outPath) {
-  const root = path.resolve(options.root);
-  const configPath = findConfigPath(root, options.configPath);
-  const configPaths = [
-    ...(options.layerConfigPaths ?? []).filter((value) => fs.existsSync(value)),
-    ...configPath ? [configPath] : []
-  ];
-  const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
-  return content;
-}
-__name(createEnvTypeDeclarations, "createEnvTypeDeclarations");
-function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
-  const imports = configPaths.map(
-    (configPath, index) => `import type FarmConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
-  ).join("\n");
-  const resolvedTypes = configPaths.map(
-    (_configPath, index) => `
-type FarmConfigEnv${index} = typeof FarmConfig${index} extends { env?: infer TEnv }
-  ? NonNullable<TEnv>
-  : never;
-type FarmResolvedEnv${index} = [FarmConfigEnv${index}] extends [never]
-  ? { server: {}; public: {} }
-  : InferEnv<FarmConfigEnv${index}>;`
-  ).join("\n");
-  const mergedTypes = configPaths.slice(1).map(
-    (_configPath, index) => `type FarmMergedEnv${index + 1} = MergeFarmEnv<${index === 0 ? "FarmResolvedEnv0" : `FarmMergedEnv${index}`}, FarmResolvedEnv${index + 1}>;`
-  ).join("\n");
-  const finalType = `FarmMergedEnv${configPaths.length - 1}`;
-  return `/**
- * Auto-generated env types from Farm layers and farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-${imports}
-import type { InferEnv } from "@farm.js/core/env";
 
-type MergeFarmEnv<TBase, TOverride> = {
-  server: Omit<TBase extends { server: infer T } ? T : {}, keyof (TOverride extends { server: infer T } ? T : {})> &
-    (TOverride extends { server: infer T } ? T : {});
-  public: Omit<TBase extends { public: infer T } ? T : {}, keyof (TOverride extends { public: infer T } ? T : {})> &
-    (TOverride extends { public: infer T } ? T : {});
-};
-${resolvedTypes}
-${mergedTypes}
 
-type FarmResolvedEnv = ${finalType};
-
-declare module "@farm.js/core/env" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-declare module "@farm.js/core" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-export {};
-`;
-}
-__name(createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
-function findConfigPath(root, configPath) {
-  if (configPath) {
-    const resolvedPath = path.isAbsolute(configPath) ? configPath : path.join(root, configPath);
-    return fs.existsSync(resolvedPath) ? resolvedPath : null;
-  }
-  for (const filename of CONFIG_FILENAMES) {
-    const resolvedPath = path.join(root, filename);
-    if (fs.existsSync(resolvedPath)) {
-      return resolvedPath;
-    }
-  }
-  return null;
-}
-__name(findConfigPath, "findConfigPath");
-function createConfigBackedEnvTypes(outPath, configPath) {
-  const configImportPath = toTypeImportPath(outPath, configPath);
-  return `/**
- * Auto-generated env types from farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-import type FarmConfig from ${JSON.stringify(configImportPath)};
-import type { InferEnv } from "@farm.js/core/env";
-
-type FarmConfigEnv = typeof FarmConfig extends { env?: infer TEnv } ? NonNullable<TEnv> : never;
-type FarmResolvedEnv = [FarmConfigEnv] extends [never]
-  ? { server: {}; public: {} }
-  : InferEnv<FarmConfigEnv>;
-
-declare module "@farm.js/core/env" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-declare module "@farm.js/core" {
-  interface FarmEnvTypes {
-    server: FarmResolvedEnv["server"];
-    public: FarmResolvedEnv["public"];
-  }
-}
-
-export {};
-`;
-}
-__name(createConfigBackedEnvTypes, "createConfigBackedEnvTypes");
-function createEmptyEnvTypes() {
-  return `/**
- * Auto-generated env types from farm.config.
- * Regenerated on dev start, build, and farm generate.
- */
-declare module "@farm.js/core/env" {
-  interface FarmEnvTypes {
-    server: {};
-    public: {};
-  }
-}
-
-declare module "@farm.js/core" {
-  interface FarmEnvTypes {
-    server: {};
-    public: {};
-  }
-}
-
-export {};
-`;
-}
-__name(createEmptyEnvTypes, "createEmptyEnvTypes");
-function toTypeImportPath(outPath, targetPath) {
-  const relativePath = path.relative(path.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-__name(toTypeImportPath, "toTypeImportPath");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createEnvTypeDeclarations,
-  generateEnvTypes
-});
+exports.createEnvTypeDeclarations = _chunk6EODJYCXcjs.createEnvTypeDeclarations; exports.generateEnvTypes = _chunk6EODJYCXcjs.generateEnvTypes;

package/dist/env.cjs

@@ -1,341 +1,24 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/env.ts
-var env_exports = {};
-__export(env_exports, {
-  createBundledEnv: () => createBundledEnv,
-  env: () => env,
-  getEnv: () => getEnv,
-  getPublicEnv: () => getPublicEnv,
-  getResolvedEnv: () => getResolvedEnv,
-  publicEnv: () => publicEnv,
-  resolveEnv: () => resolveEnv,
-  serverEnv: () => serverEnv,
-  setEnv: () => setEnv
-});
-module.exports = __toCommonJS(env_exports);
 
-// src/utils/runtime-env.ts
-function getFarmRuntimeBindings() {
-  const runtimeBindings = globalThis.__env__;
-  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
-}
-__name(getFarmRuntimeBindings, "getFarmRuntimeBindings");
-function readFarmEnvironmentValue(name) {
-  const runtimeValue = getFarmRuntimeBindings()?.[name];
-  if (typeof runtimeValue === "string") return runtimeValue;
-  return typeof process !== "undefined" ? process.env?.[name] : void 0;
-}
-__name(readFarmEnvironmentValue, "readFarmEnvironmentValue");
 
-// 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(config?.server, source, "server"),
-    public: resolveEnvScope(config?.public, source, "public")
-  };
-  return resolved;
-}
-__name(resolveEnv, "resolveEnv");
-function createBundledEnv(env2, source = getProcessEnv()) {
-  const resolved = normalizeResolvedEnv(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 } } : {}
-  };
-}
-__name(createBundledEnv, "createBundledEnv");
-function setEnv(env2) {
-  currentEnv = prepareEnv(env2);
-  if (typeof window === "undefined") {
-    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
-  }
-}
-__name(setEnv, "setEnv");
-function getResolvedEnv() {
-  const env2 = getCurrentEnv();
-  if (typeof window === "undefined") readRuntimeServerEnv(env2);
-  return env2;
-}
-__name(getResolvedEnv, "getResolvedEnv");
-function getEnv(key) {
-  const server = getEnvScope("server");
-  if (key === void 0) {
-    return server;
-  }
-  return readServerEnvKey(server, key);
-}
-__name(getEnv, "getEnv");
-function getPublicEnv(key) {
-  if (key === void 0) {
-    return getCurrentEnv().public;
-  }
-  return getCurrentEnv().public[key];
-}
-__name(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;
-}
-__name(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()");
-}
-__name(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);
-      }
-    }
-  );
-}
-__name(createEnvProxy, "createEnvProxy");
-function getEnvScope(scope) {
-  const env2 = getCurrentEnv();
-  if (scope === "server") {
-    assertServerEnvAccess();
-    readRuntimeServerEnv(env2);
-  }
-  return env2[scope] || {};
-}
-__name(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;
-}
-__name(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 = readFarmEnvironmentValue(key);
-    if (raw === void 0) continue;
-    env2.server[key] = coerceRuntimeEnvValue(raw, type);
-    delete state.pending[key];
-  }
-}
-__name(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";
-}
-__name(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 {
-      return raw;
-    }
-  }
-  return raw;
-}
-__name(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])
-  );
-}
-__name(isSameEnvValue, "isSameEnvValue");
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-__name(isPlainObject, "isPlainObject");
-function prepareEnv(env2) {
-  const normalized = normalizeResolvedEnv(env2);
-  const runtime = env2.runtime?.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;
-}
-__name(prepareEnv, "prepareEnv");
-function assertServerEnvAccess() {
-  if (typeof window !== "undefined") {
-    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
-  }
-}
-__name(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()
-  };
-}
-__name(getInitialEnv, "getInitialEnv");
-function getCurrentEnv() {
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return farmEnvGlobal[FARM_ENV_SYMBOL];
-  }
-  return currentEnv;
-}
-__name(getCurrentEnv, "getCurrentEnv");
-function getInjectedEnv() {
-  try {
-    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return prepareEnv(__FARM_ENV__);
-    }
-  } catch {
-  }
-  return null;
-}
-__name(getInjectedEnv, "getInjectedEnv");
-function getInjectedPublicEnv() {
-  try {
-    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
-      return __FARM_PUBLIC_ENV__;
-    }
-  } catch {
-  }
-  return {};
-}
-__name(getInjectedPublicEnv, "getInjectedPublicEnv");
-function normalizeResolvedEnv(env2) {
-  return {
-    server: isRecord(env2.server) ? env2.server : {},
-    public: isRecord(env2.public) ? env2.public : {}
-  };
-}
-__name(normalizeResolvedEnv, "normalizeResolvedEnv");
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isRecord, "isRecord");
-function getProcessEnv() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env;
-  }
-  return {};
-}
-__name(getProcessEnv, "getProcessEnv");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createBundledEnv,
-  env,
-  getEnv,
-  getPublicEnv,
-  getResolvedEnv,
-  publicEnv,
-  resolveEnv,
-  serverEnv,
-  setEnv
-});
+
+
+
+
+
+
+var _chunkVEKFLAQMcjs = require('./chunk-VEKFLAQM.cjs');
+require('./chunk-CMGMGHUZ.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+exports.createBundledEnv = _chunkVEKFLAQMcjs.createBundledEnv; exports.env = _chunkVEKFLAQMcjs.env; exports.getEnv = _chunkVEKFLAQMcjs.getEnv; exports.getPublicEnv = _chunkVEKFLAQMcjs.getPublicEnv; exports.getResolvedEnv = _chunkVEKFLAQMcjs.getResolvedEnv; exports.publicEnv = _chunkVEKFLAQMcjs.publicEnv; exports.resolveEnv = _chunkVEKFLAQMcjs.resolveEnv; exports.serverEnv = _chunkVEKFLAQMcjs.serverEnv; exports.setEnv = _chunkVEKFLAQMcjs.setEnv;