@weaverse/next 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/server.js

@@ -0,0 +1,892 @@
+'use strict';
+
+// src/seo.ts
+function hasOpenGraphContent(seo) {
+  return Boolean(seo?.title || seo?.description || seo?.image || seo?.type);
+}
+function hasTwitterContent(seo) {
+  return Boolean(seo?.title || seo?.description || seo?.image || seo?.cardType);
+}
+function formatWeaverseNextSeoMetadata(seo) {
+  let index = seo?.robots?.index !== false;
+  let follow = seo?.robots?.follow !== false;
+  let metadata = {
+    robots: { index, follow }
+  };
+  if (!seo) {
+    return metadata;
+  }
+  if (seo.title) {
+    metadata.title = seo.title;
+  }
+  if (seo.description) {
+    metadata.description = seo.description;
+  }
+  if (seo.keywords) {
+    metadata.keywords = seo.keywords;
+  }
+  if (seo.canonicalUrl) {
+    metadata.alternates = { canonical: seo.canonicalUrl };
+  }
+  let openGraph = seo.openGraph;
+  if (hasOpenGraphContent(openGraph)) {
+    metadata.openGraph = {
+      title: openGraph?.title,
+      description: openGraph?.description,
+      images: openGraph?.image ? [openGraph.image] : void 0,
+      type: openGraph?.type || "website"
+    };
+  }
+  let twitter = seo.twitter;
+  if (hasTwitterContent(twitter)) {
+    metadata.twitter = {
+      card: twitter?.cardType || "summary",
+      title: twitter?.title,
+      description: twitter?.description,
+      images: twitter?.image ? [twitter.image] : void 0
+    };
+  }
+  return metadata;
+}
+function getWeaverseNextSeoMetadata(data) {
+  if (!data) {
+    return formatWeaverseNextSeoMetadata(null);
+  }
+  let page = "items" in data && "id" in data ? data : data.page ?? null;
+  return formatWeaverseNextSeoMetadata(page?.seo ?? null);
+}
+
+// src/server/configs.ts
+var DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
+var DEFAULT_WEAVERSE_API_BASE = "https://api.weaverse.io";
+var TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
+function isTrustedStudioHost(host) {
+  let parsed;
+  try {
+    parsed = new URL(host);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "https:") {
+    return false;
+  }
+  let { hostname } = parsed;
+  return TRUSTED_STUDIO_DOMAINS.some(
+    (domain) => hostname === domain || hostname.endsWith(`.${domain}`)
+  );
+}
+function toUrl(value) {
+  try {
+    return typeof value === "string" ? new URL(value, "http://localhost") : value;
+  } catch {
+    return null;
+  }
+}
+function getContextSearchParams(context) {
+  if (context?.searchParams) {
+    return new URLSearchParams(context.searchParams);
+  }
+  if (context?.url) {
+    let url = toUrl(context.url);
+    if (url) {
+      return new URLSearchParams(url.searchParams);
+    }
+  }
+  return new URLSearchParams();
+}
+function lastParam(searchParams, key) {
+  let values = searchParams.getAll(key);
+  return values.length ? values.at(-1) : void 0;
+}
+function coerceBool(value) {
+  return value === "true";
+}
+function readEnv(env, key) {
+  let fromConfig = env?.[key];
+  if (fromConfig !== void 0) {
+    return fromConfig;
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return;
+}
+function getWeaverseNextConfigs(context, options = {}) {
+  let searchParams = getContextSearchParams(context);
+  let { env } = options;
+  let queryHost = lastParam(searchParams, "weaverseHost");
+  let trustedUrlHost = queryHost && isTrustedStudioHost(queryHost) ? new URL(queryHost).origin : "";
+  let configuredHost = options.weaverseHost || readEnv(env, "WEAVERSE_HOST") || "";
+  let weaverseHost = trustedUrlHost || configuredHost || DEFAULT_WEAVERSE_HOST;
+  let weaverseApiBase = trustedUrlHost || options.weaverseApiBase || readEnv(env, "WEAVERSE_PUBLIC_API_BASE") || (configuredHost && configuredHost !== DEFAULT_WEAVERSE_HOST ? configuredHost : DEFAULT_WEAVERSE_API_BASE);
+  let isRevisionPreview = context?.isRevisionPreview ?? searchParams.has("__revisionId");
+  let isDesignMode = context?.isDesignMode ?? coerceBool(lastParam(searchParams, "isDesignMode"));
+  let isPreviewMode = context?.isPreviewMode ?? coerceBool(lastParam(searchParams, "isPreviewMode"));
+  return {
+    queryProjectId: lastParam(searchParams, "weaverseProjectId") || "",
+    envProjectId: readEnv(env, "WEAVERSE_PROJECT_ID") || "",
+    weaverseHost,
+    weaverseApiBase,
+    weaverseApiKey: lastParam(searchParams, "weaverseApiKey") || readEnv(env, "WEAVERSE_API_KEY") || "",
+    weaverseVersion: lastParam(searchParams, "weaverseVersion") || options.weaverseVersion || "",
+    isDesignMode,
+    isPreviewMode,
+    isRevisionPreview,
+    sectionType: context?.sectionType || lastParam(searchParams, "sectionType") || "",
+    publicEnv: {
+      PUBLIC_STORE_DOMAIN: readEnv(env, "PUBLIC_STORE_DOMAIN") || "",
+      PUBLIC_STOREFRONT_API_TOKEN: readEnv(env, "PUBLIC_STOREFRONT_API_TOKEN") || ""
+    }
+  };
+}
+
+// src/server/normalize-page-url.ts
+var KEPT_PARAM_RE = /^(?:__revisionId|__weaverseDraftItem|isDesignMode|weaverse)/;
+var DATA_SUFFIX = ".data";
+function normalizeNextPageUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    try {
+      parsed = new URL(url, "http://localhost");
+    } catch {
+      return url;
+    }
+  }
+  let kept = [...parsed.searchParams].filter(([key]) => KEPT_PARAM_RE.test(key));
+  kept.sort(([a], [b]) => a.localeCompare(b));
+  let search = new URLSearchParams(kept).toString();
+  let { pathname } = parsed;
+  if (pathname.endsWith(DATA_SUFFIX)) {
+    pathname = pathname.slice(0, -DATA_SUFFIX.length);
+  }
+  return `${parsed.origin}${pathname}${search ? `?${search}` : ""}`;
+}
+function resolveRequestUrl(context) {
+  if (context?.url) {
+    return typeof context.url === "string" ? context.url : context.url.toString();
+  }
+  let pathname = context?.pathname || "/";
+  let search = context?.searchParams ? new URLSearchParams(context.searchParams).toString() : "";
+  return `http://localhost${pathname}${search ? `?${search}` : ""}`;
+}
+
+// src/utils.ts
+function generateDataFromSchema(schema) {
+  let data = {};
+  if (!schema) {
+    return data;
+  }
+  let groups = schema.settings ?? schema.inspector ?? [];
+  for (let group of groups) {
+    for (let input of group?.inputs ?? []) {
+      let { name, defaultValue } = input;
+      if (name && defaultValue !== null && defaultValue !== void 0) {
+        data[name] = defaultValue;
+      }
+    }
+  }
+  return data;
+}
+
+// src/server/revalidate-handler.ts
+var NO_STORE_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+var STATUS_OK = 200;
+var STATUS_BAD_REQUEST = 400;
+var STATUS_NOT_FOUND = 404;
+var STATUS_UNPROCESSABLE = 422;
+var STATUS_SERVER_ERROR = 500;
+function json(body, status) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: NO_STORE_HEADERS
+  });
+}
+function parseDraftItem(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return null;
+  }
+  let draftItem = payload.draftItem;
+  if (typeof draftItem !== "object" || draftItem === null) {
+    return null;
+  }
+  let { id, type } = draftItem;
+  if (typeof id !== "string" || !id || typeof type !== "string" || !type) {
+    return null;
+  }
+  return draftItem;
+}
+function createWeaverseNextRevalidateHandler(config) {
+  return {
+    POST: async (request) => {
+      let payload;
+      try {
+        payload = await request.json();
+      } catch {
+        return json({ error: "invalid-payload" }, STATUS_BAD_REQUEST);
+      }
+      let draftItem = parseDraftItem(payload);
+      if (!draftItem) {
+        return json({ error: "invalid-payload" }, STATUS_BAD_REQUEST);
+      }
+      let client;
+      try {
+        client = await config.getClient(request);
+      } catch (error) {
+        console.error("\u274C Revalidate handler getClient failed.", error);
+        return json({ error: "client-init-failed" }, STATUS_SERVER_ERROR);
+      }
+      let component = client.components.find(
+        (candidate) => candidate?.schema?.type === draftItem.type
+      );
+      if (!component) {
+        return json({ error: "unknown-component-type" }, STATUS_NOT_FOUND);
+      }
+      if (typeof component.loader !== "function") {
+        return json({ error: "missing-loader" }, STATUS_UNPROCESSABLE);
+      }
+      try {
+        let loaderData = await component.loader({
+          data: {
+            ...generateDataFromSchema(component.schema),
+            ...draftItem.data
+          },
+          weaverse: client,
+          context: client.requestContext,
+          commerce: client.commerce
+        });
+        return json({ loaderData: loaderData ?? null }, STATUS_OK);
+      } catch (error) {
+        console.error(
+          "\u274C Item loader revalidation failed.",
+          draftItem.type,
+          draftItem.id,
+          error
+        );
+        return json({ error: "loader-failed" }, STATUS_SERVER_ERROR);
+      }
+    }
+  };
+}
+
+// src/loader.ts
+function isItemNode(node) {
+  return typeof node === "object" && node !== null && typeof node.type === "string";
+}
+function cloneItem(item) {
+  return {
+    ...item,
+    children: Array.isArray(item.children) ? item.children.map(
+      (child) => isItemNode(child) ? cloneItem(child) : { ...child }
+    ) : item.children
+  };
+}
+async function runWeaverseComponentLoaders(args) {
+  let { client, context, commerce } = args;
+  let sourceData = args.data ?? client.data;
+  if (!sourceData) {
+    return null;
+  }
+  if (!sourceData.page.items.length) {
+    return sourceData;
+  }
+  let data = {
+    ...sourceData,
+    page: {
+      ...sourceData.page,
+      items: sourceData.page.items.map(cloneItem)
+    }
+  };
+  let items = data.page.items;
+  let componentMap = /* @__PURE__ */ new Map();
+  for (let component of client.components) {
+    if (component?.schema?.type) {
+      componentMap.set(component.schema.type, component);
+    }
+  }
+  let visited = /* @__PURE__ */ new Set();
+  let resolvedContext = context ?? client.requestContext;
+  let resolvedCommerce = commerce ?? client.commerce;
+  let resolvedWeaverse = resolvedCommerce === client.commerce ? client : {
+    ...client,
+    commerce: resolvedCommerce,
+    storefront: resolvedCommerce?.storefront
+  };
+  async function walk(nodes) {
+    for (let item of nodes) {
+      if (!item || visited.has(item.id)) {
+        continue;
+      }
+      visited.add(item.id);
+      let component = componentMap.get(item.type);
+      if (component?.loader) {
+        try {
+          item.loaderData = await component.loader({
+            data: { ...generateDataFromSchema(component.schema), ...item.data },
+            weaverse: resolvedWeaverse,
+            context: resolvedContext,
+            commerce: resolvedCommerce
+          });
+        } catch (error) {
+          console.warn("\u274C Item loader run failed.", item.type, item.id, error);
+        }
+      }
+      let children = item.children;
+      if (Array.isArray(children)) {
+        let inlineChildren = children.filter(
+          isItemNode
+        );
+        if (inlineChildren.length) {
+          await walk(inlineChildren);
+        }
+      }
+    }
+  }
+  await walk(items);
+  return data;
+}
+
+// src/request-info.ts
+function toUrl2(value) {
+  return typeof value === "string" ? new URL(value, "http://localhost") : value;
+}
+function getSearchParamsFromContext(context) {
+  if (context?.searchParams) {
+    return new URLSearchParams(context.searchParams);
+  }
+  if (context?.url) {
+    let url = toUrl2(context.url);
+    return new URLSearchParams(url.searchParams);
+  }
+  return new URLSearchParams();
+}
+function getPathnameFromContext(context) {
+  if (context?.pathname) {
+    return context.pathname;
+  }
+  if (context?.url) {
+    let url = toUrl2(context.url);
+    return url.pathname || "/";
+  }
+  return "/";
+}
+function coerceQueryValue(value) {
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  return value;
+}
+function toQueryRecord(searchParams) {
+  let queries = {};
+  for (let [key, value] of searchParams.entries()) {
+    queries[key] = coerceQueryValue(value);
+  }
+  return queries;
+}
+var TRANSIENT_STUDIO_PARAMS = /* @__PURE__ */ new Set([
+  "weaverseDraftItem",
+  // Legacy name from the original design-mode draft-item spike. Keep it out of
+  // runtime requestInfo too, in case an older Builder bundle is in front of a
+  // newer Next storefront.
+  "__weaverseDraftItem"
+]);
+function getRequestInfoSearchParams(context) {
+  let searchParams = new URLSearchParams(getSearchParamsFromContext(context));
+  for (let key of TRANSIENT_STUDIO_PARAMS) {
+    searchParams.delete(key);
+  }
+  return searchParams;
+}
+function buildWeaverseNextRequestInfo(context) {
+  let searchParams = getRequestInfoSearchParams(context);
+  let search = searchParams.toString();
+  return {
+    pathname: getPathnameFromContext(context),
+    search: search ? `?${search}` : "",
+    queries: toQueryRecord(searchParams),
+    ...context?.i18n ? { i18n: context.i18n } : {}
+  };
+}
+
+// src/server/server-client.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+var RANDOM_ID_RADIX = 36;
+var RANDOM_ID_SLICE_START = 2;
+var MAX_CUSTOM_PAGE_PAGES = 100;
+var JSON_HEADERS = {
+  "Content-Type": "application/json",
+  Accept: "application/json",
+  "Accept-Encoding": "gzip, deflate, br"
+};
+function asThemeSchema(schema) {
+  return schema && typeof schema === "object" ? schema : void 0;
+}
+function generateUuid() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `id-${Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_SLICE_START)}`;
+}
+function normalizeWeaverseNextPageAssignment(input) {
+  if (!input || typeof input !== "object") {
+    return;
+  }
+  let { projectId, type, handle, locale, meta } = input;
+  if (typeof projectId !== "string" || typeof type !== "string" || typeof handle !== "string") {
+    return;
+  }
+  let normalized = {
+    projectId,
+    type,
+    handle,
+    locale: typeof locale === "string" ? locale : ""
+  };
+  if (meta && typeof meta === "object") {
+    normalized.meta = meta;
+  }
+  return normalized;
+}
+var NextServerClient = class {
+  components;
+  commerce;
+  requestContext;
+  themeSchema;
+  themeSettings;
+  data = null;
+  dataContext = {};
+  configs;
+  _projectIdInput;
+  _baseConfigs;
+  _fetch;
+  _cache;
+  _fetchTimeoutMs;
+  _resolvedProjectId;
+  constructor(config) {
+    this.components = config.components;
+    this.commerce = config.commerce;
+    this.requestContext = config.requestContext;
+    this.themeSchema = config.themeSchema;
+    this.themeSettings = {
+      ...generateDataFromSchema(config.themeSchema),
+      ...config.themeSettings
+    };
+    this._projectIdInput = config.projectId;
+    this._fetch = config.fetch ?? globalThis.fetch;
+    this._cache = config.cache;
+    this._fetchTimeoutMs = config.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+    this._baseConfigs = getWeaverseNextConfigs(config.requestContext, {
+      env: config.env,
+      weaverseHost: config.weaverseHost,
+      weaverseApiBase: config.weaverseApiBase,
+      weaverseVersion: config.weaverseVersion
+    });
+    this.configs = this._buildPublicConfigs(
+      this._baseConfigs.queryProjectId || (typeof this._projectIdInput === "string" ? this._projectIdInput.trim() : "") || this._baseConfigs.envProjectId
+    );
+  }
+  get projectId() {
+    return this.configs.projectId;
+  }
+  /** Compatibility alias so loaders can call `weaverse.storefront.query(...)`. */
+  get storefront() {
+    return this.commerce?.storefront;
+  }
+  _buildPublicConfigs(projectId) {
+    let base = this._baseConfigs;
+    return {
+      projectId,
+      weaverseHost: base.weaverseHost,
+      weaverseApiBase: base.weaverseApiBase,
+      weaversePublicApiBase: base.weaverseApiBase,
+      weaverseVersion: base.weaverseVersion,
+      isDesignMode: base.isDesignMode,
+      isPreviewMode: base.isPreviewMode,
+      isRevisionPreview: base.isRevisionPreview,
+      sectionType: base.sectionType,
+      publicEnv: base.publicEnv
+    };
+  }
+  resolveProjectId = async () => {
+    if (this._resolvedProjectId !== void 0) {
+      return this._resolvedProjectId;
+    }
+    let resolved = this._baseConfigs.queryProjectId;
+    if (!resolved && typeof this._projectIdInput === "function") {
+      try {
+        let value = await this._projectIdInput(this.requestContext);
+        if (typeof value === "string" && value.trim()) {
+          resolved = value.trim();
+        }
+      } catch (error) {
+        console.warn(
+          "[WeaverseNextServerClient] projectId resolver threw, falling back.",
+          error
+        );
+      }
+    }
+    if (!resolved && typeof this._projectIdInput === "string") {
+      resolved = this._projectIdInput.trim();
+    }
+    if (!resolved) {
+      resolved = this._baseConfigs.envProjectId;
+    }
+    this._resolvedProjectId = resolved;
+    this.configs = this._buildPublicConfigs(resolved);
+    return resolved;
+  };
+  fetchWithCache = async (url, options = {}) => {
+    let { revalidate, tags, ...init } = options;
+    let requestInit = { ...init };
+    let { isDesignMode, isRevisionPreview } = this._baseConfigs;
+    if (isDesignMode || isRevisionPreview) {
+      requestInit.cache = "no-store";
+    } else if (requestInit.cache === void 0) {
+      let effectiveRevalidate = revalidate ?? this._cache?.revalidate;
+      let effectiveTags = tags ?? this._cache?.tags;
+      if (effectiveRevalidate !== void 0 || effectiveTags?.length) {
+        requestInit.next = {
+          ...effectiveRevalidate === void 0 ? {} : { revalidate: effectiveRevalidate },
+          ...effectiveTags?.length ? { tags: effectiveTags } : {}
+        };
+      }
+    }
+    let controller = new AbortController();
+    let timeoutId = setTimeout(() => controller.abort(), this._fetchTimeoutMs);
+    try {
+      let response = await this._fetch(url, {
+        ...requestInit,
+        signal: requestInit.signal ?? controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  };
+  _buildCustomPagesUrl(projectId, options, cursor) {
+    let params = new URLSearchParams();
+    if (options.locale) {
+      params.set("locale", options.locale);
+    }
+    if (options.limit) {
+      params.set("limit", String(options.limit));
+    }
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    let qs = params.toString();
+    return `${this._baseConfigs.weaverseApiBase}/api/public/v1/projects/${projectId}/custom-pages${qs ? `?${qs}` : ""}`;
+  }
+  /**
+   * Fetch all published custom pages for sitemap generation. Mirrors Hydrogen's
+   * helper but uses Next's fetch cache knobs (`revalidate` / `tags`). It returns
+   * accumulated results on partial pagination failure so a single API hiccup
+   * does not break sitemap generation entirely.
+   */
+  fetchCustomPages = async (options = {}) => {
+    let projectId = await this.resolveProjectId();
+    let entries = [];
+    if (!projectId) {
+      console.warn(
+        "[WeaverseNext] Failed to fetch custom pages: missing projectId"
+      );
+      return entries;
+    }
+    let cursor = null;
+    for (let page = 0; page < MAX_CUSTOM_PAGE_PAGES; page += 1) {
+      let url = this._buildCustomPagesUrl(projectId, options, cursor);
+      try {
+        let result = await this.fetchWithCache(url, {
+          revalidate: options.revalidate,
+          tags: options.tags
+        });
+        entries.push(...result.data ?? []);
+        if (!result.nextCursor) {
+          return entries;
+        }
+        cursor = result.nextCursor;
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          entries.length === 0 ? `[WeaverseNext] Failed to fetch custom pages: ${message}` : `[WeaverseNext] Custom pages pagination interrupted: ${message}`
+        );
+        return entries;
+      }
+    }
+    console.warn("[WeaverseNext] Custom pages pagination cap reached");
+    return entries;
+  };
+  _generateFallbackPage(message) {
+    let rootId = generateUuid();
+    return {
+      id: `fallback_page_${rootId}`,
+      rootId,
+      name: "Default Page",
+      items: [
+        {
+          type: "main",
+          id: rootId,
+          data: { dangerouslySetInnerHTML: { __html: message } }
+        }
+      ]
+    };
+  }
+  /**
+   * Recursively materialize a section preset (and its preset children) into a
+   * flat list of page items, returning the new item id. Ported from Hydrogen's
+   * `recursivelyAddDataItem`. Returns `undefined` when the type isn't registered.
+   */
+  _buildPreviewItems(type, items, initData = {}) {
+    let component = this.components.find((c) => c.schema?.type === type);
+    if (!component) {
+      return;
+    }
+    let { children, ...data } = component.schema?.presets ?? {};
+    let childIds = [];
+    if (children) {
+      for (let child of children) {
+        let { type: childType, children: _children, ...childData } = child;
+        let childId = this._buildPreviewItems(childType, items, childData);
+        if (childId) {
+          childIds.push({ id: childId });
+        }
+      }
+    }
+    let id = generateUuid();
+    items.push({ id, type, data: { ...data, ...initData }, children: childIds });
+    return id;
+  }
+  /**
+   * Synthetic loader data for Studio "section preview" mode. Mirrors Hydrogen's
+   * `getPreviewData`: it builds a single-section page from the requested
+   * `sectionType`'s presets without hitting `/api/public/project`, so preview
+   * works even without a resolved `projectId`.
+   */
+  _generatePreviewData(projectId) {
+    let { sectionType, weaverseHost } = this._baseConfigs;
+    let items = [];
+    let sectionId = sectionType ? this._buildPreviewItems(sectionType, items) : void 0;
+    let configs = {
+      ...this._buildPublicConfigs(projectId),
+      isPreviewMode: true,
+      weaverseHost,
+      requestInfo: buildWeaverseNextRequestInfo(this.requestContext)
+    };
+    return {
+      project: {
+        id: projectId,
+        weaverseShopId: "shop-id",
+        name: "Section Preview"
+      },
+      configs,
+      page: {
+        id: "weaverse-preview-page",
+        name: "Preview section",
+        rootId: "1",
+        items: [
+          {
+            id: "1",
+            type: "main",
+            data: {},
+            children: sectionId ? [{ id: sectionId }] : []
+          },
+          ...items
+        ]
+      }
+    };
+  }
+  _getLoadPageInput(input) {
+    let {
+      cache,
+      projectId: routeProjectId,
+      ...rest
+    } = input;
+    let params = {};
+    for (let [key, value] of Object.entries(rest)) {
+      if (value !== void 0) {
+        params[key] = value;
+      }
+    }
+    return { cache, params, routeProjectId };
+  }
+  async _resolveLoadPageProjectId(routeProjectId) {
+    let effectiveProjectId = typeof routeProjectId === "string" && routeProjectId.trim() || await this.resolveProjectId();
+    if (effectiveProjectId) {
+      this.configs = this._buildPublicConfigs(effectiveProjectId);
+    }
+    return effectiveProjectId;
+  }
+  _fetchPagePayload(projectId, params, cache) {
+    let i18n = this.requestContext?.i18n ?? this.commerce?.storefront?.i18n;
+    let url = normalizeNextPageUrl(resolveRequestUrl(this.requestContext));
+    let apiUrl = `${this._baseConfigs.weaverseApiBase}/api/public/project`;
+    let userAgent = this.requestContext?.headers?.get("user-agent") ?? "";
+    return this.fetchWithCache(apiUrl, {
+      method: "POST",
+      body: JSON.stringify({
+        projectId,
+        url,
+        i18n,
+        params,
+        isDesignMode: this._baseConfigs.isDesignMode
+      }),
+      headers: { ...JSON_HEADERS, "X-Visitor-UA": userAgent },
+      ...cache ?? {}
+    });
+  }
+  _assertNoPageError(payload) {
+    if ("error" in payload && typeof payload.error === "string") {
+      throw new Error(payload.error);
+    }
+  }
+  _createLoaderData(payload, projectId) {
+    this._assertNoPageError(payload);
+    let page = payload.page;
+    let project = payload.project;
+    let pageAssignment = normalizeWeaverseNextPageAssignment(
+      payload.pageAssignment
+    );
+    page ??= this._generateFallbackPage(
+      '<div style="text-align: center;">Please add new section to start.</div>'
+    );
+    project ??= {
+      id: projectId,
+      name: "Weaverse project not found.",
+      weaverseShopId: ""
+    };
+    if (Array.isArray(page.items) && page.items.length === 0) {
+      page.items.push({
+        type: "main",
+        id: page.rootId || generateUuid(),
+        data: {}
+      });
+    }
+    return {
+      page,
+      project,
+      pageAssignment,
+      configs: {
+        ...this._buildPublicConfigs(projectId),
+        requestInfo: buildWeaverseNextRequestInfo(this.requestContext)
+      }
+    };
+  }
+  async _runLoaders(data) {
+    this.data = data;
+    let withLoaders = await runWeaverseComponentLoaders({ client: this, data });
+    this.data = withLoaders ?? data;
+    return this.data;
+  }
+  loadPage = async (input = {}) => {
+    try {
+      let { cache, params, routeProjectId } = this._getLoadPageInput(input);
+      let projectId = await this._resolveLoadPageProjectId(routeProjectId);
+      if (this._baseConfigs.isPreviewMode) {
+        let previewData = this._generatePreviewData(projectId || "x");
+        this.data = previewData;
+        return previewData;
+      }
+      if (!projectId) {
+        throw new Error("Missing Weaverse projectId!");
+      }
+      let payload = await this._fetchPagePayload(projectId, params, cache);
+      let data = this._createLoaderData(payload, projectId);
+      return await this._runLoaders(data);
+    } catch (error) {
+      console.error("\u274C Page load failed", {
+        url: this.requestContext?.url,
+        projectId: input.projectId || this.configs.projectId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  };
+  loadThemeSettings = async (optionsInput = {}) => {
+    let options = optionsInput;
+    let themeSchema = asThemeSchema(this.themeSchema);
+    let defaultThemeSettings = generateDataFromSchema(this.themeSchema);
+    let staticContent = themeSchema?.i18n?.staticContent;
+    try {
+      let projectId = await this.resolveProjectId();
+      if (!projectId) {
+        throw new Error("Missing Weaverse projectId!");
+      }
+      let { isDesignMode } = this._baseConfigs;
+      let url = `${this._baseConfigs.weaverseApiBase}/api/public/project_configs`;
+      let result = await this.fetchWithCache(
+        url,
+        {
+          method: "POST",
+          body: JSON.stringify({ projectId, isDesignMode }),
+          headers: JSON_HEADERS,
+          revalidate: options.revalidate,
+          tags: options.tags
+        }
+      );
+      if (typeof result !== "object" || result === null) {
+        result = { theme: defaultThemeSettings };
+      }
+      if (themeSchema?.settings || themeSchema?.inspector) {
+        if (!result.theme || typeof result.theme !== "object") {
+          result.theme = defaultThemeSettings;
+        } else {
+          result.theme = { ...defaultThemeSettings, ...result.theme };
+        }
+      }
+      if (staticContent) {
+        result.staticContent = staticContent;
+      }
+      if (isDesignMode) {
+        let serializableSchema = themeSchema ? {
+          ...themeSchema,
+          settings: themeSchema.settings?.map((group) => ({
+            ...group,
+            inputs: group?.inputs?.map(
+              (inputItem) => typeof inputItem?.condition === "function" ? {
+                ...inputItem,
+                condition: inputItem.condition.toString()
+              } : inputItem
+            )
+          }))
+        } : void 0;
+        result = {
+          ...result,
+          schema: serializableSchema,
+          publicEnv: this._baseConfigs.publicEnv
+        };
+      }
+      return result;
+    } catch (error) {
+      let errorDetails = error instanceof Error ? error.message : String(error);
+      console.error("Unable to load theme settings", errorDetails);
+      return {
+        theme: defaultThemeSettings,
+        staticContent,
+        _error: errorDetails,
+        _loadFailed: true
+      };
+    }
+  };
+};
+function createWeaverseNextServerClient(config) {
+  return new NextServerClient(config);
+}
+
+exports.createWeaverseNextRevalidateHandler = createWeaverseNextRevalidateHandler;
+exports.createWeaverseNextServerClient = createWeaverseNextServerClient;
+exports.formatWeaverseNextSeoMetadata = formatWeaverseNextSeoMetadata;
+exports.getWeaverseNextConfigs = getWeaverseNextConfigs;
+exports.getWeaverseNextSeoMetadata = getWeaverseNextSeoMetadata;
+exports.normalizeNextPageUrl = normalizeNextPageUrl;
+exports.resolveRequestUrl = resolveRequestUrl;
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map