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

package/dist/chunk-SVCUSOEF.mjs

@@ -1,590 +0,0 @@
-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
-};