@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-x0y005nh.js

@@ -0,0 +1,283 @@
+// @bun
+// src/compat/segment/vary-params.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/compat/segment/vary-key.ts
+var SEARCH_PARAMS_SENTINEL = "?";
+
+// src/compat/segment/vary-params.ts
+function createSegmentVaryParamsAccumulator(kind = "page") {
+  const accumulator = {
+    kind,
+    varyParams: new Set,
+    status: "pending",
+    value: new Set,
+    then(onfulfilled) {
+      if (!onfulfilled)
+        return;
+      if (accumulator.status === "pending")
+        accumulator.resolvers.push(onfulfilled);
+      else
+        onfulfilled(accumulator.value);
+    },
+    resolvers: []
+  };
+  return accumulator;
+}
+var emptySet = new Set;
+var emptyVaryParamsAccumulator = {
+  kind: "page",
+  varyParams: emptySet,
+  status: "fulfilled",
+  value: emptySet,
+  then(onfulfilled) {
+    if (onfulfilled)
+      onfulfilled(emptySet);
+  },
+  resolvers: []
+};
+function createResponseVaryParamsAccumulator() {
+  return {
+    head: createSegmentVaryParamsAccumulator("head"),
+    rootParams: createSegmentVaryParamsAccumulator("root"),
+    segments: new Set
+  };
+}
+var VARY_PARAMS_GLOBALS = Symbol.for("pnext.compat.varyParamsGlobals");
+function varyGlobal(name, create) {
+  const root = globalThis;
+  const container = root[VARY_PARAMS_GLOBALS] ??= {};
+  if (!(name in container))
+    container[name] = create();
+  return container[name];
+}
+var varyStorage = varyGlobal("storage", () => new AsyncLocalStorage);
+function createVaryParamsAccumulator(kind = "page") {
+  const response = varyStorage.getStore();
+  if (!response)
+    return null;
+  const accumulator = createSegmentVaryParamsAccumulator(kind);
+  response.segments.add(accumulator);
+  return accumulator;
+}
+function getMetadataVaryParamsAccumulator() {
+  return varyStorage.getStore()?.head ?? null;
+}
+function getRootParamsVaryParamsAccumulator() {
+  return varyStorage.getStore()?.rootParams ?? null;
+}
+function accumulateVaryParam(accumulator, paramName) {
+  if (accumulator === emptyVaryParamsAccumulator)
+    return;
+  accumulator.varyParams.add(paramName);
+}
+function accumulateRootVaryParam(paramName) {
+  const accumulator = getRootParamsVaryParamsAccumulator();
+  if (accumulator !== null)
+    accumulateVaryParam(accumulator, paramName);
+}
+var VARY_TRACKING = Symbol.for("pnext.compat.varyTracking");
+function markVaryTracking(target, info) {
+  Object.defineProperty(target, VARY_TRACKING, {
+    value: info,
+    enumerable: false,
+    configurable: true
+  });
+}
+function varyTrackingInfo(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const info = value[VARY_TRACKING];
+  return info ?? null;
+}
+function createVaryingParams(accumulator, params, optionalCatchAllParamName = null) {
+  const originalParams = normalizeOptionalCatchAllParams(params, optionalCatchAllParamName);
+  const info = {
+    raw: originalParams,
+    kind: "params",
+    optionalCatchAllParam: optionalCatchAllParamName
+  };
+  if (optionalCatchAllParamName !== null) {
+    return new Proxy(originalParams, {
+      get(target, prop, receiver) {
+        if (prop === VARY_TRACKING)
+          return info;
+        if (typeof prop === "string" && (prop === optionalCatchAllParamName || Object.prototype.hasOwnProperty.call(target, prop))) {
+          accumulateVaryParam(accumulator, prop);
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      has(target, prop) {
+        if (prop === optionalCatchAllParamName) {
+          accumulateVaryParam(accumulator, optionalCatchAllParamName);
+        }
+        return Reflect.has(target, prop);
+      },
+      ownKeys(target) {
+        accumulateVaryParam(accumulator, optionalCatchAllParamName);
+        return Reflect.ownKeys(target);
+      }
+    });
+  }
+  const tracked = {};
+  for (const paramName in originalParams) {
+    Object.defineProperty(tracked, paramName, {
+      get() {
+        accumulateVaryParam(accumulator, paramName);
+        return originalParams[paramName];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  markVaryTracking(tracked, info);
+  return tracked;
+}
+function normalizeOptionalCatchAllParams(params, optionalCatchAllParamName) {
+  if (optionalCatchAllParamName === null)
+    return params;
+  const value = params[optionalCatchAllParamName];
+  if (!Array.isArray(value) || value.length > 0)
+    return params;
+  const { [optionalCatchAllParamName]: _empty, ...rest } = params;
+  return rest;
+}
+function createVaryingSearchParams(accumulator, originalSearchParams) {
+  const info = {
+    raw: originalSearchParams,
+    kind: "searchParams",
+    optionalCatchAllParam: null
+  };
+  return new Proxy(originalSearchParams, {
+    get(target, prop, receiver) {
+      if (prop === VARY_TRACKING)
+        return info;
+      if (typeof prop === "string" && !isPromiseProbe(target, prop)) {
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    has(target, prop) {
+      if (typeof prop === "string")
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      return Reflect.ownKeys(target);
+    }
+  });
+}
+function isPromiseProbe(target, prop) {
+  return prop === "then" && !Object.prototype.hasOwnProperty.call(target, prop);
+}
+function finishAccumulatingVaryParams(response) {
+  const rootVaryParams = response.rootParams.varyParams;
+  finishSegmentAccumulator(response.head, rootVaryParams);
+  for (const segment of response.segments)
+    finishSegmentAccumulator(segment, rootVaryParams);
+  finishSegmentAccumulator(response.rootParams, emptySet);
+}
+function finishSegmentAccumulator(accumulator, rootVaryParams) {
+  if (accumulator.status !== "pending")
+    return;
+  const merged = new Set(accumulator.varyParams);
+  for (const param of rootVaryParams)
+    merged.add(param);
+  accumulator.value = merged;
+  accumulator.status = "fulfilled";
+  const resolvers = accumulator.resolvers;
+  accumulator.resolvers = [];
+  for (const resolve of resolvers)
+    resolve(merged);
+}
+function collectResponseVaryParams(response) {
+  finishAccumulatingVaryParams(response);
+  const body = new Set;
+  const page = new Set;
+  const layout = new Set;
+  for (const segment of response.segments) {
+    const target = segment.kind === "layout" ? layout : page;
+    for (const name of segment.value) {
+      body.add(name);
+      target.add(name);
+    }
+  }
+  const head = new Set(response.head.value);
+  return {
+    params: sortedParamNames(body),
+    page: sortedParamNames(page),
+    layout: sortedParamNames(layout),
+    head: sortedParamNames(head),
+    root: sortedParamNames(response.rootParams.value),
+    search: body.has(SEARCH_PARAMS_SENTINEL),
+    pageSearch: page.has(SEARCH_PARAMS_SENTINEL),
+    layoutSearch: layout.has(SEARCH_PARAMS_SENTINEL),
+    headSearch: head.has(SEARCH_PARAMS_SENTINEL)
+  };
+}
+function sortedParamNames(set) {
+  return [...set].filter((name) => name !== SEARCH_PARAMS_SENTINEL).sort();
+}
+async function withVaryParamsTracking(produce) {
+  const outer = varyStorage.getStore();
+  if (outer)
+    return { value: await produce(), vary: collectResponseVaryParams(outer) };
+  const response = createResponseVaryParamsAccumulator();
+  const value = await varyStorage.run(response, produce);
+  return { value, vary: collectResponseVaryParams(response) };
+}
+function encodeVaryNames(names, search) {
+  return search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names];
+}
+function responseVaryParamsFromWire(wire) {
+  const split = (names) => ({
+    names: (names ?? []).filter((name) => name !== SEARCH_PARAMS_SENTINEL),
+    search: (names ?? []).includes(SEARCH_PARAMS_SENTINEL)
+  });
+  const body = split(wire.vary);
+  const layout = split(wire.layoutVary);
+  const page = split(wire.pageVary);
+  return {
+    params: body.names,
+    page: page.names,
+    layout: layout.names,
+    head: [],
+    root: [],
+    search: body.search,
+    pageSearch: page.search,
+    layoutSearch: layout.search,
+    headSearch: false
+  };
+}
+function varyNamesFor(vary, kind) {
+  switch (kind) {
+    case "head":
+      return encodeVaryNames(vary.head, vary.headSearch);
+    case "page":
+      return encodeVaryNames(vary.page, vary.pageSearch);
+    case "layout":
+      return encodeVaryNames(vary.layout, vary.layoutSearch);
+    default:
+      return encodeVaryNames(vary.params, vary.search);
+  }
+}
+
+// src/compat/static-params.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var GSP_SCOPE = Symbol.for("pnext.generateStaticParamsScope");
+var globals = globalThis;
+var gspScope = globals[GSP_SCOPE] ??= new AsyncLocalStorage2;
+function generateStaticParamsScope() {
+  return gspScope.getStore();
+}
+function aliasGenerateStaticParams(module) {
+  if (typeof module.params === "function" || typeof module.generateStaticParams !== "function") {
+    return module;
+  }
+  const generate = module.generateStaticParams;
+  const params = (args) => gspScope.run({ provided: args?.params ?? {} }, () => generate(args));
+  return { ...module, params };
+}
+
+export { createVaryParamsAccumulator, getMetadataVaryParamsAccumulator, accumulateRootVaryParam, varyTrackingInfo, createVaryingParams, normalizeOptionalCatchAllParams, createVaryingSearchParams, withVaryParamsTracking, responseVaryParamsFromWire, varyNamesFor, generateStaticParamsScope, aliasGenerateStaticParams };