@uniformdev/next-app-router 20.80.2 → 20.81.1-alpha.4.sha-de16ebeee7

package/dist/edge.mjs

@@ -0,0 +1,720 @@
+// 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 isIncontextEditingEnabled = ({
+  isDraftModeEnabled,
+  searchParams
+}) => {
+  if (!isDraftModeEnabled) {
+    return false;
+  }
+  const containsKey = searchParams.has(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM);
+  return containsKey;
+};
+
+// 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,
+  ...options
+}) => {
+  const draftModeEnabled = (await draftMode()).isEnabled;
+  if (draftModeEnabled && isPlaygroundPath(request.nextUrl.pathname)) {
+    return handlePlaygroundRequest({ request, options });
+  }
+  return resolveRouteRequest({ request, draftModeEnabled, 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,
+  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
+  };
+  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
+}) => {
+  if (!isDraftModeEnabled) {
+    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, 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) => {
+    return handleUniformEdgeRoute({ request, ...options });
+  };
+};
+var handleUniformEdgeRoute = async ({
+  request,
+  manifest,
+  onError,
+  ...options
+}) => {
+  var _a;
+  if (request.headers.has(UNIFORM_EDGE_ORIGIN_HEADER)) {
+    return NextResponse2.next();
+  }
+  const result = await resolveUniformRequest({ request, ...options });
+  if (result.type === "response") {
+    return result.response;
+  }
+  const destination = new URL(result.destination, request.nextUrl.origin);
+  if (result.draftModeEnabled || !isDocumentRequest(request)) {
+    return NextResponse2.rewrite(destination, { headers: result.headers });
+  }
+  const [originResponse, context] = await Promise.all([
+    fetch(destination, {
+      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"
+      }
+    }),
+    result.createContext({ manifest })
+  ]);
+  const headers = new Headers(originResponse.headers);
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  headers.set("cache-control", "private, no-store");
+  result.headers.forEach((value, key) => {
+    headers.append(key, value);
+  });
+  return new Response(transformBody({ body: originResponse.body, context, onError }), {
+    status: originResponse.status,
+    statusText: originResponse.statusText,
+    headers
+  });
+};
+var isDocumentRequest = (request) => {
+  var _a;
+  return request.method === "GET" && !request.headers.has("rsc") && !request.headers.has("next-router-prefetch") && ((_a = request.headers.get("accept")) != null ? _a : "").includes("text/html");
+};
+var transformBody = ({
+  body,
+  context,
+  onError
+}) => {
+  if (!body) {
+    return null;
+  }
+  const reader = body.getReader();
+  const { readable, writable } = new TransformStream();
+  const writer = writable.getWriter();
+  void transformEdgeStream({
+    context,
+    decoder: new TextDecoder(),
+    encoder: new TextEncoder(),
+    reader: {
+      read: async () => {
+        const { done, value } = await reader.read();
+        return { done, value };
+      }
+    },
+    writer: {
+      write: (value) => {
+        void writer.write(value);
+      },
+      close: () => {
+        return writer.close();
+      }
+    },
+    onError
+  });
+  return readable;
+};
+export {
+  UNIFORM_EDGE_ORIGIN_HEADER,
+  handleUniformEdgeRoute,
+  uniformEdgeMiddleware
+};