@farm.js/core 0.1.17 → 0.1.19

package/dist/after.cjs

@@ -1,226 +1,13 @@
-"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/after.ts
-var after_exports = {};
-__export(after_exports, {
-  _runWithAfterNodeResponse: () => _runWithAfterNodeResponse,
-  _runWithAfterRequest: () => _runWithAfterRequest,
-  _withAfterNodeMiddleware: () => _withAfterNodeMiddleware,
-  after: () => after
-});
-module.exports = __toCommonJS(after_exports);
-var import_node_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 import_node_async_hooks.AsyncLocalStorage) {
-    return existing;
-  }
-  const storage = new import_node_async_hooks.AsyncLocalStorage();
-  runtime[AFTER_STORAGE] = storage;
-  return storage;
-}
-__name(getAfterStorage, "getAfterStorage");
-var afterStorage = getAfterStorage();
-function defaultAfterErrorReporter(error) {
-  console.error("[Farm.js] after() callback failed:", error);
-}
-__name(defaultAfterErrorReporter, "defaultAfterErrorReporter");
-function reportAfterError(state, error) {
-  try {
-    state.reportError(error);
-  } catch {
-  }
-}
-__name(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__ */ __name(() => {
-      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;
-}
-__name(createAfterRequestState, "createAfterRequestState");
-function registerPlatformLifetime(state, context) {
-  if (!context?.waitUntil) return;
-  try {
-    context.waitUntil(state.completion);
-  } catch (error) {
-    reportAfterError(state, error);
-  }
-}
-__name(registerPlatformLifetime, "registerPlatformLifetime");
-function registerResponseFinishedHook(state, context) {
-  if (!context?.onResponseFinished) return false;
-  try {
-    context.onResponseFinished(state.finishResponse);
-    return true;
-  } catch (error) {
-    reportAfterError(state, error);
-    return false;
-  }
-}
-__name(registerResponseFinishedHook, "registerResponseFinishedHook");
-function finishSoon(state) {
-  setTimeout(state.finishResponse, 0);
-}
-__name(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__ */ __name(() => {
-    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
-  });
-}
-__name(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 });
-}
-__name(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;
-  }
-}
-__name(_runWithAfterRequest, "_runWithAfterRequest");
-async function _runWithAfterNodeResponse(response, handler, context) {
-  if (afterStorage.getStore()) {
-    return await handler();
-  }
-  const state = createAfterRequestState();
-  let finished = false;
-  const finish = /* @__PURE__ */ __name(() => {
-    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);
-}
-__name(_runWithAfterNodeResponse, "_runWithAfterNodeResponse");
-function _withAfterNodeMiddleware(handler) {
-  return async (request, response, next) => {
-    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
-  };
-}
-__name(_withAfterNodeMiddleware, "_withAfterNodeMiddleware");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  _runWithAfterNodeResponse,
-  _runWithAfterRequest,
-  _withAfterNodeMiddleware,
-  after
-});
+
+
+
+var _chunkMQ3H6LT5cjs = require('./chunk-MQ3H6LT5.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+exports._runWithAfterNodeResponse = _chunkMQ3H6LT5cjs._runWithAfterNodeResponse; exports._runWithAfterRequest = _chunkMQ3H6LT5cjs._runWithAfterRequest; exports._withAfterNodeMiddleware = _chunkMQ3H6LT5cjs._withAfterNodeMiddleware; exports.after = _chunkMQ3H6LT5cjs.after;