@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/deferred.cjs

@@ -0,0 +1,438 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/deferred.ts
+var deferred_exports = {};
+__export(deferred_exports, {
+  DeferredDataError: () => DeferredDataError,
+  FARM_DEFERRED_BRAND: () => FARM_DEFERRED_BRAND,
+  FARM_DEFERRED_CONTENT_TYPE: () => FARM_DEFERRED_CONTENT_TYPE,
+  FARM_DEFERRED_ERROR_CODE: () => FARM_DEFERRED_ERROR_CODE,
+  createDeferredDataResponse: () => createDeferredDataResponse,
+  defer: () => defer,
+  isDeferred: () => isDeferred,
+  prepareDeferredData: () => prepareDeferredData,
+  readDeferredDataResponse: () => readDeferredDataResponse,
+  reviveDeferredData: () => reviveDeferredData,
+  snapshotDeferredData: () => snapshotDeferredData
+});
+module.exports = __toCommonJS(deferred_exports);
+var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+var FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+var FARM_DEFERRED_BRAND = /* @__PURE__ */ Symbol.for(
+  "farm.deferred"
+);
+var FARM_DEFERRED_MARKER = "$farmDeferred";
+var _DeferredDataError = class _DeferredDataError extends Error {
+  constructor(message = "Deferred route data failed to load") {
+    super(message);
+    this.name = "DeferredDataError";
+    this.code = FARM_DEFERRED_ERROR_CODE;
+  }
+};
+__name(_DeferredDataError, "DeferredDataError");
+var DeferredDataError = _DeferredDataError;
+var deferredStates = /* @__PURE__ */ new WeakMap();
+function defer(value) {
+  if (isDeferred(value)) {
+    return value;
+  }
+  const promise = Promise.resolve(value);
+  Object.defineProperty(promise, FARM_DEFERRED_BRAND, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+  deferredStates.set(promise, { status: "pending" });
+  promise.then(
+    (resolved) => deferredStates.set(promise, { status: "fulfilled", value: resolved }),
+    (reason) => deferredStates.set(promise, { status: "rejected", reason })
+  );
+  return promise;
+}
+__name(defer, "defer");
+function isDeferred(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && value[FARM_DEFERRED_BRAND] === true
+  );
+}
+__name(isDeferred, "isDeferred");
+function prepareDeferredData(value) {
+  const context = createEncodingContext();
+  return {
+    data: encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet()),
+    records: context.records
+  };
+}
+__name(prepareDeferredData, "prepareDeferredData");
+function snapshotDeferredData(records) {
+  const context = createEncodingContext(records);
+  const settlements = {};
+  for (let index = 0; index < context.records.length; index++) {
+    const record = context.records[index];
+    const state = readDeferredState(record.promise);
+    if (state.status === "fulfilled") {
+      try {
+        settlements[record.id] = {
+          status: "fulfilled",
+          value: encodeDeferredValue(state.value, context, /* @__PURE__ */ new WeakSet())
+        };
+      } catch {
+        settlements[record.id] = createRejectedSettlement();
+      }
+    } else {
+      settlements[record.id] = createRejectedSettlement();
+    }
+  }
+  return settlements;
+}
+__name(snapshotDeferredData, "snapshotDeferredData");
+function reviveDeferredData(value, settlements) {
+  return reviveDeferredValue(value, /* @__PURE__ */ new Map(), settlements);
+}
+__name(reviveDeferredData, "reviveDeferredData");
+function createDeferredDataResponse(value, init = {}, options = {}) {
+  const context = createEncodingContext();
+  const data = encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet());
+  const headers = new Headers(init.headers);
+  if (context.records.length === 0) {
+    headers.set("Content-Type", "application/json; charset=utf-8");
+    return new Response(JSON.stringify(data), { ...init, headers });
+  }
+  headers.set("Content-Type", `${FARM_DEFERRED_CONTENT_TYPE}; charset=utf-8`);
+  headers.set("Cache-Control", headers.get("Cache-Control") || "private, max-age=0");
+  const initialLine = encodeDeferredMessage({ type: "data", data });
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(initialLine));
+      let pending = context.records.length;
+      const finishRecord = /* @__PURE__ */ __name(() => {
+        pending--;
+        if (!cancelled && pending === 0) controller.close();
+      }, "finishRecord");
+      const schedule = /* @__PURE__ */ __name((record) => {
+        record.promise.then(
+          (resolved) => {
+            if (cancelled) return;
+            try {
+              const previousLength = context.records.length;
+              const encoded = encodeDeferredValue(resolved, context, /* @__PURE__ */ new WeakSet());
+              const nestedRecords = context.records.slice(previousLength);
+              pending += nestedRecords.length;
+              controller.enqueue(
+                encoder.encode(
+                  encodeDeferredMessage({ type: "resolve", id: record.id, data: encoded })
+                )
+              );
+              for (const nestedRecord of nestedRecords) schedule(nestedRecord);
+            } catch (error) {
+              reportDeferredError(options, error, record.id);
+              controller.enqueue(
+                encoder.encode(
+                  encodeDeferredMessage({
+                    type: "reject",
+                    id: record.id,
+                    error: createDeferredPublicError()
+                  })
+                )
+              );
+            }
+          },
+          (error) => {
+            if (cancelled) return;
+            reportDeferredError(options, error, record.id);
+            controller.enqueue(
+              encoder.encode(
+                encodeDeferredMessage({
+                  type: "reject",
+                  id: record.id,
+                  error: createDeferredPublicError()
+                })
+              )
+            );
+          }
+        ).finally(finishRecord);
+      }, "schedule");
+      const initialRecords = context.records.slice();
+      for (const record of initialRecords) schedule(record);
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return new Response(stream, { ...init, headers });
+}
+__name(createDeferredDataResponse, "createDeferredDataResponse");
+async function readDeferredDataResponse(response) {
+  const contentType = response.headers.get("Content-Type") || "";
+  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
+    return await response.json();
+  }
+  if (!response.body) {
+    throw new DeferredDataError("Deferred route data response has no body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const controllers = /* @__PURE__ */ new Map();
+  let buffer = "";
+  let complete = false;
+  const readLine = /* @__PURE__ */ __name(async () => {
+    while (true) {
+      const newline = buffer.indexOf("\n");
+      if (newline >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        return line;
+      }
+      if (complete) {
+        if (!buffer) return void 0;
+        const line = buffer;
+        buffer = "";
+        return line;
+      }
+      const chunk = await reader.read();
+      complete = chunk.done;
+      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+      if (chunk.done) buffer += decoder.decode();
+    }
+  }, "readLine");
+  const firstLine = await readLine();
+  if (!firstLine) {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is empty");
+  }
+  const initial = parseDeferredMessage(firstLine);
+  if (initial.type !== "data") {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is invalid");
+  }
+  const data = reviveDeferredValue(initial.data, controllers);
+  void (async () => {
+    try {
+      for (let line = await readLine(); line !== void 0; line = await readLine()) {
+        if (!line) continue;
+        const message = parseDeferredMessage(line);
+        if (message.type === "resolve") {
+          const controller = getControlledDeferred(message.id, controllers);
+          controller.resolve(reviveDeferredValue(message.data, controllers));
+        } else if (message.type === "reject") {
+          getControlledDeferred(message.id, controllers).reject(
+            new DeferredDataError(message.error?.message)
+          );
+        }
+      }
+      rejectPendingDeferred(controllers, "Deferred route data stream ended before completion");
+    } catch {
+      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return data;
+}
+__name(readDeferredDataResponse, "readDeferredDataResponse");
+function createEncodingContext(records = []) {
+  return {
+    records: [...records],
+    ids: new Map(records.map((record) => [record.promise, record.id])),
+    nextId: records.reduce((highest, record) => {
+      const value = Number(record.id.replace(/^d/, ""));
+      return Number.isFinite(value) ? Math.max(highest, value + 1) : highest;
+    }, records.length)
+  };
+}
+__name(createEncodingContext, "createEncodingContext");
+function encodeDeferredValue(value, context, ancestors) {
+  if (isDeferred(value)) {
+    let id = context.ids.get(value);
+    if (!id) {
+      id = `d${context.nextId++}`;
+      context.ids.set(value, id);
+      context.records.push({ id, promise: value });
+    }
+    return { [FARM_DEFERRED_MARKER]: id };
+  }
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    assertNotCircular(value, ancestors);
+    const output2 = value.map((item) => encodeDeferredValue(item, context, ancestors));
+    ancestors.delete(value);
+    return output2;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  assertNotCircular(value, ancestors);
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    output[key] = encodeDeferredValue(item, context, ancestors);
+  }
+  ancestors.delete(value);
+  return output;
+}
+__name(encodeDeferredValue, "encodeDeferredValue");
+function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
+  if (isDeferredMarker(value)) {
+    const id = value[FARM_DEFERRED_MARKER];
+    const controller = getControlledDeferred(id, controllers);
+    const settlement = settlements?.[id];
+    if (settlement && controller.promise.status === "pending") {
+      if (applyingSettlements.has(id)) return controller.promise;
+      applyingSettlements.add(id);
+      if (settlement.status === "fulfilled") {
+        controller.resolve(
+          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements)
+        );
+      } else {
+        controller.reject(new DeferredDataError(settlement.error.message));
+      }
+      applyingSettlements.delete(id);
+    } else if (settlements && controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError("Deferred route data was not resolved"));
+    }
+    return controller.promise;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => reviveDeferredValue(item, controllers, settlements, applyingSettlements)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    output[key] = reviveDeferredValue(item, controllers, settlements, applyingSettlements);
+  }
+  return output;
+}
+__name(reviveDeferredValue, "reviveDeferredValue");
+function getControlledDeferred(id, controllers) {
+  const existing = controllers.get(id);
+  if (existing) return existing;
+  let nativeResolve;
+  let nativeReject;
+  const promise = new Promise((resolve, reject) => {
+    nativeResolve = resolve;
+    nativeReject = reject;
+  });
+  promise.status = "pending";
+  promise.catch(() => void 0);
+  const controlled = {
+    promise,
+    resolve(value) {
+      if (promise.status !== "pending") return;
+      promise.status = "fulfilled";
+      promise.value = value;
+      nativeResolve(value);
+    },
+    reject(error) {
+      if (promise.status !== "pending") return;
+      promise.status = "rejected";
+      promise.reason = error;
+      nativeReject(error);
+    }
+  };
+  controllers.set(id, controlled);
+  return controlled;
+}
+__name(getControlledDeferred, "getControlledDeferred");
+function readDeferredState(promise) {
+  const tracked = deferredStates.get(promise);
+  if (tracked && tracked.status !== "pending") return tracked;
+  const reactState = promise;
+  if (reactState.status === "fulfilled") {
+    return { status: "fulfilled", value: reactState.value };
+  }
+  if (reactState.status === "rejected") {
+    return { status: "rejected", reason: reactState.reason };
+  }
+  return tracked || { status: "pending" };
+}
+__name(readDeferredState, "readDeferredState");
+function isDeferredMarker(value) {
+  return Boolean(
+    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
+  );
+}
+__name(isDeferredMarker, "isDeferredMarker");
+function assertNotCircular(value, ancestors) {
+  if (ancestors.has(value)) {
+    throw new TypeError("Deferred route data must be JSON-serializable and cannot be circular");
+  }
+  ancestors.add(value);
+}
+__name(assertNotCircular, "assertNotCircular");
+function createDeferredPublicError() {
+  return {
+    code: FARM_DEFERRED_ERROR_CODE,
+    message: "Deferred route data failed to load"
+  };
+}
+__name(createDeferredPublicError, "createDeferredPublicError");
+function createRejectedSettlement() {
+  return { status: "rejected", error: createDeferredPublicError() };
+}
+__name(createRejectedSettlement, "createRejectedSettlement");
+function reportDeferredError(options, error, id) {
+  try {
+    options.onError?.(error, id);
+  } catch {
+  }
+}
+__name(reportDeferredError, "reportDeferredError");
+function encodeDeferredMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+__name(encodeDeferredMessage, "encodeDeferredMessage");
+function parseDeferredMessage(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new DeferredDataError("Deferred route data response contains invalid JSON");
+  }
+}
+__name(parseDeferredMessage, "parseDeferredMessage");
+function rejectPendingDeferred(controllers, message) {
+  for (const controller of controllers.values()) {
+    if (controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError(message));
+    }
+  }
+}
+__name(rejectPendingDeferred, "rejectPendingDeferred");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeferredDataError,
+  FARM_DEFERRED_BRAND,
+  FARM_DEFERRED_CONTENT_TYPE,
+  FARM_DEFERRED_ERROR_CODE,
+  createDeferredDataResponse,
+  defer,
+  isDeferred,
+  prepareDeferredData,
+  readDeferredDataResponse,
+  reviveDeferredData,
+  snapshotDeferredData
+});
+//# sourceMappingURL=deferred.cjs.map

package/dist/deferred.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/deferred.ts"],"sourcesContent":["export const FARM_DEFERRED_CONTENT_TYPE = \"application/x-farm-deferred+json\";\nexport const FARM_DEFERRED_ERROR_CODE = \"FARM_DEFERRED_DATA_ERROR\";\nexport const FARM_DEFERRED_BRAND: unique symbol = Symbol.for(\n  \"farm.deferred\",\n) as typeof FARM_DEFERRED_BRAND;\n\nconst FARM_DEFERRED_MARKER = \"$farmDeferred\";\n\ntype DeferredState<T = unknown> =\n  | { status: \"pending\" }\n  | { status: \"fulfilled\"; value: T }\n  | { status: \"rejected\"; reason: unknown };\n\nexport interface Deferred<T> extends Promise<T> {\n  readonly [FARM_DEFERRED_BRAND]: true;\n}\n\nexport interface PreparedDeferredData {\n  data: unknown;\n  records: readonly DeferredRecord[];\n}\n\nexport interface DeferredRecord {\n  id: string;\n  promise: Deferred<unknown>;\n}\n\nexport type DeferredSettlement =\n  | { status: \"fulfilled\"; value: unknown }\n  | { status: \"rejected\"; error: { code: typeof FARM_DEFERRED_ERROR_CODE; message: string } };\n\nexport type DeferredSettlements = Record<string, DeferredSettlement>;\n\nexport interface DeferredDataResponseOptions {\n  onError?: (error: unknown, id: string) => void;\n}\n\nexport class DeferredDataError extends Error {\n  readonly name = \"DeferredDataError\";\n  readonly code = FARM_DEFERRED_ERROR_CODE;\n\n  constructor(message = \"Deferred route data failed to load\") {\n    super(message);\n  }\n}\n\nconst deferredStates = new WeakMap<object, DeferredState>();\n\nexport function defer<T>(value: PromiseLike<T>): Deferred<Awaited<T>> {\n  if (isDeferred(value)) {\n    return value as Deferred<Awaited<T>>;\n  }\n\n  const promise = Promise.resolve(value) as Deferred<Awaited<T>>;\n  Object.defineProperty(promise, FARM_DEFERRED_BRAND, {\n    configurable: false,\n    enumerable: false,\n    value: true,\n    writable: false,\n  });\n  deferredStates.set(promise, { status: \"pending\" });\n  promise.then(\n    (resolved) => deferredStates.set(promise, { status: \"fulfilled\", value: resolved }),\n    (reason) => deferredStates.set(promise, { status: \"rejected\", reason }),\n  );\n  return promise;\n}\n\nexport function isDeferred<T = unknown>(value: unknown): value is Deferred<T> {\n  return Boolean(\n    value &&\n    (typeof value === \"object\" || typeof value === \"function\") &&\n    (value as Record<PropertyKey, unknown>)[FARM_DEFERRED_BRAND] === true,\n  );\n}\n\nexport function prepareDeferredData(value: unknown): PreparedDeferredData {\n  const context = createEncodingContext();\n  return {\n    data: encodeDeferredValue(value, context, new WeakSet()),\n    records: context.records,\n  };\n}\n\nexport function snapshotDeferredData(records: readonly DeferredRecord[]): DeferredSettlements {\n  const context = createEncodingContext(records);\n  const settlements: DeferredSettlements = {};\n\n  for (let index = 0; index < context.records.length; index++) {\n    const record = context.records[index]!;\n    const state = readDeferredState(record.promise);\n\n    if (state.status === \"fulfilled\") {\n      try {\n        settlements[record.id] = {\n          status: \"fulfilled\",\n          value: encodeDeferredValue(state.value, context, new WeakSet()),\n        };\n      } catch {\n        settlements[record.id] = createRejectedSettlement();\n      }\n    } else {\n      settlements[record.id] = createRejectedSettlement();\n    }\n  }\n\n  return settlements;\n}\n\nexport function reviveDeferredData<T>(value: T, settlements: DeferredSettlements): T {\n  return reviveDeferredValue(value, new Map(), settlements) as T;\n}\n\nexport function createDeferredDataResponse(\n  value: unknown,\n  init: ResponseInit = {},\n  options: DeferredDataResponseOptions = {},\n): Response {\n  const context = createEncodingContext();\n  const data = encodeDeferredValue(value, context, new WeakSet());\n  const headers = new Headers(init.headers);\n\n  if (context.records.length === 0) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n    return new Response(JSON.stringify(data), { ...init, headers });\n  }\n\n  headers.set(\"Content-Type\", `${FARM_DEFERRED_CONTENT_TYPE}; charset=utf-8`);\n  headers.set(\"Cache-Control\", headers.get(\"Cache-Control\") || \"private, max-age=0\");\n  const initialLine = encodeDeferredMessage({ type: \"data\", data });\n  const encoder = new TextEncoder();\n  let cancelled = false;\n\n  const stream = new ReadableStream<Uint8Array>({\n    start(controller) {\n      controller.enqueue(encoder.encode(initialLine));\n      let pending = context.records.length;\n\n      const finishRecord = () => {\n        pending--;\n        if (!cancelled && pending === 0) controller.close();\n      };\n\n      const schedule = (record: DeferredRecord) => {\n        record.promise\n          .then(\n            (resolved) => {\n              if (cancelled) return;\n              try {\n                const previousLength = context.records.length;\n                const encoded = encodeDeferredValue(resolved, context, new WeakSet());\n                const nestedRecords = context.records.slice(previousLength);\n                pending += nestedRecords.length;\n                controller.enqueue(\n                  encoder.encode(\n                    encodeDeferredMessage({ type: \"resolve\", id: record.id, data: encoded }),\n                  ),\n                );\n                for (const nestedRecord of nestedRecords) schedule(nestedRecord);\n              } catch (error) {\n                reportDeferredError(options, error, record.id);\n                controller.enqueue(\n                  encoder.encode(\n                    encodeDeferredMessage({\n                      type: \"reject\",\n                      id: record.id,\n                      error: createDeferredPublicError(),\n                    }),\n                  ),\n                );\n              }\n            },\n            (error) => {\n              if (cancelled) return;\n              reportDeferredError(options, error, record.id);\n              controller.enqueue(\n                encoder.encode(\n                  encodeDeferredMessage({\n                    type: \"reject\",\n                    id: record.id,\n                    error: createDeferredPublicError(),\n                  }),\n                ),\n              );\n            },\n          )\n          .finally(finishRecord);\n      };\n\n      const initialRecords = context.records.slice();\n      for (const record of initialRecords) schedule(record);\n    },\n    cancel() {\n      cancelled = true;\n    },\n  });\n\n  return new Response(stream, { ...init, headers });\n}\n\nexport async function readDeferredDataResponse<T>(response: Response): Promise<T> {\n  const contentType = response.headers.get(\"Content-Type\") || \"\";\n  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {\n    return (await response.json()) as T;\n  }\n  if (!response.body) {\n    throw new DeferredDataError(\"Deferred route data response has no body\");\n  }\n\n  const reader = response.body.getReader();\n  const decoder = new TextDecoder();\n  const controllers = new Map<string, ControlledDeferred>();\n  let buffer = \"\";\n  let complete = false;\n\n  const readLine = async (): Promise<string | undefined> => {\n    while (true) {\n      const newline = buffer.indexOf(\"\\n\");\n      if (newline >= 0) {\n        const line = buffer.slice(0, newline);\n        buffer = buffer.slice(newline + 1);\n        return line;\n      }\n      if (complete) {\n        if (!buffer) return undefined;\n        const line = buffer;\n        buffer = \"\";\n        return line;\n      }\n\n      const chunk = await reader.read();\n      complete = chunk.done;\n      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });\n      if (chunk.done) buffer += decoder.decode();\n    }\n  };\n\n  const firstLine = await readLine();\n  if (!firstLine) {\n    reader.releaseLock();\n    throw new DeferredDataError(\"Deferred route data response is empty\");\n  }\n\n  const initial = parseDeferredMessage(firstLine);\n  if (initial.type !== \"data\") {\n    reader.releaseLock();\n    throw new DeferredDataError(\"Deferred route data response is invalid\");\n  }\n  const data = reviveDeferredValue(initial.data, controllers) as T;\n\n  void (async () => {\n    try {\n      for (let line = await readLine(); line !== undefined; line = await readLine()) {\n        if (!line) continue;\n        const message = parseDeferredMessage(line);\n        if (message.type === \"resolve\") {\n          const controller = getControlledDeferred(message.id, controllers);\n          controller.resolve(reviveDeferredValue(message.data, controllers));\n        } else if (message.type === \"reject\") {\n          getControlledDeferred(message.id, controllers).reject(\n            new DeferredDataError(message.error?.message),\n          );\n        }\n      }\n      rejectPendingDeferred(controllers, \"Deferred route data stream ended before completion\");\n    } catch {\n      rejectPendingDeferred(controllers, \"Deferred route data stream could not be read\");\n    } finally {\n      reader.releaseLock();\n    }\n  })();\n\n  return data;\n}\n\ninterface EncodingContext {\n  records: DeferredRecord[];\n  ids: Map<Deferred<unknown>, string>;\n  nextId: number;\n}\n\ninterface ControlledDeferred {\n  promise: Promise<unknown> & {\n    status?: \"pending\" | \"fulfilled\" | \"rejected\";\n    value?: unknown;\n    reason?: unknown;\n  };\n  resolve(value: unknown): void;\n  reject(error: unknown): void;\n}\n\nfunction createEncodingContext(records: readonly DeferredRecord[] = []): EncodingContext {\n  return {\n    records: [...records],\n    ids: new Map(records.map((record) => [record.promise, record.id])),\n    nextId: records.reduce((highest, record) => {\n      const value = Number(record.id.replace(/^d/, \"\"));\n      return Number.isFinite(value) ? Math.max(highest, value + 1) : highest;\n    }, records.length),\n  };\n}\n\nfunction encodeDeferredValue(\n  value: unknown,\n  context: EncodingContext,\n  ancestors: WeakSet<object>,\n): unknown {\n  if (isDeferred(value)) {\n    let id = context.ids.get(value);\n    if (!id) {\n      id = `d${context.nextId++}`;\n      context.ids.set(value, id);\n      context.records.push({ id, promise: value as Deferred<unknown> });\n    }\n    return { [FARM_DEFERRED_MARKER]: id };\n  }\n  if (!value || typeof value !== \"object\") return value;\n  if (Array.isArray(value)) {\n    assertNotCircular(value, ancestors);\n    const output = value.map((item) => encodeDeferredValue(item, context, ancestors));\n    ancestors.delete(value);\n    return output;\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (prototype !== Object.prototype && prototype !== null) return value;\n\n  assertNotCircular(value, ancestors);\n  const output: Record<string, unknown> = {};\n  for (const [key, item] of Object.entries(value)) {\n    output[key] = encodeDeferredValue(item, context, ancestors);\n  }\n  ancestors.delete(value);\n  return output;\n}\n\nfunction reviveDeferredValue(\n  value: unknown,\n  controllers: Map<string, ControlledDeferred>,\n  settlements?: DeferredSettlements,\n  applyingSettlements = new Set<string>(),\n): unknown {\n  if (isDeferredMarker(value)) {\n    const id = value[FARM_DEFERRED_MARKER];\n    const controller = getControlledDeferred(id, controllers);\n    const settlement = settlements?.[id];\n    if (settlement && controller.promise.status === \"pending\") {\n      if (applyingSettlements.has(id)) return controller.promise;\n      applyingSettlements.add(id);\n      if (settlement.status === \"fulfilled\") {\n        controller.resolve(\n          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements),\n        );\n      } else {\n        controller.reject(new DeferredDataError(settlement.error.message));\n      }\n      applyingSettlements.delete(id);\n    } else if (settlements && controller.promise.status === \"pending\") {\n      controller.reject(new DeferredDataError(\"Deferred route data was not resolved\"));\n    }\n    return controller.promise;\n  }\n  if (Array.isArray(value)) {\n    return value.map((item) =>\n      reviveDeferredValue(item, controllers, settlements, applyingSettlements),\n    );\n  }\n  if (!value || typeof value !== \"object\") return value;\n\n  const prototype = Object.getPrototypeOf(value);\n  if (prototype !== Object.prototype && prototype !== null) return value;\n  const output: Record<string, unknown> = {};\n  for (const [key, item] of Object.entries(value)) {\n    output[key] = reviveDeferredValue(item, controllers, settlements, applyingSettlements);\n  }\n  return output;\n}\n\nfunction getControlledDeferred(\n  id: string,\n  controllers: Map<string, ControlledDeferred>,\n): ControlledDeferred {\n  const existing = controllers.get(id);\n  if (existing) return existing;\n\n  let nativeResolve!: (value: unknown) => void;\n  let nativeReject!: (error: unknown) => void;\n  const promise = new Promise<unknown>((resolve, reject) => {\n    nativeResolve = resolve;\n    nativeReject = reject;\n  }) as ControlledDeferred[\"promise\"];\n  promise.status = \"pending\";\n  promise.catch(() => undefined);\n\n  const controlled: ControlledDeferred = {\n    promise,\n    resolve(value) {\n      if (promise.status !== \"pending\") return;\n      promise.status = \"fulfilled\";\n      promise.value = value;\n      nativeResolve(value);\n    },\n    reject(error) {\n      if (promise.status !== \"pending\") return;\n      promise.status = \"rejected\";\n      promise.reason = error;\n      nativeReject(error);\n    },\n  };\n  controllers.set(id, controlled);\n  return controlled;\n}\n\nfunction readDeferredState(promise: Deferred<unknown>): DeferredState {\n  const tracked = deferredStates.get(promise);\n  if (tracked && tracked.status !== \"pending\") return tracked;\n\n  const reactState = promise as Deferred<unknown> & {\n    status?: string;\n    value?: unknown;\n    reason?: unknown;\n  };\n  if (reactState.status === \"fulfilled\") {\n    return { status: \"fulfilled\", value: reactState.value };\n  }\n  if (reactState.status === \"rejected\") {\n    return { status: \"rejected\", reason: reactState.reason };\n  }\n  return tracked || { status: \"pending\" };\n}\n\nfunction isDeferredMarker(value: unknown): value is { [FARM_DEFERRED_MARKER]: string } {\n  return Boolean(\n    value &&\n    typeof value === \"object\" &&\n    Object.keys(value).length === 1 &&\n    typeof (value as Record<string, unknown>)[FARM_DEFERRED_MARKER] === \"string\",\n  );\n}\n\nfunction assertNotCircular(value: object, ancestors: WeakSet<object>): void {\n  if (ancestors.has(value)) {\n    throw new TypeError(\"Deferred route data must be JSON-serializable and cannot be circular\");\n  }\n  ancestors.add(value);\n}\n\nfunction createDeferredPublicError() {\n  return {\n    code: FARM_DEFERRED_ERROR_CODE,\n    message: \"Deferred route data failed to load\",\n  } as const;\n}\n\nfunction createRejectedSettlement(): DeferredSettlement {\n  return { status: \"rejected\", error: createDeferredPublicError() };\n}\n\nfunction reportDeferredError(\n  options: DeferredDataResponseOptions,\n  error: unknown,\n  id: string,\n): void {\n  try {\n    options.onError?.(error, id);\n  } catch {\n    // Error reporting must not break the response stream.\n  }\n}\n\nfunction encodeDeferredMessage(message: Record<string, unknown>): string {\n  return `${JSON.stringify(message)}\\n`;\n}\n\nfunction parseDeferredMessage(line: string): any {\n  try {\n    return JSON.parse(line);\n  } catch {\n    throw new DeferredDataError(\"Deferred route data response contains invalid JSON\");\n  }\n}\n\nfunction rejectPendingDeferred(\n  controllers: Map<string, ControlledDeferred>,\n  message: string,\n): void {\n  for (const controller of controllers.values()) {\n    if (controller.promise.status === \"pending\") {\n      controller.reject(new DeferredDataError(message));\n    }\n  }\n}\n"],"mappings":"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","names":["output"]}

package/dist/deferred.d.mts

@@ -0,0 +1,42 @@
+declare const FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+declare const FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+declare const FARM_DEFERRED_BRAND: unique symbol;
+interface Deferred<T> extends Promise<T> {
+    readonly [FARM_DEFERRED_BRAND]: true;
+}
+interface PreparedDeferredData {
+    data: unknown;
+    records: readonly DeferredRecord[];
+}
+interface DeferredRecord {
+    id: string;
+    promise: Deferred<unknown>;
+}
+type DeferredSettlement = {
+    status: "fulfilled";
+    value: unknown;
+} | {
+    status: "rejected";
+    error: {
+        code: typeof FARM_DEFERRED_ERROR_CODE;
+        message: string;
+    };
+};
+type DeferredSettlements = Record<string, DeferredSettlement>;
+interface DeferredDataResponseOptions {
+    onError?: (error: unknown, id: string) => void;
+}
+declare class DeferredDataError extends Error {
+    readonly name = "DeferredDataError";
+    readonly code = "FARM_DEFERRED_DATA_ERROR";
+    constructor(message?: string);
+}
+declare function defer<T>(value: PromiseLike<T>): Deferred<Awaited<T>>;
+declare function isDeferred<T = unknown>(value: unknown): value is Deferred<T>;
+declare function prepareDeferredData(value: unknown): PreparedDeferredData;
+declare function snapshotDeferredData(records: readonly DeferredRecord[]): DeferredSettlements;
+declare function reviveDeferredData<T>(value: T, settlements: DeferredSettlements): T;
+declare function createDeferredDataResponse(value: unknown, init?: ResponseInit, options?: DeferredDataResponseOptions): Response;
+declare function readDeferredDataResponse<T>(response: Response): Promise<T>;
+
+export { type Deferred, DeferredDataError, type DeferredDataResponseOptions, type DeferredRecord, type DeferredSettlement, type DeferredSettlements, FARM_DEFERRED_BRAND, FARM_DEFERRED_CONTENT_TYPE, FARM_DEFERRED_ERROR_CODE, type PreparedDeferredData, createDeferredDataResponse, defer, isDeferred, prepareDeferredData, readDeferredDataResponse, reviveDeferredData, snapshotDeferredData };

package/dist/deferred.d.ts

@@ -0,0 +1,42 @@
+declare const FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+declare const FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+declare const FARM_DEFERRED_BRAND: unique symbol;
+interface Deferred<T> extends Promise<T> {
+    readonly [FARM_DEFERRED_BRAND]: true;
+}
+interface PreparedDeferredData {
+    data: unknown;
+    records: readonly DeferredRecord[];
+}
+interface DeferredRecord {
+    id: string;
+    promise: Deferred<unknown>;
+}
+type DeferredSettlement = {
+    status: "fulfilled";
+    value: unknown;
+} | {
+    status: "rejected";
+    error: {
+        code: typeof FARM_DEFERRED_ERROR_CODE;
+        message: string;
+    };
+};
+type DeferredSettlements = Record<string, DeferredSettlement>;
+interface DeferredDataResponseOptions {
+    onError?: (error: unknown, id: string) => void;
+}
+declare class DeferredDataError extends Error {
+    readonly name = "DeferredDataError";
+    readonly code = "FARM_DEFERRED_DATA_ERROR";
+    constructor(message?: string);
+}
+declare function defer<T>(value: PromiseLike<T>): Deferred<Awaited<T>>;
+declare function isDeferred<T = unknown>(value: unknown): value is Deferred<T>;
+declare function prepareDeferredData(value: unknown): PreparedDeferredData;
+declare function snapshotDeferredData(records: readonly DeferredRecord[]): DeferredSettlements;
+declare function reviveDeferredData<T>(value: T, settlements: DeferredSettlements): T;
+declare function createDeferredDataResponse(value: unknown, init?: ResponseInit, options?: DeferredDataResponseOptions): Response;
+declare function readDeferredDataResponse<T>(response: Response): Promise<T>;
+
+export { type Deferred, DeferredDataError, type DeferredDataResponseOptions, type DeferredRecord, type DeferredSettlement, type DeferredSettlements, FARM_DEFERRED_BRAND, FARM_DEFERRED_CONTENT_TYPE, FARM_DEFERRED_ERROR_CODE, type PreparedDeferredData, createDeferredDataResponse, defer, isDeferred, prepareDeferredData, readDeferredDataResponse, reviveDeferredData, snapshotDeferredData };

package/dist/deferred.mjs

@@ -0,0 +1,28 @@
+import {
+  DeferredDataError,
+  FARM_DEFERRED_BRAND,
+  FARM_DEFERRED_CONTENT_TYPE,
+  FARM_DEFERRED_ERROR_CODE,
+  createDeferredDataResponse,
+  defer,
+  isDeferred,
+  prepareDeferredData,
+  readDeferredDataResponse,
+  reviveDeferredData,
+  snapshotDeferredData
+} from "./chunk-GS6K5OCM.mjs";
+import "./chunk-CGILA3WO.mjs";
+export {
+  DeferredDataError,
+  FARM_DEFERRED_BRAND,
+  FARM_DEFERRED_CONTENT_TYPE,
+  FARM_DEFERRED_ERROR_CODE,
+  createDeferredDataResponse,
+  defer,
+  isDeferred,
+  prepareDeferredData,
+  readDeferredDataResponse,
+  reviveDeferredData,
+  snapshotDeferredData
+};
+//# sourceMappingURL=deferred.mjs.map

package/dist/deferred.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}