@nubitio/core 0.5.10 → 0.5.13

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import React, { createContext, useContext, useEffect, useMemo, useRef } from "react";
+import React, { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 import { useTranslation } from "react-i18next";
 import i18next from "i18next";
@@ -7,7 +7,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).
@@ -19,6 +20,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.
@@ -37,24 +39,30 @@ function getCoreApiBaseUrl() {
 function getCoreCurrency() {
 	return _coreConfig.currency;
 }
+function getMercureTopicOrigin() {
+	return _coreConfig.mercureTopicOrigin;
+}
 const CoreConfigContext = React.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.useMemo(() => ({
 		locale,
 		timezone,
 		apiBaseUrl,
-		currency
+		currency,
+		mercureTopicOrigin
 	}), [
 		locale,
 		timezone,
 		apiBaseUrl,
-		currency
+		currency,
+		mercureTopicOrigin
 	]);
 	return /* @__PURE__ */ jsx(CoreConfigContext.Provider, {
 		value,
@@ -489,6 +497,230 @@ function initCoreI18n() {
 	i18next.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;
@@ -584,12 +816,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";
@@ -688,124 +924,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.
@@ -818,14 +936,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 = createContext(null);
@@ -833,10 +956,17 @@ const MercureContext = 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] = useState(() => mercureManager.getHubUrl());
 	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__ */ jsx(MercureContext.Provider, {
 		value: hubUrl,
 		children
@@ -853,7 +983,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
 *
@@ -870,6 +1001,52 @@ function useMercureHub() {
 	return 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] = useState(getDiscoveredMercureTopicOrigin);
+	useEffect(() => onMercureTopicOriginChange(setOrigin), []);
+	return origin;
+}
+//#endregion
 //#region packages/core/mercure/useMercureSubscription.ts
 /**
 * useMercureSubscription — Hook that subscribes to a Mercure topic and calls
@@ -879,6 +1056,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
@@ -898,10 +1078,12 @@ function useMercureHub() {
 */
 function useMercureSubscription(apiUrl, onUpdate, enabled = true) {
 	const hubUrl = useMercureHub();
+	const { mercureTopicOrigin, apiBaseUrl } = useCoreConfig();
+	const discoveredTopicOrigin = useDiscoveredMercureTopicOrigin();
 	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();
 		};
@@ -912,8 +1094,11 @@ function useMercureSubscription(apiUrl, onUpdate, enabled = true) {
 	}, [
 		hubUrl,
 		enabled,
-		apiUrl
+		apiUrl,
+		mercureTopicOrigin,
+		discoveredTopicOrigin,
+		apiBaseUrl
 	]);
 }
 //#endregion
-export { CoreConfigProvider, CoreHttpClient, CoreHttpProvider, CoreProvider, CoreRuntimeProvider, DEFAULT_TIMEZONE, DateUtils, mercureManager as MercureManager, MercureProvider, configureCore, configureCoreDate, coreTranslationsEn, coreTranslationsEs, createCoreHttpClient, createCrudEvents, createScopedEventBus, dispatch, getCoreApiBaseUrl, getCoreCurrency, getCoreLocale, getCoreTimezone, initCoreI18n, useCoreConfig, useCoreHttpClient, useCoreRuntime, useCoreTranslation, useEvents, useMercureHub, useMercureSubscription };
+export { CoreConfigProvider, CoreHttpClient, CoreHttpProvider, CoreProvider, CoreRuntimeProvider, DEFAULT_TIMEZONE, DateUtils, mercureManager as MercureManager, MercureProvider, buildMercureCollectionTopic, configureCore, configureCoreDate, coreTranslationsEn, coreTranslationsEs, createCoreHttpClient, createCrudEvents, createScopedEventBus, discoverMercureFromResponse, dispatch, extractMercureHubUrl, extractTopicOriginFromPayload, getCoreApiBaseUrl, getCoreCurrency, getCoreLocale, getCoreTimezone, getDiscoveredMercureTopicOrigin, getMercureTopicOrigin, initCoreI18n, parseLinkHeader, resolveMercureTopicOrigin, useCoreConfig, useCoreHttpClient, useCoreRuntime, useCoreTranslation, useDiscoveredMercureTopicOrigin, useEvents, useMercureHub, useMercureSubscription };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nubitio/core",
-  "version": "0.5.10",
+  "version": "0.5.13",
   "type": "module",
   "description": "Runtime foundation for Nubit: HTTP client, event bus, i18n, Mercure SSE, CoreProvider, and date utilities.",
   "license": "MIT",