one/dist/cjs/vite/one-server-only.cjs

One is a new React Framework that makes Vite serve both native and web.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
    for (var name in all) __defProp(target, name, {
      get: all[name],
      enumerable: !0
    });
  },
  __copyProps = (to, from, except, desc) => {
    if (from && typeof from == "object" || typeof from == "function") for (let key2 of __getOwnPropNames(from)) !__hasOwnProp.call(to, key2) && key2 !== except && __defProp(to, key2, {
      get: () => from[key2],
      enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable
    });
    return to;
  };
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: !0
}), mod);
var one_server_only_exports = {};
__export(one_server_only_exports, {
  asyncHeadersCache: () => asyncHeadersCache,
  ensureAsyncLocalID: () => ensureAsyncLocalID,
  getServerContext: () => getServerContext,
  getServerData: () => getServerData,
  mergeHeaders: () => mergeHeaders,
  requestAsyncLocalStore: () => requestAsyncLocalStore,
  runWithAsyncLocalContext: () => runWithAsyncLocalContext,
  setResponseHeaders: () => setResponseHeaders,
  setServerContext: () => setServerContext,
  setServerData: () => setServerData,
  useServerContext: () => useServerContext
});
module.exports = __toCommonJS(one_server_only_exports);
var import_node_async_hooks = require("node:async_hooks"),
  import_constants = require("../constants.cjs");
const key = "__vxrnrequestAsyncLocalStore",
  read = () => globalThis[key],
  ASYNC_LOCAL_STORE = {
    get current() {
      if (read()) return read();
      const _ = new import_node_async_hooks.AsyncLocalStorage();
      return globalThis[key] = _, _;
    }
  },
  requestAsyncLocalStore = process.env.VITE_ENVIRONMENT === "ssr" ? ASYNC_LOCAL_STORE.current : null,
  newCache = /* @__PURE__ */new WeakMap(),
  asyncHeadersCache = globalThis.__vxrnasyncHeadersCache ?? newCache;
globalThis.__vxrnasyncHeadersCache ||= asyncHeadersCache;
async function runWithAsyncLocalContext(cb) {
  const id = {
    _id: Math.random()
  };
  let out = null;
  return await ASYNC_LOCAL_STORE.current.run(id, async () => {
    out = await cb(id);
  }), out;
}
async function setResponseHeaders(cb) {
  const id = ensureAsyncLocalID(),
    headers = asyncHeadersCache.get(id) ?? new Headers();
  asyncHeadersCache.set(id, headers), cb(headers);
}
function mergeHeaders(onto, from) {
  from.forEach((value, key2) => {
    value === void 0 || value === "undefined" ? onto.delete(key2) : onto.append(key2, value);
  });
}
const globalId = {
    _id: Math.random()
  },
  GLOBAL_ID_KEY = "__oneGlobalContextId";
globalThis[GLOBAL_ID_KEY] || (globalThis[GLOBAL_ID_KEY] = globalId);
function ensureAsyncLocalID() {
  const id = process.env.VERCEL ? globalThis[GLOBAL_ID_KEY] : requestAsyncLocalStore?.getStore();
  if (!id) throw new Error("Internal One error, no AsyncLocalStorage id!");
  return id;
}
const SERVER_CONTEXTS_KEY = "__oneServerContexts";
globalThis[SERVER_CONTEXTS_KEY] || (globalThis[SERVER_CONTEXTS_KEY] = /* @__PURE__ */new WeakMap());
const serverContexts = globalThis[SERVER_CONTEXTS_KEY];
function setServerContext(data) {
  if (process.env.VITE_ENVIRONMENT === "ssr") {
    const id = ensureAsyncLocalID();
    serverContexts.has(id) || serverContexts.set(id, {});
    const context = serverContexts.get(id);
    Object.assign(context, data);
  } else throw new Error("Don't call setServerContext on client");
}
function getServerContext() {
  return (() => {
    if (process.env.VITE_ENVIRONMENT === "ssr") {
      const id = ensureAsyncLocalID();
      return serverContexts.get(id);
    }
    return globalThis[import_constants.SERVER_CONTEXT_KEY];
  })();
}
function useServerContext() {
  if (process.env.VITE_ENVIRONMENT === "ssr") try {
    const useContext = globalThis.__vxrnGetContextFromReactContext;
    if (useContext) return serverContexts.get(useContext());
  } catch {}
  return getServerContext();
}
function setServerData(key2, value) {
  if (process.env.VITE_ENVIRONMENT === "ssr") {
    const context = getServerContext();
    setServerContext({
      postRenderData: {
        ...context?.postRenderData,
        [key2]: value
      }
    });
  } else throw new Error(`Cannot setServerData in ${process.env.VITE_ENVIRONMENT} environment!`);
}
function getServerData(key2) {
  if (process.env.VITE_ENVIRONMENT === "ssr") throw new Error("Cannot getServerData on the server");
  if (process.env.VITE_ENVIRONMENT !== "ssr") return getServerContext()?.postRenderData?.[key2];
}