@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-22GUSVNJ.cjs

@@ -0,0 +1,351 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/environment-vite.ts
+var ENVIRONMENT_IMPORTS = /* @__PURE__ */ new Set([
+  "@farm.js/core",
+  "@farm.js/core/environment",
+  "@farm.js/core/server"
+]);
+var ENVIRONMENT_FUNCTIONS = /* @__PURE__ */ new Set([
+  "createServerOnlyFn",
+  "createClientOnlyFn",
+  "createIsomorphicFn"
+]);
+var MODULE_EXTENSION_RE = /\.[cm]?[jt]sx?$/;
+function transformEnvironmentFunctions(options) {
+  if (!isTransformableModule(options.id) || !containsEnvironmentFunction(options.code)) {
+    return null;
+  }
+  let output = options.code;
+  let transformed = false;
+  for (let pass = 0; pass < 20; pass++) {
+    const ast = options.parse(output);
+    const bindings = findEnvironmentFunctionBindings(ast);
+    if (bindings.named.size === 0 && bindings.namespaces.size === 0) break;
+    const calls = findEnvironmentCalls(ast, bindings);
+    if (calls.length === 0) break;
+    const innermostCalls = calls.filter(
+      (call) => !calls.some(
+        (candidate) => candidate !== call && candidate.node.start > call.node.start && candidate.node.end < call.node.end
+      )
+    );
+    const replacements = innermostCalls.map(
+      (call) => createReplacement(output, options.id, options.environment, call)
+    );
+    output = applyReplacements(output, replacements);
+    transformed = true;
+  }
+  if (!transformed) return null;
+  const remainingAst = options.parse(output);
+  const remainingBindings = findEnvironmentFunctionBindings(remainingAst);
+  if (findEnvironmentCalls(remainingAst, remainingBindings).length > 0) {
+    throw transformError(options.id, "environment functions are nested too deeply");
+  }
+  return { code: output };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, transformEnvironmentFunctions, "transformEnvironmentFunctions");
+function farmEnvironmentFunctionsPlugin() {
+  return {
+    name: "farm:environment-functions",
+    enforce: "post",
+    transform(code, id, transformOptions) {
+      const result = transformEnvironmentFunctions({
+        code,
+        id,
+        environment: resolveBuildEnvironment(
+          this,
+          _optionalChain([transformOptions, 'optionalAccess', _ => _.ssr])
+        ),
+        parse: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (source) => this.parse(source), "parse")
+      });
+      return result ? { code: result.code, map: null } : null;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmEnvironmentFunctionsPlugin, "farmEnvironmentFunctionsPlugin");
+function resolveBuildEnvironment(context, ssr) {
+  if (_optionalChain([context, 'access', _2 => _2.environment, 'optionalAccess', _3 => _3.name]) === "client") return "client";
+  if (_optionalChain([context, 'access', _4 => _4.environment, 'optionalAccess', _5 => _5.name]) === "rsc" || _optionalChain([context, 'access', _6 => _6.environment, 'optionalAccess', _7 => _7.name]) === "ssr") {
+    return "server";
+  }
+  return ssr ? "server" : "client";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveBuildEnvironment, "resolveBuildEnvironment");
+function findEnvironmentFunctionBindings(ast) {
+  const named = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const body = Array.isArray(ast.body) ? ast.body : [];
+  for (const statement of body) {
+    if (!isAstNode(statement) || statement.type !== "ImportDeclaration") continue;
+    const source = isAstNode(statement.source) ? statement.source.value : void 0;
+    if (typeof source !== "string" || !ENVIRONMENT_IMPORTS.has(source)) continue;
+    const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers : [];
+    for (const specifier of specifiers) {
+      if (!isAstNode(specifier) || !isAstNode(specifier.local)) continue;
+      const localName = specifier.local.name;
+      if (typeof localName !== "string") continue;
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        namespaces.add(localName);
+        continue;
+      }
+      if (specifier.type !== "ImportSpecifier" || !isAstNode(specifier.imported)) continue;
+      const importedName = _nullishCoalesce(specifier.imported.name, () => ( specifier.imported.value));
+      if (isEnvironmentFunctionKind(importedName)) {
+        named.set(localName, importedName);
+      }
+    }
+  }
+  return { named, namespaces };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findEnvironmentFunctionBindings, "findEnvironmentFunctionBindings");
+function findEnvironmentCalls(ast, bindings) {
+  const calls = [];
+  walkAst(ast, (node, ancestors) => {
+    if (node.type !== "CallExpression" || !isAstNode(node.callee)) return;
+    if (node.callee.type === "Identifier" && typeof node.callee.name === "string") {
+      const kind = bindings.named.get(node.callee.name);
+      if (kind && !isNameShadowed(node.callee.name, ancestors)) calls.push({ node, kind });
+      return;
+    }
+    if (node.callee.type !== "MemberExpression" || node.callee.computed === true || !isAstNode(node.callee.object) || !isAstNode(node.callee.property) || node.callee.object.type !== "Identifier" || node.callee.property.type !== "Identifier" || typeof node.callee.object.name !== "string" || typeof node.callee.property.name !== "string" || !bindings.namespaces.has(node.callee.object.name) || isNameShadowed(node.callee.object.name, ancestors) || !isEnvironmentFunctionKind(node.callee.property.name)) {
+      return;
+    }
+    calls.push({ node, kind: node.callee.property.name });
+  });
+  return calls;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findEnvironmentCalls, "findEnvironmentCalls");
+function createReplacement(code, id, environment, call) {
+  const args = Array.isArray(call.node.arguments) ? call.node.arguments : [];
+  if (args.length !== 1 || !isAstNode(args[0]) || args[0].type === "SpreadElement") {
+    throw transformError(id, `${call.kind}() requires exactly one static argument`);
+  }
+  let replacement;
+  if (call.kind === "createIsomorphicFn") {
+    replacement = selectIsomorphicImplementation(code, id, environment, args[0]);
+  } else {
+    const expected = call.kind === "createServerOnlyFn" ? "server" : "client";
+    replacement = environment === expected ? readNode(code, args[0]) : `(0, ${readNode(code, call.node.callee)})(undefined, ${JSON.stringify(environment)})`;
+  }
+  return {
+    start: call.node.start,
+    end: call.node.end,
+    code: `(${replacement})`
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createReplacement, "createReplacement");
+function selectIsomorphicImplementation(code, id, environment, optionsNode) {
+  if (optionsNode.type !== "ObjectExpression") {
+    throw transformError(id, "createIsomorphicFn() requires an inline options object");
+  }
+  const properties = Array.isArray(optionsNode.properties) ? optionsNode.properties : [];
+  if (properties.some((property) => isAstNode(property) && property.type === "SpreadElement")) {
+    throw transformError(id, "createIsomorphicFn() does not support spread properties");
+  }
+  let selectedProperty;
+  for (const property of properties) {
+    if (!isAstNode(property) || property.type !== "Property" || property.computed === true) {
+      continue;
+    }
+    const key = readPropertyName(property.key);
+    if (key === environment) selectedProperty = property;
+  }
+  if (!selectedProperty || !isAstNode(selectedProperty.value)) {
+    throw transformError(id, `createIsomorphicFn() requires a ${environment} implementation`);
+  }
+  if (selectedProperty.kind !== void 0 && selectedProperty.kind !== "init") {
+    throw transformError(id, "createIsomorphicFn() does not support getters or setters");
+  }
+  return selectedProperty.method === true ? renderObjectMethod(code, id, selectedProperty.value) : readNode(code, selectedProperty.value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, selectIsomorphicImplementation, "selectIsomorphicImplementation");
+function renderObjectMethod(code, id, functionNode) {
+  if (!isAstNode(functionNode.body) || !Array.isArray(functionNode.params)) {
+    throw transformError(id, "createIsomorphicFn() received an unsupported method");
+  }
+  const params = functionNode.params.map((param) => {
+    if (!isAstNode(param)) {
+      throw transformError(id, "createIsomorphicFn() received an unsupported parameter");
+    }
+    return readNode(code, param);
+  });
+  const asyncPrefix = functionNode.async === true ? "async " : "";
+  const generatorMarker = functionNode.generator === true ? "*" : "";
+  return `${asyncPrefix}function${generatorMarker}(${params.join(", ")}) ${readNode(code, functionNode.body)}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, renderObjectMethod, "renderObjectMethod");
+function applyReplacements(code, replacements) {
+  let output = code;
+  for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+    output = output.slice(0, replacement.start) + replacement.code + output.slice(replacement.end);
+  }
+  return output;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyReplacements, "applyReplacements");
+function walkAst(node, visit, ancestors = []) {
+  visit(node, ancestors);
+  const childAncestors = [...ancestors, node];
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (isAstNode(value)) {
+      walkAst(value, visit, childAncestors);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isAstNode(item)) walkAst(item, visit, childAncestors);
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, walkAst, "walkAst");
+function isNameShadowed(name, ancestors) {
+  for (const [index, ancestor] of ancestors.entries()) {
+    if (isFunctionNode(ancestor)) {
+      const params = Array.isArray(ancestor.params) ? ancestor.params : [];
+      if (params.some((param) => patternContainsName(param, name))) return true;
+      if (patternContainsName(ancestor.id, name)) return true;
+      if (isAstNode(ancestor.body) && ancestors.slice(index + 1).includes(ancestor.body) && functionBodyDeclaresVarName(ancestor.body, name)) {
+        return true;
+      }
+    }
+    if (ancestor.type === "CatchClause" && patternContainsName(ancestor.param, name)) {
+      return true;
+    }
+    if ((ancestor.type === "BlockStatement" || ancestor.type === "StaticBlock") && blockDeclaresName(ancestor, name)) {
+      return true;
+    }
+    if (loopDeclaresName(ancestor, name)) return true;
+    if (ancestor.type === "SwitchStatement" && ancestors.slice(index + 1).some((candidate) => candidate.type === "SwitchCase") && switchDeclaresName(ancestor, name)) {
+      return true;
+    }
+    if (ancestor.type === "ClassExpression" && patternContainsName(ancestor.id, name) && ancestors.slice(index + 1).some((candidate) => candidate.type === "ClassBody")) {
+      return true;
+    }
+  }
+  return false;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isNameShadowed, "isNameShadowed");
+function functionBodyDeclaresVarName(body, name) {
+  if (body.type === "VariableDeclaration" && body.kind === "var") {
+    const declarations = Array.isArray(body.declarations) ? body.declarations : [];
+    if (declarations.some(
+      (declaration) => isAstNode(declaration) && patternContainsName(declaration.id, name)
+    )) {
+      return true;
+    }
+  }
+  for (const [key, value] of Object.entries(body)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (isAstNode(value)) {
+      if (isNestedVarScope(value)) continue;
+      if (functionBodyDeclaresVarName(value, name)) return true;
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (!isAstNode(item) || isNestedVarScope(item)) continue;
+        if (functionBodyDeclaresVarName(item, name)) return true;
+      }
+    }
+  }
+  return false;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, functionBodyDeclaresVarName, "functionBodyDeclaresVarName");
+function isNestedVarScope(node) {
+  return isFunctionNode(node) || node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isNestedVarScope, "isNestedVarScope");
+function loopDeclaresName(node, name) {
+  const declaration = node.type === "ForStatement" ? node.init : node.type === "ForInStatement" || node.type === "ForOfStatement" ? node.left : void 0;
+  if (!isAstNode(declaration) || declaration.type !== "VariableDeclaration") return false;
+  const declarations = Array.isArray(declaration.declarations) ? declaration.declarations : [];
+  return declarations.some((item) => isAstNode(item) && patternContainsName(item.id, name));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loopDeclaresName, "loopDeclaresName");
+function switchDeclaresName(node, name) {
+  const cases = Array.isArray(node.cases) ? node.cases : [];
+  return cases.some((switchCase) => {
+    if (!isAstNode(switchCase) || !Array.isArray(switchCase.consequent)) return false;
+    return switchCase.consequent.some((statement) => {
+      if (!isAstNode(statement)) return false;
+      if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && patternContainsName(statement.id, name)) {
+        return true;
+      }
+      if (statement.type !== "VariableDeclaration" || statement.kind === "var") return false;
+      const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+      return declarations.some(
+        (declaration) => isAstNode(declaration) && patternContainsName(declaration.id, name)
+      );
+    });
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, switchDeclaresName, "switchDeclaresName");
+function blockDeclaresName(block, name) {
+  const statements = Array.isArray(block.body) ? block.body : [];
+  for (const statement of statements) {
+    if (!isAstNode(statement)) continue;
+    if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && patternContainsName(statement.id, name)) {
+      return true;
+    }
+    if (statement.type !== "VariableDeclaration" || !Array.isArray(statement.declarations)) {
+      continue;
+    }
+    if (statement.declarations.some(
+      (declaration) => isAstNode(declaration) && patternContainsName(declaration.id, name)
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, blockDeclaresName, "blockDeclaresName");
+function patternContainsName(value, name) {
+  if (!isAstNode(value)) return false;
+  if (value.type === "Identifier") return value.name === name;
+  if (value.type === "RestElement") return patternContainsName(value.argument, name);
+  if (value.type === "AssignmentPattern") return patternContainsName(value.left, name);
+  if (value.type === "Property") return patternContainsName(value.value, name);
+  const elements = Array.isArray(value.elements) ? value.elements : Array.isArray(value.properties) ? value.properties : [];
+  return elements.some((element) => patternContainsName(element, name));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, patternContainsName, "patternContainsName");
+function isFunctionNode(node) {
+  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFunctionNode, "isFunctionNode");
+function readPropertyName(value) {
+  if (!isAstNode(value)) return void 0;
+  if (value.type === "Identifier" && typeof value.name === "string") return value.name;
+  if (value.type === "Literal" && typeof value.value === "string") return value.value;
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readPropertyName, "readPropertyName");
+function readNode(code, node) {
+  return code.slice(node.start, node.end);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readNode, "readNode");
+function isAstNode(value) {
+  return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isAstNode, "isAstNode");
+function isEnvironmentFunctionKind(value) {
+  return typeof value === "string" && ENVIRONMENT_FUNCTIONS.has(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isEnvironmentFunctionKind, "isEnvironmentFunctionKind");
+function containsEnvironmentFunction(code) {
+  return Array.from(ENVIRONMENT_FUNCTIONS).some((name) => code.includes(name));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, containsEnvironmentFunction, "containsEnvironmentFunction");
+function isTransformableModule(id) {
+  const cleanId = id.split("?", 1)[0];
+  return MODULE_EXTENSION_RE.test(cleanId) && !/\.d\.[cm]?ts$/.test(cleanId);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isTransformableModule, "isTransformableModule");
+function transformError(id, message) {
+  return new Error(`[Farm environment functions] ${message} in ${id.split("?", 1)[0]}`);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, transformError, "transformError");
+
+
+
+
+exports.transformEnvironmentFunctions = transformEnvironmentFunctions; exports.farmEnvironmentFunctionsPlugin = farmEnvironmentFunctionsPlugin;

package/dist/chunk-2CQ74SP6.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/route-files.ts
+function isFarmAPIRouteFileName(fileName) {
+  return /^route\.(?:ts|tsx|js|jsx)$/.test(fileName);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmAPIRouteFileName, "isFarmAPIRouteFileName");
+
+
+
+exports.isFarmAPIRouteFileName = isFarmAPIRouteFileName;

package/dist/chunk-2SJ4RQ6P.cjs

@@ -0,0 +1,57 @@
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/instrumentation-runtime.ts
+function createFarmInstrumentationLifecycle(module, context) {
+  let startPromise;
+  let shutdownPromise;
+  let cleanup;
+  return {
+    start() {
+      if (!startPromise) {
+        startPromise = Promise.resolve(_optionalChain([module, 'optionalAccess', _ => _.register, 'optionalCall', _2 => _2(context)])).then((result) => {
+          cleanup = result || void 0;
+        });
+      }
+      return startPromise;
+    },
+    shutdown() {
+      if (!shutdownPromise) {
+        shutdownPromise = (async () => {
+          try {
+            await startPromise;
+          } catch (e) {
+          }
+          try {
+            if (typeof cleanup === "function") {
+              await cleanup();
+            } else if (_optionalChain([cleanup, 'optionalAccess', _3 => _3.shutdown])) {
+              await cleanup.shutdown();
+            }
+          } finally {
+            if (_optionalChain([module, 'optionalAccess', _4 => _4.shutdown])) {
+              await module.shutdown();
+            }
+          }
+        })();
+      }
+      return shutdownPromise;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmInstrumentationLifecycle, "createFarmInstrumentationLifecycle");
+function resolveFarmInstrumentationRuntime(preset) {
+  const normalized = _nullishCoalesce(_optionalChain([preset, 'optionalAccess', _5 => _5.toLowerCase, 'call', _6 => _6()]), () => ( ""));
+  if (normalized.includes("cloudflare") || normalized.includes("worker") || normalized.includes("edge")) {
+    return "edge";
+  }
+  if (normalized.includes("bun")) return "bun";
+  return "nodejs";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmInstrumentationRuntime, "resolveFarmInstrumentationRuntime");
+
+
+
+
+exports.createFarmInstrumentationLifecycle = createFarmInstrumentationLifecycle; exports.resolveFarmInstrumentationRuntime = resolveFarmInstrumentationRuntime;

package/dist/chunk-3376ZTRC.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/{chunk-YD4J4XCI.mjs → chunk-3XG26Z3J.mjs}

@@ -1,5 +1,5 @@
 // package.json
-var version = "0.1.17";
+var version = "0.1.18";
 
 // src/version.ts
 var FARM_VERSION = version;