@uniformdev/canvas-next-rsc 19.61.1-alpha.10 → 19.61.1-alpha.18

package/dist/index.js

@@ -1,29 +1,1011 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { UniformComposition as BaseUniformComposition, } from './components/UniformComposition';
-// Canvas Components
-export { GoogleTagManagerAnalytics } from './components/GoogleTagManagerAnalytics';
-export { UniformSlot } from './components/UniformSlot';
-// Parameter Components
-export { UniformText } from './components/UniformText';
-// Hooks
-export { useForgetMe } from './hooks/useForgetMe';
-export { useToggleConsent } from './hooks/useToggleConsent';
-export { useUniformContext } from './hooks/useUniformContext';
-// Component Registry
-export { componentStore } from './register/componentStore';
-export { registerUniformComponent } from './register/registerUniformComponent';
-// Context
-export { getUniformContext } from './components/getUniformContext';
-// Clients
-export { getCanvasClient } from './client/canvasClient';
-export { getManifestClient } from './client/manifestClient';
-export { getProjectMapClient } from './client/projectMapClient';
-export { getRouteClient } from './client/routeClient';
-export { resolveComposition } from './components/retrieveRoute';
-// actions
-export { updateContextAction } from './actions/updateContext';
-export const UniformComposition = (props) => _jsx(BaseUniformComposition, { ...props });
-export const UniformCompositionCustom = (props) => (_jsx(BaseUniformComposition, { ...props }));
-export { UniformRichText } from './components/UniformRichText';
-export { isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment } from './utils/draft';
-export { CANVAS_DRAFT_STATE, CANVAS_PUBLISHED_STATE, IN_CONTEXT_EDITOR_QUERY_STRING_PARAM, } from '@uniformdev/canvas';
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ContextUpdateTransfer: () => ContextUpdateTransfer,
+  UniformComposition: () => UniformComposition,
+  UniformContext: () => UniformContext,
+  UniformPlayground: () => UniformPlayground,
+  createServerUniformContext: () => createServerUniformContext,
+  createStaticParams: () => createStaticParams,
+  generateStaticParams: () => generateStaticParams,
+  getCanvasClient: () => getCanvasClient,
+  getDefaultCanvasClient: () => getDefaultCanvasClient,
+  getDefaultManifestClient: () => getDefaultManifestClient,
+  getDefaultProjectMapClient: () => getDefaultProjectMapClient,
+  getDefaultRouteClient: () => getDefaultRouteClient,
+  getManifest: () => getManifest,
+  getManifestClient: () => getManifestClient,
+  getProjectMapClient: () => getProjectMapClient,
+  getRouteClient: () => getRouteClient,
+  isDevelopmentEnvironment: () => isDevelopmentEnvironment,
+  isDraftModeEnabled: () => isDraftModeEnabled,
+  isIncontextEditingEnabled: () => isIncontextEditingEnabled,
+  isOnVercelPreviewEnvironment: () => isOnVercelPreviewEnvironment,
+  resolveComposition: () => resolveComposition,
+  retrieveRoute: () => retrieveRoute
+});
+module.exports = __toCommonJS(src_exports);
+var import_server_only = require("server-only");
+
+// src/clients/canvasClient.ts
+var import_canvas2 = require("@uniformdev/canvas");
+
+// src/config/helpers.ts
+var import_canvas_next_rsc_shared = require("@uniformdev/canvas-next-rsc-shared");
+
+// src/utils/draft.ts
+var import_canvas = require("@uniformdev/canvas");
+var import_headers = require("next/headers");
+var isDraftModeEnabled = ({
+  searchParams
+}) => {
+  if (isDevelopmentEnvironment()) {
+    return isIncontextEditingEnabled({ searchParams });
+  }
+  let draftModeEnabled = false;
+  try {
+    draftModeEnabled = (0, import_headers.draftMode)().isEnabled;
+  } catch (e) {
+  }
+  return draftModeEnabled || isIncontextEditingEnabled({ searchParams });
+};
+var isIncontextEditingEnabled = ({
+  searchParams
+}) => {
+  const containsKey = typeof (searchParams == null ? void 0 : searchParams[import_canvas.IN_CONTEXT_EDITOR_QUERY_STRING_PARAM]) !== "undefined";
+  return containsKey;
+};
+var isOnVercelPreviewEnvironment = () => {
+  return process.env.VERCEL_ENV === "preview";
+};
+var isDevelopmentEnvironment = () => {
+  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+};
+
+// src/config/helpers.ts
+var shouldCacheBeDisabled = (options) => {
+  if (isDraftModeEnabled(options)) {
+    return { disabled: true, reason: "DRAFT" };
+  }
+  if (isIncontextEditingEnabled(options)) {
+    return { disabled: true, reason: "INCONTEXT" };
+  }
+  if (isDevelopmentEnvironment()) {
+    return { disabled: true, reason: "DEV" };
+  }
+  return {
+    disabled: false,
+    reason: void 0
+  };
+};
+var getCanvasCacheStrategy = (options) => {
+  const { disabled, reason } = shouldCacheBeDisabled(options);
+  const config = (0, import_canvas_next_rsc_shared.getServerConfig)();
+  if (disabled) {
+    if (reason === "DEV" && config.canvasCache) {
+      console.warn("Canvas cache (disabled) has been overridden by canvasCache config.");
+      return config.canvasCache;
+    }
+    return {
+      type: "no-cache"
+    };
+  }
+  if (config.canvasCache) {
+    return config.canvasCache;
+  }
+  return {
+    type: "force-cache"
+  };
+};
+var getManifestCacheStrategy = (options) => {
+  const { disabled, reason } = shouldCacheBeDisabled(options);
+  const config = (0, import_canvas_next_rsc_shared.getServerConfig)();
+  if (disabled) {
+    if (reason === "DEV" && config.manifestCache) {
+      console.warn("Manifest cache (disabled) has been overridden by manifestCache config.");
+      return config.manifestCache;
+    }
+    return {
+      type: "no-cache"
+    };
+  }
+  if (config.manifestCache) {
+    return config.manifestCache;
+  }
+  return {
+    type: "force-cache"
+  };
+};
+var getProjectMapCacheStrategy = (options) => {
+  const { disabled, reason } = shouldCacheBeDisabled(options);
+  const config = (0, import_canvas_next_rsc_shared.getServerConfig)();
+  if (disabled) {
+    if (reason === "DEV" && config.projectMapCache) {
+      console.warn("Project map cache (disabled) has been overridden by projectMapCache config.");
+      return config.projectMapCache;
+    }
+    return {
+      type: "no-cache"
+    };
+  }
+  if (config.projectMapCache) {
+    return config.projectMapCache;
+  }
+  return {
+    type: "force-cache"
+  };
+};
+
+// src/env/index.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 buildPathTag = (path) => {
+  const actualPath = path.startsWith("/") ? path : `/${path}`;
+  return `path:${actualPath}`.toLowerCase();
+};
+var buildCompositionTag = (compositionId) => {
+  return `composition:${compositionId}`.toLowerCase();
+};
+
+// src/clients/shared.ts
+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/canvasClient.ts
+var getCanvasClient = (options) => {
+  return new import_canvas2.CanvasClient({
+    projectId: env.getProjectId(),
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    edgeApiHost: env.getEdgeApiHost(),
+    fetch: (req, init) => {
+      let requestedUrl;
+      if (typeof req === "string") {
+        requestedUrl = new URL(req);
+      } else if (req instanceof URL) {
+        requestedUrl = req;
+      } else {
+        requestedUrl = new URL(req.url);
+      }
+      const tags = [];
+      if (requestedUrl) {
+        const compositionIdKey = "compositionId";
+        const compositionIdsKey = "compositionIDs";
+        const compositionId = requestedUrl.searchParams.get(compositionIdKey);
+        const compositionIds = requestedUrl.searchParams.get(compositionIdsKey);
+        if (compositionId) {
+          tags.push(buildCompositionTag(compositionId));
+        }
+        if (compositionIds) {
+          const ids = compositionIds.split(",");
+          for (let i = 0; i < ids.length; i++) {
+            tags.push(buildCompositionTag(ids[i]));
+          }
+        }
+      }
+      const { cache, revalidate } = determineFetchCacheOptions(options.cache);
+      return fetch(req, {
+        ...init,
+        cache,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": "true"
+        },
+        next: {
+          revalidate
+        }
+      });
+    }
+  });
+};
+var getDefaultCanvasClient = ({
+  searchParams
+}) => {
+  return getCanvasClient({
+    cache: getCanvasCacheStrategy({
+      searchParams
+    })
+  });
+};
+
+// src/clients/manifestClient.ts
+var import_api = require("@uniformdev/context/api");
+var getManifestClient = (options) => {
+  const manifestClient = new import_api.ManifestClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    fetch: (req, init) => {
+      const { cache, revalidate } = determineFetchCacheOptions(options.cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": "true"
+        },
+        cache,
+        next: {
+          revalidate,
+          tags: ["manifest"]
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+var getDefaultManifestClient = ({
+  searchParams
+}) => {
+  return getManifestClient({
+    cache: getManifestCacheStrategy({
+      searchParams
+    })
+  });
+};
+var getManifest = ({ searchParams }) => {
+  const manifestClient = getDefaultManifestClient({
+    searchParams
+  });
+  return manifestClient.get();
+};
+
+// src/clients/projectMapClient.ts
+var import_project_map = require("@uniformdev/project-map");
+var getProjectMapClient = (options) => {
+  const manifestClient = new import_project_map.ProjectMapClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    fetch: (req, init) => {
+      const { cache, revalidate } = determineFetchCacheOptions(options.cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": "true"
+        },
+        cache,
+        next: {
+          revalidate
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+var getDefaultProjectMapClient = ({
+  searchParams
+}) => {
+  return getProjectMapClient({
+    cache: getProjectMapCacheStrategy({
+      searchParams
+    })
+  });
+};
+
+// src/clients/routeClient.ts
+var import_canvas3 = require("@uniformdev/canvas");
+var getRouteClient = (options) => {
+  const client = new import_canvas3.RouteClient({
+    projectId: env.getProjectId(),
+    apiKey: env.getApiKey(),
+    edgeApiHost: env.getEdgeApiHost(),
+    fetch: (req, init) => {
+      let requestedUrl;
+      if (typeof req === "string") {
+        requestedUrl = new URL(req);
+      } else if (req instanceof URL) {
+        requestedUrl = req;
+      } else {
+        requestedUrl = new URL(req.url);
+      }
+      const tags = [];
+      if (requestedUrl) {
+        const pathKey = "path";
+        const path = requestedUrl.searchParams.get(pathKey);
+        if (path) {
+          const pieces = path.split("/");
+          for (let i = 0; i < pieces.length; i++) {
+            const segmentPieces = pieces.slice(0, i + 1);
+            const segment = segmentPieces.join("/");
+            tags.push(buildPathTag(segment));
+          }
+        }
+      }
+      const { cache, revalidate } = determineFetchCacheOptions(options.cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": "true"
+        },
+        cache,
+        next: {
+          revalidate,
+          tags: tags.length ? tags : void 0
+        }
+      });
+    }
+  });
+  return client;
+};
+var getDefaultRouteClient = ({ searchParams }) => {
+  return getRouteClient({
+    cache: getCanvasCacheStrategy({
+      searchParams
+    })
+  });
+};
+
+// src/components/ContextUpdateTransfer.tsx
+var import_canvas_next_rsc_client = require("@uniformdev/canvas-next-rsc-client");
+var import_react = __toESM(require("react"));
+var ContextUpdateTransfer = async ({
+  update,
+  serverContext
+}) => {
+  const result = typeof update === "function" ? await update() : update;
+  if (!result) {
+    return null;
+  }
+  if (serverContext) {
+    await serverContext.__INTERNAL__.update(result);
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_canvas_next_rsc_client.ContextUpdateTransferClient, { ts: (/* @__PURE__ */ new Date()).valueOf(), update: result });
+};
+
+// src/components/generateStaticParams.ts
+var createStaticParams = async (options) => {
+  var _a, _b;
+  const { expand } = options != null ? options : {};
+  const client = getProjectMapClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  const { nodes } = await client.getNodes({});
+  const resolvedPaths = [];
+  if (nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const isDynamic = node.path.includes(":");
+      if (!isDynamic) {
+        resolvedPaths.push(node.path);
+      } else if (expand) {
+        const expandedPaths = (_a = await expand(node)) != null ? _a : [];
+        resolvedPaths.push(...expandedPaths);
+      }
+    }
+  }
+  return (_b = resolvedPaths == null ? void 0 : resolvedPaths.map((path) => {
+    return {
+      path: path.split("/").filter(Boolean)
+    };
+  })) != null ? _b : [];
+};
+async function generateStaticParams() {
+  return createStaticParams();
+}
+
+// src/components/UniformComposition.ts
+var import_canvas7 = require("@uniformdev/canvas");
+var import_canvas_next_rsc_client4 = require("@uniformdev/canvas-next-rsc-client");
+var import_canvas_next_rsc_shared6 = require("@uniformdev/canvas-next-rsc-shared");
+var import_core = require("@uniformdev/canvas-react/core");
+var import_headers3 = require("next/headers");
+var import_navigation = require("next/navigation");
+var import_react6 = require("react");
+
+// src/context/createServerUniformContext.ts
+var import_canvas_next_rsc_shared2 = require("@uniformdev/canvas-next-rsc-shared");
+var import_context = require("@uniformdev/context");
+var import_headers2 = require("next/headers");
+var createServerUniformContext = async (options) => {
+  const manifest = await getManifest(options);
+  const context = createServerUniformContextFromManifest({
+    ...options || {},
+    manifest
+  });
+  return context;
+};
+var createServerUniformContextFromManifest = async (options) => {
+  var _a;
+  const context = (0, import_canvas_next_rsc_shared2.createUniformContext)({
+    ...options || {},
+    serverCookieValue: (_a = (0, import_headers2.cookies)().get(import_context.UNIFORM_DEFAULT_COOKIE_NAME)) == null ? void 0 : _a.value
+  });
+  return {
+    ...context,
+    __INTERNAL__: {
+      update: (...props) => context.update(...props)
+    }
+  };
+};
+
+// src/utils/route.ts
+var import_canvas4 = require("@uniformdev/canvas");
+var import_canvas_next_rsc_shared3 = require("@uniformdev/canvas-next-rsc-shared");
+var import_redirect = require("@uniformdev/redirect");
+var retrieveRoute = async ({
+  params,
+  searchParams
+}) => {
+  const { type, value } = (0, import_canvas_next_rsc_shared3.resolvePath)({
+    params
+  });
+  const states = determineState({
+    searchParams
+  });
+  let result;
+  for (let i = 0; i < states.length; i++) {
+    const state = states[i];
+    if (type === "path") {
+      try {
+        result = await retrieveRouteByPath({
+          path: value,
+          state,
+          searchParams
+        });
+      } catch (e) {
+        console.warn(`Failed to retrieve route by path: ${value} with state ${state}`, e);
+      }
+    } else if (type === "slug") {
+      const canvasClient = getDefaultCanvasClient({
+        searchParams
+      });
+      try {
+        const composition = await canvasClient.getCompositionBySlug({
+          slug: value,
+          state
+        });
+        result = {
+          type: "composition",
+          compositionApiResponse: composition,
+          matchedRoute: "slug"
+        };
+      } catch (e) {
+        console.warn(`Failed to retrieve composition by slug: ${value} with state ${state}`, e);
+      }
+    }
+    if ((result == null ? void 0 : result.type) !== "notFound") {
+      break;
+    }
+  }
+  return result || {
+    type: "notFound"
+  };
+};
+var retrieveRouteByPath = async ({
+  path,
+  state,
+  searchParams
+}) => {
+  var _a;
+  const client = getDefaultRouteClient({
+    searchParams
+  });
+  return await client.getRoute({
+    path,
+    state,
+    withComponentIDs: true,
+    withContentSourceMap: isOnVercelPreviewEnvironment() && ((_a = (0, import_canvas_next_rsc_shared3.getServerConfig)().experimental) == null ? void 0 : _a.vercelVisualEditing)
+  });
+};
+var resolveRedirectHref = (resolveResult, path) => {
+  let href;
+  if (resolveResult.redirect.targetProjectMapNodeId) {
+    const requestUrl = `${(0, import_canvas_next_rsc_shared3.getBaseUrl)()}${path}`;
+    const expandedUrl = (0, import_redirect.getTargetVariableExpandedUrl)(requestUrl, resolveResult.redirect);
+    const url = new URL(expandedUrl);
+    href = url.pathname;
+  } else {
+    href = resolveResult.redirect.targetUrl;
+  }
+  return href;
+};
+var determineState = ({ searchParams }) => {
+  const draftMode2 = isDraftModeEnabled({ searchParams });
+  const previewEnvironment = isOnVercelPreviewEnvironment();
+  const isDevelopment = isDevelopmentEnvironment();
+  const isCanvasEditing = isIncontextEditingEnabled({
+    searchParams
+  });
+  let states;
+  if (isCanvasEditing) {
+    states = [import_canvas4.CANVAS_EDITOR_STATE, import_canvas4.CANVAS_DRAFT_STATE];
+  } else {
+    states = draftMode2 || previewEnvironment || isDevelopment ? [import_canvas4.CANVAS_DRAFT_STATE] : [import_canvas4.CANVAS_PUBLISHED_STATE];
+  }
+  return states;
+};
+
+// src/components/ContextUpdateTrigger.tsx
+var import_canvas_next_rsc_client2 = require("@uniformdev/canvas-next-rsc-client");
+var import_react2 = __toESM(require("react"));
+var ContextUpdateTrigger = () => {
+  return /* @__PURE__ */ import_react2.default.createElement(import_canvas_next_rsc_client2.ClientContextUpdate, null);
+};
+
+// src/components/PersonalizeClientWrapper.tsx
+var import_canvas_next_rsc_client3 = require("@uniformdev/canvas-next-rsc-client");
+var import_canvas_next_rsc_shared4 = require("@uniformdev/canvas-next-rsc-shared");
+var import_react3 = __toESM(require("react"));
+var PersonalizeClientWrapper = (props) => {
+  const { indexes } = (0, import_canvas_next_rsc_shared4.runPersonalization)({
+    ...props,
+    contextInstance: void 0
+  });
+  return /* @__PURE__ */ import_react3.default.createElement(import_canvas_next_rsc_client3.PersonalizeClient, { ...props, indexes });
+};
+
+// src/components/PersonalizeServer.ts
+var import_canvas5 = require("@uniformdev/canvas");
+var import_canvas_next_rsc_shared5 = require("@uniformdev/canvas-next-rsc-shared");
+var import_react4 = require("react");
+var PersonalizeServer = (props) => {
+  var _a;
+  const { indexes } = (0, import_canvas_next_rsc_shared5.runPersonalization)(props);
+  const slot = (_a = props.slots) == null ? void 0 : _a[import_canvas5.CANVAS_PERSONALIZE_SLOT];
+  const components = indexes.map((index) => {
+    const component = slot.items[index];
+    return component;
+  });
+  return (0, import_react4.createElement)(import_react4.Fragment, void 0, components);
+};
+
+// src/components/TestServer.ts
+var import_canvas6 = require("@uniformdev/canvas");
+var import_react5 = require("react");
+var TestServer = ({ test, component, contextInstance, slots }) => {
+  var _a, _b, _c;
+  const slot = ((_a = component.slots) == null ? void 0 : _a[import_canvas6.CANVAS_TEST_SLOT]) || [];
+  const { result } = contextInstance.test({
+    name: test,
+    variations: slot.map((v, i) => {
+      var _a2, _b2, _c2;
+      const contextTag = (_b2 = (_a2 = v.parameters) == null ? void 0 : _a2[import_canvas6.CANVAS_TEST_VARIANT_PARAM]) == null ? void 0 : _b2.value;
+      const id = (_c2 = contextTag == null ? void 0 : contextTag.id) != null ? _c2 : "testId" in v ? v.testId : `ab-${i}-${v.type}`;
+      return {
+        id,
+        testDistribution: contextTag == null ? void 0 : contextTag.testDistribution,
+        index: i
+      };
+    })
+  });
+  const components = result ? (_c = (_b = slots == null ? void 0 : slots[import_canvas6.CANVAS_TEST_SLOT]) == null ? void 0 : _b.items[result.index]) != null ? _c : null : null;
+  return (0, import_react5.createElement)(import_react5.Fragment, void 0, components);
+};
+
+// src/components/UniformComposition.ts
+var UniformComposition = async ({
+  resolveComponent,
+  route,
+  ...props
+}) => {
+  let searchParams;
+  let serverContext = void 0;
+  if (props.mode === "static") {
+    searchParams = void 0;
+  } else if (props.mode === "server") {
+    serverContext = props.serverContext || await createServerUniformContext({
+      searchParams: props.searchParams
+    });
+    searchParams = props.searchParams;
+  }
+  const { value: path } = (0, import_canvas_next_rsc_shared6.resolvePath)(props);
+  if (!route || route.type === "notFound") {
+    (0, import_navigation.notFound)();
+  }
+  if (route.type === "redirect") {
+    const href = resolveRedirectHref(route, path);
+    (0, import_navigation.redirect)(href);
+  }
+  const state = route.compositionApiResponse.state;
+  if (state === import_canvas7.CANVAS_DRAFT_STATE || state === import_canvas7.CANVAS_EDITOR_STATE) {
+    (0, import_canvas7.walkNodeTree)(route.compositionApiResponse.composition, (node) => {
+      if (node.type === "component" && node.node.parameters) {
+        Object.keys(node.node.parameters).forEach((key) => {
+          const parameter = node.node.parameters[key];
+          if (parameter.type === "text") {
+            const contextualParameter = parameter;
+            contextualParameter._contextualEditing = {
+              isEditable: true
+            };
+          }
+        });
+      }
+    });
+  }
+  const compositionContext = {
+    composition: route.compositionApiResponse.composition,
+    matchedRoute: route.matchedRoute,
+    searchParams,
+    dynamicInputs: route.dynamicInputs,
+    type: "composition",
+    isContextualEditing: isIncontextEditingEnabled({ searchParams }),
+    isDraftMode: isDraftModeEnabled({ searchParams }),
+    state: route.compositionApiResponse.state,
+    path
+  };
+  const resolved = resolveComposition({
+    composition: route.compositionApiResponse.composition,
+    resolveComponent,
+    serverContext,
+    compositionContext,
+    mode: props.mode
+  });
+  let transfer = null;
+  if (props.mode === "server") {
+    const headersValue = (0, import_headers3.headers)();
+    const missingQuirkValue = "unknown";
+    transfer = (0, import_react6.createElement)(ContextUpdateTransfer, {
+      serverContext,
+      update: {
+        params: props.params,
+        searchParams,
+        cookies: (0, import_headers3.cookies)().getAll().reduce((acc, cookie) => {
+          acc[cookie.name] = cookie.value;
+          return acc;
+        }, {}),
+        quirks: {
+          "vc-country": headersValue.get("x-vercel-ip-country") || missingQuirkValue,
+          "vc-region": headersValue.get("x-vercel-ip-country-region") || missingQuirkValue,
+          "vc-city": headersValue.get("x-vercel-ip-city") || missingQuirkValue
+        }
+      }
+    });
+  } else if (props.mode === "static") {
+    transfer = (0, import_react6.createElement)(ContextUpdateTrigger);
+  }
+  return (0, import_react6.createElement)(import_react6.Fragment, void 0, transfer, resolved);
+};
+var isServerComponent = ({
+  component,
+  serverContext
+}) => {
+  var _a, _b;
+  if (component.type === import_canvas7.CANVAS_PERSONALIZE_TYPE) {
+    return serverContext && ((_a = (0, import_canvas_next_rsc_shared6.getServerConfig)().evaluation) == null ? void 0 : _a.personalization) !== "client";
+  }
+  if (component.type === import_canvas7.CANVAS_TEST_TYPE) {
+    return serverContext && ((_b = (0, import_canvas_next_rsc_shared6.getServerConfig)().evaluation) == null ? void 0 : _b.testing) !== "client";
+  }
+};
+var resolveSystemComponent = ({
+  component,
+  serverContext
+}) => {
+  const server = isServerComponent({
+    component,
+    serverContext
+  });
+  if (component.type === import_canvas7.CANVAS_PERSONALIZE_TYPE) {
+    return server ? PersonalizeServer : PersonalizeClientWrapper;
+  }
+  if (component.type === import_canvas7.CANVAS_TEST_TYPE) {
+    return server ? TestServer : import_canvas_next_rsc_client4.TestClient;
+  }
+  return null;
+};
+var resolveSlots = ({
+  component,
+  root,
+  resolveComponent,
+  serverContext,
+  compositionContext,
+  mode
+}) => {
+  const slots = {};
+  if (component.slots) {
+    Object.keys(component.slots).forEach((slotName, slotIndex) => {
+      const resolved = resolveComponents({
+        target: {
+          type: "slot",
+          components: component.slots[slotName],
+          root,
+          parent: component
+        },
+        slotName,
+        slotIndex,
+        resolveComponent,
+        serverContext,
+        compositionContext,
+        mode
+      });
+      if (resolved) {
+        slots[slotName] = {
+          name: slotName,
+          items: resolved
+        };
+      }
+    });
+  }
+  return slots;
+};
+var resolveComposition = (props) => {
+  const [resolved] = resolveComponents({
+    ...props,
+    target: {
+      type: "root",
+      composition: props.composition
+    },
+    slotName: void 0,
+    slotIndex: void 0,
+    compositionContext: props.compositionContext
+  });
+  return resolved;
+};
+var resolveComponents = ({
+  serverContext,
+  target,
+  slotName,
+  slotIndex,
+  resolveComponent,
+  compositionContext,
+  mode
+}) => {
+  const isRoot = !slotName && typeof slotIndex !== "number";
+  let root;
+  let parent = void 0;
+  let components;
+  if (target.type === "root") {
+    root = target.composition;
+    components = [target.composition];
+  } else {
+    root = target.root;
+    components = target.components;
+    parent = target.parent;
+  }
+  const resolved = components.map((component, componentIndex) => {
+    var _a, _b;
+    const isServer = isServerComponent({
+      component,
+      serverContext
+    });
+    const systemComponent = resolveSystemComponent({
+      component,
+      serverContext
+    });
+    const { component: regularComponent, includeContext } = resolveComponent({ component }) || {
+      component: null
+    };
+    if (!systemComponent && !regularComponent) {
+      return null;
+    }
+    const slots = resolveSlots({
+      component,
+      root,
+      resolveComponent,
+      serverContext,
+      compositionContext,
+      mode
+    });
+    const resolvedComponent = systemComponent || regularComponent;
+    const parameters = (_a = component.parameters) != null ? _a : {};
+    const enrichmentTags = (_b = parameters[import_canvas7.CANVAS_ENRICHMENT_TAG_PARAM]) == null ? void 0 : _b.value;
+    const componentProps = {
+      key: `${slotName}-${componentIndex}-component`,
+      ...Object.keys(parameters).reduce((acc, cur) => {
+        acc[cur] = parameters[cur].value;
+        return acc;
+      }, {}),
+      component,
+      slots,
+      contextInstance: isServer || includeContext ? serverContext : void 0,
+      context: compositionContext
+    };
+    const element = (0, import_react6.createElement)(resolvedComponent, componentProps);
+    let tagElement = null;
+    if (enrichmentTags == null ? void 0 : enrichmentTags.length) {
+      tagElement = (0, import_react6.createElement)(ContextUpdateTransfer, {
+        key: `${slotName}-${componentIndex}-tags`,
+        update: {
+          enrichments: enrichmentTags
+        },
+        serverContext
+      });
+    }
+    let childNode;
+    if (compositionContext.isContextualEditing) {
+      const elements = [element];
+      if (tagElement) {
+        elements.push(tagElement);
+      }
+      childNode = (0, import_react6.createElement)(
+        import_core.PureContextualEditingComponentWrapper,
+        {
+          key: `${slotName}-${componentIndex}-wrapper`,
+          isPlaceholder: false,
+          parentComponent: parent,
+          component,
+          slotName,
+          indexInSlot: componentIndex,
+          slotChildrenCount: components.length,
+          isReadOnly: "false"
+        },
+        elements
+      );
+    } else if (mode === "static") {
+      const elements = [element];
+      if (tagElement) {
+        elements.push(tagElement);
+      }
+      childNode = (0, import_react6.createElement)(
+        import_canvas_next_rsc_client4.ClientContextualEditingComponentWrapper,
+        {
+          key: `${slotName}-${componentIndex}-wrapper`,
+          isPlaceholder: false,
+          parentComponent: parent,
+          component,
+          slotName,
+          indexInSlot: componentIndex,
+          slotChildrenCount: components.length,
+          isReadOnly: "false"
+        },
+        elements
+      );
+    } else {
+      const elements = [element];
+      if (tagElement) {
+        elements.push(tagElement);
+      }
+      childNode = elements;
+    }
+    return (0, import_react6.createElement)(
+      import_react6.Fragment,
+      {
+        key: !isRoot ? `${slotName}-${componentIndex}` : void 0
+      },
+      childNode
+    );
+  });
+  return resolved;
+};
+
+// src/components/UniformContext.tsx
+var import_canvas_next_rsc_client5 = require("@uniformdev/canvas-next-rsc-client");
+var import_react7 = require("react");
+var import_react8 = __toESM(require("react"));
+var UniformContext = async ({
+  clientContextComponent,
+  children
+}) => {
+  const manifest = await getManifest({
+    searchParams: {}
+  });
+  const ContextComponent = clientContextComponent || import_canvas_next_rsc_client5.DefaultUniformClientContext;
+  return /* @__PURE__ */ import_react8.default.createElement(import_react8.default.Fragment, null, children, /* @__PURE__ */ import_react8.default.createElement(ContextComponent, { manifest }), /* @__PURE__ */ import_react8.default.createElement(import_react7.Suspense, { fallback: /* @__PURE__ */ import_react8.default.createElement(import_react8.default.Fragment, null) }, /* @__PURE__ */ import_react8.default.createElement(import_canvas_next_rsc_client5.UniformScript, null)));
+};
+
+// src/components/UniformPlayground.tsx
+var import_canvas8 = require("@uniformdev/canvas");
+var import_navigation2 = require("next/navigation");
+var import_react9 = __toESM(require("react"));
+var UniformPlayground = async ({ searchParams, ...rest }) => {
+  if (!isDraftModeEnabled({ searchParams })) {
+    return /* @__PURE__ */ import_react9.default.createElement("div", null, /* @__PURE__ */ import_react9.default.createElement("h1", null, "Playground is only available in draft mode"));
+  }
+  const id = searchParams["id"];
+  if (!id) {
+    (0, import_navigation2.notFound)();
+  }
+  const canvasClient = getCanvasClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  const possibleStates = [import_canvas8.CANVAS_EDITOR_STATE, import_canvas8.CANVAS_DRAFT_STATE];
+  let composition = void 0;
+  for (let i = 0; i < possibleStates.length; i++) {
+    const state = possibleStates[i];
+    try {
+      composition = await canvasClient.getCompositionById({
+        compositionId: id,
+        state,
+        withComponentIDs: true
+      });
+    } catch (e) {
+      console.warn(`Failed to get composition ${id} with state ${state}`, e);
+    }
+    if (composition) {
+      break;
+    }
+  }
+  if (!composition) {
+    (0, import_navigation2.notFound)();
+  }
+  return /* @__PURE__ */ import_react9.default.createElement(
+    UniformComposition,
+    {
+      mode: "server",
+      params: {},
+      searchParams,
+      route: {
+        type: "composition",
+        compositionApiResponse: composition,
+        matchedRoute: "composition"
+      },
+      ...rest
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextUpdateTransfer,
+  UniformComposition,
+  UniformContext,
+  UniformPlayground,
+  createServerUniformContext,
+  createStaticParams,
+  generateStaticParams,
+  getCanvasClient,
+  getDefaultCanvasClient,
+  getDefaultManifestClient,
+  getDefaultProjectMapClient,
+  getDefaultRouteClient,
+  getManifest,
+  getManifestClient,
+  getProjectMapClient,
+  getRouteClient,
+  isDevelopmentEnvironment,
+  isDraftModeEnabled,
+  isIncontextEditingEnabled,
+  isOnVercelPreviewEnvironment,
+  resolveComposition,
+  retrieveRoute
+});