@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-PZYCPSCC.cjs

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkFK6GO24Vcjs = require('./chunk-FK6GO24V.cjs');
+
+
+var _chunk7W3CPVXScjs = require('./chunk-7W3CPVXS.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/theme/client.tsx
+var _react = require('react');
+function getHydrationSnapshot() {
+  if (typeof window !== "undefined" && _optionalChain([window, 'access', _ => _.__FARM_THEME__, 'optionalAccess', _2 => _2.serverSnapshot])) {
+    return window.__FARM_THEME__.serverSnapshot;
+  }
+  return _chunk7W3CPVXScjs.getFarmThemeServerSnapshot.call(void 0, );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getHydrationSnapshot, "getHydrationSnapshot");
+function useTheme() {
+  const snapshot = _react.useSyncExternalStore.call(void 0, _chunkFK6GO24Vcjs.subscribeTheme, _chunkFK6GO24Vcjs.getTheme, getHydrationSnapshot);
+  return {
+    ...snapshot,
+    setTheme: _chunkFK6GO24Vcjs.setTheme,
+    toggleTheme: _chunkFK6GO24Vcjs.toggleTheme
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useTheme, "useTheme");
+
+
+
+exports.useTheme = useTheme;

package/dist/chunk-QBK2AA4U.cjs

@@ -0,0 +1,445 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/deferred.ts
+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;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defer, "defer");
+function isDeferred(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && value[FARM_DEFERRED_BRAND] === true
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isDeferred, "isDeferred");
+function prepareDeferredData(value) {
+  const context = createEncodingContext();
+  return {
+    data: encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet()),
+    records: context.records
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 (e) {
+        settlements[record.id] = createRejectedSettlement();
+      }
+    } else {
+      settlements[record.id] = createRejectedSettlement();
+    }
+  }
+  return settlements;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, snapshotDeferredData, "snapshotDeferredData");
+function reviveDeferredData(value, settlements) {
+  return reviveDeferredValue(value, /* @__PURE__ */ new Map(), settlements);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+        pending--;
+        if (!cancelled && pending === 0) controller.close();
+      }, "finishRecord");
+      const schedule = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, 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(_optionalChain([message, 'access', _ => _.error, 'optionalAccess', _2 => _2.message]))
+          );
+        }
+      }
+      const outstanding = rejectPendingDeferred(
+        controllers,
+        "Deferred route data stream ended before completion"
+      );
+      if (outstanding === 0) notifyDeferredComplete(options);
+    } catch (e2) {
+      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return data;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readDeferredDataResponse, "readDeferredDataResponse");
+function notifyDeferredComplete(options) {
+  try {
+    _optionalChain([options, 'access', _3 => _3.onComplete, 'optionalCall', _4 => _4()]);
+  } catch (e3) {
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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)
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _optionalChain([settlements, 'optionalAccess', _5 => _5[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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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" };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readDeferredState, "readDeferredState");
+function isDeferredMarker(value) {
+  return Boolean(
+    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertNotCircular, "assertNotCircular");
+function createDeferredPublicError() {
+  return {
+    code: FARM_DEFERRED_ERROR_CODE,
+    message: "Deferred route data failed to load"
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createDeferredPublicError, "createDeferredPublicError");
+function createRejectedSettlement() {
+  return { status: "rejected", error: createDeferredPublicError() };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRejectedSettlement, "createRejectedSettlement");
+function reportDeferredError(options, error, id) {
+  try {
+    _optionalChain([options, 'access', _6 => _6.onError, 'optionalCall', _7 => _7(error, id)]);
+  } catch (e4) {
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, reportDeferredError, "reportDeferredError");
+function encodeDeferredMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, encodeDeferredMessage, "encodeDeferredMessage");
+function parseDeferredMessage(line) {
+  try {
+    return JSON.parse(line);
+  } catch (e5) {
+    throw new DeferredDataError("Deferred route data response contains invalid JSON");
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, rejectPendingDeferred, "rejectPendingDeferred");
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_DEFERRED_CONTENT_TYPE = FARM_DEFERRED_CONTENT_TYPE; exports.FARM_DEFERRED_ERROR_CODE = FARM_DEFERRED_ERROR_CODE; exports.FARM_DEFERRED_BRAND = FARM_DEFERRED_BRAND; exports.DeferredDataError = DeferredDataError; exports.defer = defer; exports.isDeferred = isDeferred; exports.prepareDeferredData = prepareDeferredData; exports.snapshotDeferredData = snapshotDeferredData; exports.reviveDeferredData = reviveDeferredData; exports.createDeferredDataResponse = createDeferredDataResponse; exports.readDeferredDataResponse = readDeferredDataResponse;

package/dist/{chunk-UTBVHYS3.mjs → chunk-QBPKKQTD.mjs}

@@ -3,10 +3,10 @@ import {
   loadFarmDocsPage,
   resolveFarmDocsContentDir,
   toFarmDocsMarkdownPage
-} from "./chunk-5QOEPUYE.mjs";
+} from "./chunk-HSDL2AUR.mjs";
 import {
   resolveDocsConfig
-} from "./chunk-QGVJVSNX.mjs";
+} from "./chunk-V4AICMQA.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";