@weaverse/hydrogen 5.25.0 → 6.0.0

package/dist/translation-store-BpPWqZ0B.js

@@ -0,0 +1,548 @@
+let _weaverse_schema = require("@weaverse/schema");
+//#region src/types.ts
+/**
+* Type guard for detecting function-based projectId.
+*
+* Used internally by WeaverseClient constructor to determine
+* if projectId needs evaluation or can be used directly.
+*/
+function isProjectIdFunction(projectId) {
+	return typeof projectId === "function";
+}
+/** Error raised by Weaverse requests with a stable code and optional context. */
+var WeaverseError = class WeaverseError extends Error {
+	/** Machine-readable error code. */
+	code;
+	/** HTTP status associated with the failure, when available. */
+	statusCode;
+	/** Structured diagnostic details for logging and error handling. */
+	context;
+	/** Creates a Weaverse request error with a stable code and diagnostics. */
+	constructor(message, code = "WEAVERSE_ERROR", statusCode, context) {
+		super(message);
+		this.name = "WeaverseError";
+		this.code = code;
+		this.statusCode = statusCode;
+		this.context = context;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, WeaverseError);
+	}
+};
+/**
+* Error thrown by `WeaverseClient.loadPage()` when the client is created
+* with `throwPageLoadFailures: true` and the page cannot be loaded.
+*
+* Genuine absence is not an error: a missing project still resolves to `null`
+* and an unassigned page still resolves to a fallback page.
+*/
+var WeaverseLoadError = class extends WeaverseError {
+	/** Failure class used to choose a response status or recovery action. */
+	kind;
+	/** Creates a classified page-load failure. */
+	constructor(message, kind, statusCode, context) {
+		super(message, "LOAD_FAILURE", statusCode, context);
+		this.name = "WeaverseLoadError";
+		this.kind = kind;
+	}
+};
+/**
+* Type guards for response validation
+*/
+function isWithCacheFetchResponse(response) {
+	return typeof response === "object" && response !== null && "data" in response && "response" in response;
+}
+/** Checks whether a value contains the required project response fields. */
+function isFetchProjectPayload(payload) {
+	return typeof payload === "object" && payload !== null && "page" in payload && "project" in payload && "pageAssignment" in payload;
+}
+/** Checks whether a response contains a string error message. */
+function hasError(response) {
+	return typeof response === "object" && response !== null && "error" in response && typeof response.error === "string";
+}
+/** Checks whether a value contains a theme settings object. */
+function isThemeSettingsResponse(data) {
+	if (typeof data !== "object" || data === null) return false;
+	const record = data;
+	return "theme" in record && typeof record.theme === "object" && record.theme !== null;
+}
+/**
+* Type guard to check if a schema is valid.
+* Leverages validation from @weaverse/schema package which provides
+* comprehensive Zod-based validation with the ElementSchema.
+*
+* @param schema - Unknown value to validate
+* @returns True if schema is a valid WeaverseComponentSchema
+*
+* @example
+* ```typescript
+* if (isValidHydrogenSchema(userInput)) {
+*   // userInput is now typed as WeaverseComponentSchema
+*   console.log(userInput.type)
+* }
+* ```
+*/
+function isValidHydrogenSchema(schema) {
+	return (0, _weaverse_schema.isValidSchema)(schema);
+}
+/** Checks whether the browser window exposes the Weaverse Studio bridge. */
+function hasWeaverseStudio(window) {
+	return "weaverseStudio" in window && typeof window.weaverseStudio === "object";
+}
+//#endregion
+//#region src/utils/studio-script-src.ts
+const DEFAULT_WEAVERSE_HOST = "https://studio.weaverse.io";
+/**
+* Weaverse-controlled apex domains the Studio bridge may be served from
+* (matched on the host itself and any subdomain).
+*/
+const TRUSTED_STUDIO_DOMAINS = ["weaverse.io", "weaverse.dev"];
+function isLoopbackHostname(hostname) {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".localhost");
+}
+/**
+* Whether `host` is an origin we trust to serve the Studio bridge script (or,
+* server-side, to resolve page/theme data).
+*
+* The bridge executes inside the storefront document and the host can drive
+* server-side fetches, so a host taken from an attacker-controllable source —
+* e.g. a crafted `?weaverseHost=` query — is both an XSS and an SSRF vector.
+* Callers MUST reject untrusted hosts before acting on them. Trusts
+* `weaverse.io`/`weaverse.dev` and their subdomains over https; loopback is
+* opt-in (see {@link TrustedStudioHostOptions.allowLoopback}).
+*/
+function isTrustedStudioHost(host, options) {
+	let parsed;
+	try {
+		parsed = new URL(host);
+	} catch {
+		return false;
+	}
+	let { hostname, protocol } = parsed;
+	if (options?.allowLoopback && isLoopbackHostname(hostname)) return protocol === "http:" || protocol === "https:";
+	if (protocol !== "https:") return false;
+	return TRUSTED_STUDIO_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+}
+/**
+* Build the Studio bridge script URL for the current mode, or `null` when the
+* storefront is not being previewed inside Weaverse Studio.
+*
+* This is the single gate that keeps the bridge off production storefronts:
+* a normal visitor's URL carries none of the design/preview markers, so the
+* result is `null` and no script is ever requested.
+*
+* Shared by the page-scoped `useStudio` (which also binds the page for
+* editing) and the root-level `useStudioConnect` (which only needs the script
+* to load so Studio's `checkWeaversePage()` handshake can answer on routes
+* with no Weaverse content).
+*/
+function getStudioScriptSrc(mode) {
+	let { isDesignMode, isPreviewMode, isRevisionPreview, weaverseHost, weaverseVersion } = mode;
+	let base = `${weaverseHost}/static/studio/hydrogen`;
+	let version = `?v=${weaverseVersion}`;
+	if (isRevisionPreview || isPreviewMode) return `${base}/preview.js${version}`;
+	if (isDesignMode) return `${base}/index.js${version}`;
+	return null;
+}
+/**
+* Resolve the Studio bridge script URL from a URL query string — the markers
+* Studio attaches when it drives the preview iframe (`isDesignMode`,
+* `isPreviewMode`, `__revisionId`, `weaverseHost`, `weaverseVersion`) — or
+* `null` outside Studio.
+*
+* `storefrontHostname` is the document's own hostname: a loopback Studio host
+* is only honored when the storefront itself is loopback (genuine local-builder
+* dev), so a crafted public link can't load a script from a visitor's loopback
+* service into the storefront origin.
+*
+* The `weaverseHost` query is attacker-controllable, so a host that is not a
+* {@link isTrustedStudioHost trusted origin} resolves to `null` (no bridge) —
+* it is never silently replaced with production Studio, which would otherwise
+* inject the wrong bridge for self-hosted/staging deployments. Such deployments
+* (a non-`weaverse.io` `WEAVERSE_HOST`) therefore don't load the root bridge on
+* content-less routes; the page-scoped {@link getStudioScriptSrc} via
+* `useStudio` still uses the configured host on content routes.
+*
+* Pure (no DOM) so the root-level connect's production gate stays unit-testable
+* and needs no loader data.
+*/
+function resolveStudioScriptSrc(search, storefrontHostname = "") {
+	let params = new URLSearchParams(search);
+	let last = (key) => params.getAll(key).at(-1);
+	let host = last("weaverseHost");
+	if (host) {
+		if (!isTrustedStudioHost(host, { allowLoopback: isLoopbackHostname(storefrontHostname) })) return null;
+	}
+	return getStudioScriptSrc({
+		isDesignMode: last("isDesignMode") === "true",
+		isPreviewMode: last("isPreviewMode") === "true",
+		isRevisionPreview: params.has("__revisionId"),
+		weaverseHost: host || DEFAULT_WEAVERSE_HOST,
+		weaverseVersion: last("weaverseVersion") || ""
+	});
+}
+//#endregion
+//#region src/utils/index.ts
+let warnedTypes = /* @__PURE__ */ new Set();
+function logOnce(type, message) {
+	if (!warnedTypes.has(type)) {
+		console.warn(message);
+		warnedTypes.add(type);
+	}
+}
+function deepMergeArrays(target, source) {
+	return [...target, ...source];
+}
+function mergeInspectorSettings(settings, inspector, type) {
+	if (!inspector?.length) return settings;
+	if (!settings?.length) return inspector;
+	console.info(`Schema "${type}": Both 'settings' and 'inspector' found. Using 'settings' with 'inspector' as fallback.`);
+	return deepMergeArrays(settings, inspector);
+}
+/**
+* Extract and parse query parameters from a request URL.
+* Supports optional allowlist for security-sensitive applications.
+*
+* @param request - The incoming request
+* @param options - Optional configuration
+* @param options.allowedKeys - If provided, only these keys will be extracted
+* @returns Parsed query parameters with type coercion for booleans
+*
+* @example
+* ```typescript
+* // Extract all params
+* const queries = getRequestQueries(request)
+*
+* // Extract only allowed params (security-sensitive)
+* const queries = getRequestQueries(request, {
+*   allowedKeys: ['weaverseProjectId', 'weaverseHost']
+* })
+* ```
+*/
+function getRequestQueries(request, options) {
+	let url = new URL(request.url);
+	let queries = {};
+	for (let [key, value] of url.searchParams.entries()) {
+		if (options?.allowedKeys && !options.allowedKeys.includes(key)) continue;
+		if (value === "true") queries[key] = true;
+		else if (value === "false") queries[key] = false;
+		else queries[key] = value;
+	}
+	return queries;
+}
+/**
+* Resolves project, endpoint, and Studio mode configuration for a request.
+* URL-provided Studio values take precedence over environment defaults.
+*/
+function getWeaverseConfigs(request, env) {
+	let queries = getRequestQueries(request);
+	let { WEAVERSE_PROJECT_ID, WEAVERSE_API_KEY, WEAVERSE_HOST, WEAVERSE_PUBLIC_API_BASE, PUBLIC_STORE_DOMAIN, PUBLIC_STOREFRONT_API_TOKEN } = env || {};
+	let envFromProcess = typeof process !== "undefined" && process.env || {};
+	let { weaverseProjectId, weaverseHost, isDesignMode, isPreviewMode, sectionType, weaverseVersion, weaverseApiKey } = queries;
+	let isRevisionPreview = new URL(request.url).searchParams.has("__revisionId");
+	let configuredWeaverseHost = WEAVERSE_HOST || envFromProcess.WEAVERSE_HOST;
+	let trustedUrlHost = typeof weaverseHost === "string" && isTrustedStudioHost(weaverseHost) ? weaverseHost : "";
+	let resolvedWeaverseHost = trustedUrlHost || configuredWeaverseHost || "https://studio.weaverse.io";
+	let resolvedWeaverseApiBase = trustedUrlHost ? trustedUrlHost : WEAVERSE_PUBLIC_API_BASE || envFromProcess.WEAVERSE_PUBLIC_API_BASE || (configuredWeaverseHost && configuredWeaverseHost !== "https://studio.weaverse.io" ? configuredWeaverseHost : "https://api.weaverse.io");
+	return {
+		projectId: weaverseProjectId || WEAVERSE_PROJECT_ID || envFromProcess.WEAVERSE_PROJECT_ID || "",
+		weaverseHost: resolvedWeaverseHost,
+		weaverseApiBase: resolvedWeaverseApiBase,
+		weaversePublicApiBase: resolvedWeaverseApiBase,
+		weaverseApiKey: weaverseApiKey || WEAVERSE_API_KEY || envFromProcess.WEAVERSE_API_KEY || "",
+		weaverseVersion: weaverseVersion || "",
+		isDesignMode,
+		isPreviewMode,
+		isRevisionPreview,
+		sectionType: sectionType || "",
+		publicEnv: {
+			PUBLIC_STORE_DOMAIN: PUBLIC_STORE_DOMAIN || "",
+			PUBLIC_STOREFRONT_API_TOKEN: PUBLIC_STOREFRONT_API_TOKEN || ""
+		}
+	};
+}
+/**
+* Cache for generateDataFromSchema results using WeakMap.
+* WeakMap allows garbage collection when schema objects are no longer referenced.
+*/
+const schemaDefaultsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Generate default data from component or theme schema.
+* Results are memoized using WeakMap for performance.
+*
+* @param schema - Component or theme schema
+* @returns Default data object extracted from schema inputs
+*/
+function generateDataFromSchema(schema) {
+	const cached = schemaDefaultsCache.get(schema);
+	if (cached) return cached;
+	let data = {};
+	let inspectorGroups = [];
+	const isComponentSchema = (s) => "type" in s && typeof s.type === "string";
+	if (isComponentSchema(schema)) {
+		if (schema.settings) inspectorGroups = schema.settings;
+		if (schema.inspector) if (schema.settings?.length) inspectorGroups = mergeInspectorSettings(schema.settings, schema.inspector, schema.type || "unknown");
+		else {
+			inspectorGroups = schema.inspector;
+			if (schema.type) logOnce(schema.type, `⚠️  Schema "${schema.type}": The 'inspector' property is deprecated. Please use 'settings' instead.`);
+		}
+	} else {
+		if (schema.settings) inspectorGroups = schema.settings;
+		if (schema.inspector) if (schema.settings?.length) inspectorGroups = mergeInspectorSettings(schema.settings, schema.inspector, "Theme Schema");
+		else {
+			inspectorGroups = schema.inspector;
+			logOnce("ThemeSchema", `⚠️  Theme Schema: The 'inspector' property is deprecated. Please use 'settings' instead.`);
+		}
+	}
+	if (inspectorGroups?.length) for (let group of inspectorGroups) for (let input of group.inputs) {
+		let { name, defaultValue } = input;
+		if (name && defaultValue !== null && defaultValue !== void 0) data[name] = defaultValue;
+	}
+	schemaDefaultsCache.set(schema, data);
+	return data;
+}
+function recursivelyAddDataItem(type, components, items, initData) {
+	let component = components.find((c) => c.schema.type === type);
+	if (!component) return;
+	let childIds = [];
+	let id = crypto.randomUUID();
+	let { children, ...data } = component.schema?.presets || {};
+	if (children) for (let c of children) {
+		let { type, children, ...data } = c;
+		let childId = recursivelyAddDataItem(type, components, items, data);
+		childIds.push({ id: childId });
+	}
+	items.push({
+		data: {
+			...data,
+			...initData
+		},
+		id,
+		type,
+		children: childIds
+	});
+	return id;
+}
+/** Creates synthetic loader data for previewing one registered component type. */
+function getPreviewData(type, components, weaverseHost) {
+	let items = [];
+	return {
+		project: {
+			id: "x",
+			weaverseShopId: "shop-id",
+			name: "Section Preview"
+		},
+		configs: {
+			projectId: "x",
+			weaverseHost,
+			isDesignMode: false,
+			isPreviewMode: true,
+			requestInfo: {
+				i18n: {
+					label: "United States (USD $)",
+					language: "EN",
+					country: "US",
+					currency: "USD",
+					pathPrefix: ""
+				},
+				queries: {},
+				pathname: "/",
+				search: ""
+			}
+		},
+		page: {
+			id: "weaverse-preview-page",
+			name: "Preview section",
+			rootId: "1",
+			items: [{
+				data: {},
+				id: "1",
+				type: "main",
+				children: [{ id: recursivelyAddDataItem(type, components, items) }]
+			}, ...items]
+		}
+	};
+}
+//#endregion
+//#region src/utils/nested-key.ts
+/**
+* Traverse a nested object by dot-path.
+*
+* @example
+* getNestedKey({ cart: { title: 'Cart' } }, 'cart.title') // => 'Cart'
+* getNestedKey({}, 'cart.title', 'fallback')              // => 'fallback'
+*/
+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/translation-store.ts
+/**
+* Minimal mutable store for design-mode static text overrides.
+*
+* useSyncExternalStore-compatible. Passed into TranslationProvider which
+* subscribes internally and merges overrides into merchantOverrides.
+* The studio bridge calls updateOverrides() via weaverse.internal.translationStore
+* (also exposed as the deprecated weaverse.internal.themeTextStore alias).
+*
+* Shape: flat Record<string, string> — dot-notation keys map to values
+* (e.g. "cart.title" → "Shopping Cart").
+*/
+var TranslationStore = class {
+	/** Current flat translation overrides keyed by dot-path. */
+	overrides = {};
+	listeners = /* @__PURE__ */ new Set();
+	/** Replaces all overrides and notifies subscribers. */
+	setOverrides = (overrides) => {
+		this.overrides = { ...overrides };
+		this.emit();
+	};
+	/** Merges changed overrides and notifies subscribers. */
+	updateOverrides = (newOverrides) => {
+		this.overrides = {
+			...this.overrides,
+			...newOverrides
+		};
+		this.emit();
+	};
+	/** Returns the current client snapshot for `useSyncExternalStore`. */
+	getSnapshot = () => this.overrides;
+	/** Returns the current server snapshot for `useSyncExternalStore`. */
+	getServerSnapshot = () => this.overrides;
+	/** Subscribes to override changes and returns an unsubscribe callback. */
+	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);
+		}
+	};
+};
+/**
+* Legacy constructor alias retained for existing theme text integrations.
+* @deprecated Use {@link TranslationStore} instead. This alias remains available
+* for backward compatibility.
+*/
+const ThemeTextStore = TranslationStore;
+//#endregion
+Object.defineProperty(exports, "ThemeTextStore", {
+	enumerable: true,
+	get: function() {
+		return ThemeTextStore;
+	}
+});
+Object.defineProperty(exports, "TranslationStore", {
+	enumerable: true,
+	get: function() {
+		return TranslationStore;
+	}
+});
+Object.defineProperty(exports, "WeaverseError", {
+	enumerable: true,
+	get: function() {
+		return WeaverseError;
+	}
+});
+Object.defineProperty(exports, "WeaverseLoadError", {
+	enumerable: true,
+	get: function() {
+		return WeaverseLoadError;
+	}
+});
+Object.defineProperty(exports, "generateDataFromSchema", {
+	enumerable: true,
+	get: function() {
+		return generateDataFromSchema;
+	}
+});
+Object.defineProperty(exports, "getNestedKey", {
+	enumerable: true,
+	get: function() {
+		return getNestedKey;
+	}
+});
+Object.defineProperty(exports, "getPreviewData", {
+	enumerable: true,
+	get: function() {
+		return getPreviewData;
+	}
+});
+Object.defineProperty(exports, "getRequestQueries", {
+	enumerable: true,
+	get: function() {
+		return getRequestQueries;
+	}
+});
+Object.defineProperty(exports, "getStudioScriptSrc", {
+	enumerable: true,
+	get: function() {
+		return getStudioScriptSrc;
+	}
+});
+Object.defineProperty(exports, "getWeaverseConfigs", {
+	enumerable: true,
+	get: function() {
+		return getWeaverseConfigs;
+	}
+});
+Object.defineProperty(exports, "hasError", {
+	enumerable: true,
+	get: function() {
+		return hasError;
+	}
+});
+Object.defineProperty(exports, "hasWeaverseStudio", {
+	enumerable: true,
+	get: function() {
+		return hasWeaverseStudio;
+	}
+});
+Object.defineProperty(exports, "isFetchProjectPayload", {
+	enumerable: true,
+	get: function() {
+		return isFetchProjectPayload;
+	}
+});
+Object.defineProperty(exports, "isProjectIdFunction", {
+	enumerable: true,
+	get: function() {
+		return isProjectIdFunction;
+	}
+});
+Object.defineProperty(exports, "isThemeSettingsResponse", {
+	enumerable: true,
+	get: function() {
+		return isThemeSettingsResponse;
+	}
+});
+Object.defineProperty(exports, "isValidHydrogenSchema", {
+	enumerable: true,
+	get: function() {
+		return isValidHydrogenSchema;
+	}
+});
+Object.defineProperty(exports, "isWithCacheFetchResponse", {
+	enumerable: true,
+	get: function() {
+		return isWithCacheFetchResponse;
+	}
+});
+Object.defineProperty(exports, "resolveStudioScriptSrc", {
+	enumerable: true,
+	get: function() {
+		return resolveStudioScriptSrc;
+	}
+});
+
+//# sourceMappingURL=translation-store-BpPWqZ0B.js.map