@farm.js/core 0.1.42 → 0.1.43

package/dist/{chunk-YWMZUGIS.mjs → chunk-R3ZFQJEF.mjs}

@@ -1,12 +1,29 @@
 import {
+  getFarmActionId,
   markFarmClientReference,
   updateFarmServerTreeModule
-} from "./chunk-NRDBW4MP.mjs";
+} from "./chunk-7IQQIPRZ.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-2NXO5SBY.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.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");
@@ -23,6 +40,9 @@ function getBoundaryGraphContext(ReactRuntime) {
 }
 __name(getBoundaryGraphContext, "getBoundaryGraphContext");
 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");
@@ -31,6 +51,10 @@ function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
   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`);
   }
@@ -41,22 +65,143 @@ function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
   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");
     }
-    return Object.fromEntries(
+    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);
   }
 }
 __name(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");
+  return escapeScriptJson(JSON.stringify(serializeBoundaryProps(value)));
 }
 __name(serializeBoundaryPayload, "serializeBoundaryPayload");
+function escapeScriptJson(json) {
+  return json.replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(escapeScriptJson, "escapeScriptJson");
+var SLOT_ELEMENT = FARM_SLOT_ELEMENT;
+function isReactElementValue(value) {
+  const type = value?.$$typeof;
+  return type === REACT_ELEMENT_TYPE || type === LEGACY_REACT_ELEMENT_TYPE;
+}
+__name(isReactElementValue, "isReactElementValue");
+function slotReference(id) {
+  const reference = { [FARM_TAG]: FARM_SLOT_TAG, [FARM_TAG_VALUE]: id };
+  runtimeTagged.add(reference);
+  return reference;
+}
+__name(slotReference, "slotReference");
+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 };
+}
+__name(splitSlotProps, "splitSlotProps");
+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;
+}
+__name(reviveSlotProps, "reviveSlotProps");
 function wrapFarmIsolatedClientGraph(ReactRuntime, element) {
   const Context = getBoundaryGraphContext(ReactRuntime);
   return ReactRuntime.createElement(Context.Provider, { value: true }, element);
@@ -68,7 +213,7 @@ function isolateFarmServerPageGraph(ReactRuntime, element) {
 }
 __name(isolateFarmServerPageGraph, "isolateFarmServerPageGraph");
 var warnedUnserializableBoundaries = /* @__PURE__ */ new Set();
-function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReference, exportName, islandStrategy) {
+function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReference, exportName, islandStrategy, boundaryOptions = {}) {
   function FarmIsolatedClientBoundary(props) {
     const Context = getBoundaryGraphContext(ReactRuntime);
     const belongsToParentClientGraph = ReactRuntime.useContext(Context);
@@ -77,8 +222,30 @@ function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReferen
       return ReactRuntime.createElement(Component, props);
     }
     let serializedProps;
+    let renderProps = props;
+    let valueScripts = [];
     try {
-      serializedProps = serializeBoundaryPayload(props);
+      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}`;
@@ -93,24 +260,25 @@ function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReferen
     return ReactRuntime.createElement(
       ReactRuntime.Fragment,
       null,
+      ...valueScripts,
       ReactRuntime.createElement(
-        "farm-client-boundary",
+        FARM_ISLAND_ELEMENT,
         {
-          "data-farm-client-boundary": moduleReference,
-          "data-farm-client-id": boundaryId,
-          "data-farm-client-export": exportName,
-          "data-farm-island-strategy": islandStrategy,
+          src: moduleReference,
+          export: exportName,
+          props: boundaryId,
+          strategy: islandStrategy,
           style: { display: "contents" }
         },
         ReactRuntime.createElement(
           Context.Provider,
           { value: true },
-          ReactRuntime.createElement(Component, props)
+          ReactRuntime.createElement(Component, renderProps)
         )
       ),
       ReactRuntime.createElement("script", {
-        type: "application/json",
-        "data-farm-client-props": boundaryId,
+        type: FARM_PROPS_SCRIPT_TYPE,
+        htmlFor: boundaryId,
         dangerouslySetInnerHTML: { __html: serializedProps }
       })
     );
@@ -131,13 +299,13 @@ function isEarlyHydrationUpdate(error) {
 __name(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) {
+  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="application/json"][data-farm-client-props]'
+    `script[type="${FARM_PROPS_SCRIPT_TYPE}"]`
   )) {
-    if (candidate.getAttribute("data-farm-client-props") === boundaryId) return candidate;
+    if (candidate.getAttribute("for") === boundaryId) return candidate;
   }
   return null;
 }
@@ -191,23 +359,73 @@ function createFarmIsolatedHydrationRuntime(options) {
       )
     );
   }, "createBoundaryGraph");
-  async function hydrate(scope = document, signal) {
-    const candidates = Array.from(
-      scope.querySelectorAll("farm-client-boundary[data-farm-client-boundary]")
+  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
     );
-    if (scope instanceof Element && scope.matches("farm-client-boundary[data-farm-client-boundary]")) {
+  }
+  __name(readBoundaryProps, "readBoundaryProps");
+  const topLevelBoundaries = /* @__PURE__ */ __name((scope) => Array.from(scope.querySelectorAll(ISLAND_SELECTOR)).filter(
+    (container) => !container.parentElement?.closest(ISLAND_SELECTOR)
+  ), "topLevelBoundaries");
+  const boundaryKey = /* @__PURE__ */ __name((container) => `${container.getAttribute("src")}#${container.getAttribute("export") || "default"}`, "boundaryKey");
+  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;
+  }
+  __name(carryOver, "carryOver");
+  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("farm-client-boundary[data-farm-client-boundary]");
+      return !container.parentElement?.closest(ISLAND_SELECTOR);
     });
     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 = container.getAttribute("data-farm-island-strategy") ?? "load";
+        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;
@@ -242,12 +460,7 @@ function createFarmIsolatedHydrationRuntime(options) {
                 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");
-                }
+                const props = readBoundaryProps(container, boundaryId);
                 let rootFailure;
                 const restore = /* @__PURE__ */ __name((error) => {
                   if (rootFailure !== void 0) return;
@@ -271,6 +484,7 @@ function createFarmIsolatedHydrationRuntime(options) {
                 });
                 roots.set(container, {
                   root,
+                  Component,
                   dispose() {
                     disposing = true;
                     try {
@@ -361,6 +575,7 @@ function createFarmIsolatedHydrationRuntime(options) {
   __name(dispose, "dispose");
   return {
     hydrate,
+    carryOver,
     updateModule,
     dispose,
     rootCount: /* @__PURE__ */ __name(() => roots.size, "rootCount")
@@ -374,9 +589,7 @@ function createFarmServerPageBoundary(ReactRuntime, runtime) {
     ReactRuntime.useLayoutEffect(() => {
       const page = ref.current;
       if (!page) return;
-      const islands = Array.from(
-        page.querySelectorAll("farm-client-boundary[data-farm-client-boundary]")
-      );
+      const islands = Array.from(page.querySelectorAll(ISLAND_SELECTOR));
       if (islands.length === 0) return;
       const controller = new AbortController();
       runtime.hydrate(page, controller.signal).catch((error) => {