@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-TUOO6IK3.mjs

@@ -1,87 +0,0 @@
-// src/dev-module.ts
-var failedModules = /* @__PURE__ */ new WeakMap();
-var startedContainers = /* @__PURE__ */ new WeakSet();
-async function startPluginContainer(server) {
-  if (server.config?.experimental?.bundledDev) return;
-  const container = server.environments.client?.pluginContainer;
-  if (!container || startedContainers.has(container)) return;
-  await container.buildStart?.();
-  startedContainers.add(container);
-}
-var FarmDevEnvironmentError = class extends Error {
-};
-async function loadFarmDevModule(server, id, environmentName = "ssr") {
-  const environment = server.environments[environmentName];
-  const runner = environment?.runner;
-  if (!environment || !runner || typeof runner.import !== "function") {
-    throw new FarmDevEnvironmentError(
-      `[Farm.js] Cannot load ${JSON.stringify(id)}: the "${environmentName}" development environment must provide a module runner. Remote runtimes require a request/response adapter.`
-    );
-  }
-  try {
-    await startPluginContainer(server);
-    return await runner.import(id);
-  } catch (error) {
-    const failures = failedModules.get(environment) ?? /* @__PURE__ */ new Map();
-    failedModules.set(environment, failures);
-    await Promise.all(
-      [...runner.evaluatedModules?.idToModuleMap.values() ?? []].filter((module) => module.evaluated && module.promise).map(async (module) => {
-        try {
-          await module.promise;
-        } catch {
-          failures.set(module.id, module.promise);
-        }
-      })
-    );
-    throw error;
-  }
-}
-function invalidateFarmDevDependents(server, file, targets, environmentName = "ssr") {
-  const environment = server.environments[environmentName];
-  const graph = environment?.moduleGraph;
-  if (!graph || targets.size === 0) return [];
-  const posix = (filePath) => filePath.replace(/\\/g, "/");
-  const byFile = new Map([...targets].map((target) => [posix(target), target]));
-  const reached = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [...graph.getModulesByFile(posix(file)) ?? []];
-  while (queue.length > 0) {
-    const node = queue.pop();
-    if (seen.has(node)) continue;
-    seen.add(node);
-    const target = node.file ? byFile.get(posix(node.file)) : void 0;
-    if (target) reached.add(target);
-    queue.push(...node.importers);
-  }
-  if (reached.size === 0) return [];
-  const evaluatedModules = environment.runner?.evaluatedModules;
-  for (const node of seen) {
-    graph.invalidateModule(node);
-    const evaluated = node.id ? evaluatedModules?.getModuleById(node.id) : void 0;
-    if (evaluated) evaluatedModules.invalidateModule(evaluated);
-  }
-  return [...reached];
-}
-function invalidateFailedFarmDevModules(server) {
-  for (const entry of Object.values(server.environments)) {
-    const environment = entry;
-    const failures = failedModules.get(environment);
-    if (!failures?.size) continue;
-    const runner = environment.runner;
-    for (const [id, failed] of failures) {
-      const evaluated = runner.evaluatedModules.getModuleById(id);
-      if (evaluated?.promise !== failed) continue;
-      const transformed = environment.moduleGraph.getModuleById(id);
-      if (transformed) environment.moduleGraph.invalidateModule(transformed);
-      if (evaluated) runner.evaluatedModules.invalidateModule(evaluated);
-    }
-    failures.clear();
-  }
-}
-
-export {
-  FarmDevEnvironmentError,
-  loadFarmDevModule,
-  invalidateFarmDevDependents,
-  invalidateFailedFarmDevModules
-};

package/dist/chunk-TUPKMMXT.mjs

@@ -1,173 +0,0 @@
-import {
-  writeFileIfChanged
-} from "./chunk-Q5B4LNON.mjs";
-
-// src/env-types.ts
-import * as fs from "fs";
-import * as path from "path";
-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;
-}
-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;
-}
-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 {};
-`;
-}
-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;
-}
-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 {};
-`;
-}
-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 {};
-`;
-}
-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}`;
-}
-
-export {
-  generateEnvTypes,
-  createEnvTypeDeclarations
-};

package/dist/chunk-TVCFY3KK.cjs

@@ -1,217 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-var _chunkCQL5ZGFUcjs = require('./chunk-CQL5ZGFU.cjs');
-
-// 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);
-}
-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;
-}
-function farmTagged(tag, value) {
-  return value === void 0 ? { [_chunkCQL5ZGFUcjs.FARM_TAG]: tag } : { [_chunkCQL5ZGFUcjs.FARM_TAG]: tag, [_chunkCQL5ZGFUcjs.FARM_TAG_VALUE]: value };
-}
-function needsFarmObjectTag(object) {
-  return Object.prototype.hasOwnProperty.call(object, _chunkCQL5ZGFUcjs.FARM_TAG);
-}
-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;
-}
-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;
-}
-function decodeFarmTagged(object, decodeChild) {
-  const tag = object[_chunkCQL5ZGFUcjs.FARM_TAG];
-  const data = object[_chunkCQL5ZGFUcjs.FARM_TAG_VALUE];
-  switch (tag) {
-    case _chunkCQL5ZGFUcjs.FARM_REFERENCE_TAG:
-    case _chunkCQL5ZGFUcjs.FARM_SLOT_TAG:
-    case _chunkCQL5ZGFUcjs.FARM_ACTION_TAG:
-      return NOT_A_FARM_MARKER;
-    case _chunkCQL5ZGFUcjs.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`);
-}
-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(_chunkCQL5ZGFUcjs.FARM_OBJECT_TAG, encoded) : encoded;
-  } finally {
-    seen.delete(value);
-  }
-}
-function decodeFarmJson(value) {
-  if (Array.isArray(value)) return value.map(decodeFarmJson);
-  if (!value || typeof value !== "object") return value;
-  if (_chunkCQL5ZGFUcjs.getFarmTag.call(void 0, value) !== void 0) {
-    const decoded = decodeFarmTagged(value, decodeFarmJson);
-    if (decoded === NOT_A_FARM_MARKER) {
-      throw new TypeError(
-        `a ${JSON.stringify(value[_chunkCQL5ZGFUcjs.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)]));
-}
-
-
-
-
-
-
-
-
-
-
-exports.farmTagged = farmTagged; exports.needsFarmObjectTag = needsFarmObjectTag; exports.encodeFarmLeaf = encodeFarmLeaf; exports.NOT_A_FARM_MARKER = NOT_A_FARM_MARKER; exports.farmPlainObject = farmPlainObject; exports.decodeFarmTagged = decodeFarmTagged; exports.encodeFarmJson = encodeFarmJson; exports.decodeFarmJson = decodeFarmJson;