@uniformdev/next-app-router 20.80.2 → 20.81.1-alpha.10.sha-def425616f

package/dist/edge.mjs

@@ -0,0 +1,1191 @@
+// src/edge/uniformEdgeMiddleware.ts
+import { transformEdgeStream } from "@uniformdev/context-edge";
+import { NextResponse as NextResponse2 } from "next/server";
+
+// ../canvas/dist/index.mjs
+import { ApiClient } from "@uniformdev/context/api";
+import { ApiClientError } from "@uniformdev/context/api";
+import { ApiClientError as ApiClientError2 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient2 } from "@uniformdev/context/api";
+import { rewriteFiltersForApi } from "@uniformdev/context/api";
+import { rewriteFiltersForApi as rewriteFiltersForApi2 } from "@uniformdev/context/api";
+import { ApiClientError as ApiClientError3 } from "@uniformdev/context/api";
+import { rewriteFiltersForApi as rewriteFiltersForApi3 } from "@uniformdev/context/api";
+import { ApiClientError as ApiClientError4 } from "@uniformdev/context/api";
+import { rewriteFiltersForApi as rewriteFiltersForApi4 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient3, rewriteFiltersForApi as rewriteFiltersForApi5 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient4, rewriteFiltersForApi as rewriteFiltersForApi6 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient5 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient9 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient12 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient13 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient14 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient15 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient16 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient17 } from "@uniformdev/context/api";
+import { ApiClientError as ApiClientError5 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient18 } from "@uniformdev/context/api";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var SELECT_QUERY_PREFIX = "select.";
+function appendCsv(out, key, values) {
+  if (values === void 0) {
+    return;
+  }
+  out[key] = values.join(",");
+}
+function projectionToQuery(spec) {
+  const out = {};
+  if (!spec) {
+    return out;
+  }
+  const { fields, fieldTypes, slots } = spec;
+  const p = SELECT_QUERY_PREFIX;
+  if (fields) {
+    appendCsv(out, `${p}fields[only]`, fields.only);
+    appendCsv(out, `${p}fields[except]`, fields.except);
+    appendCsv(out, `${p}fields[locales]`, fields.locales);
+    if (fields.blockDepth === "preserveAll" || typeof fields.blockDepth === "number") {
+      out[`${p}fields[blockDepth]`] = String(fields.blockDepth);
+    }
+  }
+  if (fieldTypes) {
+    appendCsv(out, `${p}fieldTypes[only]`, fieldTypes.only);
+    appendCsv(out, `${p}fieldTypes[except]`, fieldTypes.except);
+  }
+  if (slots) {
+    appendCsv(out, `${p}slots[only]`, slots.only);
+    appendCsv(out, `${p}slots[except]`, slots.except);
+    if (typeof slots.depth === "number") {
+      out[`${p}slots[depth]`] = String(slots.depth);
+    }
+    if (slots.named) {
+      const slotNames = Object.keys(slots.named).sort();
+      for (const slotName of slotNames) {
+        const named = slots.named[slotName];
+        if (named && typeof named.depth === "number") {
+          out[`${p}slots.${slotName}[depth]`] = String(named.depth);
+        }
+      }
+    }
+  }
+  return out;
+}
+var CANVAS_DRAFT_STATE = 0;
+var CANVAS_PUBLISHED_STATE = 64;
+var CANVAS_EDITOR_STATE = 63;
+var CANVAS_INTERNAL_PARAM_PREFIX = "$internal_";
+var CANVAS_COMPONENT_DISPLAY_NAME_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}displayName`;
+var CANVAS_HYPOTHESIS_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}hypothesis`;
+var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
+var IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM = "is_incontext_editing_forced_settings";
+var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
+var _contentTypesUrl;
+var _entriesUrl;
+var _ContentClient = class _ContentClient2 extends ApiClient4 {
+  constructor(options) {
+    var _a;
+    super(options);
+    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
+  }
+  getContentTypes(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _contentTypesUrl), { ...options, projectId });
+    return this.apiClient(fetchUri);
+  }
+  getEntries(options) {
+    const { projectId } = this.options;
+    const { skipDataResolution, filters, select, ...params } = options;
+    const rewrittenFilters = rewriteFiltersForApi6(filters);
+    const rewrittenSelect = projectionToQuery(select);
+    if (skipDataResolution) {
+      const url = this.createUrl(__privateGet(_ContentClient2, _entriesUrl), {
+        ...params,
+        ...rewrittenFilters,
+        ...rewrittenSelect,
+        projectId
+      });
+      return this.apiClient(url);
+    }
+    const edgeUrl = this.createUrl(
+      __privateGet(_ContentClient2, _entriesUrl),
+      { ...this.getEdgeOptions(params), ...rewrittenFilters, ...rewrittenSelect },
+      this.edgeApiHost
+    );
+    return this.apiClient(
+      edgeUrl,
+      this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
+    );
+  }
+  /** Fetches historical versions of an entry */
+  async getEntryHistory(options) {
+    const historyUrl = this.createUrl("/api/v1/entries-history", {
+      ...options,
+      projectId: this.options.projectId
+    });
+    return this.apiClient(historyUrl);
+  }
+  async upsertContentType(body, opts = {}) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _contentTypesUrl));
+    if (typeof body.contentType.slugSettings === "object" && body.contentType.slugSettings !== null && Object.keys(body.contentType.slugSettings).length === 0) {
+      delete body.contentType.slugSettings;
+    }
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers: opts.autogenerateDataTypes ? { "x-uniform-autogenerate-data-types": "true" } : {}
+    });
+  }
+  async upsertEntry(body, options) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _entriesUrl));
+    const headers = {};
+    if (options == null ? void 0 : options.ifUnmodifiedSince) {
+      headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
+    }
+    const { response } = await this.apiClientWithResponse(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers
+    });
+    return { modified: response.headers.get("x-modified-at") };
+  }
+  async deleteContentType(body) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _contentTypesUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  async deleteEntry(body) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _entriesUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  getEdgeOptions(options) {
+    const { projectId } = this.options;
+    const { skipDataResolution, ...params } = options;
+    return {
+      projectId,
+      ...params,
+      diagnostics: typeof options.diagnostics === "boolean" ? options.diagnostics : options.diagnostics === "no-data" ? "no-data" : void 0
+    };
+  }
+};
+_contentTypesUrl = /* @__PURE__ */ new WeakMap();
+_entriesUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_ContentClient, _contentTypesUrl, "/api/v1/content-types");
+__privateAdd(_ContentClient, _entriesUrl, "/api/v1/entries");
+var _url;
+var _DataTypeClient = class _DataTypeClient2 extends ApiClient6 {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches a list of DataTypes for a project */
+  async list(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_DataTypeClient2, _url), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
+  /** Updates or creates (based on id) a DataType */
+  async save(body) {
+    const fetchUri = this.createUrl(__privateGet(_DataTypeClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
+  /** Deletes a DataType */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_DataTypeClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url = /* @__PURE__ */ new WeakMap();
+__privateAdd(_DataTypeClient, _url, "/api/v1/data-types");
+var _baseUrl;
+var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2 extends ApiClient8 {
+  constructor(options) {
+    super(options);
+    this.teamId = options.teamId;
+  }
+  /**
+   * Gets a list of property type and hook names for the current team, including public integrations' hooks.
+   */
+  get(options) {
+    const fetchUri = this.createUrl(__privateGet(_IntegrationPropertyEditorsClient2, _baseUrl), {
+      ...options,
+      teamId: this.teamId
+    });
+    return this.apiClient(fetchUri);
+  }
+  /**
+   * Creates or updates a custom AI property editor on a Mesh app.
+   */
+  async deploy(body) {
+    const fetchUri = this.createUrl(__privateGet(_IntegrationPropertyEditorsClient2, _baseUrl));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, teamId: this.teamId }),
+      expectNoContent: true
+    });
+  }
+  /**
+   * Removes a custom AI property editor from a Mesh app.
+   */
+  async delete(body) {
+    const fetchUri = this.createUrl(__privateGet(_IntegrationPropertyEditorsClient2, _baseUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, teamId: this.teamId }),
+      expectNoContent: true
+    });
+  }
+};
+_baseUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-property-editors");
+var _url2;
+var _projectsUrl;
+var _ProjectClient = class _ProjectClient2 extends ApiClient12 {
+  constructor(options) {
+    super({ ...options, bypassCache: true });
+  }
+  /** Fetches single Project */
+  async get(options) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _url2), { ...options });
+    return await this.apiClient(fetchUri);
+  }
+  /**
+   * Fetches projects grouped by team.
+   * When teamId is provided, returns a single team with its projects.
+   * When omitted, returns all accessible teams and their projects.
+   */
+  async list(options) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _projectsUrl), options ? { ...options } : {});
+    return await this.apiClient(fetchUri);
+  }
+  /** @deprecated Use {@link list} instead. */
+  async getProjects(options) {
+    return this.list(options);
+  }
+  /** Updates or creates (based on id) a Project */
+  async save(body) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _url2));
+    return await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body })
+    });
+  }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
+  /** Deletes a Project */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _url2));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link remove} instead. */
+  async delete(body) {
+    return this.remove(body);
+  }
+};
+_url2 = /* @__PURE__ */ new WeakMap();
+_projectsUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_ProjectClient, _url2, "/api/v1/project");
+__privateAdd(_ProjectClient, _projectsUrl, "/api/v1/projects");
+
+// src/middleware.ts
+import {
+  Context,
+  CookieTransitionDataStore,
+  UNIFORM_DEFAULT_COOKIE_NAME,
+  UNIFORM_DEFAULT_QUIRK_COOKIE_NAME
+} from "@uniformdev/context";
+import {
+  serializeEvaluationResult,
+  UNIFORM_MIDDLEWARE_QUIRK_COOKIE_NAME
+} from "@uniformdev/next-app-router-shared";
+import { draftMode } from "next/headers";
+import { NextResponse } from "next/server";
+
+// src/config/helpers.ts
+import config from "@uniformdev/next-app-router/config/resolved";
+var getServerConfig = () => {
+  return config;
+};
+var getDefaultConsent = () => {
+  if (typeof config.defaultConsent === "boolean") {
+    return config.defaultConsent;
+  }
+  return false;
+};
+var getQuirkSerialization = () => {
+  if (typeof config.quirkSerialization === "boolean") {
+    return config.quirkSerialization;
+  }
+  return true;
+};
+var getPlaygroundPath = () => {
+  if (typeof config.playgroundPath === "string") {
+    return config.playgroundPath;
+  }
+  return "/uniform/playground";
+};
+
+// src/data/routes.ts
+var findRouteMatch = (routes, path) => {
+  const pieces = path.split("/").filter(Boolean);
+  for (const route of routes) {
+    const patternPieces = route.pattern.split("/").filter(Boolean);
+    if (patternPieces.length !== pieces.length) {
+      continue;
+    }
+    let match = true;
+    const params = {};
+    for (let i = 0; i < patternPieces.length; i++) {
+      const patternPiece = patternPieces[i];
+      const piece = pieces[i];
+      if (patternPiece.startsWith(":")) {
+        const paramName = patternPiece.slice(1);
+        params[paramName] = piece;
+      } else if (patternPiece !== piece) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return void 0;
+};
+
+// src/utils/draft.ts
+var isDraftModeEnabled = ({
+  draftModeEnabled
+}) => {
+  return draftModeEnabled;
+};
+var isIncontextEditingEnabled = ({
+  isDraftModeEnabled: isDraftModeEnabled2,
+  searchParams
+}) => {
+  if (!isDraftModeEnabled2) {
+    return false;
+  }
+  const containsKey = searchParams.has(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM);
+  return containsKey;
+};
+var isDevelopmentEnvironment = () => {
+  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+};
+
+// src/utils/quirks.ts
+var buildQuirksFromHeaders = (headers) => {
+  const headerToQuirkKey = {
+    "x-vercel-ip-country": "vc-country",
+    "x-vercel-ip-country-region": "vc-region",
+    "x-vercel-ip-city": "vc-city"
+  };
+  return Object.entries(headerToQuirkKey).reduce((acc, [headerName, quirkKey]) => {
+    const value = headers.get(headerName);
+    if (value) {
+      acc[quirkKey] = value;
+    }
+    return acc;
+  }, {});
+};
+
+// src/middleware.ts
+var resolveUniformRequest = async ({
+  request,
+  edgeMode,
+  ...options
+}) => {
+  const draftModeEnabled = (await draftMode()).isEnabled;
+  if (draftModeEnabled && isPlaygroundPath(request.nextUrl.pathname)) {
+    return handlePlaygroundRequest({ request, options });
+  }
+  return resolveRouteRequest({ request, draftModeEnabled, edgeMode, options });
+};
+var isPlaygroundPath = (path) => {
+  const { playgroundPath } = getServerConfig();
+  if (!playgroundPath) {
+    return false;
+  }
+  const PLAYGROUND_ID = "playground";
+  const match = findRouteMatch(
+    [
+      {
+        id: PLAYGROUND_ID,
+        pattern: playgroundPath
+      }
+    ],
+    path
+  );
+  return (match == null ? void 0 : match.route.id) === PLAYGROUND_ID;
+};
+var handlePlaygroundRequest = async ({
+  request,
+  options
+}) => {
+  var _a, _b;
+  const id = request.nextUrl.searchParams.get("id");
+  if (!id) {
+    return {
+      type: "response",
+      response: NextResponse.json({ error: "No id provided" }, { status: 400 })
+    };
+  }
+  const playgroundPath = getPlaygroundPath();
+  const pageState = {
+    routePath: id,
+    compositionState: CANVAS_EDITOR_STATE,
+    keys: void 0,
+    releaseId: (_a = options.release) == null ? void 0 : _a.id,
+    defaultConsent: determineDefaultConsent({
+      serverConfig: getServerConfig(),
+      defaultConsent: options.defaultConsent
+    }),
+    previewMode: determinePreviewMode({
+      searchParams: request.nextUrl.searchParams,
+      isDraftModeEnabled: true
+    }),
+    locale: options.locale
+  };
+  const code = serializeEvaluationResult({ payload: pageState });
+  const destination = await ((_b = options.rewriteDestinationPath) == null ? void 0 : _b.call(options, { code, pageState, source: "playground" })) || `${playgroundPath}${playgroundPath.endsWith("/") ? "" : "/"}${code}`;
+  return {
+    type: "response",
+    response: NextResponse.rewrite(new URL(destination, request.nextUrl.origin))
+  };
+};
+var resolveRouteRequest = async ({
+  request,
+  draftModeEnabled,
+  edgeMode,
+  options
+}) => {
+  var _a, _b, _c, _d, _e;
+  const releaseId = (_b = (_a = options.release) == null ? void 0 : _a.id) != null ? _b : draftModeEnabled ? request.nextUrl.searchParams.get("releaseId") || void 0 : void 0;
+  const requestPath = (_d = await ((_c = options.rewriteRequestPath) == null ? void 0 : _c.call(options, {
+    request,
+    url: new URL(request.url)
+  }))) != null ? _d : {
+    path: `${request.nextUrl.pathname}${request.nextUrl.search}`
+  };
+  const defaultConsent = determineDefaultConsent({
+    serverConfig: getServerConfig(),
+    defaultConsent: options.defaultConsent
+  });
+  const pageState = {
+    routePath: buildRoutePath({ path: requestPath.path, queryStrings: options.queryStrings }),
+    compositionState: determineCompositionState({
+      searchParams: request.nextUrl.searchParams,
+      draftModeEnabled
+    }),
+    keys: requestPath.keys,
+    releaseId,
+    defaultConsent,
+    previewMode: determinePreviewMode({
+      searchParams: request.nextUrl.searchParams,
+      isDraftModeEnabled: draftModeEnabled
+    }),
+    locale: options.locale
+  };
+  if (edgeMode && pageState.compositionState === CANVAS_PUBLISHED_STATE && await edgeMode({ pageState })) {
+    pageState.edgeMode = true;
+  }
+  const code = serializeEvaluationResult({ payload: pageState });
+  const destination = await ((_e = options.rewriteDestinationPath) == null ? void 0 : _e.call(options, { code, pageState, source: "route" })) || `/uniform/${code}`;
+  const quirks = {
+    ...buildQuirksFromHeaders(request.headers),
+    ...options.quirks
+  };
+  const headers = new Headers();
+  if (Object.keys(quirks).length > 0) {
+    headers.append(
+      "Set-Cookie",
+      `${UNIFORM_MIDDLEWARE_QUIRK_COOKIE_NAME}=${JSON.stringify(quirks)}; Path=/; SameSite=Lax; Max-Age=10`
+    );
+  }
+  const createContext = async ({ manifest }) => {
+    var _a2, _b2, _c2, _d2;
+    const context = new Context({
+      manifest,
+      defaultConsent: defaultConsent != null ? defaultConsent : getDefaultConsent(),
+      transitionStore: new CookieTransitionDataStore({
+        serverCookieValue: (_b2 = (_a2 = request.cookies.get(UNIFORM_DEFAULT_COOKIE_NAME)) == null ? void 0 : _a2.value) != null ? _b2 : "",
+        experimental_quirksEnabled: getQuirkSerialization(),
+        quirkCookieValue: (_d2 = (_c2 = request.cookies.get(UNIFORM_DEFAULT_QUIRK_COOKIE_NAME)) == null ? void 0 : _c2.value) != null ? _d2 : ""
+      })
+    });
+    await context.update({
+      url: new URL(request.nextUrl.href),
+      cookies: Object.fromEntries(request.cookies.getAll().map((cookie) => [cookie.name, cookie.value])),
+      quirks
+    });
+    return context;
+  };
+  return {
+    type: "rewrite",
+    destination,
+    pageState,
+    code,
+    headers,
+    draftModeEnabled,
+    createContext
+  };
+};
+var buildRoutePath = ({
+  path,
+  queryStrings
+}) => {
+  const [pathname = "", search] = path.split("?");
+  if (!search || !queryStrings) {
+    return pathname;
+  }
+  const patterns = Object.keys(queryStrings);
+  const match = findRouteMatch(
+    patterns.map((pattern) => ({ id: pattern, pattern })),
+    pathname
+  );
+  const allowed = match ? queryStrings[match.route.id] : void 0;
+  if (!(allowed == null ? void 0 : allowed.length)) {
+    return pathname;
+  }
+  const requestSearchParams = new URLSearchParams(search);
+  const searchParams = new URLSearchParams();
+  [...allowed].sort().forEach((name) => {
+    const value = requestSearchParams.get(name);
+    if (value !== null) {
+      searchParams.set(name, value);
+    }
+  });
+  return searchParams.size ? `${pathname}?${searchParams.toString()}` : pathname;
+};
+var determineCompositionState = ({
+  searchParams,
+  draftModeEnabled
+}) => {
+  if (!draftModeEnabled) {
+    return CANVAS_PUBLISHED_STATE;
+  }
+  return isIncontextEditingEnabled({ isDraftModeEnabled: draftModeEnabled, searchParams }) ? CANVAS_EDITOR_STATE : CANVAS_DRAFT_STATE;
+};
+var determineDefaultConsent = ({
+  serverConfig,
+  defaultConsent
+}) => {
+  return defaultConsent !== serverConfig.defaultConsent ? defaultConsent : void 0;
+};
+var determinePreviewMode = ({
+  searchParams,
+  isDraftModeEnabled: isDraftModeEnabled2
+}) => {
+  if (!isDraftModeEnabled2) {
+    return void 0;
+  }
+  const queryStringSettings = searchParams.get(IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM);
+  let previewSettings = void 0;
+  if (queryStringSettings) {
+    try {
+      previewSettings = JSON.parse(queryStringSettings);
+    } catch (e) {
+    }
+  }
+  if (previewSettings == null ? void 0 : previewSettings.isVisualEditingDisabled) {
+    return "preview";
+  }
+  const isInContextEditingEnabled = isIncontextEditingEnabled({ isDraftModeEnabled: isDraftModeEnabled2, searchParams });
+  if (isInContextEditingEnabled) {
+    return "editor";
+  }
+  return void 0;
+};
+
+// src/edge/uniformEdgeMiddleware.ts
+var UNIFORM_EDGE_ORIGIN_HEADER = "x-uniform-edge-origin";
+var uniformEdgeMiddleware = (options) => {
+  return async (request, event) => {
+    return handleUniformEdgeRoute({
+      request,
+      waitUntil: event ? (promise) => event.waitUntil(promise) : void 0,
+      ...options
+    });
+  };
+};
+var handleUniformEdgeRoute = async ({
+  request,
+  manifest,
+  onError,
+  filter,
+  waitUntil = ignorePromise,
+  ...options
+}) => {
+  var _a;
+  if (request.headers.has(UNIFORM_EDGE_ORIGIN_HEADER)) {
+    return NextResponse2.next();
+  }
+  const result = await resolveUniformRequest({
+    request,
+    ...options,
+    edgeMode: ({ pageState }) => filter ? filter.shouldProcess({ pageState, waitUntil }) : true
+  });
+  if (result.type === "response") {
+    return result.response;
+  }
+  const destination = new URL(result.destination, request.nextUrl.origin);
+  if (!result.pageState.edgeMode || !isDocumentRequest(request)) {
+    return NextResponse2.rewrite(destination, { headers: result.headers });
+  }
+  const [originResponse, context] = await Promise.all([
+    fetch(destination, {
+      // A page that calls `redirect()` answers with a redirect, which belongs to the visitor.
+      redirect: "manual",
+      headers: {
+        cookie: (_a = request.headers.get("cookie")) != null ? _a : "",
+        accept: "text/html",
+        // Node's fetch decompresses the body but keeps the header, so ask for plain HTML.
+        "accept-encoding": "identity",
+        [UNIFORM_EDGE_ORIGIN_HEADER]: "1"
+      }
+    }),
+    resolveManifest({ manifest, waitUntil, onError }).then(
+      (resolved) => result.createContext({ manifest: resolved })
+    )
+  ]);
+  const headers = new Headers(originResponse.headers);
+  result.headers.forEach((value, key) => {
+    headers.append(key, value);
+  });
+  if (originResponse.status >= 300 && originResponse.status < 400) {
+    return new Response(originResponse.body, {
+      status: originResponse.status,
+      statusText: originResponse.statusText,
+      headers
+    });
+  }
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  headers.set("cache-control", "private, no-store");
+  const observe = filter == null ? void 0 : filter.observe;
+  const onComplete = observe && originResponse.status === 200 ? (hasPlacements) => observe({ pageState: result.pageState, hasPlacements, waitUntil }) : void 0;
+  return new Response(transformBody({ body: originResponse.body, context, onError, onComplete }), {
+    status: originResponse.status,
+    statusText: originResponse.statusText,
+    headers
+  });
+};
+var ignorePromise = (promise) => {
+  promise.catch(() => {
+  });
+};
+var EMPTY_MANIFEST = { project: {} };
+var resolveManifest = async ({
+  manifest,
+  waitUntil,
+  onError
+}) => {
+  if (typeof manifest !== "function") {
+    return manifest;
+  }
+  try {
+    return await manifest({ waitUntil });
+  } catch (error) {
+    onError == null ? void 0 : onError({ error });
+    return EMPTY_MANIFEST;
+  }
+};
+var isDocumentRequest = (request) => {
+  const accept = request.headers.get("accept");
+  return request.method === "GET" && !request.headers.has("rsc") && !request.headers.has("next-router-prefetch") && (!accept || accept.includes("text/html") || accept.includes("*/*"));
+};
+var transformBody = ({
+  body,
+  context,
+  onError,
+  onComplete
+}) => {
+  if (!body) {
+    return null;
+  }
+  const reader = body.getReader();
+  const { readable, writable } = new TransformStream();
+  const writer = writable.getWriter();
+  let hasPlacements = false;
+  let complete = true;
+  writer.closed.catch(() => {
+    complete = false;
+    return reader.cancel();
+  }).catch(() => {
+  });
+  void transformEdgeStream({
+    context,
+    decoder: new TextDecoder(),
+    encoder: new TextEncoder(),
+    reader: {
+      read: async () => {
+        await writer.ready.catch(() => {
+        });
+        const { done, value } = await reader.read();
+        return { done, value };
+      }
+    },
+    writer: {
+      // Write and close fail only after the visitor disconnects, which `writer.closed` handles.
+      write: (value) => {
+        writer.write(value).catch(() => {
+        });
+      },
+      close: () => {
+        return writer.close().catch(() => {
+        });
+      }
+    },
+    onError: (details) => {
+      complete = false;
+      if (onError) {
+        onError(details);
+      } else {
+        console.error("[transformEdgeStream]", details.error);
+      }
+    },
+    onPlacement: () => {
+      hasPlacements = true;
+    }
+  }).then(() => {
+    if (complete) {
+      onComplete == null ? void 0 : onComplete(hasPlacements);
+    }
+  });
+  return readable;
+};
+
+// src/utils/env.ts
+var env = {
+  getProjectId: () => {
+    return process.env.UNIFORM_PROJECT_ID;
+  },
+  getApiKey: () => {
+    return process.env.UNIFORM_API_KEY;
+  },
+  getApiHost: () => {
+    return process.env.UNIFORM_API_HOST || process.env.UNIFORM_CLI_BASE_URL;
+  },
+  getEdgeApiHost: () => {
+    return process.env.UNIFORM_EDGE_API_HOST || process.env.UNIFORM_CLI_BASE_EDGE_URL;
+  }
+};
+
+// src/utils/tag.ts
+var encodePathForTag = (path) => path.split("/").map((segment) => /[^\x00-\x7F]/.test(segment) ? encodeURIComponent(segment) : segment).join("/");
+var buildPathTag = (path) => {
+  const actualPath = path.startsWith("/") ? path : `/${path}`;
+  return `path:${encodePathForTag(actualPath)}`.toLowerCase();
+};
+
+// src/edgeRouteFilter/createLearnedEdgeRouteFilter.ts
+var createLearnedEdgeRouteFilter = ({
+  cache,
+  ttl = 3600,
+  maxAge = 10,
+  maxEntries = 1e3
+} = {}) => {
+  const memory = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const remember = (key, hasPlacements) => {
+    memory.delete(key);
+    memory.set(key, { hasPlacements, checkedAt: Date.now() });
+    if (memory.size > maxEntries) {
+      const oldest = memory.keys().next().value;
+      if (oldest !== void 0) {
+        memory.delete(oldest);
+      }
+    }
+  };
+  const read = async (key) => {
+    const stored = await (cache == null ? void 0 : cache.get(key).catch(() => void 0));
+    const hasPlacements = isRecord(stored) ? stored.hasPlacements : void 0;
+    remember(key, hasPlacements);
+    return hasPlacements;
+  };
+  return {
+    shouldProcess: async ({ pageState }) => {
+      var _a, _b;
+      const key = buildKey(pageState);
+      const known = memory.get(key);
+      if (known && Date.now() - known.checkedAt < maxAge * 1e3) {
+        return (_a = known.hasPlacements) != null ? _a : true;
+      }
+      let lookup = pending.get(key);
+      if (!lookup) {
+        lookup = read(key).finally(() => {
+          pending.delete(key);
+        });
+        pending.set(key, lookup);
+      }
+      return (_b = await lookup) != null ? _b : true;
+    },
+    observe: ({ pageState, hasPlacements, waitUntil }) => {
+      var _a, _b;
+      const key = buildKey(pageState);
+      if (((_a = memory.get(key)) == null ? void 0 : _a.hasPlacements) === hasPlacements) {
+        return;
+      }
+      remember(key, hasPlacements);
+      if (cache) {
+        const tags = [buildPathTag((_b = pageState.routePath.split("?")[0]) != null ? _b : "")];
+        waitUntil(cache.set(key, { hasPlacements }, { ttl, tags }).catch(() => {
+        }));
+      }
+    }
+  };
+};
+var buildKey = (pageState) => {
+  var _a, _b;
+  return `uniform-edge-route-${(_a = env.getProjectId()) != null ? _a : ""}-${(_b = pageState.locale) != null ? _b : ""}-${pageState.routePath}`;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && "hasPlacements" in value && typeof value.hasPlacements === "boolean";
+
+// src/edgeRouteFilter/createStaticEdgeRouteFilter.ts
+var createStaticEdgeRouteFilter = ({
+  paths
+}) => {
+  const routes = paths.map((pattern) => ({ id: pattern, pattern }));
+  return {
+    shouldProcess: ({ pageState }) => Boolean(findRouteMatch(routes, stripQuery(pageState.routePath)))
+  };
+};
+var stripQuery = (routePath) => {
+  var _a;
+  return (_a = routePath.split("?")[0]) != null ? _a : "";
+};
+
+// src/clients/manifest.ts
+import "server-only";
+import { ManifestClient } from "@uniformdev/context/api";
+
+// src/clients/cache.ts
+var isSpecificCacheMode = (options) => {
+  return "cache" in options;
+};
+var isStateCacheMode = (options) => {
+  return "state" in options;
+};
+var isDetectCacheMode = (options) => {
+  return "searchParams" in options && "draftModeEnabled" in options;
+};
+var resolveManifestCache = (options) => {
+  return resolveCache({
+    options
+  });
+};
+var resolveCache = ({
+  options
+}) => {
+  let cache = void 0;
+  if (options) {
+    if (isSpecificCacheMode(options)) {
+      cache = options.cache;
+    } else if (isStateCacheMode(options)) {
+      if (options.state === CANVAS_DRAFT_STATE || options.state === CANVAS_EDITOR_STATE) {
+        cache = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    } else if (isDetectCacheMode(options)) {
+      const { disabled } = shouldCacheBeDisabled(options);
+      if (disabled) {
+        cache = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    }
+  }
+  return cache || {
+    type: "force-cache"
+  };
+};
+var shouldCacheBeDisabled = (options) => {
+  if (isDraftModeEnabled(options)) {
+    return { disabled: true, reason: "DRAFT" };
+  }
+  if (isIncontextEditingEnabled({
+    isDraftModeEnabled: options.draftModeEnabled,
+    searchParams: options.searchParams
+  })) {
+    return { disabled: true, reason: "INCONTEXT" };
+  }
+  if (isDevelopmentEnvironment()) {
+    return { disabled: true, reason: "DEV" };
+  }
+  return {
+    disabled: false,
+    reason: void 0
+  };
+};
+var determineFetchCacheOptions = (mode) => {
+  let cache = void 0;
+  let revalidate = void 0;
+  if (mode.type === "revalidate") {
+    cache = void 0;
+    revalidate = mode.interval;
+  } else {
+    cache = mode.type;
+  }
+  return {
+    cache,
+    revalidate
+  };
+};
+
+// src/clients/retry.ts
+import { ApiClientError as ApiClientError6 } from "@uniformdev/context/api";
+function createThrottler(limit, interval) {
+  let available = limit;
+  let refillScheduled = false;
+  const waiting = [];
+  function scheduleRefill() {
+    if (refillScheduled) return;
+    refillScheduled = true;
+    setTimeout(() => {
+      refillScheduled = false;
+      available = limit;
+      while (available > 0 && waiting.length > 0) {
+        available--;
+        const next = waiting.shift();
+        next();
+      }
+      if (waiting.length > 0) {
+        scheduleRefill();
+      }
+    }, interval);
+  }
+  return async function throttle(fn) {
+    if (available > 0) {
+      available--;
+      if (!refillScheduled) {
+        scheduleRefill();
+      }
+      return fn();
+    }
+    return new Promise((resolve, reject) => {
+      waiting.push(() => {
+        fn().then(resolve, reject);
+      });
+      scheduleRefill();
+    });
+  };
+}
+function createLimiter(concurrency) {
+  let active = 0;
+  const queue = [];
+  return async function limit(fn) {
+    return new Promise((resolve, reject) => {
+      const run = async () => {
+        active++;
+        try {
+          const result = await fn();
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        } finally {
+          active--;
+          if (queue.length > 0) {
+            const next = queue.shift();
+            next();
+          }
+        }
+      };
+      if (active < concurrency) {
+        run();
+      } else {
+        queue.push(run);
+      }
+    });
+  };
+}
+async function retry(fn, options) {
+  let lastError;
+  let delay = 1e3;
+  for (let attempt = 1; attempt <= options.retries + 1; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const attemptError = Object.assign(error, { attemptNumber: attempt });
+      if (options.onFailedAttempt) {
+        await options.onFailedAttempt(attemptError);
+      }
+      if (attempt > options.retries) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay *= options.factor;
+    }
+  }
+  throw lastError;
+}
+function createLimitPolicy({
+  throttle = { interval: 1e3, limit: 10 },
+  retry: retryOptions = { retries: 1, factor: 1.66 },
+  limit = 10
+}) {
+  const throttler = throttle ? createThrottler(throttle.limit, throttle.interval) : null;
+  const limiter = limit ? createLimiter(limit) : null;
+  return function limitPolicy(func) {
+    let currentFunc = async () => await func();
+    if (throttler) {
+      const throttleFunc = currentFunc;
+      currentFunc = () => throttler(throttleFunc);
+    }
+    if (limiter) {
+      const limitFunc = currentFunc;
+      currentFunc = () => limiter(limitFunc);
+    }
+    if (retryOptions) {
+      const retryFunc = currentFunc;
+      currentFunc = () => retry(retryFunc, {
+        ...retryOptions,
+        onFailedAttempt: async (error) => {
+          if (retryOptions.onFailedAttempt) {
+            await retryOptions.onFailedAttempt(error);
+          }
+          if (error instanceof ApiClientError6 && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
+            throw error;
+          }
+        }
+      });
+    }
+    return currentFunc();
+  };
+}
+
+// src/clients/tags.ts
+var generateManifestCacheTags = () => {
+  return ["manifest"];
+};
+
+// src/clients/manifest.ts
+var getManifestClient = (options) => {
+  const cache = resolveManifestCache(options);
+  const manifestClient = new ManifestClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    limitPolicy: createLimitPolicy({
+      limit: 6
+    }),
+    fetch: (req, init) => {
+      const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache.bypassCache !== "undefined" ? cache.bypassCache.toString() : "false"
+        },
+        cache: fetchCache,
+        next: {
+          revalidate,
+          tags: generateManifestCacheTags()
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+
+// src/manifest/createCachedManifestProvider.ts
+var createCachedManifestProvider = ({
+  cache,
+  fallback,
+  ttl = 3600,
+  maxAge = 10,
+  fetchManifest = fetchPublishedManifest
+} = {}) => {
+  let current;
+  let pending;
+  const load = async ({ waitUntil }) => {
+    var _a;
+    const key = `uniform-manifest-${(_a = env.getProjectId()) != null ? _a : ""}`;
+    const cached = await (cache == null ? void 0 : cache.get(key).catch(() => void 0));
+    if (isManifest(cached)) {
+      return cached;
+    }
+    const manifest = await fetchManifest();
+    if (cache) {
+      waitUntil(cache.set(key, manifest, { ttl, tags: generateManifestCacheTags() }).catch(() => {
+      }));
+    }
+    return manifest;
+  };
+  return async (options) => {
+    var _a;
+    if (current && Date.now() - current.loadedAt < maxAge * 1e3) {
+      return current.manifest;
+    }
+    pending != null ? pending : pending = load(options).then((manifest) => {
+      current = { manifest, loadedAt: Date.now() };
+      return manifest;
+    }).finally(() => {
+      pending = void 0;
+    });
+    try {
+      return await pending;
+    } catch (error) {
+      const known = (_a = current == null ? void 0 : current.manifest) != null ? _a : fallback;
+      if (known) {
+        return known;
+      }
+      throw error;
+    }
+  };
+};
+var fetchPublishedManifest = () => getManifestClient({ cache: { type: "no-store" } }).get({ preview: false });
+var isManifest = (value) => typeof value === "object" && value !== null && "project" in value;
+export {
+  UNIFORM_EDGE_ORIGIN_HEADER,
+  createCachedManifestProvider,
+  createLearnedEdgeRouteFilter,
+  createStaticEdgeRouteFilter,
+  handleUniformEdgeRoute,
+  uniformEdgeMiddleware
+};