@nubitio/core 0.5.11 → 0.5.13

package/dist/index.cjs

@@ -32,7 +32,8 @@ const _coreConfig = {
 	locale: "es",
 	timezone: "UTC",
 	apiBaseUrl: "/api/",
-	currency: void 0
+	currency: void 0,
+	mercureTopicOrigin: void 0
 };
 /**
 * Configure core runtime values (locale, timezone, apiBaseUrl).
@@ -44,6 +45,7 @@ function configureCore(config) {
 	if (config.timezone !== void 0) _coreConfig.timezone = config.timezone;
 	if (config.apiBaseUrl !== void 0) _coreConfig.apiBaseUrl = config.apiBaseUrl;
 	if ("currency" in config) _coreConfig.currency = config.currency;
+	if ("mercureTopicOrigin" in config) _coreConfig.mercureTopicOrigin = config.mercureTopicOrigin;
 }
 /**
 * @deprecated Use configureCore() instead.
@@ -62,24 +64,30 @@ function getCoreApiBaseUrl() {
 function getCoreCurrency() {
 	return _coreConfig.currency;
 }
+function getMercureTopicOrigin() {
+	return _coreConfig.mercureTopicOrigin;
+}
 const CoreConfigContext = react.default.createContext(_coreConfig);
-const CoreConfigProvider = ({ locale, timezone, apiBaseUrl, currency, children }) => {
+const CoreConfigProvider = ({ locale, timezone, apiBaseUrl, currency, mercureTopicOrigin, children }) => {
 	configureCore({
 		locale,
 		timezone,
 		apiBaseUrl,
-		currency
+		currency,
+		mercureTopicOrigin
 	});
 	const value = react.default.useMemo(() => ({
 		locale,
 		timezone,
 		apiBaseUrl,
-		currency
+		currency,
+		mercureTopicOrigin
 	}), [
 		locale,
 		timezone,
 		apiBaseUrl,
-		currency
+		currency,
+		mercureTopicOrigin
 	]);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CoreConfigContext.Provider, {
 		value,
@@ -514,6 +522,230 @@ function initCoreI18n() {
 	i18next.default.addResourceBundle("en", "core", coreTranslationsEn, true, false);
 }
 //#endregion
+//#region packages/core/mercure/MercureManager.ts
+var MercureManager = class {
+	hubUrl = null;
+	topics = /* @__PURE__ */ new Map();
+	hubUrlListeners = /* @__PURE__ */ new Set();
+	/**
+	* Update the hub URL (called by the Axios interceptor when the `Link` header is discovered,
+	* or by MercureProvider). Notifies all registered listeners.
+	*
+	* Idempotent: if the URL is already set to the same value, listeners are NOT re-notified.
+	*/
+	setHubUrl(url) {
+		if (this.hubUrl === url) return;
+		this.disconnectAll();
+		this.hubUrl = url;
+		this.hubUrlListeners.forEach((cb) => cb(url));
+	}
+	getHubUrl() {
+		return this.hubUrl;
+	}
+	/**
+	* Register a callback that fires whenever the hub URL changes.
+	*
+	* Returns an unsubscribe function — call it in a `useEffect` cleanup to avoid memory leaks.
+	*
+	* @example
+	* ```tsx
+	* useEffect(() => {
+	*   return MercureManager.onHubUrlChange(setHubUrl);
+	* }, []);
+	* ```
+	*/
+	onHubUrlChange(callback) {
+		this.hubUrlListeners.add(callback);
+		return () => {
+			this.hubUrlListeners.delete(callback);
+		};
+	}
+	/**
+	* Subscribe to a Mercure topic.
+	*
+	* @param topic    Full topic URI or URI Template, e.g. `https://host/api/products/{id}`.
+	* @param callback Called with the parsed JSON payload on each SSE message.
+	*
+	* If `hubUrl` is null (hub not configured), this is a no-op (graceful degradation).
+	* If an EventSource for this topic already exists, it is reused (ref-counting).
+	*/
+	subscribe(topic, callback) {
+		if (this.hubUrl === null) return;
+		const existing = this.topics.get(topic);
+		if (existing) {
+			const listener = (e) => {
+				try {
+					callback(JSON.parse(e.data));
+				} catch {
+					callback(e.data);
+				}
+			};
+			existing.eventSource.addEventListener("message", listener);
+			existing.listeners.set(callback, listener);
+			existing.count += 1;
+			return;
+		}
+		const url = new URL(this.hubUrl);
+		url.searchParams.append("topic", topic);
+		const eventSource = new EventSource(url.toString(), { withCredentials: true });
+		const listener = (e) => {
+			try {
+				callback(JSON.parse(e.data));
+			} catch {
+				callback(e.data);
+			}
+		};
+		eventSource.addEventListener("message", listener);
+		const listeners = /* @__PURE__ */ new Map();
+		listeners.set(callback, listener);
+		this.topics.set(topic, {
+			eventSource,
+			count: 1,
+			listeners
+		});
+	}
+	/**
+	* Unsubscribe a specific callback from a topic.
+	*
+	* Decrements the ref count. When count reaches 0, the EventSource is closed
+	* and removed from the internal map.
+	*/
+	unsubscribe(topic, callback) {
+		const entry = this.topics.get(topic);
+		if (!entry) return;
+		const listener = entry.listeners.get(callback);
+		if (listener) {
+			entry.eventSource.removeEventListener("message", listener);
+			entry.listeners.delete(callback);
+		}
+		entry.count -= 1;
+		if (entry.count <= 0) {
+			entry.eventSource.close();
+			this.topics.delete(topic);
+		}
+	}
+	/**
+	* Close all active EventSource connections and clear the topic map.
+	*
+	* Called internally when the hub URL changes so stale connections
+	* bound to the previous hub are not leaked.
+	*/
+	disconnectAll() {
+		this.topics.forEach((entry) => {
+			entry.eventSource.close();
+		});
+		this.topics.clear();
+	}
+};
+/** Singleton instance — shared across the entire application. */
+const mercureManager = new MercureManager();
+//#endregion
+//#region packages/core/mercure/mercureDiscovery.ts
+let discoveredTopicOrigin;
+const topicOriginListeners = /* @__PURE__ */ new Set();
+/**
+* Parse a `Link` response header value into `{ url, rel }` pairs.
+* Handles API Platform's `</.well-known/mercure>; rel="mercure"` format.
+*/
+function parseLinkHeader(header) {
+	const links = [];
+	for (const segment of header.split(/,(?=\s*<)/)) {
+		const urlMatch = segment.match(/<([^>]+)>/);
+		const relMatch = segment.match(/rel=(?:"([^"]+)"|([^;\s,]+))/i);
+		if (urlMatch && relMatch) links.push({
+			url: urlMatch[1],
+			rel: (relMatch[1] ?? relMatch[2]).trim()
+		});
+	}
+	return links;
+}
+/**
+* When the API advertises an absolute hub on another origin (common in Docker:
+* `MERCURE_PUBLIC_URL=http://localhost:3000/...` while the SPA proxies the hub
+* at `/.well-known/mercure`), prefer the same-origin path so EventSource and
+* cookies go through the dev proxy.
+*/
+function normalizeMercureHubUrl(hubUrl) {
+	if (typeof window === "undefined") return hubUrl;
+	try {
+		const parsed = new URL(hubUrl, window.location.origin);
+		if (parsed.pathname === "/.well-known/mercure" && parsed.origin !== window.location.origin) return `${window.location.origin}${parsed.pathname}`;
+		return parsed.toString();
+	} catch {
+		return hubUrl;
+	}
+}
+/**
+* Extract the Mercure hub URL from response headers, if present.
+* Relative URLs are resolved against the request URL.
+*/
+function extractMercureHubUrl(headers, responseUrl) {
+	const linkHeader = headers.get("link") ?? headers.get("Link");
+	if (!linkHeader) return null;
+	const mercureLink = parseLinkHeader(linkHeader).find((link) => link.rel === "mercure");
+	if (!mercureLink) return null;
+	try {
+		return normalizeMercureHubUrl(new URL(mercureLink.url, responseUrl).toString());
+	} catch {
+		return normalizeMercureHubUrl(mercureLink.url);
+	}
+}
+function originFromAbsoluteIri(iri) {
+	if (!/^https?:\/\//i.test(iri)) return null;
+	try {
+		return new URL(iri).origin;
+	} catch {
+		return null;
+	}
+}
+/**
+* Infer the API origin from Hydra `@id` values (entrypoint or collection items).
+* API Platform publishes absolute IRIs when `DEFAULT_URI` is configured.
+*/
+function extractTopicOriginFromPayload(data) {
+	if (!data || typeof data !== "object") return null;
+	const record = data;
+	if (typeof record["@id"] === "string") {
+		const origin = originFromAbsoluteIri(record["@id"]);
+		if (origin) return origin;
+	}
+	const members = record["hydra:member"];
+	if (Array.isArray(members)) for (const member of members) {
+		if (!member || typeof member !== "object") continue;
+		const memberId = member["@id"];
+		if (typeof memberId === "string") {
+			const origin = originFromAbsoluteIri(memberId);
+			if (origin) return origin;
+		}
+	}
+	return null;
+}
+function getDiscoveredMercureTopicOrigin() {
+	return discoveredTopicOrigin;
+}
+/** Subscribe to autodiscovered topic-origin changes (for React hooks). */
+function onMercureTopicOriginChange(callback) {
+	topicOriginListeners.add(callback);
+	return () => {
+		topicOriginListeners.delete(callback);
+	};
+}
+function setDiscoveredTopicOrigin(origin) {
+	if (discoveredTopicOrigin === origin) return;
+	discoveredTopicOrigin = origin;
+	topicOriginListeners.forEach((listener) => listener(origin));
+}
+/**
+* Inspect an API response and update Mercure hub URL / topic origin when found.
+* Called from `CoreHttpClient` on every successful response.
+*/
+function discoverMercureFromResponse(response, data) {
+	const hubUrl = extractMercureHubUrl(response.headers, response.url);
+	if (hubUrl) mercureManager.setHubUrl(hubUrl);
+	const topicOrigin = extractTopicOriginFromPayload(data);
+	if (topicOrigin) setDiscoveredTopicOrigin(topicOrigin);
+}
+//#endregion
 //#region packages/core/http/CoreHttpClient.ts
 function joinUrl(baseUrl, url) {
 	if (/^https?:\/\//.test(url) || url.startsWith("/")) return url;
@@ -609,12 +841,16 @@ var CoreHttpClient = class {
 			signal: config?.signal,
 			body: body === void 0 || body === null ? void 0 : body instanceof FormData ? body : JSON.stringify(body)
 		});
-		if (response.ok) return {
-			response,
-			data: await readResponseBody(response, config?.responseType),
-			headers: response.headers,
-			status: response.status
-		};
+		if (response.ok) {
+			const data = await readResponseBody(response, config?.responseType);
+			if (config?.responseType === void 0 || config.responseType === "json") discoverMercureFromResponse(response, data);
+			return {
+				response,
+				data,
+				headers: response.headers,
+				status: response.status
+			};
+		}
 		const errorData = await this.safeErrorData(response);
 		const error = createHttpError(errorData.detail ?? errorData.message ?? "HTTP request failed", response.status, errorData);
 		const loginPath = this.config.loginPath ?? "auth/login";
@@ -713,124 +949,6 @@ function CoreProvider({ children, http, httpClient, runtime }) {
 	});
 }
 //#endregion
-//#region packages/core/mercure/MercureManager.ts
-var MercureManager = class {
-	hubUrl = null;
-	topics = /* @__PURE__ */ new Map();
-	hubUrlListeners = /* @__PURE__ */ new Set();
-	/**
-	* Update the hub URL (called by the Axios interceptor when the `Link` header is discovered,
-	* or by MercureProvider). Notifies all registered listeners.
-	*
-	* Idempotent: if the URL is already set to the same value, listeners are NOT re-notified.
-	*/
-	setHubUrl(url) {
-		if (this.hubUrl === url) return;
-		this.disconnectAll();
-		this.hubUrl = url;
-		this.hubUrlListeners.forEach((cb) => cb(url));
-	}
-	getHubUrl() {
-		return this.hubUrl;
-	}
-	/**
-	* Register a callback that fires whenever the hub URL changes.
-	*
-	* Returns an unsubscribe function — call it in a `useEffect` cleanup to avoid memory leaks.
-	*
-	* @example
-	* ```tsx
-	* useEffect(() => {
-	*   return MercureManager.onHubUrlChange(setHubUrl);
-	* }, []);
-	* ```
-	*/
-	onHubUrlChange(callback) {
-		this.hubUrlListeners.add(callback);
-		return () => {
-			this.hubUrlListeners.delete(callback);
-		};
-	}
-	/**
-	* Subscribe to a Mercure topic.
-	*
-	* @param topic    Full topic URI or URI Template, e.g. `https://host/api/products/{id}`.
-	* @param callback Called with the parsed JSON payload on each SSE message.
-	*
-	* If `hubUrl` is null (hub not configured), this is a no-op (graceful degradation).
-	* If an EventSource for this topic already exists, it is reused (ref-counting).
-	*/
-	subscribe(topic, callback) {
-		if (this.hubUrl === null) return;
-		const existing = this.topics.get(topic);
-		if (existing) {
-			const listener = (e) => {
-				try {
-					callback(JSON.parse(e.data));
-				} catch {
-					callback(e.data);
-				}
-			};
-			existing.eventSource.addEventListener("message", listener);
-			existing.listeners.set(callback, listener);
-			existing.count += 1;
-			return;
-		}
-		const url = new URL(this.hubUrl);
-		url.searchParams.append("topic", topic);
-		const eventSource = new EventSource(url.toString(), { withCredentials: true });
-		const listener = (e) => {
-			try {
-				callback(JSON.parse(e.data));
-			} catch {
-				callback(e.data);
-			}
-		};
-		eventSource.addEventListener("message", listener);
-		const listeners = /* @__PURE__ */ new Map();
-		listeners.set(callback, listener);
-		this.topics.set(topic, {
-			eventSource,
-			count: 1,
-			listeners
-		});
-	}
-	/**
-	* Unsubscribe a specific callback from a topic.
-	*
-	* Decrements the ref count. When count reaches 0, the EventSource is closed
-	* and removed from the internal map.
-	*/
-	unsubscribe(topic, callback) {
-		const entry = this.topics.get(topic);
-		if (!entry) return;
-		const listener = entry.listeners.get(callback);
-		if (listener) {
-			entry.eventSource.removeEventListener("message", listener);
-			entry.listeners.delete(callback);
-		}
-		entry.count -= 1;
-		if (entry.count <= 0) {
-			entry.eventSource.close();
-			this.topics.delete(topic);
-		}
-	}
-	/**
-	* Close all active EventSource connections and clear the topic map.
-	*
-	* Called internally when the hub URL changes so stale connections
-	* bound to the previous hub are not leaked.
-	*/
-	disconnectAll() {
-		this.topics.forEach((entry) => {
-			entry.eventSource.close();
-		});
-		this.topics.clear();
-	}
-};
-/** Singleton instance — shared across the entire application. */
-const mercureManager = new MercureManager();
-//#endregion
 //#region packages/core/mercure/MercureProvider.tsx
 /**
 * MercureProvider — React context provider for the Mercure hub URL.
@@ -843,14 +961,19 @@ const mercureManager = new MercureManager();
 * ## Usage
 *
 * ```tsx
-* // In your app root:
-* <MercureProvider hubUrl={discoveredHubUrl}>
+* // Autodiscovery (recommended): hub URL comes from API `Link` headers.
+* <MercureProvider>
+*   <App />
+* </MercureProvider>
+*
+* // Manual override (e.g. before the first API response):
+* <MercureProvider hubUrl="/.well-known/mercure">
 *   <App />
 * </MercureProvider>
 * ```
 *
-* The `hubUrl` is typically discovered from the `Link` header of API responses
-* (common pattern with API Platform + Mercure).
+* The hub URL is autodiscovered from the `Link` header of API responses
+* (API Platform + Mercure). Pass `hubUrl` only when you need an explicit override.
 */
 /** The hub URL, or null if Mercure is not configured / not yet discovered. */
 const MercureContext = (0, react.createContext)(null);
@@ -858,10 +981,17 @@ const MercureContext = (0, react.createContext)(null);
 * Provides the Mercure hub URL to the React tree and keeps `MercureManager`
 * in sync whenever the URL changes.
 */
-function MercureProvider({ hubUrl, children }) {
+function MercureProvider({ hubUrl: hubUrlOverride, children }) {
+	const [discoveredHubUrl, setDiscoveredHubUrl] = (0, react.useState)(() => mercureManager.getHubUrl());
 	(0, react.useEffect)(() => {
-		mercureManager.setHubUrl(hubUrl);
-	}, [hubUrl]);
+		if (hubUrlOverride !== void 0) {
+			mercureManager.setHubUrl(hubUrlOverride);
+			return;
+		}
+		setDiscoveredHubUrl(mercureManager.getHubUrl());
+		return mercureManager.onHubUrlChange(setDiscoveredHubUrl);
+	}, [hubUrlOverride]);
+	const hubUrl = hubUrlOverride !== void 0 ? hubUrlOverride : discoveredHubUrl;
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MercureContext.Provider, {
 		value: hubUrl,
 		children
@@ -878,7 +1008,8 @@ function MercureProvider({ hubUrl, children }) {
 * - Mercure is not configured in the backend.
 *
 * This hook does NOT perform any fetch or side effect — it only reads from context.
-* Hub discovery (usually from a `Link` header) must be done by the host application.
+* Hub discovery happens automatically via `CoreHttpClient` (`Link` header parsing).
+* Use `<MercureProvider>` without a `hubUrl` prop to expose the discovered URL.
 *
 * ## Usage
 *
@@ -895,6 +1026,52 @@ function useMercureHub() {
 	return (0, react.useContext)(MercureContext);
 }
 //#endregion
+//#region packages/core/mercure/mercureTopics.ts
+/**
+* Resolves the origin used to build Mercure collection topic URIs.
+*
+* API Platform publishes item updates to IRIs such as
+* `http://localhost:8000/api/products/42`. The SPA may run on another origin
+* in dev (Vite on :5173, API on :8000). The origin is normally autodiscovered
+* from absolute Hydra `@id` values on API responses. Set `mercureTopicOrigin`
+* on CoreConfig only when autodiscovery cannot infer the correct origin.
+*/
+function resolveMercureTopicOrigin(apiBaseUrl = getCoreApiBaseUrl(), configuredOrigin, discoveredOrigin = getDiscoveredMercureTopicOrigin()) {
+	const explicit = configuredOrigin?.trim().replace(/\/+$/, "");
+	if (explicit) return explicit;
+	const discovered = discoveredOrigin?.trim().replace(/\/+$/, "");
+	if (discovered) return discovered;
+	const trimmedBase = apiBaseUrl.trim();
+	if (/^https?:\/\//i.test(trimmedBase)) try {
+		return new URL(trimmedBase).origin;
+	} catch {}
+	if (typeof window !== "undefined") return window.location.origin;
+	return "";
+}
+/**
+* Wildcard collection topic (RFC 6570 URI Template) for a resource API path.
+* e.g. `/api/products` → `http://localhost:8000/api/products/{id}`
+*/
+function buildMercureCollectionTopic(apiUrl, configuredOrigin, apiBaseUrl = getCoreApiBaseUrl()) {
+	if (!apiUrl) return null;
+	const origin = resolveMercureTopicOrigin(apiBaseUrl, configuredOrigin);
+	if (!origin) return null;
+	const normalizedPath = apiUrl.replace(/^\//, "").replace(/\/+$/, "");
+	if (!normalizedPath) return null;
+	return `${origin}/${normalizedPath}/{id}`;
+}
+//#endregion
+//#region packages/core/mercure/useDiscoveredMercureTopicOrigin.ts
+/**
+* Returns the Mercure topic origin autodiscovered from Hydra `@id` IRIs.
+* Re-renders when a new origin is discovered from a subsequent API response.
+*/
+function useDiscoveredMercureTopicOrigin() {
+	const [origin, setOrigin] = (0, react.useState)(getDiscoveredMercureTopicOrigin);
+	(0, react.useEffect)(() => onMercureTopicOriginChange(setOrigin), []);
+	return origin;
+}
+//#endregion
 //#region packages/core/mercure/useMercureSubscription.ts
 /**
 * useMercureSubscription — Hook that subscribes to a Mercure topic and calls
@@ -904,6 +1081,9 @@ function useMercureHub() {
 * - If `hubUrl` is null (Mercure not configured) or `enabled` is false → no-op.
 * - Subscribes to the wildcard topic `<origin>/<apiUrl>/{id}` (URI Template RFC 6570),
 *   which captures any item-level event (create / update / delete) for the collection.
+* - `<origin>` comes from `CoreConfig.mercureTopicOrigin`, autodiscovered Hydra
+*   `@id`, an absolute `apiBaseUrl`, or `window.location.origin`
+*   (see `buildMercureCollectionTopic`).
 * - Cleanup: unsubscribes on unmount or when dependencies change (no memory leaks).
 *
 * ## Usage
@@ -923,10 +1103,12 @@ function useMercureHub() {
 */
 function useMercureSubscription(apiUrl, onUpdate, enabled = true) {
 	const hubUrl = useMercureHub();
+	const { mercureTopicOrigin, apiBaseUrl } = useCoreConfig();
+	const discoveredTopicOrigin = useDiscoveredMercureTopicOrigin();
 	(0, react.useEffect)(() => {
 		if (!hubUrl || !enabled || !apiUrl) return;
-		const normalizedPath = apiUrl.replace(/^\//, "");
-		const topic = `${window.location.origin}/${normalizedPath}/{id}`;
+		const topic = buildMercureCollectionTopic(apiUrl, mercureTopicOrigin ?? discoveredTopicOrigin, apiBaseUrl);
+		if (!topic) return;
 		const handler = (_data) => {
 			onUpdate();
 		};
@@ -937,7 +1119,10 @@ function useMercureSubscription(apiUrl, onUpdate, enabled = true) {
 	}, [
 		hubUrl,
 		enabled,
-		apiUrl
+		apiUrl,
+		mercureTopicOrigin,
+		discoveredTopicOrigin,
+		apiBaseUrl
 	]);
 }
 //#endregion
@@ -950,6 +1135,7 @@ exports.DEFAULT_TIMEZONE = DEFAULT_TIMEZONE;
 exports.DateUtils = DateUtils;
 exports.MercureManager = mercureManager;
 exports.MercureProvider = MercureProvider;
+exports.buildMercureCollectionTopic = buildMercureCollectionTopic;
 exports.configureCore = configureCore;
 exports.configureCoreDate = configureCoreDate;
 exports.coreTranslationsEn = coreTranslationsEn;
@@ -957,16 +1143,24 @@ exports.coreTranslationsEs = coreTranslationsEs;
 exports.createCoreHttpClient = createCoreHttpClient;
 exports.createCrudEvents = createCrudEvents;
 exports.createScopedEventBus = createScopedEventBus;
+exports.discoverMercureFromResponse = discoverMercureFromResponse;
 exports.dispatch = dispatch;
+exports.extractMercureHubUrl = extractMercureHubUrl;
+exports.extractTopicOriginFromPayload = extractTopicOriginFromPayload;
 exports.getCoreApiBaseUrl = getCoreApiBaseUrl;
 exports.getCoreCurrency = getCoreCurrency;
 exports.getCoreLocale = getCoreLocale;
 exports.getCoreTimezone = getCoreTimezone;
+exports.getDiscoveredMercureTopicOrigin = getDiscoveredMercureTopicOrigin;
+exports.getMercureTopicOrigin = getMercureTopicOrigin;
 exports.initCoreI18n = initCoreI18n;
+exports.parseLinkHeader = parseLinkHeader;
+exports.resolveMercureTopicOrigin = resolveMercureTopicOrigin;
 exports.useCoreConfig = useCoreConfig;
 exports.useCoreHttpClient = useCoreHttpClient;
 exports.useCoreRuntime = useCoreRuntime;
 exports.useCoreTranslation = useCoreTranslation;
+exports.useDiscoveredMercureTopicOrigin = useDiscoveredMercureTopicOrigin;
 exports.useEvents = useEvents;
 exports.useMercureHub = useMercureHub;
 exports.useMercureSubscription = useMercureSubscription;