@moku-labs/web 2.4.12 → 2.4.13

package/dist/browser.d.mts

@@ -1998,6 +1998,12 @@ interface DataState {
   lastWrite: DataWriteSummary | null;
   /** Per-path fetched data, cached after the first `at(path)` (browser). */
   cache: Map<string, unknown>;
+  /**
+   * Per-path fetches still in flight (browser). A second `at(path)` awaits the
+   * same promise instead of starting another request. The entry is removed when
+   * the fetch settles, on success and on failure, so a failure is never cached.
+   */
+  pending: Map<string, Promise<unknown | null>>;
 }
 /**
  * Public API mounted at `app.data` — the agnostic data provider. `write()` is the

package/dist/browser.mjs

@@ -2367,6 +2367,30 @@ async function loadJson(pathOrUrl) {
 * the isomorphic `loadJson` (whose Node branch is itself lazy).
 */
 /**
+* Fetches one path's data, caches it on success, and always clears the path's
+* in-flight entry. Never rejects: a failed fetch or JSON parse resolves `null`
+* and caches nothing, so a later `at(path)` retries.
+*
+* @param ctx - The data plugin context.
+* @param path - The page URL path (e.g. `/en/hello/`).
+* @returns The page's raw data, or `null` on failure.
+* @example
+* ```ts
+* const raw = await fetchAndCache(ctx, "/en/hello/");
+* ```
+*/
+async function fetchAndCache(ctx, path) {
+	try {
+		const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
+		ctx.state.cache.set(path, data);
+		return data;
+	} catch {
+		return null;
+	} finally {
+		ctx.state.pending.delete(path);
+	}
+}
+/**
 * Builds the data provider — the agnostic bridge. `write()` is the Node persist
 * side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
 * convention. No `onStart`/`onStop` (holds no long-lived resource).
@@ -2384,6 +2408,7 @@ function dataApi(ctx) {
 	return {
 		/**
 		* READ (browser) — fetch (and cache) the persisted data for a page path.
+		* Concurrent calls for one path share one in-flight request.
 		* Returns the raw JSON as `unknown`, which the route uses directly as `ctx.data`
 		* (no route `.parse()`); returns `null` if the fetch or JSON parse fails (so
 		* `spa` can fall back to HTML).
@@ -2397,13 +2422,11 @@ function dataApi(ctx) {
 		*/
 		async at(path) {
 			if (ctx.state.cache.has(path)) return ctx.state.cache.get(path);
-			try {
-				const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
-				ctx.state.cache.set(path, data);
-				return data;
-			} catch {
-				return null;
-			}
+			const inFlight = ctx.state.pending.get(path);
+			if (inFlight) return inFlight;
+			const request = fetchAndCache(ctx, path);
+			ctx.state.pending.set(path, request);
+			return request;
 		},
 		/**
 		* WRITE (Node) — persist one JSON file per entry, keyed by page path. Called by
@@ -2472,13 +2495,13 @@ const defaultDataConfig = {
 //#region src/plugins/data/state.ts
 /**
 * Creates initial data state: a null `lastWrite` slot (populated by the Node
-* `write()` side) and an empty `cache` (populated lazily by the browser `at(path)`
-* side on first fetch).
+* `write()` side), an empty `cache` (populated lazily by the browser `at(path)`
+* side on first fetch) and an empty `pending` map of in-flight fetches.
 *
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global framework configuration.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh data state with no recorded write and an empty per-path cache.
+* @returns Fresh data state with no recorded write and an empty per-path cache and no pending fetch.
 * @example
 * ```ts
 * const state = createDataState({ global: {}, config });
@@ -2487,7 +2510,8 @@ const defaultDataConfig = {
 function createDataState(_ctx) {
 	return {
 		lastWrite: null,
-		cache: /* @__PURE__ */ new Map()
+		cache: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
 	};
 }
 //#endregion

package/dist/index.cjs

@@ -4625,6 +4625,30 @@ async function loadJson(pathOrUrl) {
 * the isomorphic `loadJson` (whose Node branch is itself lazy).
 */
 /**
+* Fetches one path's data, caches it on success, and always clears the path's
+* in-flight entry. Never rejects: a failed fetch or JSON parse resolves `null`
+* and caches nothing, so a later `at(path)` retries.
+*
+* @param ctx - The data plugin context.
+* @param path - The page URL path (e.g. `/en/hello/`).
+* @returns The page's raw data, or `null` on failure.
+* @example
+* ```ts
+* const raw = await fetchAndCache(ctx, "/en/hello/");
+* ```
+*/
+async function fetchAndCache(ctx, path) {
+	try {
+		const data = await loadJson(`${ctx.config.baseUrl}${require_convention.dataSuffix(path)}`);
+		ctx.state.cache.set(path, data);
+		return data;
+	} catch {
+		return null;
+	} finally {
+		ctx.state.pending.delete(path);
+	}
+}
+/**
 * Builds the data provider — the agnostic bridge. `write()` is the Node persist
 * side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
 * convention. No `onStart`/`onStop` (holds no long-lived resource).
@@ -4642,6 +4666,7 @@ function dataApi(ctx) {
 	return {
 		/**
 		* READ (browser) — fetch (and cache) the persisted data for a page path.
+		* Concurrent calls for one path share one in-flight request.
 		* Returns the raw JSON as `unknown`, which the route uses directly as `ctx.data`
 		* (no route `.parse()`); returns `null` if the fetch or JSON parse fails (so
 		* `spa` can fall back to HTML).
@@ -4655,13 +4680,11 @@ function dataApi(ctx) {
 		*/
 		async at(path) {
 			if (ctx.state.cache.has(path)) return ctx.state.cache.get(path);
-			try {
-				const data = await loadJson(`${ctx.config.baseUrl}${require_convention.dataSuffix(path)}`);
-				ctx.state.cache.set(path, data);
-				return data;
-			} catch {
-				return null;
-			}
+			const inFlight = ctx.state.pending.get(path);
+			if (inFlight) return inFlight;
+			const request = fetchAndCache(ctx, path);
+			ctx.state.pending.set(path, request);
+			return request;
 		},
 		/**
 		* WRITE (Node) — persist one JSON file per entry, keyed by page path. Called by
@@ -4730,13 +4753,13 @@ const defaultDataConfig = {
 //#region src/plugins/data/state.ts
 /**
 * Creates initial data state: a null `lastWrite` slot (populated by the Node
-* `write()` side) and an empty `cache` (populated lazily by the browser `at(path)`
-* side on first fetch).
+* `write()` side), an empty `cache` (populated lazily by the browser `at(path)`
+* side on first fetch) and an empty `pending` map of in-flight fetches.
 *
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global framework configuration.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh data state with no recorded write and an empty per-path cache.
+* @returns Fresh data state with no recorded write and an empty per-path cache and no pending fetch.
 * @example
 * ```ts
 * const state = createDataState({ global: {}, config });
@@ -4745,7 +4768,8 @@ const defaultDataConfig = {
 function createDataState(_ctx) {
 	return {
 		lastWrite: null,
-		cache: /* @__PURE__ */ new Map()
+		cache: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
 	};
 }
 //#endregion

package/dist/index.d.cts

@@ -3467,6 +3467,12 @@ interface DataState {
   lastWrite: DataWriteSummary | null;
   /** Per-path fetched data, cached after the first `at(path)` (browser). */
   cache: Map<string, unknown>;
+  /**
+   * Per-path fetches still in flight (browser). A second `at(path)` awaits the
+   * same promise instead of starting another request. The entry is removed when
+   * the fetch settles, on success and on failure, so a failure is never cached.
+   */
+  pending: Map<string, Promise<unknown | null>>;
 }
 /**
  * Public API mounted at `app.data` — the agnostic data provider. `write()` is the

package/dist/index.d.mts

@@ -3465,6 +3465,12 @@ interface DataState {
   lastWrite: DataWriteSummary | null;
   /** Per-path fetched data, cached after the first `at(path)` (browser). */
   cache: Map<string, unknown>;
+  /**
+   * Per-path fetches still in flight (browser). A second `at(path)` awaits the
+   * same promise instead of starting another request. The entry is removed when
+   * the fetch settles, on success and on failure, so a failure is never cached.
+   */
+  pending: Map<string, Promise<unknown | null>>;
 }
 /**
  * Public API mounted at `app.data` — the agnostic data provider. `write()` is the

package/dist/index.mjs

@@ -4581,6 +4581,30 @@ async function loadJson(pathOrUrl) {
 * the isomorphic `loadJson` (whose Node branch is itself lazy).
 */
 /**
+* Fetches one path's data, caches it on success, and always clears the path's
+* in-flight entry. Never rejects: a failed fetch or JSON parse resolves `null`
+* and caches nothing, so a later `at(path)` retries.
+*
+* @param ctx - The data plugin context.
+* @param path - The page URL path (e.g. `/en/hello/`).
+* @returns The page's raw data, or `null` on failure.
+* @example
+* ```ts
+* const raw = await fetchAndCache(ctx, "/en/hello/");
+* ```
+*/
+async function fetchAndCache(ctx, path) {
+	try {
+		const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
+		ctx.state.cache.set(path, data);
+		return data;
+	} catch {
+		return null;
+	} finally {
+		ctx.state.pending.delete(path);
+	}
+}
+/**
 * Builds the data provider — the agnostic bridge. `write()` is the Node persist
 * side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
 * convention. No `onStart`/`onStop` (holds no long-lived resource).
@@ -4598,6 +4622,7 @@ function dataApi(ctx) {
 	return {
 		/**
 		* READ (browser) — fetch (and cache) the persisted data for a page path.
+		* Concurrent calls for one path share one in-flight request.
 		* Returns the raw JSON as `unknown`, which the route uses directly as `ctx.data`
 		* (no route `.parse()`); returns `null` if the fetch or JSON parse fails (so
 		* `spa` can fall back to HTML).
@@ -4611,13 +4636,11 @@ function dataApi(ctx) {
 		*/
 		async at(path) {
 			if (ctx.state.cache.has(path)) return ctx.state.cache.get(path);
-			try {
-				const data = await loadJson(`${ctx.config.baseUrl}${dataSuffix(path)}`);
-				ctx.state.cache.set(path, data);
-				return data;
-			} catch {
-				return null;
-			}
+			const inFlight = ctx.state.pending.get(path);
+			if (inFlight) return inFlight;
+			const request = fetchAndCache(ctx, path);
+			ctx.state.pending.set(path, request);
+			return request;
 		},
 		/**
 		* WRITE (Node) — persist one JSON file per entry, keyed by page path. Called by
@@ -4686,13 +4709,13 @@ const defaultDataConfig = {
 //#region src/plugins/data/state.ts
 /**
 * Creates initial data state: a null `lastWrite` slot (populated by the Node
-* `write()` side) and an empty `cache` (populated lazily by the browser `at(path)`
-* side on first fetch).
+* `write()` side), an empty `cache` (populated lazily by the browser `at(path)`
+* side on first fetch) and an empty `pending` map of in-flight fetches.
 *
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global framework configuration.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh data state with no recorded write and an empty per-path cache.
+* @returns Fresh data state with no recorded write and an empty per-path cache and no pending fetch.
 * @example
 * ```ts
 * const state = createDataState({ global: {}, config });
@@ -4701,7 +4724,8 @@ const defaultDataConfig = {
 function createDataState(_ctx) {
 	return {
 		lastWrite: null,
-		cache: /* @__PURE__ */ new Map()
+		cache: /* @__PURE__ */ new Map(),
+		pending: /* @__PURE__ */ new Map()
 	};
 }
 //#endregion

package/package.json

@@ -139,5 +139,5 @@
     "typescript-eslint": "8.58.0",
     "vitest": "4.0.18"
   },
-  "version": "2.4.12"
+  "version": "2.4.13"
 }