@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-SVCUSOEF.mjs

@@ -0,0 +1,590 @@
+import {
+  getFarmActionId,
+  markFarmClientReference,
+  updateFarmServerTreeModule
+} from "./chunk-FHURJABM.mjs";
+import {
+  FARM_ACTION_TAG,
+  FARM_ISLAND_ELEMENT,
+  FARM_OBJECT_TAG,
+  FARM_PROPS_SCRIPT_TYPE,
+  FARM_REFERENCE_TAG,
+  FARM_SLOT_ELEMENT,
+  FARM_SLOT_TAG,
+  FARM_TAG,
+  FARM_TAG_VALUE,
+  FARM_VALUE_SCRIPT_TYPE,
+  getFarmIslandValuesServer,
+  getFarmTag
+} from "./chunk-NBIVGHAT.mjs";
+
+// src/client/isolated-boundary.ts
+var ISLAND_SELECTOR = `${FARM_ISLAND_ELEMENT}[src]`;
+var runtimeTagged = /* @__PURE__ */ new WeakSet();
+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 = 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;
+}
+function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
+  const codec = getFarmIslandValuesServer();
+  const leaf = codec?.encodeLeaf(value);
+  if (leaf) return leaf;
+  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 === "function") {
+    const actionId = getFarmActionId(value);
+    if (actionId) return { [FARM_TAG]: FARM_ACTION_TAG, [FARM_TAG_VALUE]: actionId };
+  }
+  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));
+    if (codec && value instanceof Map) {
+      return {
+        [FARM_TAG]: "M",
+        [FARM_TAG_VALUE]: Array.from(value, ([key, entry]) => [
+          serializeBoundaryProps(key, seen),
+          serializeBoundaryProps(entry, seen)
+        ])
+      };
+    }
+    if (codec && value instanceof Set) {
+      return {
+        [FARM_TAG]: "S",
+        [FARM_TAG_VALUE]: Array.from(value, (entry) => serializeBoundaryProps(entry, seen))
+      };
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("class instances are not serializable");
+    }
+    const serialized = Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, serializeBoundaryProps(entry, seen)])
+    );
+    return codec && !runtimeTagged.has(value) && Object.prototype.hasOwnProperty.call(value, FARM_TAG) ? { [FARM_TAG]: FARM_OBJECT_TAG, [FARM_TAG_VALUE]: serialized } : serialized;
+  } finally {
+    seen.delete(value);
+  }
+}
+function serializeBoundaryPayload(value) {
+  return escapeScriptJson(JSON.stringify(serializeBoundaryProps(value)));
+}
+function escapeScriptJson(json) {
+  return json.replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+var SLOT_ELEMENT = FARM_SLOT_ELEMENT;
+function isReactElementValue(value) {
+  const type = value?.$$typeof;
+  return type === REACT_ELEMENT_TYPE || type === LEGACY_REACT_ELEMENT_TYPE;
+}
+function slotReference(id) {
+  const reference = { [FARM_TAG]: FARM_SLOT_TAG, [FARM_TAG_VALUE]: id };
+  runtimeTagged.add(reference);
+  return reference;
+}
+function splitSlotProps(ReactRuntime, value, slotPrefix, counter) {
+  if (isReactElementValue(value)) {
+    const id = `${slotPrefix}${counter.next++}`;
+    return {
+      render: ReactRuntime.createElement(
+        SLOT_ELEMENT,
+        { key: value.key ?? id, name: id, style: { display: "contents" } },
+        value
+      ),
+      wire: slotReference(id)
+    };
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((entry) => splitSlotProps(ReactRuntime, entry, slotPrefix, counter));
+    return { render: parts.map((part) => part.render), wire: parts.map((part) => part.wire) };
+  }
+  if (value && typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) return { render: value, wire: value };
+    const render = {};
+    const wire = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const part = splitSlotProps(ReactRuntime, entry, slotPrefix, counter);
+      render[key] = part.render;
+      wire[key] = part.wire;
+    }
+    return { render, wire };
+  }
+  return { render: value, wire: value };
+}
+var FARM_NOT_A_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
+function reviveSlotProps(ReactRuntime, value, container, actions, decode) {
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    const revived2 = value.map((entry) => {
+      const next = reviveSlotProps(ReactRuntime, entry, container, actions, decode);
+      if (next !== entry) changed2 = true;
+      return next;
+    });
+    return changed2 ? revived2 : value;
+  }
+  if (!value || typeof value !== "object") return value;
+  const tag = decode || actions ? getFarmTag(value) : void 0;
+  const data = tag === void 0 ? void 0 : value[FARM_TAG_VALUE];
+  if (tag === FARM_ACTION_TAG && typeof data === "string") {
+    if (!actions) throw new Error("server action props need islands mode");
+    return actions(data);
+  }
+  if (tag === FARM_SLOT_TAG && typeof data === "string") {
+    let html = "";
+    for (const slot of container.querySelectorAll(SLOT_ELEMENT)) {
+      if (slot.getAttribute("name") === data) {
+        html = slot.innerHTML;
+        break;
+      }
+    }
+    return ReactRuntime.createElement(SLOT_ELEMENT, {
+      key: data,
+      name: data,
+      style: { display: "contents" },
+      suppressHydrationWarning: true,
+      dangerouslySetInnerHTML: { __html: html }
+    });
+  }
+  if (tag === FARM_REFERENCE_TAG) throw new Error(`island value ${String(data)} was not resolved`);
+  if (tag !== void 0) {
+    if (!decode) throw new Error("typed props need islands mode");
+    const decoded = decode(
+      value,
+      (child) => reviveSlotProps(ReactRuntime, child, container, actions, decode)
+    );
+    if (decoded !== FARM_NOT_A_MARKER) return decoded;
+  }
+  let changed = false;
+  const revived = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const next = reviveSlotProps(ReactRuntime, entry, container, actions, decode);
+    Object.defineProperty(revived, key, {
+      value: next,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    if (next !== entry) changed = true;
+  }
+  return changed ? revived : value;
+}
+function wrapFarmIsolatedClientGraph(ReactRuntime, element) {
+  const Context = getBoundaryGraphContext(ReactRuntime);
+  return ReactRuntime.createElement(Context.Provider, { value: true }, element);
+}
+function isolateFarmServerPageGraph(ReactRuntime, element) {
+  const Context = getBoundaryGraphContext(ReactRuntime);
+  return ReactRuntime.createElement(Context.Provider, { value: false }, element);
+}
+var warnedUnserializableBoundaries = /* @__PURE__ */ new Set();
+function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReference, exportName, islandStrategy, boundaryOptions = {}) {
+  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;
+    let renderProps = props;
+    let valueScripts = [];
+    try {
+      if (boundaryOptions.slots) {
+        const { render, wire } = splitSlotProps(ReactRuntime, props, `${boundaryId}s`, { next: 0 });
+        renderProps = render;
+        const values = boundaryOptions.values ? getFarmIslandValuesServer() : void 0;
+        if (values) {
+          const addressed = values.address(serializeBoundaryProps(wire));
+          serializedProps = escapeScriptJson(addressed.json);
+          valueScripts = values.select(addressed, values.held()).map(
+            (value) => ReactRuntime.createElement("script", {
+              key: value.key,
+              type: FARM_VALUE_SCRIPT_TYPE,
+              name: value.key,
+              dangerouslySetInnerHTML: { __html: escapeScriptJson(value.json) }
+            })
+          );
+        } else {
+          serializedProps = serializeBoundaryPayload(wire);
+        }
+      } else {
+        serializedProps = serializeBoundaryPayload(props);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const warningKey = `${moduleReference}#${exportName}:${message}`;
+      if (typeof window === "undefined" && !warnedUnserializableBoundaries.has(warningKey)) {
+        warnedUnserializableBoundaries.add(warningKey);
+        console.warn(
+          `[Farm.js] Could not isolate ${moduleReference}#${exportName}: ${message}. The server-rendered component was preserved without client hydration.`
+        );
+      }
+      return ReactRuntime.createElement(Component, props);
+    }
+    return ReactRuntime.createElement(
+      ReactRuntime.Fragment,
+      null,
+      ...valueScripts,
+      ReactRuntime.createElement(
+        FARM_ISLAND_ELEMENT,
+        {
+          src: moduleReference,
+          export: exportName,
+          props: boundaryId,
+          strategy: islandStrategy,
+          style: { display: "contents" }
+        },
+        ReactRuntime.createElement(
+          Context.Provider,
+          { value: true },
+          ReactRuntime.createElement(Component, renderProps)
+        )
+      ),
+      ReactRuntime.createElement("script", {
+        type: FARM_PROPS_SCRIPT_TYPE,
+        htmlFor: boundaryId,
+        dangerouslySetInnerHTML: { __html: serializedProps }
+      })
+    );
+  }
+  FarmIsolatedClientBoundary.displayName = `FarmIsolated(${Component.displayName || Component.name || exportName})`;
+  markFarmClientReference(FarmIsolatedClientBoundary, {
+    reference: moduleReference,
+    exportName,
+    Component
+  });
+  return FarmIsolatedClientBoundary;
+}
+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;"));
+}
+function findBoundaryPayload(container, boundaryId) {
+  const sibling = container.nextElementSibling;
+  if (sibling instanceof HTMLScriptElement && sibling.type === FARM_PROPS_SCRIPT_TYPE && sibling.getAttribute("for") === boundaryId) {
+    return sibling;
+  }
+  for (const candidate of container.ownerDocument.querySelectorAll(
+    `script[type="${FARM_PROPS_SCRIPT_TYPE}"]`
+  )) {
+    if (candidate.getAttribute("for") === boundaryId) return candidate;
+  }
+  return null;
+}
+function createFarmIsolatedHydrationRuntime(options) {
+  const roots = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const report = options.report ?? ((message, error) => console.warn(`[Farm.js] ${message}`, error));
+  const failRoot = (container, reference, exportName, serverHTML, error) => {
+    report(
+      `Could not hydrate isolated client boundary ${reference}#${exportName}. The server-rendered HTML was restored.`,
+      error
+    );
+    queueMicrotask(() => {
+      try {
+        roots.get(container)?.root.unmount();
+      } catch {
+      }
+      roots.delete(container);
+      container.removeAttribute("data-farm-hydrated");
+      container.removeAttribute("data-farm-island-hydrated");
+      container.innerHTML = serverHTML;
+    });
+  };
+  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;
+    }
+  }
+  const createBoundaryGraph = (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
+      )
+    );
+  };
+  function readBoundaryProps(container, boundaryId) {
+    const payload = findBoundaryPayload(container, boundaryId);
+    if (!payload) throw new Error(`serialized props ${boundaryId} were not found`);
+    const parsedProps = JSON.parse(payload.textContent || "{}");
+    if (!parsedProps || typeof parsedProps !== "object" || Array.isArray(parsedProps)) {
+      throw new Error("serialized props must be an object");
+    }
+    let resolvedProps = parsedProps;
+    if (payload.textContent?.includes(`"${FARM_TAG}":"${FARM_REFERENCE_TAG}"`)) {
+      if (!options.values) throw new Error("island values need islands mode");
+      options.values.ingest(container.ownerDocument);
+      resolvedProps = options.values.resolve(parsedProps);
+    }
+    return reviveSlotProps(
+      options.ReactRuntime,
+      resolvedProps,
+      container,
+      options.actions,
+      options.decode
+    );
+  }
+  const topLevelBoundaries = (scope) => Array.from(scope.querySelectorAll(ISLAND_SELECTOR)).filter(
+    (container) => !container.parentElement?.closest(ISLAND_SELECTOR)
+  );
+  const boundaryKey = (container) => `${container.getAttribute("src")}#${container.getAttribute("export") || "default"}`;
+  function carryOver(current, next) {
+    const live = /* @__PURE__ */ new Map();
+    for (const container of topLevelBoundaries(current)) {
+      if (!roots.has(container)) continue;
+      const key = boundaryKey(container);
+      live.set(key, [...live.get(key) ?? [], container]);
+    }
+    let carried = 0;
+    for (const container of topLevelBoundaries(next)) {
+      const previous = live.get(boundaryKey(container))?.shift();
+      const record = previous && roots.get(previous);
+      const boundaryId = container.getAttribute("props");
+      if (!previous || !record || !boundaryId) continue;
+      try {
+        const props = readBoundaryProps(container, boundaryId);
+        record.root.render(createBoundaryGraph(record.Component, props, record.restore));
+        record.props = props;
+        container.replaceWith(previous);
+        carried++;
+      } catch (error) {
+        report(`Could not keep ${boundaryKey(container)} across the refresh.`, error);
+      }
+    }
+    return carried;
+  }
+  async function hydrate(scope = document, signal) {
+    const candidates = Array.from(scope.querySelectorAll(ISLAND_SELECTOR));
+    if (scope instanceof Element && scope.matches(ISLAND_SELECTOR)) {
+      candidates.unshift(scope);
+    }
+    const boundaries = candidates.filter((container) => {
+      if (roots.has(container) || pending.has(container)) return false;
+      return !container.parentElement?.closest(ISLAND_SELECTOR);
+    });
+    await Promise.all(
+      boundaries.map(async (container) => {
+        const reference = container.getAttribute("src");
+        const boundaryId = container.getAttribute("props");
+        const exportName = container.getAttribute("export") || "default";
+        const strategy = container.getAttribute("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 = () => {
+          if (pending.get(container) === controller) pending.delete(container);
+        };
+        controller.signal.addEventListener("abort", releasePending, { once: true });
+        const abort = () => controller.abort();
+        if (signal?.aborted) abort();
+        else signal?.addEventListener("abort", abort, { once: true });
+        const cleanup = () => {
+          signal?.removeEventListener("abort", abort);
+          releasePending();
+        };
+        let scheduled;
+        try {
+          scheduled = options.schedule({
+            container,
+            strategy,
+            signal: controller.signal,
+            hydrate: 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 = originals?.[exportName];
+                if (typeof Component !== "function" && typeof Component !== "object") {
+                  throw new Error("compiled original export was not found");
+                }
+                const props = readBoundaryProps(container, boundaryId);
+                let rootFailure;
+                const restore = (error) => {
+                  if (rootFailure !== void 0) return;
+                  rootFailure = error;
+                  failRoot(container, reference, exportName, serverHTML, error);
+                  controller.abort();
+                };
+                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,
+                  Component,
+                  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();
+              }
+            }
+          });
+        } 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;
+      })
+    );
+  }
+  function updateModule(reference, module) {
+    const originals = module.__farm_client_boundary_originals__;
+    let updated = updateFarmServerTreeModule(reference, module);
+    for (const [container, record] of roots) {
+      if (record.reference !== reference) continue;
+      const Component = originals?.[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;
+  }
+  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 {
+        }
+        roots.delete(container);
+        container.removeAttribute("data-farm-hydrated");
+        container.removeAttribute("data-farm-island-hydrated");
+      }
+    }
+  }
+  return {
+    hydrate,
+    carryOver,
+    updateModule,
+    dispose,
+    rootCount: () => roots.size
+  };
+}
+function createFarmServerPageBoundary(ReactRuntime, runtime) {
+  return function FarmServerPage({ as = "div", ...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(ISLAND_SELECTOR));
+      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(as, { ...props, ref });
+  };
+}
+
+export {
+  wrapFarmIsolatedClientGraph,
+  isolateFarmServerPageGraph,
+  createFarmIsolatedClientBoundary,
+  createFarmIsolatedHydrationRuntime,
+  createFarmServerPageBoundary
+};