@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-MQ3H6LT5.cjs

@@ -0,0 +1,202 @@
+"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/after.ts
+var _async_hooks = require('async_hooks');
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getAfterStorage, "getAfterStorage");
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defaultAfterErrorReporter, "defaultAfterErrorReporter");
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch (e) {
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, reportAfterError, "reportAfterError");
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    }, "finishResponse"),
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createAfterRequestState, "createAfterRequestState");
+function registerPlatformLifetime(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _ => _.waitUntil])) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, registerPlatformLifetime, "registerPlatformLifetime");
+function registerResponseFinishedHook(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _2 => _2.onResponseFinished])) return false;
+  try {
+    context.onResponseFinished(state.finishResponse);
+    return true;
+  } catch (error) {
+    reportAfterError(state, error);
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, registerResponseFinishedHook, "registerResponseFinishedHook");
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, finishSoon, "finishSoon");
+function wrapResponseBody(response, request, state) {
+  if (request.method === "HEAD" || response.status < 200 || response.status > 599 || !response.body || response.bodyUsed || response.body.locked) {
+    finishSoon(state);
+    return response;
+  }
+  const reader = response.body.getReader();
+  let released = false;
+  const releaseReader = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  }, "releaseReader");
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReader();
+          controller.close();
+          finishSoon(state);
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        releaseReader();
+        controller.error(error);
+        finishSoon(state);
+      }
+    },
+    cancel(reason) {
+      try {
+        return reader.cancel(reason);
+      } finally {
+        releaseReader();
+        finishSoon(state);
+      }
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, wrapResponseBody, "wrapResponseBody");
+function after(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError("after() expects a callback function.");
+  }
+  const state = afterStorage.getStore();
+  if (!state) {
+    throw new Error("after() can only be used while Farm is handling a server request.");
+  }
+  if (state.phase === "closed") {
+    throw new Error("after() cannot schedule work after the request lifecycle has completed.");
+  }
+  let start;
+  const ready = new Promise((resolve) => {
+    start = resolve;
+  });
+  const result = ready.then(callback);
+  state.tasks.push({ result, start });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, after, "after");
+async function _runWithAfterRequest(request, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  registerPlatformLifetime(state, context);
+  const hasResponseHook = registerResponseFinishedHook(state, context);
+  try {
+    const response = await afterStorage.run(state, handler);
+    return hasResponseHook ? response : wrapResponseBody(response, request, state);
+  } catch (error) {
+    finishSoon(state);
+    throw error;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithAfterRequest, "_runWithAfterRequest");
+async function _runWithAfterNodeResponse(response, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  let finished = false;
+  const finish = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (finished) return;
+    finished = true;
+    response.off("finish", finish);
+    response.off("close", finish);
+    state.finishResponse();
+  }, "finish");
+  response.once("finish", finish);
+  response.once("close", finish);
+  if (response.writableEnded || response.destroyed) setTimeout(finish, 0);
+  registerPlatformLifetime(state, context);
+  return await afterStorage.run(state, handler);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithAfterNodeResponse, "_runWithAfterNodeResponse");
+function _withAfterNodeMiddleware(handler) {
+  return async (request, response, next) => {
+    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _withAfterNodeMiddleware, "_withAfterNodeMiddleware");
+
+
+
+
+
+
+exports.after = after; exports._runWithAfterRequest = _runWithAfterRequest; exports._runWithAfterNodeResponse = _runWithAfterNodeResponse; exports._withAfterNodeMiddleware = _withAfterNodeMiddleware;

package/dist/chunk-MT763TDW.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/build/production-node-env.ts
+var productionNodeEnvStateKey = /* @__PURE__ */ Symbol.for("@farm.js/core/production-node-env-state");
+function getProductionNodeEnvState() {
+  return Reflect.get(globalThis, productionNodeEnvStateKey);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getProductionNodeEnvState, "getProductionNodeEnvState");
+async function withProductionNodeEnv(operation) {
+  let state = getProductionNodeEnvState();
+  if (state) {
+    state.depth += 1;
+  } else {
+    state = {
+      depth: 1,
+      original: process.env.NODE_ENV
+    };
+    Reflect.set(globalThis, productionNodeEnvStateKey, state);
+  }
+  process.env.NODE_ENV = "production";
+  try {
+    return await operation();
+  } finally {
+    state.depth -= 1;
+    if (state.depth > 0) {
+      process.env.NODE_ENV = "production";
+    } else {
+      Reflect.deleteProperty(globalThis, productionNodeEnvStateKey);
+      if (state.original === void 0) {
+        delete process.env.NODE_ENV;
+      } else {
+        process.env.NODE_ENV = state.original;
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withProductionNodeEnv, "withProductionNodeEnv");
+
+
+
+exports.withProductionNodeEnv = withProductionNodeEnv;

package/dist/{chunk-XWAYMDLB.mjs → chunk-MVUREHPN.mjs}

@@ -1,6 +1,6 @@
 import {
   createFarmMarkdownRouteModule
-} from "./chunk-6VQIKZZO.mjs";
+} from "./chunk-N255VYFP.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";

package/dist/chunk-MWSK6C4J.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/island.ts
+var FARM_ISLAND_STRATEGIES = ["load", "interaction", "visible", "idle"];
+function isFarmIslandStrategy(value) {
+  return FARM_ISLAND_STRATEGIES.includes(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmIslandStrategy, "isFarmIslandStrategy");
+var FARM_ISLAND_ACTIVATION_EVENTS = ["click", "submit", "pointerdown", "focusin"];
+var FARM_ISLAND_REPLAYABLE_SELECTOR = 'button,[role="button"],input[type="button"],input[type="submit"],input[type="reset"]';
+
+
+
+
+
+exports.isFarmIslandStrategy = isFarmIslandStrategy; exports.FARM_ISLAND_ACTIVATION_EVENTS = FARM_ISLAND_ACTIVATION_EVENTS; exports.FARM_ISLAND_REPLAYABLE_SELECTOR = FARM_ISLAND_REPLAYABLE_SELECTOR;

package/dist/chunk-MWWVKDW3.cjs

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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/docs/search-client.ts
+var _fs = require('fs');
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function isFarmDocsSearchEnabled(docs) {
+  if (!_optionalChain([docs, 'optionalAccess', _ => _.enabled])) return false;
+  const search = docs.config.search;
+  if (search === false) return false;
+  return !(search && typeof search === "object" && search.enabled === false);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmDocsSearchEnabled, "isFarmDocsSearchEnabled");
+function resolveFarmDocsSearchClientModule(root) {
+  try {
+    const requireFromApp = _module.createRequire.call(void 0, _path2.default.join(_path2.default.resolve(root), "package.json"));
+    const themeEntry = requireFromApp.resolve("@farming-labs/theme");
+    const commandSearchModule = _path2.default.join(_path2.default.dirname(themeEntry), "docs-command-search.mjs");
+    if (_fs.existsSync.call(void 0, commandSearchModule)) return commandSearchModule;
+  } catch (e) {
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmDocsSearchClientModule, "resolveFarmDocsSearchClientModule");
+function generateFarmDocsSearchBootstrapRuntime() {
+  return `(()=>{if(window.__farmDocsSearchBootstrap)return;window.__farmDocsSearchBootstrap=true;const queue=(trigger,event)=>{if(window.__FARM_DOCS_SEARCH_BRIDGE_ACTIVE__)return;event.preventDefault();event.stopPropagation();event.stopImmediatePropagation();window.__FARM_DOCS_SEARCH_PENDING__=trigger;window.__FARM_MOUNT_DOCS_SEARCH__?.()};document.addEventListener("click",(event)=>{const target=event.target instanceof Element?event.target.closest("[data-search-full]"):null;if(target)queue("button",event)},true);document.addEventListener("keydown",(event)=>{if((event.metaKey||event.ctrlKey)&&event.key.toLowerCase()==="k")queue("keyboard",event)},true)})();`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, generateFarmDocsSearchBootstrapRuntime, "generateFarmDocsSearchBootstrapRuntime");
+function generateFarmDocsSearchClientRuntime(enabled, moduleId) {
+  if (!enabled || !moduleId) {
+    return `
+function isFarmDocsSearchPage() {
+  return false;
+}
+
+async function mountFarmDocsSearch() {
+  return false;
+}
+`;
+  }
+  return `
+let farmDocsSearchRoot = null;
+let farmDocsSearchContainer = null;
+let farmDocsSearchModulePromise = null;
+let farmDocsSearchPendingTrigger = window.__FARM_DOCS_SEARCH_PENDING__ === 'keyboard'
+  ? 'keyboard'
+  : window.__FARM_DOCS_SEARCH_PENDING__
+    ? 'button'
+    : null;
+let farmDocsSearchReady = false;
+
+function isFarmDocsSearchPage() {
+  return document.querySelector('[data-farm-docs-search-root]') instanceof HTMLElement;
+}
+
+function replayFarmDocsSearchOpen() {
+  const pendingTrigger = farmDocsSearchPendingTrigger;
+  farmDocsSearchPendingTrigger = null;
+  window.__FARM_DOCS_SEARCH_PENDING__ = null;
+  if (!pendingTrigger) return;
+
+  queueMicrotask(() => {
+    if (pendingTrigger === 'keyboard') {
+      document.dispatchEvent(
+        new KeyboardEvent('keydown', {
+          key: 'k',
+          metaKey: true,
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+    } else {
+      const trigger = document.querySelector('[data-search-full]');
+      if (trigger instanceof HTMLElement) trigger.click();
+    }
+  });
+}
+
+function FarmDocsSearchBridge({ component, api }) {
+  React.useEffect(() => {
+    farmDocsSearchReady = true;
+    replayFarmDocsSearchOpen();
+    return () => {
+      farmDocsSearchReady = false;
+    };
+  }, []);
+
+  return React.createElement(component, { api });
+}
+
+function queueFarmDocsSearchOpen(trigger, event) {
+  if (farmDocsSearchReady) return;
+  event.preventDefault();
+  event.stopPropagation();
+  event.stopImmediatePropagation();
+  farmDocsSearchPendingTrigger = trigger;
+  window.__FARM_DOCS_SEARCH_PENDING__ = trigger;
+  void mountFarmDocsSearch();
+}
+
+document.addEventListener(
+  'click',
+  (event) => {
+    const target = event.target instanceof Element
+      ? event.target.closest('[data-search-full]')
+      : null;
+    if (target) queueFarmDocsSearchOpen('button', event);
+  },
+  true,
+);
+
+document.addEventListener(
+  'keydown',
+  (event) => {
+    if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k') {
+      queueFarmDocsSearchOpen('keyboard', event);
+    }
+  },
+  true,
+);
+
+window.__FARM_DOCS_SEARCH_BRIDGE_ACTIVE__ = true;
+
+async function mountFarmDocsSearch() {
+  const container = document.querySelector('[data-farm-docs-search-root]');
+  if (!(container instanceof HTMLElement)) return false;
+  if (farmDocsSearchContainer === container && farmDocsSearchRoot) return true;
+
+  try {
+    farmDocsSearchModulePromise ||= import(${JSON.stringify(moduleId)});
+    const { DocsCommandSearch } = await farmDocsSearchModulePromise;
+    if (!container.isConnected) return false;
+
+    if (farmDocsSearchRoot) {
+      farmDocsSearchReady = false;
+      try {
+        farmDocsSearchRoot.unmount();
+      } catch {}
+    }
+
+    farmDocsSearchContainer = container;
+    farmDocsSearchRoot = createRoot(container);
+    farmDocsSearchRoot.render(
+      React.createElement(FarmDocsSearchBridge, {
+        component: DocsCommandSearch,
+        api: container.dataset.api || '/api/docs',
+      }),
+    );
+    return true;
+  } catch (error) {
+    farmDocsSearchModulePromise = null;
+    console.error('[Farm.js] Could not load docs search:', error);
+    return false;
+  }
+}
+
+window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, generateFarmDocsSearchClientRuntime, "generateFarmDocsSearchClientRuntime");
+
+
+
+
+
+
+exports.isFarmDocsSearchEnabled = isFarmDocsSearchEnabled; exports.resolveFarmDocsSearchClientModule = resolveFarmDocsSearchClientModule; exports.generateFarmDocsSearchBootstrapRuntime = generateFarmDocsSearchBootstrapRuntime; exports.generateFarmDocsSearchClientRuntime = generateFarmDocsSearchClientRuntime;

package/dist/{chunk-6VQIKZZO.mjs → chunk-N255VYFP.mjs}

@@ -1,6 +1,6 @@
 import {
   requestAcceptsMarkdown
-} from "./chunk-SXHV42UQ.mjs";
+} from "./chunk-OFEY6KHO.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";