@farm.js/core 0.1.17 → 0.1.18

package/dist/deferred.cjs

@@ -1,476 +1,27 @@
-"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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// 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, options = {}) {
-  const contentType = response.headers.get("Content-Type") || "";
-  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
-    const data2 = await response.json();
-    notifyDeferredComplete(options);
-    return data2;
-  }
-  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)
-          );
-        }
-      }
-      const outstanding = rejectPendingDeferred(
-        controllers,
-        "Deferred route data stream ended before completion"
-      );
-      if (outstanding === 0) notifyDeferredComplete(options);
-    } catch {
-      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return data;
-}
-__name(readDeferredDataResponse, "readDeferredDataResponse");
-function notifyDeferredComplete(options) {
-  try {
-    options.onComplete?.();
-  } catch {
-  }
-}
-__name(notifyDeferredComplete, "notifyDeferredComplete");
-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)) {
-    defineDataProperty(output, key, encodeDeferredValue(item, context, ancestors));
-  }
-  ancestors.delete(value);
-  if (isDeferredMarker(output)) {
-    return { [FARM_DEFERRED_MARKER]: `!${output[FARM_DEFERRED_MARKER]}` };
-  }
-  return output;
-}
-__name(encodeDeferredValue, "encodeDeferredValue");
-function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
-  if (isDeferredMarker(value)) {
-    const id = value[FARM_DEFERRED_MARKER];
-    if (id.startsWith("!")) {
-      return { [FARM_DEFERRED_MARKER]: id.slice(1) };
-    }
-    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)) {
-    defineDataProperty(
-      output,
-      key,
-      reviveDeferredValue(item, controllers, settlements, applyingSettlements)
-    );
-  }
-  return output;
-}
-__name(reviveDeferredValue, "reviveDeferredValue");
-function defineDataProperty(output, key, value) {
-  if (key === "__proto__") {
-    Object.defineProperty(output, key, {
-      value,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-  } else {
-    output[key] = value;
-  }
-}
-__name(defineDataProperty, "defineDataProperty");
-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) {
-  let rejected = 0;
-  for (const controller of controllers.values()) {
-    if (controller.promise.status === "pending") {
-      controller.reject(new DeferredDataError(message));
-      rejected += 1;
-    }
-  }
-  return rejected;
-}
-__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
-});
+
+
+
+
+
+
+
+
+
+
+var _chunkQBK2AA4Ucjs = require('./chunk-QBK2AA4U.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DeferredDataError = _chunkQBK2AA4Ucjs.DeferredDataError; exports.FARM_DEFERRED_BRAND = _chunkQBK2AA4Ucjs.FARM_DEFERRED_BRAND; exports.FARM_DEFERRED_CONTENT_TYPE = _chunkQBK2AA4Ucjs.FARM_DEFERRED_CONTENT_TYPE; exports.FARM_DEFERRED_ERROR_CODE = _chunkQBK2AA4Ucjs.FARM_DEFERRED_ERROR_CODE; exports.createDeferredDataResponse = _chunkQBK2AA4Ucjs.createDeferredDataResponse; exports.defer = _chunkQBK2AA4Ucjs.defer; exports.isDeferred = _chunkQBK2AA4Ucjs.isDeferred; exports.prepareDeferredData = _chunkQBK2AA4Ucjs.prepareDeferredData; exports.readDeferredDataResponse = _chunkQBK2AA4Ucjs.readDeferredDataResponse; exports.reviveDeferredData = _chunkQBK2AA4Ucjs.reviveDeferredData; exports.snapshotDeferredData = _chunkQBK2AA4Ucjs.snapshotDeferredData;