@uniformdev/canvas-next-rsc 19.69.0 → 19.73.0

package/dist/index.esm.js

@@ -0,0 +1,977 @@
+// src/index.ts
+import "server-only";
+
+// src/clients/canvasClient.ts
+import { CanvasClient } from "@uniformdev/canvas";
+
+// src/config/helpers.ts
+import { getServerConfig } from "@uniformdev/canvas-next-rsc-shared";
+
+// src/utils/draft.ts
+import { IN_CONTEXT_EDITOR_QUERY_STRING_PARAM } from "@uniformdev/canvas";
+import { draftMode } from "next/headers";
+var isDraftModeEnabled = ({
+  searchParams
+}) => {
+  if (isDevelopmentEnvironment()) {
+    return isIncontextEditingEnabled({ searchParams });
+  }
+  let draftModeEnabled = false;
+  try {
+    draftModeEnabled = draftMode().isEnabled;
+  } catch (e) {
+  }
+  return draftModeEnabled || isIncontextEditingEnabled({ searchParams });
+};
+var isIncontextEditingEnabled = ({
+  searchParams
+}) => {
+  const containsKey = typeof (searchParams == null ? void 0 : searchParams[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 = 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 = 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 = 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 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
+import { ManifestClient } from "@uniformdev/context/api";
+var getManifestClient = (options) => {
+  const manifestClient = new 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
+import { ProjectMapClient } from "@uniformdev/project-map";
+var getProjectMapClient = (options) => {
+  const manifestClient = new 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
+import { RouteClient } from "@uniformdev/canvas";
+var getRouteClient = (options) => {
+  const client = new 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
+import { ContextUpdateTransferClient } from "@uniformdev/canvas-next-rsc-client";
+import React from "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__ */ React.createElement(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
+import {
+  CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE2,
+  CANVAS_EDITOR_STATE as CANVAS_EDITOR_STATE2,
+  CANVAS_ENRICHMENT_TAG_PARAM,
+  CANVAS_PERSONALIZE_TYPE,
+  CANVAS_TEST_TYPE,
+  walkNodeTree
+} from "@uniformdev/canvas";
+import { ClientContextualEditingComponentWrapper, TestClient } from "@uniformdev/canvas-next-rsc-client";
+import {
+  getServerConfig as getServerConfig3,
+  resolvePath as resolvePath2
+} from "@uniformdev/canvas-next-rsc-shared";
+import { PureContextualEditingComponentWrapper } from "@uniformdev/canvas-react/core";
+import { cookies as cookies2, headers } from "next/headers";
+import { notFound, redirect } from "next/navigation";
+import { createElement as createElement3, Fragment as Fragment3 } from "react";
+
+// src/context/createServerUniformContext.ts
+import {
+  createUniformContext
+} from "@uniformdev/canvas-next-rsc-shared";
+import { UNIFORM_DEFAULT_COOKIE_NAME } from "@uniformdev/context";
+import { cookies } from "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 = createUniformContext({
+    ...options || {},
+    serverCookieValue: (_a = cookies().get(UNIFORM_DEFAULT_COOKIE_NAME)) == null ? void 0 : _a.value
+  });
+  return {
+    ...context,
+    __INTERNAL__: {
+      update: (...props) => context.update(...props)
+    }
+  };
+};
+
+// src/utils/route.ts
+import {
+  CANVAS_DRAFT_STATE,
+  CANVAS_EDITOR_STATE,
+  CANVAS_PUBLISHED_STATE
+} from "@uniformdev/canvas";
+import { getBaseUrl, getServerConfig as getServerConfig2, resolvePath } from "@uniformdev/canvas-next-rsc-shared";
+import { getTargetVariableExpandedUrl } from "@uniformdev/redirect";
+var retrieveRoute = async ({
+  params,
+  searchParams
+}) => {
+  const { type, value } = 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;
+    }
+  }
+  if (!result) {
+    return void 0;
+  }
+  return {
+    ...result,
+    path: value
+  };
+};
+var retrieveRouteByPath = async ({
+  path,
+  state,
+  searchParams
+}) => {
+  var _a;
+  const client = getDefaultRouteClient({
+    searchParams
+  });
+  return await client.getRoute({
+    path,
+    state,
+    withComponentIDs: true,
+    withContentSourceMap: isOnVercelPreviewEnvironment() && ((_a = getServerConfig2().experimental) == null ? void 0 : _a.vercelVisualEditing)
+  });
+};
+var resolveRedirectHref = (resolveResult, path) => {
+  let href;
+  if (resolveResult.redirect.targetProjectMapNodeId) {
+    const requestUrl = `${getBaseUrl()}${path}`;
+    const expandedUrl = 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 = [CANVAS_EDITOR_STATE, CANVAS_DRAFT_STATE];
+  } else {
+    states = draftMode2 || previewEnvironment || isDevelopment ? [CANVAS_DRAFT_STATE] : [CANVAS_PUBLISHED_STATE];
+  }
+  return states;
+};
+
+// src/components/ContextUpdateTrigger.tsx
+import { ClientContextUpdate } from "@uniformdev/canvas-next-rsc-client";
+import React2 from "react";
+var ContextUpdateTrigger = () => {
+  return /* @__PURE__ */ React2.createElement(ClientContextUpdate, null);
+};
+
+// src/components/PersonalizeClientWrapper.tsx
+import { PersonalizeClient } from "@uniformdev/canvas-next-rsc-client";
+import { runPersonalization } from "@uniformdev/canvas-next-rsc-shared";
+import React3 from "react";
+var PersonalizeClientWrapper = (props) => {
+  const { indexes } = runPersonalization({
+    ...props,
+    contextInstance: void 0
+  });
+  return /* @__PURE__ */ React3.createElement(PersonalizeClient, { ...props, indexes });
+};
+
+// src/components/PersonalizeServer.ts
+import { CANVAS_PERSONALIZE_SLOT } from "@uniformdev/canvas";
+import { runPersonalization as runPersonalization2 } from "@uniformdev/canvas-next-rsc-shared";
+import { createElement, Fragment } from "react";
+var PersonalizeServer = (props) => {
+  var _a;
+  const { indexes } = runPersonalization2(props);
+  const slot = (_a = props.slots) == null ? void 0 : _a[CANVAS_PERSONALIZE_SLOT];
+  const components = indexes.map((index) => {
+    const component = slot.items[index];
+    return component;
+  });
+  return createElement(Fragment, void 0, components);
+};
+
+// src/components/TestServer.ts
+import { CANVAS_TEST_SLOT, CANVAS_TEST_VARIANT_PARAM } from "@uniformdev/canvas";
+import { createElement as createElement2, Fragment as Fragment2 } from "react";
+var TestServer = ({ test, component, contextInstance, slots }) => {
+  var _a, _b, _c;
+  const slot = ((_a = component.slots) == null ? void 0 : _a[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[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[CANVAS_TEST_SLOT]) == null ? void 0 : _b.items[result.index]) != null ? _c : null : null;
+  return createElement2(Fragment2, void 0, components);
+};
+
+// src/components/UniformComposition.ts
+var UniformComposition = async ({
+  resolveComponent,
+  ...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;
+  }
+  let route = void 0;
+  if (props.composition) {
+    const { value } = resolvePath2(props);
+    route = {
+      type: "composition",
+      compositionApiResponse: props.composition,
+      matchedRoute: "composition",
+      path: value
+    };
+  } else {
+    route = await retrieveRoute({
+      params: props.params,
+      searchParams
+    });
+  }
+  if (!route || route.type === "notFound") {
+    notFound();
+  }
+  if (route.type === "redirect") {
+    const href = resolveRedirectHref(route, route.path);
+    redirect(href);
+  }
+  const state = route.compositionApiResponse.state;
+  if (state === CANVAS_DRAFT_STATE2 || state === CANVAS_EDITOR_STATE2) {
+    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: route.path
+  };
+  const resolved = resolveComposition({
+    composition: route.compositionApiResponse.composition,
+    resolveComponent,
+    serverContext,
+    compositionContext,
+    mode: props.mode
+  });
+  let transfer = null;
+  if (props.mode === "server") {
+    const headersValue = headers();
+    const missingQuirkValue = "unknown";
+    transfer = createElement3(ContextUpdateTransfer, {
+      serverContext,
+      update: {
+        params: props.params,
+        searchParams,
+        cookies: cookies2().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 = createElement3(ContextUpdateTrigger);
+  }
+  return createElement3(Fragment3, void 0, transfer, resolved);
+};
+var isServerComponent = ({
+  component,
+  serverContext
+}) => {
+  var _a, _b;
+  if (component.type === CANVAS_PERSONALIZE_TYPE) {
+    return serverContext && ((_a = getServerConfig3().evaluation) == null ? void 0 : _a.personalization) !== "client";
+  }
+  if (component.type === CANVAS_TEST_TYPE) {
+    return serverContext && ((_b = getServerConfig3().evaluation) == null ? void 0 : _b.testing) !== "client";
+  }
+};
+var resolveSystemComponent = ({
+  component,
+  serverContext
+}) => {
+  const server = isServerComponent({
+    component,
+    serverContext
+  });
+  if (component.type === CANVAS_PERSONALIZE_TYPE) {
+    return server ? PersonalizeServer : PersonalizeClientWrapper;
+  }
+  if (component.type === CANVAS_TEST_TYPE) {
+    return server ? TestServer : 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[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 = createElement3(resolvedComponent, componentProps);
+    let tagElement = null;
+    if (enrichmentTags == null ? void 0 : enrichmentTags.length) {
+      tagElement = createElement3(ContextUpdateTransfer, {
+        key: `${slotName}-${componentIndex}-tags`,
+        update: {
+          enrichments: enrichmentTags
+        },
+        serverContext
+      });
+    }
+    let childNode;
+    if (compositionContext.isContextualEditing) {
+      const elements = [element];
+      if (tagElement) {
+        elements.push(tagElement);
+      }
+      childNode = createElement3(
+        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 = createElement3(
+        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 createElement3(
+      Fragment3,
+      {
+        key: !isRoot ? `${slotName}-${componentIndex}` : void 0
+      },
+      childNode
+    );
+  });
+  return resolved;
+};
+
+// src/components/UniformContext.tsx
+import {
+  DefaultUniformClientContext,
+  UniformScript
+} from "@uniformdev/canvas-next-rsc-client";
+import { Suspense } from "react";
+import React4 from "react";
+var UniformContext = async ({
+  clientContextComponent,
+  children
+}) => {
+  const manifest = await getManifest({
+    searchParams: {}
+  });
+  const ContextComponent = clientContextComponent || DefaultUniformClientContext;
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, children, /* @__PURE__ */ React4.createElement(ContextComponent, { manifest }), /* @__PURE__ */ React4.createElement(Suspense, { fallback: /* @__PURE__ */ React4.createElement(React4.Fragment, null) }, /* @__PURE__ */ React4.createElement(UniformScript, null)));
+};
+
+// src/components/UniformPlayground.tsx
+import { CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE3, CANVAS_EDITOR_STATE as CANVAS_EDITOR_STATE3 } from "@uniformdev/canvas";
+import { notFound as notFound2 } from "next/navigation";
+import React5 from "react";
+var UniformPlayground = async ({ searchParams, ...rest }) => {
+  if (!isDraftModeEnabled({ searchParams })) {
+    return /* @__PURE__ */ React5.createElement("div", null, /* @__PURE__ */ React5.createElement("h1", null, "Playground is only available in draft mode"));
+  }
+  const id = searchParams["id"];
+  if (!id) {
+    notFound2();
+  }
+  const canvasClient = getCanvasClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  const possibleStates = [CANVAS_EDITOR_STATE3, CANVAS_DRAFT_STATE3];
+  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) {
+    notFound2();
+  }
+  return /* @__PURE__ */ React5.createElement(UniformComposition, { mode: "server", params: {}, composition, ...rest });
+};
+export {
+  ContextUpdateTransfer,
+  UniformComposition,
+  UniformContext,
+  UniformPlayground,
+  createServerUniformContext,
+  createStaticParams,
+  generateStaticParams,
+  getCanvasClient,
+  getDefaultCanvasClient,
+  getDefaultManifestClient,
+  getDefaultProjectMapClient,
+  getDefaultRouteClient,
+  getManifest,
+  getManifestClient,
+  getProjectMapClient,
+  getRouteClient,
+  isDevelopmentEnvironment,
+  isDraftModeEnabled,
+  isIncontextEditingEnabled,
+  isOnVercelPreviewEnvironment,
+  resolveComposition
+};