@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-ROUTX2E5.cjs

@@ -0,0 +1,390 @@
+"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/client/isolated-boundary.ts
+var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+var LEGACY_REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+var BOUNDARY_GRAPH_CONTEXT = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.client-graph-context");
+function getBoundaryGraphContext(ReactRuntime) {
+  const shared = globalThis;
+  const contexts = _nullishCoalesce(shared[BOUNDARY_GRAPH_CONTEXT], () => ( /* @__PURE__ */ new WeakMap()));
+  shared[BOUNDARY_GRAPH_CONTEXT] = contexts;
+  const runtimeIdentity = ReactRuntime.createElement;
+  const existing = contexts.get(runtimeIdentity);
+  if (existing) return existing;
+  const context = ReactRuntime.createContext(false);
+  contexts.set(runtimeIdentity, context);
+  return context;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getBoundaryGraphContext, "getBoundaryGraphContext");
+function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("non-finite numbers are not serializable");
+    return value;
+  }
+  if (typeof value === "undefined") {
+    throw new TypeError("undefined values are not serializable");
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`${typeof value} values are not serializable`);
+  }
+  if (value.$$typeof === REACT_ELEMENT_TYPE || value.$$typeof === LEGACY_REACT_ELEMENT_TYPE) {
+    throw new TypeError("React elements cannot cross an isolated hydration boundary");
+  }
+  if (seen.has(value)) throw new TypeError("circular props are not serializable");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((entry) => serializeBoundaryProps(entry, seen));
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("class instances are not serializable");
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, serializeBoundaryProps(entry, seen)])
+    );
+  } finally {
+    seen.delete(value);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeBoundaryProps, "serializeBoundaryProps");
+function serializeBoundaryPayload(value) {
+  return JSON.stringify(serializeBoundaryProps(value)).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeBoundaryPayload, "serializeBoundaryPayload");
+function wrapFarmIsolatedClientGraph(ReactRuntime, element) {
+  const Context = getBoundaryGraphContext(ReactRuntime);
+  return ReactRuntime.createElement(Context.Provider, { value: true }, element);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, wrapFarmIsolatedClientGraph, "wrapFarmIsolatedClientGraph");
+function isolateFarmServerPageGraph(ReactRuntime, element) {
+  const Context = getBoundaryGraphContext(ReactRuntime);
+  return ReactRuntime.createElement(Context.Provider, { value: false }, element);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isolateFarmServerPageGraph, "isolateFarmServerPageGraph");
+function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReference, exportName, islandStrategy) {
+  function FarmIsolatedClientBoundary(props) {
+    const Context = getBoundaryGraphContext(ReactRuntime);
+    const belongsToParentClientGraph = ReactRuntime.useContext(Context);
+    const boundaryId = ReactRuntime.useId();
+    if (belongsToParentClientGraph) {
+      return ReactRuntime.createElement(Component, props);
+    }
+    let serializedProps;
+    try {
+      serializedProps = serializeBoundaryPayload(props);
+    } catch (error) {
+      if (typeof window === "undefined") {
+        console.warn(
+          `[Farm.js] Could not isolate ${moduleReference}#${exportName}: ${error instanceof Error ? error.message : String(error)}. The server-rendered component was preserved without client hydration.`
+        );
+      }
+      return ReactRuntime.createElement(Component, props);
+    }
+    return ReactRuntime.createElement(
+      ReactRuntime.Fragment,
+      null,
+      ReactRuntime.createElement(
+        "farm-client-boundary",
+        {
+          "data-farm-client-boundary": moduleReference,
+          "data-farm-client-id": boundaryId,
+          "data-farm-client-export": exportName,
+          "data-farm-island-strategy": islandStrategy,
+          style: { display: "contents" }
+        },
+        ReactRuntime.createElement(
+          Context.Provider,
+          { value: true },
+          ReactRuntime.createElement(Component, props)
+        )
+      ),
+      ReactRuntime.createElement("script", {
+        type: "application/json",
+        "data-farm-client-props": boundaryId,
+        dangerouslySetInnerHTML: { __html: serializedProps }
+      })
+    );
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, FarmIsolatedClientBoundary, "FarmIsolatedClientBoundary");
+  FarmIsolatedClientBoundary.displayName = `FarmIsolated(${Component.displayName || Component.name || exportName})`;
+  return FarmIsolatedClientBoundary;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmIsolatedClientBoundary, "createFarmIsolatedClientBoundary");
+function isEarlyHydrationUpdate(error) {
+  return error instanceof Error && (error.message === "This root received an early update, before anything was able hydrate. Switched the entire root to client rendering." || error.message.startsWith("Minified React error #424;"));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isEarlyHydrationUpdate, "isEarlyHydrationUpdate");
+function findBoundaryPayload(container, boundaryId) {
+  const sibling = container.nextElementSibling;
+  if (sibling instanceof HTMLScriptElement && sibling.type === "application/json" && sibling.getAttribute("data-farm-client-props") === boundaryId) {
+    return sibling;
+  }
+  for (const candidate of container.ownerDocument.querySelectorAll(
+    'script[type="application/json"][data-farm-client-props]'
+  )) {
+    if (candidate.getAttribute("data-farm-client-props") === boundaryId) return candidate;
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findBoundaryPayload, "findBoundaryPayload");
+function createFarmIsolatedHydrationRuntime(options) {
+  const roots = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const report = _nullishCoalesce(options.report, () => ( ((message, error) => console.warn(`[Farm.js] ${message}`, error))));
+  const failRoot = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (container, reference, exportName, serverHTML, error) => {
+    report(
+      `Could not hydrate isolated client boundary ${reference}#${exportName}. The server-rendered HTML was restored.`,
+      error
+    );
+    queueMicrotask(() => {
+      try {
+        _optionalChain([roots, 'access', _ => _.get, 'call', _2 => _2(container), 'optionalAccess', _3 => _3.root, 'access', _4 => _4.unmount, 'call', _5 => _5()]);
+      } catch (e) {
+      }
+      roots.delete(container);
+      container.removeAttribute("data-farm-hydrated");
+      container.removeAttribute("data-farm-island-hydrated");
+      container.innerHTML = serverHTML;
+    });
+  }, "failRoot");
+  const _FarmIsolatedRootErrorBoundary = class _FarmIsolatedRootErrorBoundary extends options.ReactRuntime.Component {
+    constructor() {
+      super(...arguments);
+      this.state = { failed: false };
+    }
+    static getDerivedStateFromError() {
+      return { failed: true };
+    }
+    componentDidCatch(error) {
+      this.props.onError(error);
+    }
+    render() {
+      return this.state.failed ? null : this.props.children;
+    }
+  };
+  _chunkS3JO3N4Hcjs.__name.call(void 0, _FarmIsolatedRootErrorBoundary, "FarmIsolatedRootErrorBoundary");
+  let FarmIsolatedRootErrorBoundary = _FarmIsolatedRootErrorBoundary;
+  const createBoundaryGraph = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (Component, props, restore) => {
+    const componentElement = options.ReactRuntime.createElement(Component, props);
+    const wrappedElement = options.wrap ? options.wrap(componentElement) : componentElement;
+    return wrapFarmIsolatedClientGraph(
+      options.ReactRuntime,
+      options.ReactRuntime.createElement(
+        FarmIsolatedRootErrorBoundary,
+        { onError: restore },
+        wrappedElement
+      )
+    );
+  }, "createBoundaryGraph");
+  async function hydrate(scope = document, signal) {
+    const candidates = Array.from(
+      scope.querySelectorAll("farm-client-boundary[data-farm-client-boundary]")
+    );
+    if (scope instanceof Element && scope.matches("farm-client-boundary[data-farm-client-boundary]")) {
+      candidates.unshift(scope);
+    }
+    const boundaries = candidates.filter((container) => {
+      if (roots.has(container) || pending.has(container)) return false;
+      return !_optionalChain([container, 'access', _6 => _6.parentElement, 'optionalAccess', _7 => _7.closest, 'call', _8 => _8("farm-client-boundary[data-farm-client-boundary]")]);
+    });
+    await Promise.all(
+      boundaries.map(async (container) => {
+        const reference = container.getAttribute("data-farm-client-boundary");
+        const boundaryId = container.getAttribute("data-farm-client-id");
+        const exportName = container.getAttribute("data-farm-client-export") || "default";
+        const strategy = _nullishCoalesce(container.getAttribute("data-farm-island-strategy"), () => ( "load"));
+        if (!reference || !boundaryId) {
+          report("An isolated client boundary is missing its module reference or payload ID.");
+          return;
+        }
+        const controller = new AbortController();
+        pending.set(container, controller);
+        const releasePending = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+          if (pending.get(container) === controller) pending.delete(container);
+        }, "releasePending");
+        controller.signal.addEventListener("abort", releasePending, { once: true });
+        const abort = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => controller.abort(), "abort");
+        if (_optionalChain([signal, 'optionalAccess', _9 => _9.aborted])) abort();
+        else _optionalChain([signal, 'optionalAccess', _10 => _10.addEventListener, 'call', _11 => _11("abort", abort, { once: true })]);
+        const cleanup = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+          _optionalChain([signal, 'optionalAccess', _12 => _12.removeEventListener, 'call', _13 => _13("abort", abort)]);
+          releasePending();
+        }, "cleanup");
+        let scheduled;
+        try {
+          scheduled = options.schedule({
+            container,
+            strategy,
+            signal: controller.signal,
+            hydrate: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+              if (controller.signal.aborted || !container.isConnected) return;
+              const serverHTML = container.innerHTML;
+              try {
+                const module = await options.load(reference);
+                if (controller.signal.aborted || !container.isConnected) return;
+                const originals = module.__farm_client_boundary_originals__;
+                const Component = _optionalChain([originals, 'optionalAccess', _14 => _14[exportName]]);
+                if (typeof Component !== "function" && typeof Component !== "object") {
+                  throw new Error("compiled original export was not found");
+                }
+                const payload = findBoundaryPayload(container, boundaryId);
+                if (!payload) throw new Error(`serialized props ${boundaryId} were not found`);
+                const props = JSON.parse(payload.textContent || "{}");
+                if (!props || typeof props !== "object" || Array.isArray(props)) {
+                  throw new Error("serialized props must be an object");
+                }
+                let rootFailure;
+                const restore = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => {
+                  if (rootFailure !== void 0) return;
+                  rootFailure = error;
+                  failRoot(container, reference, exportName, serverHTML, error);
+                  controller.abort();
+                }, "restore");
+                const graphElement = createBoundaryGraph(
+                  Component,
+                  props,
+                  restore
+                );
+                let disposing = false;
+                const root = options.hydrateRoot(container, graphElement, {
+                  onUncaughtError: restore,
+                  onRecoverableError(error) {
+                    if (disposing && isEarlyHydrationUpdate(error)) return;
+                    if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+                    else console.error(error);
+                  }
+                });
+                roots.set(container, {
+                  root,
+                  dispose() {
+                    disposing = true;
+                    try {
+                      root.unmount();
+                    } finally {
+                      disposing = false;
+                    }
+                  },
+                  reference,
+                  exportName,
+                  props,
+                  serverHTML,
+                  restore
+                });
+                container.setAttribute("data-farm-hydrated", "true");
+              } catch (error) {
+                if (controller.signal.aborted) return;
+                failRoot(container, reference, exportName, serverHTML, error);
+                controller.abort();
+              }
+            }, "hydrate")
+          });
+        } catch (error) {
+          failRoot(container, reference, exportName, container.innerHTML, error);
+          controller.abort();
+          cleanup();
+          return;
+        }
+        const tracked = Promise.resolve(scheduled).catch((error) => {
+          if (!controller.signal.aborted) {
+            failRoot(container, reference, exportName, container.innerHTML, error);
+            controller.abort();
+          }
+        }).finally(cleanup);
+        if (strategy === "load") await tracked;
+        else void tracked;
+      })
+    );
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, hydrate, "hydrate");
+  function updateModule(reference, module) {
+    const originals = module.__farm_client_boundary_originals__;
+    let updated = 0;
+    for (const [container, record] of roots) {
+      if (record.reference !== reference) continue;
+      const Component = _optionalChain([originals, 'optionalAccess', _15 => _15[record.exportName]]);
+      if (typeof Component !== "function" && typeof Component !== "object") {
+        failRoot(
+          container,
+          record.reference,
+          record.exportName,
+          record.serverHTML,
+          new Error("updated compiled original export was not found")
+        );
+        continue;
+      }
+      try {
+        record.root.render(
+          createBoundaryGraph(Component, record.props, record.restore)
+        );
+        updated++;
+      } catch (error) {
+        failRoot(container, record.reference, record.exportName, record.serverHTML, error);
+      }
+    }
+    return updated;
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, updateModule, "updateModule");
+  function dispose(scope) {
+    for (const [container, controller] of pending) {
+      if (container === scope || scope.contains(container)) {
+        controller.abort();
+        pending.delete(container);
+      }
+    }
+    for (const [container, record] of roots) {
+      if (container === scope || scope.contains(container)) {
+        try {
+          record.dispose();
+        } catch (e2) {
+        }
+        roots.delete(container);
+        container.removeAttribute("data-farm-hydrated");
+        container.removeAttribute("data-farm-island-hydrated");
+      }
+    }
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, dispose, "dispose");
+  return {
+    hydrate,
+    updateModule,
+    dispose,
+    rootCount: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => roots.size, "rootCount")
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmIsolatedHydrationRuntime, "createFarmIsolatedHydrationRuntime");
+function createFarmServerPageBoundary(ReactRuntime, runtime) {
+  return /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, function FarmServerPage(props) {
+    const ref = ReactRuntime.useRef(null);
+    const html = props.dangerouslySetInnerHTML.__html;
+    ReactRuntime.useLayoutEffect(() => {
+      const page = ref.current;
+      if (!page) return;
+      const islands = Array.from(
+        page.querySelectorAll("farm-client-boundary[data-farm-client-boundary]")
+      );
+      if (islands.length === 0) return;
+      const controller = new AbortController();
+      runtime.hydrate(page, controller.signal).catch((error) => {
+        console.error("[Farm.js] Could not hydrate the islands in this page:", error);
+      });
+      return () => {
+        controller.abort();
+        queueMicrotask(() => {
+          for (const island of islands) runtime.dispose(island);
+        });
+      };
+    }, [html]);
+    return ReactRuntime.createElement("div", { ...props, ref });
+  }, "FarmServerPage");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmServerPageBoundary, "createFarmServerPageBoundary");
+
+
+
+
+
+
+
+exports.wrapFarmIsolatedClientGraph = wrapFarmIsolatedClientGraph; exports.isolateFarmServerPageGraph = isolateFarmServerPageGraph; exports.createFarmIsolatedClientBoundary = createFarmIsolatedClientBoundary; exports.createFarmIsolatedHydrationRuntime = createFarmIsolatedHydrationRuntime; exports.createFarmServerPageBoundary = createFarmServerPageBoundary;

package/dist/chunk-RTHIVJ2G.cjs

@@ -0,0 +1,54 @@
+"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 _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/instrumentation.ts
+var _esbuild = require('esbuild');
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+var INSTRUMENTATION_EXTENSIONS = ["ts", "mts", "js", "mjs"];
+function resolveFarmInstrumentationFile(root, srcDir = "src") {
+  const candidates = [
+    ...INSTRUMENTATION_EXTENSIONS.map(
+      (extension) => _path2.default.join(root, srcDir, `instrumentation.${extension}`)
+    ),
+    ...INSTRUMENTATION_EXTENSIONS.map(
+      (extension) => _path2.default.join(root, `instrumentation.${extension}`)
+    )
+  ].filter((candidate) => _fs2.default.existsSync(candidate));
+  if (candidates.length > 1) {
+    throw new Error(
+      `Farm.js found multiple instrumentation files:
+${candidates.map((candidate) => `- ${_path2.default.relative(root, candidate)}`).join("\n")}
+Keep only one instrumentation file in the project root or ${srcDir}/.`
+    );
+  }
+  return _nullishCoalesce(candidates[0], () => ( null));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmInstrumentationFile, "resolveFarmInstrumentationFile");
+async function loadFarmInstrumentation(filePath, root) {
+  if (!filePath) return null;
+  const outputDirectory = _path2.default.join(root, ".farm", ".instrumentation-loader");
+  const outputFile = _path2.default.join(outputDirectory, "instrumentation.mjs");
+  await _fs2.default.promises.mkdir(outputDirectory, { recursive: true });
+  await _esbuild.build.call(void 0, {
+    entryPoints: [filePath],
+    outfile: outputFile,
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    packages: "external",
+    sourcemap: "inline"
+  });
+  const url = _url.pathToFileURL.call(void 0, outputFile);
+  url.searchParams.set("t", String(Date.now()));
+  return await import(url.href);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmInstrumentation, "loadFarmInstrumentation");
+
+
+
+
+exports.resolveFarmInstrumentationFile = resolveFarmInstrumentationFile; exports.loadFarmInstrumentation = loadFarmInstrumentation;