@weaverse/hydrogen 6.1.3 → 6.2.0

package/dist/next-client-boundary.mjs

@@ -0,0 +1,1038 @@
+'use client'
+import { StudioSelectionStore, StudioSelectionStoreContext, Weaverse, WeaverseItemStore, WeaverseRoot, useChildInstances, useItemInstance, useParentInstance, useSafeExternalStore, useStudioSelection, useWeaverse } from "@weaverse/react";
+import { PageTypeSchema, createSchema } from "@weaverse/schema";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createContext, memo, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { useRouter } from "next/navigation";
+//#region src/next/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;
+}
+typeof window !== "undefined" && (window.top, window.self);
+//#endregion
+//#region src/next/item.ts
+function flattenItemData(update) {
+	let { data, ...rest } = update;
+	if (!(data && typeof data === "object" && !Array.isArray(data))) return rest;
+	return {
+		...data,
+		...rest
+	};
+}
+let deferredItemUpdates = null;
+function collectDeferredItemUpdates(create) {
+	let previousQueue = deferredItemUpdates;
+	let queue = /* @__PURE__ */ new Set();
+	deferredItemUpdates = queue;
+	try {
+		return [create(), [...queue]];
+	} finally {
+		deferredItemUpdates = previousQueue;
+	}
+}
+var WeaverseNextItem = class extends WeaverseItemStore {
+	_cachedSnapshot = null;
+	_snapshotStoreRef = null;
+	_snapshotTranslationRef = null;
+	constructor(initialData, weaverse) {
+		super(initialData, weaverse);
+		let schemaData = generateDataFromSchema(this.Element?.schema);
+		Object.assign(this._store, schemaData, flattenItemData(initialData));
+	}
+	setData = (update) => {
+		if ("id" in update && "type" in update) {
+			let { data, type } = update;
+			let schema = this.weaverse.elementRegistry.get(type)?.schema;
+			this._store = {
+				...generateDataFromSchema(schema),
+				...data === void 0 ? {} : { data },
+				...flattenItemData(update)
+			};
+		} else this.data = flattenItemData(update);
+		if (deferredItemUpdates) deferredItemUpdates.add(this);
+		else this.triggerUpdate();
+		return this.data;
+	};
+	getSnapShot = () => {
+		let base = this._store;
+		let translations = this.weaverse.translationMap[this._id];
+		if (!translations) return base;
+		if (this._cachedSnapshot && this._snapshotStoreRef === base && this._snapshotTranslationRef === translations) return this._cachedSnapshot;
+		let merged = { ...base };
+		for (let [key, entry] of Object.entries(translations)) if (entry.translatedValue !== void 0) merged[key] = entry.translatedValue;
+		this._cachedSnapshot = merged;
+		this._snapshotStoreRef = base;
+		this._snapshotTranslationRef = translations;
+		return merged;
+	};
+};
+function ensureNextItemConstructor() {
+	if (!Weaverse.ItemConstructor || Weaverse.ItemConstructor === WeaverseItemStore || Weaverse.ItemConstructor === WeaverseNextItem) Weaverse.ItemConstructor = WeaverseNextItem;
+}
+//#endregion
+//#region src/next/main.tsx
+function Main(props) {
+	let { children, loaderData, ...rest } = props;
+	return /* @__PURE__ */ jsx("div", {
+		...rest,
+		children
+	});
+}
+Main.displayName = "main";
+const defaultMainComponent = {
+	default: Main,
+	schema: createSchema({
+		type: "main",
+		title: "Main"
+	})
+};
+//#endregion
+//#region src/next/registry.ts
+const MAIN_TYPE = "main";
+const registeredComponentTypes = /* @__PURE__ */ new Set();
+function registerWeaverseNextComponents(components) {
+	ensureNextItemConstructor();
+	let hasUserMain = components.some((component) => component.schema?.type === MAIN_TYPE);
+	let effectiveComponents = hasUserMain ? components : [defaultMainComponent, ...components];
+	for (let component of effectiveComponents) {
+		let type = component.schema.type;
+		let element = {
+			type,
+			Component: component.default,
+			schema: component.schema,
+			loader: component.loader
+		};
+		if (type === MAIN_TYPE && hasUserMain) {
+			Weaverse.elementRegistry.set(type, element);
+			registeredComponentTypes.add(type);
+			continue;
+		}
+		if (type && !registeredComponentTypes.has(type)) {
+			Weaverse.registerElement(element);
+			registeredComponentTypes.add(type);
+		}
+	}
+}
+//#endregion
+//#region src/next/client.ts
+var NextClient = class {
+	projectId;
+	components;
+	themeSchema;
+	themeSettings;
+	requestContext;
+	commerce;
+	data = null;
+	dataContext = {};
+	_fetchPage;
+	_fetchThemeSettings;
+	constructor(config) {
+		this.projectId = config.projectId;
+		this.components = config.components;
+		registerWeaverseNextComponents(this.components);
+		this.themeSchema = config.themeSchema;
+		this.themeSettings = {
+			...generateDataFromSchema(config.themeSchema),
+			...config.themeSettings
+		};
+		this.requestContext = config.requestContext;
+		this.commerce = config.commerce;
+		this._fetchPage = config.fetchPage;
+		this._fetchThemeSettings = config.fetchThemeSettings;
+	}
+	get storefront() {
+		return this.commerce?.storefront;
+	}
+	loadPage = (input = {}) => {
+		if (!this._fetchPage) throw new Error("[WeaverseNextClient] loadPage requires a `fetchPage` function in client config.");
+		return this._fetchPage(input);
+	};
+	loadThemeSettings = (context) => {
+		if (!this._fetchThemeSettings) throw new Error("[WeaverseNextClient] loadThemeSettings requires a `fetchThemeSettings` function in client config.");
+		return this._fetchThemeSettings(context ?? this.requestContext);
+	};
+};
+function createWeaverseNextClient(config) {
+	return new NextClient(config);
+}
+//#endregion
+//#region src/utils/translation-store.ts
+var TranslationStore = class {
+	overrides = {};
+	listeners = /* @__PURE__ */ new Set();
+	setOverrides = (overrides) => {
+		this.overrides = { ...overrides };
+		this.emit();
+	};
+	updateOverrides = (newOverrides) => {
+		this.overrides = {
+			...this.overrides,
+			...newOverrides
+		};
+		this.emit();
+	};
+	getSnapshot = () => this.overrides;
+	getServerSnapshot = () => this.overrides;
+	subscribe = (callback) => {
+		this.listeners.add(callback);
+		return () => {
+			this.listeners.delete(callback);
+		};
+	};
+	emit = () => {
+		for (const listener of Array.from(this.listeners)) try {
+			listener();
+		} catch (error) {
+			console.error("TranslationStore: Listener error", error);
+		}
+	};
+};
+//#endregion
+//#region src/next/theme-settings-store.ts
+function createWeaverseNextThemeSettingsStore(options = {}) {
+	let listeners = /* @__PURE__ */ new Set();
+	let store = {
+		publicEnv: options.publicEnv,
+		schema: options.schema,
+		settings: { ...options.settings ?? {} },
+		getServerSnapshot: () => store.settings,
+		getSnapshot: () => store.settings,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		updateThemeSettings: (next) => {
+			store.settings = {
+				...store.settings,
+				...next
+			};
+			for (let listener of listeners) listener();
+		}
+	};
+	return store;
+}
+//#endregion
+//#region src/utils/nested-key.ts
+function getNestedKey(obj, path, fallback) {
+	const keys = path.split(".");
+	let current = obj;
+	for (const key of keys) {
+		if (current == null || typeof current !== "object") return fallback;
+		current = current[key];
+	}
+	if (typeof current === "string") return current;
+	return fallback;
+}
+//#endregion
+//#region src/utils/translate.ts
+function interpolate(template, variables) {
+	if (!variables) return template;
+	return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+		let value = variables[key];
+		return value === void 0 ? match : String(value);
+	});
+}
+function createTranslate(sources) {
+	let { staticContent, merchantOverrides, designOverrides, externalT } = sources;
+	return (key, variables) => {
+		if (externalT) {
+			let external = externalT(key, variables);
+			if (external && external !== key) return external;
+		}
+		let design = designOverrides && Object.hasOwn(designOverrides, key) ? designOverrides[key] : void 0;
+		let override = merchantOverrides ? getNestedKey(merchantOverrides, key) : void 0;
+		let staticValue = getNestedKey(staticContent, key);
+		return interpolate(design ?? override ?? staticValue ?? key, variables);
+	};
+}
+//#endregion
+//#region src/next/translation-context.tsx
+const TranslationContext = createContext(null);
+TranslationContext.displayName = "WeaverseNextTranslationContext";
+const EMPTY = {};
+const NOOP_SUBSCRIBE = () => () => {};
+const NOOP_SNAPSHOT = () => EMPTY;
+function TranslationProvider({ staticContent, merchantOverrides, t: externalT, translationStore, themeTextStore, children }) {
+	let store = translationStore ?? themeTextStore ?? null;
+	let designOverrides = useSafeExternalStore(store?.subscribe ?? NOOP_SUBSCRIBE, store?.getSnapshot ?? NOOP_SNAPSHOT, store?.getServerSnapshot ?? NOOP_SNAPSHOT);
+	let value = useMemo(() => ({
+		t: createTranslate({
+			staticContent,
+			merchantOverrides,
+			designOverrides,
+			externalT
+		}),
+		translationStore: store,
+		themeTextStore: store,
+		merchantOverrides: merchantOverrides ?? null
+	}), [
+		staticContent,
+		merchantOverrides,
+		designOverrides,
+		externalT,
+		store
+	]);
+	return /* @__PURE__ */ jsx(TranslationContext.Provider, {
+		value,
+		children
+	});
+}
+function useTranslation() {
+	let ctx = useContext(TranslationContext);
+	if (!ctx) throw new Error("useTranslation must be used within <TranslationProvider>. Wrap your app with <WeaverseNextRootProvider>.");
+	return ctx;
+}
+const ThemeTextProvider = TranslationProvider;
+const useThemeText = useTranslation;
+//#endregion
+//#region src/next/root-provider.tsx
+const WeaverseNextRootContext = createContext(null);
+function WeaverseNextRootProvider(props) {
+	let { children, initialThemeSettings, merchantOverrides, staticContent, t, themeSchema, publicEnv } = props;
+	let storeRef = useRef(null);
+	if (!storeRef.current) storeRef.current = createWeaverseNextThemeSettingsStore({
+		publicEnv,
+		schema: themeSchema,
+		settings: initialThemeSettings
+	});
+	let themeSettingsStore = storeRef.current;
+	let translationStoreRef = useRef(null);
+	if (!translationStoreRef.current) translationStoreRef.current = new TranslationStore();
+	let translationStore = translationStoreRef.current;
+	let [studioSelectionStore] = useState(() => new StudioSelectionStore());
+	let appliedThemeSettingsRef = useRef(initialThemeSettings);
+	useEffect(() => {
+		if (initialThemeSettings && appliedThemeSettingsRef.current !== initialThemeSettings) {
+			themeSettingsStore.updateThemeSettings(initialThemeSettings);
+			appliedThemeSettingsRef.current = initialThemeSettings;
+		}
+	}, [initialThemeSettings, themeSettingsStore]);
+	let resolvedStaticContent = staticContent ?? getSchemaStaticContent(themeSchema);
+	let rootContextValue = useMemo(() => ({
+		merchantOverrides,
+		staticContent: resolvedStaticContent,
+		themeSettingsStore,
+		studioSelectionStore,
+		translationStore
+	}), [
+		merchantOverrides,
+		resolvedStaticContent,
+		themeSettingsStore,
+		studioSelectionStore,
+		translationStore
+	]);
+	let contextValue = useMemo(() => ({
+		merchantOverrides,
+		themeSettings: themeSettingsStore.getSnapshot(),
+		themeSettingsStore,
+		studioSelectionStore,
+		translationStore
+	}), [
+		merchantOverrides,
+		themeSettingsStore,
+		studioSelectionStore,
+		translationStore
+	]);
+	return /* @__PURE__ */ jsx(WeaverseNextRootContext.Provider, {
+		value: rootContextValue,
+		children: /* @__PURE__ */ jsx(WeaverseNextContext.Provider, {
+			value: contextValue,
+			children: /* @__PURE__ */ jsx(StudioSelectionStoreContext.Provider, {
+				value: studioSelectionStore,
+				children: /* @__PURE__ */ jsx(TranslationProvider, {
+					merchantOverrides,
+					staticContent: resolvedStaticContent,
+					t,
+					translationStore,
+					children
+				})
+			})
+		})
+	});
+}
+//#endregion
+//#region src/next/provider.tsx
+const EMPTY_THEME_SETTINGS = {};
+const EMPTY_STATIC_CONTENT = {};
+function getSchemaStaticContent(schema) {
+	return (schema?.i18n)?.staticContent ?? EMPTY_STATIC_CONTENT;
+}
+const WeaverseNextContext = createContext(null);
+function WeaverseNextProvider(props) {
+	let { children, client, rootData, pageData, commerce, themeSettings } = props;
+	let rootContext = useContext(WeaverseNextRootContext);
+	let themeSettingsValue = themeSettings ?? client?.themeSettings ?? EMPTY_THEME_SETTINGS;
+	let ownTranslationStoreRef = useRef(null);
+	if (!(rootContext || ownTranslationStoreRef.current)) ownTranslationStoreRef.current = new TranslationStore();
+	let translationStore = rootContext?.translationStore ?? ownTranslationStoreRef.current;
+	let [ownSelectionStore] = useState(() => new StudioSelectionStore());
+	let studioSelectionStore = rootContext?.studioSelectionStore ?? ownSelectionStore;
+	let staticContent = props.staticContent ?? rootContext?.staticContent ?? getSchemaStaticContent(client?.themeSchema);
+	let merchantOverrides = props.merchantOverrides ?? rootContext?.merchantOverrides;
+	let ownThemeSettingsStore = useMemo(() => {
+		if (rootContext) return null;
+		return createWeaverseNextThemeSettingsStore({
+			schema: client?.themeSchema,
+			settings: themeSettingsValue
+		});
+	}, [
+		rootContext,
+		client?.themeSchema,
+		themeSettingsValue
+	]);
+	let themeSettingsStore = rootContext?.themeSettingsStore ?? ownThemeSettingsStore;
+	let mergedIntoRootRef = useRef(void 0);
+	useEffect(() => {
+		if (rootContext && themeSettingsValue !== EMPTY_THEME_SETTINGS && mergedIntoRootRef.current !== themeSettingsValue) {
+			rootContext.themeSettingsStore.updateThemeSettings(themeSettingsValue);
+			mergedIntoRootRef.current = themeSettingsValue;
+		}
+	}, [rootContext, themeSettingsValue]);
+	let value = useMemo(() => ({
+		client,
+		rootData,
+		pageData,
+		commerce: commerce ?? client?.commerce,
+		merchantOverrides,
+		themeSettings: themeSettingsStore.getSnapshot(),
+		themeSettingsStore,
+		studioSelectionStore,
+		translationStore
+	}), [
+		client,
+		rootData,
+		pageData,
+		commerce,
+		merchantOverrides,
+		themeSettingsStore,
+		studioSelectionStore,
+		translationStore
+	]);
+	return /* @__PURE__ */ jsx(WeaverseNextContext.Provider, {
+		value,
+		children: /* @__PURE__ */ jsx(StudioSelectionStoreContext.Provider, {
+			value: studioSelectionStore,
+			children: /* @__PURE__ */ jsx(TranslationProvider, {
+				merchantOverrides,
+				staticContent,
+				t: props.t,
+				translationStore,
+				children
+			})
+		})
+	});
+}
+//#endregion
+//#region src/next/hooks.ts
+const OUTSIDE_PROVIDER_ERROR = "must be used inside a <WeaverseNextProvider>.";
+function useWeaverseNextContext(hookName) {
+	let context = useContext(WeaverseNextContext);
+	if (!context) throw new Error(`[@weaverse/hydrogen/next] ${hookName} ${OUTSIDE_PROVIDER_ERROR}`);
+	return context;
+}
+function useWeaverseRootData() {
+	return useWeaverseNextContext("useWeaverseRootData").rootData;
+}
+function useWeaversePageData() {
+	return useWeaverseNextContext("useWeaversePageData").pageData;
+}
+function useWeaverseCommerce() {
+	return useWeaverseNextContext("useWeaverseCommerce").commerce;
+}
+function useThemeSettings() {
+	let { themeSettingsStore } = useWeaverseNextContext("useThemeSettings");
+	return useSyncExternalStore(themeSettingsStore.subscribe, themeSettingsStore.getSnapshot, themeSettingsStore.getServerSnapshot);
+}
+//#endregion
+//#region src/next/request-info.ts
+function toUrl(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 = toUrl(context.url);
+		return new URLSearchParams(url.searchParams);
+	}
+	return new URLSearchParams();
+}
+function withPathPrefix(pathname, i18n) {
+	let segments = (typeof i18n?.pathPrefix === "string" ? i18n.pathPrefix : "").split("/").filter(Boolean);
+	let prefix = segments.length > 0 ? `/${segments.join("/")}` : "";
+	if (prefix === "" || pathname === prefix || pathname.startsWith(`${prefix}/`)) return pathname;
+	return pathname === "/" ? prefix : `${prefix}${pathname}`;
+}
+function getPathnameFromContext(context) {
+	if (context?.pathname) return withPathPrefix(context.pathname, context.i18n);
+	if (context?.url) return withPathPrefix(toUrl(context.url).pathname || "/", context.i18n);
+	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;
+}
+const TRANSIENT_STUDIO_PARAMS = new Set(["weaverseDraftItem", "__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 } : {},
+		...context?.pageType ? { pageType: context.pageType } : {},
+		...context?.handle ? { handle: context.handle } : {}
+	};
+}
+//#endregion
+//#region src/next/runtime.ts
+function getRuntimeWindow() {
+	return typeof window === "undefined" ? void 0 : window;
+}
+function getRenderablePage$1(data) {
+	let page = data.page;
+	let rootId = page.rootId ?? page.items.find((item) => item.type === "main")?.id ?? page.items[0]?.id ?? page.id;
+	return {
+		...page,
+		rootId
+	};
+}
+function getConfigString(configs, key) {
+	let value = configs?.[key];
+	return typeof value === "string" ? value : void 0;
+}
+function resolveModeFlag(config, key) {
+	return config.client?.requestContext?.[key] === true || config.data.configs?.[key] === true;
+}
+function resolveSectionType(config) {
+	return config.client?.requestContext?.sectionType || getConfigString(config.data.configs, "sectionType") || void 0;
+}
+function getRecordString(record, key) {
+	let value = record?.[key];
+	return typeof value === "string" ? value : void 0;
+}
+function resolveProjectId(client, data, fallback) {
+	let projectId = client?.projectId;
+	if (projectId) return projectId;
+	let configProjectId = getConfigString(data.configs, "projectId");
+	if (configProjectId) return configProjectId;
+	return getRecordString(data.project, "id") ?? fallback;
+}
+function resolveDataContext(config) {
+	if (config.dataContext) return config.dataContext;
+	if (config.client?.dataContext) return config.client.dataContext;
+	return {};
+}
+function getRuntimeKey(pageId, requestInfo) {
+	return `${pageId}:${requestInfo.pathname}:${requestInfo.search}`;
+}
+function registerRuntime(runtime) {
+	let runtimeWindow = getRuntimeWindow();
+	if (!runtimeWindow) return;
+	runtimeWindow.__weaverses ??= {};
+	runtimeWindow.__weaverses[runtime.pageId] = runtime;
+	runtimeWindow.__weaverse = runtime;
+}
+function rebindPageItemsToRuntime(runtime) {
+	let items = runtime.data?.items;
+	if (!items) return;
+	for (let { id } of items) {
+		let instance = runtime.itemInstances.get(id);
+		if (instance && instance.weaverse !== runtime) instance.weaverse = runtime;
+	}
+}
+var WeaverseNextRuntime = class extends Weaverse {
+	pageId;
+	internal;
+	requestInfo;
+	isPreviewMode;
+	isRevisionPreview;
+	sectionType;
+	translationMap = {};
+	translationLocale = String();
+	translationLanguageId = String();
+	pendingProjectData;
+	pendingItemUpdates = [];
+	constructor(config) {
+		let { client, data } = config;
+		let page = getRenderablePage$1(data);
+		let configs = data.configs;
+		let requestContext = client?.requestContext;
+		let isDesignMode = resolveModeFlag(config, "isDesignMode");
+		let isPreviewMode = resolveModeFlag(config, "isPreviewMode");
+		let isRevisionPreview = resolveModeFlag(config, "isRevisionPreview");
+		let sectionType = resolveSectionType(config);
+		let projectId = resolveProjectId(client, data, page.id);
+		ensureNextItemConstructor();
+		super({
+			projectId,
+			data: page,
+			isDesignMode,
+			weaverseHost: getConfigString(configs, "weaverseHost"),
+			weaverseVersion: getConfigString(configs, "weaverseVersion")
+		});
+		this.pageId = page.id;
+		this.dataContext = resolveDataContext(config);
+		this.requestInfo = buildWeaverseNextRequestInfo(requestContext);
+		this.isDesignMode = isDesignMode;
+		this.isPreviewMode = isPreviewMode;
+		this.isRevisionPreview = isRevisionPreview;
+		this.sectionType = sectionType;
+		let translationStore = config.translationStore ?? new TranslationStore();
+		this.internal = {
+			merchantOverrides: config.merchantOverrides,
+			navigate: config.navigate,
+			pageAssignment: data.pageAssignment,
+			project: data.project,
+			revalidate: config.revalidate,
+			themeSettingsStore: config.themeSettingsStore ?? createWeaverseNextThemeSettingsStore({
+				schema: client?.themeSchema,
+				settings: client?.themeSettings
+			}),
+			studioSelectionStore: config.studioSelectionStore,
+			translationStore,
+			themeTextStore: translationStore
+		};
+		this.extractTranslationSidecar();
+	}
+	extractTranslationSidecar = () => {
+		let pageData = this.data;
+		let translationMap = pageData?.translationMap;
+		if (translationMap) {
+			this.translationMap = translationMap;
+			this.translationLocale = pageData?.translationLocale || "";
+			this.translationLanguageId = pageData?.translationLanguageId || "";
+		} else {
+			this.translationMap = {};
+			this.translationLocale = "";
+			this.translationLanguageId = "";
+		}
+	};
+	setTranslationSidecar = (map = {}, locale = "", languageId = "") => {
+		this.translationMap = map;
+		this.translationLocale = locale;
+		this.translationLanguageId = languageId;
+		this.refreshAllItems();
+	};
+	updateTranslation = (itemId, key, originalValue, translatedValue) => {
+		if (!this.translationMap[itemId]) this.translationMap[itemId] = {};
+		this.translationMap[itemId] = {
+			...this.translationMap[itemId],
+			[key]: {
+				originalValue,
+				translatedValue
+			}
+		};
+		let instance = this.itemInstances.get(itemId);
+		if (instance) instance.triggerUpdate();
+	};
+	getTranslationChanges = () => {
+		let languageId = this.translationLanguageId;
+		if (!(this.translationLocale && languageId)) return;
+		let entries = [];
+		for (let [itemId, fields] of Object.entries(this.translationMap)) for (let [key, entry] of Object.entries(fields)) entries.push({
+			itemId,
+			key: `data.${key}`,
+			originalValue: entry.originalValue,
+			translatedValue: entry.translatedValue
+		});
+		if (entries.length === 0) return;
+		return {
+			languageId,
+			entries
+		};
+	};
+	setProjectData = (data) => {
+		this.data = data;
+		this.extractTranslationSidecar();
+		this.initProject();
+	};
+	flushRenderPhaseUpdates = () => {
+		let pendingData = this.pendingProjectData;
+		if (pendingData) {
+			this.pendingProjectData = void 0;
+			this.setProjectData(pendingData);
+		}
+		let pendingItems = this.pendingItemUpdates;
+		if (pendingItems.length > 0) {
+			this.pendingItemUpdates = [];
+			for (let item of pendingItems) item.triggerUpdate();
+		}
+	};
+};
+function createWeaverseNextRuntime(config) {
+	let requestInfo = buildWeaverseNextRequestInfo(config.client?.requestContext);
+	let page = getRenderablePage$1(config.data);
+	let existing = getRuntimeWindow()?.__weaverses?.[page.id];
+	let requestKey = getRuntimeKey(page.id, requestInfo);
+	if (existing?.__weaverseNextRequestKey === requestKey) {
+		let configs = config.data.configs;
+		let nextIsDesignMode = resolveModeFlag(config, "isDesignMode");
+		let nextIsPreviewMode = resolveModeFlag(config, "isPreviewMode");
+		let nextIsRevisionPreview = resolveModeFlag(config, "isRevisionPreview");
+		let nextSectionType = resolveSectionType(config);
+		if (existing.isDesignMode || nextIsDesignMode) existing.pendingProjectData = void 0;
+		else existing.pendingProjectData = page;
+		existing.__weaverseNextLatestData = page;
+		existing.dataContext = resolveDataContext(config);
+		existing.requestInfo = requestInfo;
+		existing.projectId = resolveProjectId(config.client, config.data, page.id);
+		existing.isDesignMode = nextIsDesignMode;
+		existing.isPreviewMode = nextIsPreviewMode;
+		existing.isRevisionPreview = nextIsRevisionPreview;
+		existing.sectionType = nextSectionType;
+		existing.weaverseHost = getConfigString(configs, "weaverseHost") ?? existing.weaverseHost;
+		existing.weaverseVersion = getConfigString(configs, "weaverseVersion") ?? existing.weaverseVersion;
+		existing.internal.pageAssignment = config.data.pageAssignment;
+		existing.internal.project = config.data.project;
+		if (config.navigate) existing.internal.navigate = config.navigate;
+		if (config.revalidate) existing.internal.revalidate = config.revalidate;
+		if (config.themeSettingsStore) existing.internal.themeSettingsStore = config.themeSettingsStore;
+		if (config.studioSelectionStore) existing.internal.studioSelectionStore = config.studioSelectionStore;
+		if (config.translationStore) {
+			existing.internal.translationStore = config.translationStore;
+			existing.internal.themeTextStore = config.translationStore;
+		}
+		existing.internal.merchantOverrides = config.merchantOverrides;
+		registerRuntime(existing);
+		return existing;
+	}
+	let [runtime, refreshedItems] = collectDeferredItemUpdates(() => new WeaverseNextRuntime(config));
+	runtime.pendingItemUpdates = refreshedItems;
+	rebindPageItemsToRuntime(runtime);
+	runtime.__weaverseNextRequestKey = requestKey;
+	runtime.__weaverseNextLatestData = page;
+	registerRuntime(runtime);
+	return runtime;
+}
+function bindWeaverseNextStudioRuntime(runtime) {
+	if (!runtime.isDesignMode) return false;
+	let studio = getRuntimeWindow()?.weaverseStudio;
+	if (!studio) return false;
+	let boundRuntime = runtime;
+	let activeRequestInfo = studio.weaverse?.requestInfo;
+	let isActiveUrl = !activeRequestInfo || activeRequestInfo.pathname === runtime.requestInfo.pathname && activeRequestInfo.search === runtime.requestInfo.search;
+	if (!(boundRuntime.__weaverseNextStudioBound && isActiveUrl)) {
+		studio.init?.(runtime);
+		boundRuntime.__weaverseNextStudioBound = true;
+		return true;
+	}
+	studio.refreshStudio?.({
+		data: boundRuntime.__weaverseNextLatestData ?? runtime.data,
+		pageId: runtime.pageId,
+		requestInfo: runtime.requestInfo
+	});
+	return true;
+}
+//#endregion
+//#region src/next/revalidate-item.ts
+const DEFAULT_REVALIDATE_ENDPOINT = "/api/weaverse/revalidate";
+const MAX_ROUTE_CONTEXT_HANDLE_LENGTH = 512;
+const DENIED_ROUTE_CONTEXT_PARAMS = [
+	"weaverseprojectid",
+	"weaversehost",
+	"weaverseapikey",
+	"weaverseapibase",
+	"weaversepublicapibase",
+	"weaverseversion",
+	"projectid",
+	"weaversedraftitem",
+	"__weaversedraftitem",
+	"_rsc"
+];
+const ROUTE_CONTEXT_I18N_KEYS = [
+	"country",
+	"label",
+	"language",
+	"locale",
+	"pathPrefix"
+];
+function sanitizeRouteContextSearch(search) {
+	let params = new URLSearchParams(search);
+	let denied = new Set(DENIED_ROUTE_CONTEXT_PARAMS);
+	for (let key of [...new Set(params.keys())]) if (denied.has(key.toLowerCase())) params.delete(key);
+	let serialized = params.toString();
+	return serialized ? `?${serialized}` : "";
+}
+function buildWeaverseNextRevalidateRouteContext(requestInfo) {
+	if (!requestInfo || typeof requestInfo.pathname !== "string" || !requestInfo.pathname) return;
+	let routeContext = {
+		pathname: requestInfo.pathname,
+		search: sanitizeRouteContextSearch(requestInfo.search ?? "")
+	};
+	let { i18n } = requestInfo;
+	if (i18n && typeof i18n === "object") {
+		let picked = {};
+		for (let key of ROUTE_CONTEXT_I18N_KEYS) {
+			let value = i18n[key];
+			if (typeof value === "string") picked[key] = value;
+		}
+		if (Object.keys(picked).length) routeContext.i18n = picked;
+	}
+	if (requestInfo.pageType && PageTypeSchema.safeParse(requestInfo.pageType).success) routeContext.pageType = requestInfo.pageType;
+	if (typeof requestInfo.handle === "string" && requestInfo.handle && requestInfo.handle.length <= MAX_ROUTE_CONTEXT_HANDLE_LENGTH) routeContext.handle = requestInfo.handle;
+	return routeContext;
+}
+async function revalidateWeaverseNextItem(runtime, draftItem, endpoint = DEFAULT_REVALIDATE_ENDPOINT) {
+	let instance = runtime.itemInstances.get(draftItem.id);
+	if (!instance) throw new Error(`[weaverse-next] No live item instance for "${draftItem.id}".`);
+	let routeContext = buildWeaverseNextRevalidateRouteContext(runtime.requestInfo);
+	let response = await fetch(endpoint, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(routeContext ? {
+			draftItem,
+			routeContext
+		} : { draftItem })
+	});
+	if (!response.ok) throw new Error(`[weaverse-next] Revalidate endpoint responded ${response.status}.`);
+	let { loaderData } = await response.json();
+	instance.setData({ loaderData: loaderData ?? null });
+}
+//#endregion
+//#region src/next/studio-bridge.tsx
+const STUDIO_BIND_RETRY_INTERVAL_MS = 50;
+const STUDIO_BIND_MAX_ATTEMPTS = 100;
+function WeaverseNextStudioBridge(props) {
+	let { runtime, navigate, revalidate, revalidateItem } = props;
+	let lastRuntimeRef = useRef(runtime);
+	let lastRuntimeDataRef = useRef(runtime.data);
+	let lastRequestInfoRef = useRef(runtime.requestInfo);
+	useEffect(() => {
+		if (navigate) runtime.internal.navigate = navigate;
+		if (revalidate) runtime.internal.revalidate = revalidate;
+		if (revalidateItem) runtime.internal.revalidateItem = revalidateItem;
+		if (bindWeaverseNextStudioRuntime(runtime) || !runtime.isDesignMode) return;
+		let attempts = 0;
+		let interval = window.setInterval(() => {
+			attempts += 1;
+			if (bindWeaverseNextStudioRuntime(runtime) || attempts >= STUDIO_BIND_MAX_ATTEMPTS) window.clearInterval(interval);
+		}, STUDIO_BIND_RETRY_INTERVAL_MS);
+		return () => window.clearInterval(interval);
+	}, [
+		runtime,
+		navigate,
+		revalidate,
+		revalidateItem
+	]);
+	useEffect(() => {
+		if (lastRuntimeRef.current !== runtime) {
+			lastRuntimeRef.current = runtime;
+			lastRuntimeDataRef.current = runtime.data;
+			lastRequestInfoRef.current = runtime.requestInfo;
+			return;
+		}
+		if (lastRuntimeDataRef.current === runtime.data && lastRequestInfoRef.current === runtime.requestInfo) return;
+		lastRuntimeDataRef.current = runtime.data;
+		lastRequestInfoRef.current = runtime.requestInfo;
+		bindWeaverseNextStudioRuntime(runtime);
+	}, [
+		runtime,
+		runtime.data,
+		runtime.requestInfo
+	]);
+	return null;
+}
+//#endregion
+//#region src/next/studio-router.ts
+function shouldResetScroll(options) {
+	if (!options || typeof options !== "object") return true;
+	return !options.preventScrollReset;
+}
+function createWeaverseNextStudioInternals(router, options = {}) {
+	return {
+		navigate: (to, navigateOptions) => {
+			let scroll = shouldResetScroll(navigateOptions);
+			if (options.replace) router.replace(to, { scroll });
+			else router.push(to, { scroll });
+		},
+		revalidate: () => {
+			router.refresh();
+		}
+	};
+}
+//#endregion
+//#region src/next/use-weaverse-next-studio.tsx
+function useWeaverseNextStudioInternals(options) {
+	let router = useRouter();
+	let ref = useRef(null);
+	if (!ref.current || ref.current.router !== router || ref.current.replace !== options?.replace) ref.current = {
+		internals: createWeaverseNextStudioInternals(router, options),
+		replace: options?.replace,
+		router
+	};
+	return ref.current.internals;
+}
+function WeaverseNextStudio(props) {
+	let { runtime, replace, revalidateEndpoint } = props;
+	let { navigate, revalidate } = useWeaverseNextStudioInternals({ replace });
+	let endpoint = revalidateEndpoint ?? "/api/weaverse/revalidate";
+	let revalidateItemRef = useRef(null);
+	if (revalidateItemRef.current?.endpoint !== endpoint || revalidateItemRef.current.runtime !== runtime) revalidateItemRef.current = {
+		endpoint,
+		revalidateItem: (draftItem) => revalidateWeaverseNextItem(runtime, draftItem, endpoint),
+		runtime
+	};
+	return /* @__PURE__ */ jsx(WeaverseNextStudioBridge, {
+		navigate,
+		revalidate,
+		revalidateItem: revalidateItemRef.current.revalidateItem,
+		runtime
+	});
+}
+//#endregion
+//#region src/next/renderer.tsx
+const EMPTY_DATA_CONTEXT = {};
+const useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+function getRenderablePage(data) {
+	let page = data?.page;
+	if (!page) return null;
+	let rootId = page.rootId ?? page.items.find((item) => item.type === "main")?.id ?? page.items[0]?.id ?? page.id;
+	return {
+		...page,
+		rootId
+	};
+}
+const WeaverseNextRenderer = memo(function WeaverseNextRendererComponent(props) {
+	let context = useContext(WeaverseNextContext);
+	let client = props.client ?? context?.client;
+	let data = props.data ?? client?.data ?? null;
+	let dataContext = props.dataContext ?? client?.dataContext ?? EMPTY_DATA_CONTEXT;
+	let page = useMemo(() => getRenderablePage(data), [data]);
+	let weaverse = useMemo(() => {
+		if (!page) return null;
+		return createWeaverseNextRuntime({
+			client,
+			data: {
+				...data,
+				page
+			},
+			dataContext,
+			merchantOverrides: context?.merchantOverrides,
+			themeSettingsStore: context?.themeSettingsStore,
+			studioSelectionStore: context?.studioSelectionStore,
+			translationStore: context?.translationStore
+		});
+	}, [
+		client,
+		page,
+		data,
+		dataContext,
+		context?.merchantOverrides,
+		context?.themeSettingsStore,
+		context?.studioSelectionStore,
+		context?.translationStore
+	]);
+	useIsomorphicLayoutEffect(() => {
+		weaverse?.flushRenderPhaseUpdates();
+	}, [weaverse]);
+	if (!weaverse) return null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(WeaverseRoot, { context: weaverse }), /* @__PURE__ */ jsx(WeaverseNextStudio, { runtime: weaverse })] });
+});
+//#endregion
+//#region src/next/studio-script-src.ts
+const TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
+function isLoopbackHostname(hostname) {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".localhost");
+}
+function normalizeOrigin(value) {
+	if (!value) return null;
+	try {
+		return new URL(value).origin;
+	} catch {
+		return null;
+	}
+}
+function isTrustedStudioOrigin(origin, storefrontHostname) {
+	let parsed;
+	try {
+		parsed = new URL(origin);
+	} catch {
+		return false;
+	}
+	let { hostname, protocol } = parsed;
+	if (isLoopbackHostname(storefrontHostname) && isLoopbackHostname(hostname)) return protocol === "http:" || protocol === "https:";
+	if (protocol !== "https:") return false;
+	return TRUSTED_STUDIO_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+}
+function toSearchParams(context) {
+	if (context?.searchParams) return new URLSearchParams(context.searchParams);
+	if (context?.url) {
+		let url = typeof context.url === "string" ? new URL(context.url, "http://localhost") : context.url;
+		return new URLSearchParams(url.searchParams);
+	}
+	return new URLSearchParams();
+}
+function last(searchParams, key) {
+	let values = searchParams.getAll(key);
+	return values.length ? values.at(-1) ?? null : null;
+}
+function resolveWeaverseNextStudioScriptSrc(context, options = {}) {
+	let searchParams = toSearchParams(context);
+	let isDesignMode = context?.isDesignMode ?? last(searchParams, "isDesignMode") === "true";
+	let isPreviewMode = context?.isPreviewMode ?? last(searchParams, "isPreviewMode") === "true";
+	let isRevisionPreview = context?.isRevisionPreview ?? Boolean(last(searchParams, "__revisionId"));
+	if (!(isDesignMode || isPreviewMode || isRevisionPreview)) return null;
+	let origin = normalizeOrigin(last(searchParams, "weaverseHost"));
+	if (!origin) return null;
+	if (!isTrustedStudioOrigin(origin, options.storefrontHostname ?? "")) return null;
+	let bundle = isPreviewMode || isRevisionPreview ? "preview.js" : "index.js";
+	let version = last(searchParams, "weaverseVersion");
+	let url = `${origin}/static/studio/next/${bundle}`;
+	return version ? `${url}?v=${encodeURIComponent(version)}` : url;
+}
+//#endregion
+//#region src/next/studio-connect.tsx
+const loadedScriptSrcs = /* @__PURE__ */ new Set();
+function loadScript(src) {
+	if (typeof document === "undefined") return;
+	if (loadedScriptSrcs.has(src)) return;
+	if (document.querySelector(`script[src="${src}"]`)) {
+		loadedScriptSrcs.add(src);
+		return;
+	}
+	let script = document.createElement("script");
+	script.async = true;
+	script.src = src;
+	document.head.appendChild(script);
+	loadedScriptSrcs.add(src);
+}
+function loadWeaverseNextStudioScript(context, options = {}) {
+	let resolvedContext = context;
+	if (!resolvedContext && typeof window !== "undefined") resolvedContext = {
+		searchParams: new URLSearchParams(window.location.search),
+		url: window.location.href
+	};
+	let src = resolveWeaverseNextStudioScriptSrc(resolvedContext, { storefrontHostname: options.storefrontHostname ?? (typeof window === "undefined" ? void 0 : window.location.hostname) });
+	if (src) loadScript(src);
+}
+function WeaverseNextStudioConnect(props) {
+	useEffect(() => {
+		loadWeaverseNextStudioScript(props.context, { storefrontHostname: props.storefrontHostname });
+	}, [props.context, props.storefrontHostname]);
+	return null;
+}
+//#endregion
+export { ThemeTextProvider, TranslationProvider, WeaverseNextProvider, WeaverseNextRenderer, WeaverseNextRootProvider, WeaverseNextRuntime, WeaverseNextStudio, WeaverseNextStudioBridge, WeaverseNextStudioConnect, bindWeaverseNextStudioRuntime, createWeaverseNextClient, createWeaverseNextRuntime, loadWeaverseNextStudioScript, useChildInstances, useItemInstance, useParentInstance, useStudioSelection, useThemeSettings, useThemeText, useTranslation, useWeaverse, useWeaverseCommerce, useWeaverseNextStudioInternals, useWeaversePageData, useWeaverseRootData };
+
+//# sourceMappingURL=next-client-boundary.mjs.map