@weaverse/hydrogen 6.1.2 → 6.2.0

package/dist/next-server.js

@@ -1,14 +1,670 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _weaverse_next_server = require("@weaverse/next/server");
-Object.defineProperty(exports, "createWeaverseNextRevalidateHandler", {
-	enumerable: true,
-	get: function() {
-		return _weaverse_next_server.createWeaverseNextRevalidateHandler;
-	}
-});
-Object.defineProperty(exports, "createWeaverseNextServerClient", {
-	enumerable: true,
-	get: function() {
-		return _weaverse_next_server.createWeaverseNextServerClient;
-	}
-});
+const require_seo = require("./seo-D9A9uRQ4.js");
+let _weaverse_schema = require("@weaverse/schema");
+//#region src/next/server/configs.ts
+const DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
+const DEFAULT_WEAVERSE_API_BASE = "https://api.weaverse.io";
+const 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];
+}
+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,
+		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") || ""
+		}
+	};
+}
+//#endregion
+//#region src/next/server/normalize-page-url.ts
+const KEPT_PARAM_RE = /^(?:__revisionId|__weaverseDraftItem|isDesignMode|weaverse)/;
+const 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, -5);
+	return `${parsed.origin}${pathname}${search ? `?${search}` : ""}`;
+}
+function resolveRequestUrl(context) {
+	if (context?.url) {
+		let raw = String(context.url);
+		let url = new URL(raw, "http://localhost");
+		let pathname = require_seo.withPathPrefix(url.pathname, context.i18n);
+		if (pathname === url.pathname) return raw;
+		url.pathname = pathname;
+		return url.toString();
+	}
+	let pathname = require_seo.withPathPrefix(context?.pathname || "/", context?.i18n);
+	let search = context?.searchParams ? new URLSearchParams(context.searchParams).toString() : "";
+	return `http://localhost${pathname}${search ? `?${search}` : ""}`;
+}
+//#endregion
+//#region src/next/server/revalidate-handler.ts
+const NO_STORE_HEADERS = {
+	"Content-Type": "application/json",
+	"Cache-Control": "no-store"
+};
+const STATUS_OK = 200;
+const STATUS_BAD_REQUEST = 400;
+const STATUS_NOT_FOUND = 404;
+const STATUS_UNPROCESSABLE = 422;
+const STATUS_SERVER_ERROR = 500;
+const MAX_PATHNAME_LENGTH = 2048;
+const MAX_SEARCH_LENGTH = 8192;
+const MAX_HANDLE_LENGTH = 512;
+const MAX_I18N_FIELD_LENGTH = 256;
+const CONTROL_CHAR_PATTERN = /[\u0000-\u001F\u007F]/;
+function isValidPathname(pathname) {
+	if (!pathname || pathname.length > MAX_PATHNAME_LENGTH) return false;
+	if (pathname[0] !== "/" || pathname.startsWith("//")) return false;
+	if (pathname.includes("\\") || pathname.includes("?")) return false;
+	if (pathname.includes("#") || CONTROL_CHAR_PATTERN.test(pathname)) return false;
+	return true;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	let proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function sanitizeRouteContextI18n(input) {
+	if (input === void 0) return;
+	if (!isPlainObject(input)) return null;
+	let source = input;
+	let allowed = new Set(require_seo.ROUTE_CONTEXT_I18N_KEYS);
+	for (let key of Object.keys(source)) if (!allowed.has(key)) return null;
+	let result = {};
+	for (let key of require_seo.ROUTE_CONTEXT_I18N_KEYS) {
+		let value = source[key];
+		if (value === void 0) continue;
+		if (typeof value !== "string" || value.length > MAX_I18N_FIELD_LENGTH) return null;
+		result[key] = value;
+	}
+	return Object.keys(result).length ? result : void 0;
+}
+function reconstructRouteContext(request, routeContext) {
+	if (typeof routeContext !== "object" || routeContext === null || Array.isArray(routeContext)) return null;
+	let { pathname, search, handle, pageType, i18n } = routeContext;
+	if (typeof pathname !== "string" || !isValidPathname(pathname)) return null;
+	if (typeof search !== "string" || search.length > MAX_SEARCH_LENGTH) return null;
+	let rawSearch = search;
+	if (rawSearch.length && !rawSearch.startsWith("?")) return null;
+	let sanitizedI18n = sanitizeRouteContextI18n(i18n);
+	if (sanitizedI18n === null) return null;
+	let resolvedPageType;
+	if (pageType !== void 0) {
+		let parsed = _weaverse_schema.PageTypeSchema.safeParse(pageType);
+		if (!parsed.success) return null;
+		resolvedPageType = parsed.data;
+	}
+	let resolvedHandle;
+	if (handle !== void 0) {
+		if (typeof handle !== "string" || !handle || handle.length > MAX_HANDLE_LENGTH) return null;
+		resolvedHandle = handle;
+	}
+	let endpointUrl = new URL(request.url);
+	let routeUrl = new URL(endpointUrl.origin);
+	routeUrl.pathname = pathname;
+	routeUrl.search = require_seo.sanitizeRouteContextSearch(rawSearch);
+	let canonicalPathname = routeUrl.pathname;
+	let searchParams = routeUrl.searchParams;
+	let lastParam = (key) => {
+		let values = searchParams.getAll(key);
+		return values.length ? values.at(-1) : void 0;
+	};
+	return {
+		pathname: canonicalPathname,
+		searchParams,
+		url: routeUrl,
+		headers: new Headers(request.headers),
+		...sanitizedI18n ? { i18n: sanitizedI18n } : {},
+		...resolvedPageType ? { pageType: resolvedPageType } : {},
+		...resolvedHandle ? { handle: resolvedHandle } : {},
+		isDesignMode: lastParam("isDesignMode") === "true",
+		isPreviewMode: lastParam("isPreviewMode") === "true",
+		isRevisionPreview: searchParams.has("__revisionId"),
+		sectionType: lastParam("sectionType") || void 0
+	};
+}
+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 requestContext;
+		let body = payload;
+		if (Object.hasOwn(body, "routeContext")) {
+			let reconstructed = reconstructRouteContext(request, body.routeContext);
+			if (!reconstructed) return json({ error: "invalid-route-context" }, STATUS_BAD_REQUEST);
+			requestContext = reconstructed;
+		}
+		let client;
+		try {
+			client = await config.getClient(request, requestContext);
+		} catch (error) {
+			console.error("❌ 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 {
+			return json({ loaderData: await component.loader({
+				data: {
+					...require_seo.generateDataFromSchema(component.schema),
+					...draftItem.data
+				},
+				weaverse: client,
+				context: client.requestContext,
+				commerce: client.commerce
+			}) ?? null }, STATUS_OK);
+		} catch (error) {
+			console.error("❌ Item loader revalidation failed.", draftItem.type, draftItem.id, error);
+			return json({ error: "loader-failed" }, STATUS_SERVER_ERROR);
+		}
+	} };
+}
+//#endregion
+//#region src/next/server/server-client.ts
+const DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+const RANDOM_ID_RADIX = 36;
+const RANDOM_ID_SLICE_START = 2;
+const MAX_CUSTOM_PAGE_PAGES = 100;
+const 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 = {
+			...require_seo.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;
+	}
+	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}` : ""}`;
+	}
+	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 } }
+			}]
+		};
+	}
+	_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;
+	}
+	_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: require_seo.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: require_seo.buildWeaverseNextRequestInfo(this.requestContext)
+			}
+		};
+	}
+	async _runLoaders(data) {
+		this.data = data;
+		let withLoaders = await require_seo.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("❌ Page load failed", {
+				url: this.requestContext?.url,
+				projectId: input.projectId || this.configs.projectId,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			return null;
+		}
+	};
+	_resolveOverridesLocale() {
+		let i18n = this.requestContext?.i18n;
+		let language = typeof i18n?.language === "string" ? i18n.language.trim() : "";
+		let country = typeof i18n?.country === "string" ? i18n.country.trim() : "";
+		if (!(language && country)) return;
+		return `${language.toLowerCase()}-${country.toLowerCase()}`;
+	}
+	async _fetchMerchantOverrides(projectId, options) {
+		let { weaverseHost } = this._baseConfigs;
+		if (!(asThemeSchema(this.themeSchema)?.i18n && projectId && weaverseHost)) return;
+		let locale = this._resolveOverridesLocale();
+		if (!locale) return;
+		let url = `${weaverseHost}/api/translation/static?projectId=${projectId}&locale=${locale}`;
+		try {
+			let overrides = await this.fetchWithCache(url, {
+				method: "GET",
+				headers: { Accept: "application/json" },
+				revalidate: options.revalidate,
+				tags: options.tags
+			});
+			return typeof overrides === "object" && overrides !== null ? overrides : void 0;
+		} catch (error) {
+			console.warn("[WeaverseNext] Unable to load merchant overrides, using theme defaults:", error instanceof Error ? error.message : String(error));
+			return;
+		}
+	}
+	loadThemeSettings = async (optionsInput = {}) => {
+		let options = optionsInput;
+		let themeSchema = asThemeSchema(this.themeSchema);
+		let defaultThemeSettings = require_seo.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, merchantOverrides] = await Promise.all([this.fetchWithCache(url, {
+				method: "POST",
+				body: JSON.stringify({
+					projectId,
+					isDesignMode
+				}),
+				headers: JSON_HEADERS,
+				revalidate: options.revalidate,
+				tags: options.tags
+			}), this._fetchMerchantOverrides(projectId, options)]);
+			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 (merchantOverrides) result.merchantOverrides = merchantOverrides;
+			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);
+}
+//#endregion
+exports.createWeaverseNextRevalidateHandler = createWeaverseNextRevalidateHandler;
+exports.createWeaverseNextServerClient = createWeaverseNextServerClient;
+exports.formatWeaverseNextSeoMetadata = require_seo.formatWeaverseNextSeoMetadata;
+exports.getWeaverseNextSeoMetadata = require_seo.getWeaverseNextSeoMetadata;
+
+//# sourceMappingURL=next-server.js.map