@moku-labs/web 1.2.0 → 1.3.1

package/dist/browser.d.mts

@@ -1853,7 +1853,7 @@ type DataProvider = {
  */
 declare const dataPlugin: import("@moku-labs/core").PluginInstance<"data", DataConfig, DataState, DataProvider, {}> & Record<never, never>;
 declare namespace types_d_exports {
-  export { Api, Article, ArticleCard, ComputedFields, Config, ContentApiContext, ContentEvents, ContentProvider, ContentProviderState, FileSystemContentOptions, Frontmatter, State };
+  export { Api, Article, ArticleCard, ComputedFields, Config, ContentApiContext, ContentEvents, ContentProvider, ContentProviderState, FileSystemContentOptions, Frontmatter, LoadAllOptions, State };
 }
 /**
  * YAML frontmatter parsed from each article file.
@@ -2028,11 +2028,18 @@ type Config = {
  *
  * @example
  * ```ts
- * { articles: new Map() }
+ * { articles: new Map(), loadedAll: null }
  * ```
  */
 type State = {
   /** Article cache keyed locale -> (slug -> Article). Starts empty. */articles: Map<string, Map<string, Article>>;
+  /**
+   * Memoized full `loadAll()` result, or `null` when not yet loaded / invalidated. List-route
+   * loaders call `loadAll()` once PER PAGE, so without this every page re-reads + re-renders
+   * every article (the dev-loop killer). The memo makes repeated calls O(1); `invalidate()`
+   * clears it so a dev rebuild reloads (re-resolving only the changed slugs). Starts `null`.
+   */
+  loadedAll: Map<string, Article[]> | null;
 };
 /**
  * Notification-only events emitted by the content plugin.
@@ -2072,6 +2079,26 @@ type ContentApiContext = {
   defaultLocale: () => string; /** The resolved content source (merged from `config.providers`). */
   provider: ContentProvider;
 };
+/**
+ * Options for {@link Api.loadAll}.
+ *
+ * @example
+ * ```ts
+ * await app.content.loadAll({ reuse: true });
+ * ```
+ */
+type LoadAllOptions = {
+  /**
+   * Reuse the per-build memo + per-slug cache (re-resolving only slugs a preceding
+   * `invalidate()` dropped). Default `true` — this is what keeps repeated `loadAll()` calls
+   * (a list route's loader runs once per page) cheap, and makes a dev rebuild re-render only
+   * changed articles. Set `false` to force a FRESH full reload (cold build / an
+   * unclassifiable change), which re-reads + re-renders every article and rebuilds the memo.
+   * The post-sort `contentId` ordinals are always recomputed across the full set, so order +
+   * ids match a full load either way.
+   */
+  reuse?: boolean;
+};
 /**
  * Public API for the content plugin.
  *
@@ -2082,10 +2109,15 @@ type ContentApiContext = {
  */
 type Api = {
   /**
-   * Load every article across every active locale, returning a locale-keyed
-   * map of date-descending Article arrays. Emits content:ready.
+   * Load every article across every active locale, returning a locale-keyed map of
+   * date-descending Article arrays. Emits content:ready (once per actual load). Cache-first
+   * + memoized: repeated calls (e.g. a list route's loader on every page) return the SAME
+   * cached result with no re-read — so treat the result as READ-ONLY (do not sort/mutate it
+   * in place; slice/copy first). Pass `{ reuse: false }` to force a fresh full reload.
+   *
+   * @param options - Optional load behaviour ({@link LoadAllOptions}); default reuses the cache.
    */
-  loadAll(): Promise<Map<string, Article[]>>;
+  loadAll(options?: LoadAllOptions): Promise<Map<string, Article[]>>;
   /**
    * Resolve and render a single article for one locale, with locale fallback.
    *

package/dist/browser.mjs

@@ -4355,18 +4355,24 @@ function isPublished(article, isProduction) {
 * locale collection: existing files only, drafts dropped in production, sorted
 * date-descending. The single load+filter+sort step behind {@link createContentApi.loadAll}.
 *
+* When a `cached` map is supplied (incremental dev rebuild), a slug already present in it
+* is reused as-is (skipping the re-read + Markdown/Shiki re-render); only slugs absent
+* from it — the ones a preceding `invalidate()` dropped, plus any never-loaded — are
+* resolved fresh. With no `cached` map every slug is resolved (the full load).
+*
 * @param ctx - Kernel-free domain context (provider + i18n helpers + stage).
 * @param slugs - Every known article slug from the provider.
 * @param locale - The locale to resolve and collect.
+* @param cached - Optional per-locale article cache to reuse for unchanged slugs.
 * @returns The published (date-descending) articles for this locale.
 * @example
 * ```ts
 * const present = await loadAndFilterArticles(ctx, slugs, "en");
 * ```
 */
-async function loadAndFilterArticles(ctx, slugs, locale) {
+async function loadAndFilterArticles(ctx, slugs, locale, cached) {
 	const isProduction = ctx.global.stage === "production";
-	return (await Promise.all(slugs.map((slug) => resolveArticle(ctx, slug, locale)))).filter((article) => article !== null).filter((article) => isPublished(article, isProduction)).toSorted(byDateDescending);
+	return (await Promise.all(slugs.map((slug) => cached?.get(slug) ?? resolveArticle(ctx, slug, locale)))).filter((article) => article !== null).filter((article) => isPublished(article, isProduction)).toSorted(byDateDescending);
 }
 /**
 * Derive the article slug from a source file path — the parent directory name
@@ -4403,19 +4409,31 @@ function createContentApi(ctx) {
 		* Load every article across every active locale (locale fallback, production
 		* draft exclusion, date sort, `contentId` after sort), cache them, emit `content:ready`.
 		*
+		* Cache-first by default: repeated calls return the per-build memo (list-route loaders
+		* call this once PER PAGE — without the memo every page would re-read + re-render every
+		* article, the dev-loop killer), and a rebuild after `invalidate()` re-resolves only the
+		* dropped slugs while reusing the cached articles for the rest (`contentId` ordinals are
+		* still recomputed across the FULL sorted set, so ids + order match a full load). Pass
+		* `{ reuse: false }` to force a FRESH full reload (cold build / an unclassifiable change
+		* where the caller cannot pinpoint what changed) — this bypasses the memo + per-slug cache.
+		*
+		* @param options - Optional load behaviour (`reuse`, default `true`).
 		* @returns A locale-keyed map of date-descending articles.
 		* @example
 		* ```ts
 		* const byLocale = await api.loadAll();
 		* ```
 		*/
-		async loadAll() {
+		async loadAll(options) {
+			const reuse = options?.reuse !== false;
+			const memo = ctx.state.loadedAll;
+			if (reuse && memo !== null) return memo;
 			const slugs = await ctx.provider.slugs();
 			const locales = ctx.locales();
 			const result = /* @__PURE__ */ new Map();
 			let total = 0;
 			for (const locale of locales) {
-				const present = await loadAndFilterArticles(ctx, slugs, locale);
+				const present = await loadAndFilterArticles(ctx, slugs, locale, reuse ? ctx.state.articles.get(locale) : void 0);
 				const cache = /* @__PURE__ */ new Map();
 				let index = 0;
 				for (const article of present) {
@@ -4427,6 +4445,7 @@ function createContentApi(ctx) {
 				result.set(locale, present);
 				total += present.length;
 			}
+			ctx.state.loadedAll = result;
 			ctx.emit("content:ready", {
 				locales,
 				articleCount: total
@@ -4490,6 +4509,7 @@ function createContentApi(ctx) {
 				if (slug === void 0) continue;
 				for (const cache of ctx.state.articles.values()) cache.delete(slug);
 			}
+			if (accepted.length > 0) ctx.state.loadedAll = null;
 			ctx.emit("content:invalidated", { paths: accepted });
 		},
 		/**
@@ -4559,14 +4579,17 @@ const contentEvents = (register) => ({
 * @param _ctx - Minimal context with global and config.
 * @param _ctx.global - Global plugin registry.
 * @param _ctx.config - Resolved plugin configuration.
-* @returns Fresh content shell state: an empty article cache.
+* @returns Fresh content shell state: an empty article cache + an empty loadAll memo.
 * @example
 * ```ts
 * const state = createContentState({ global: {}, config: { providers: [] } });
 * ```
 */
 function createContentState(_ctx) {
-	return { articles: /* @__PURE__ */ new Map() };
+	return {
+		articles: /* @__PURE__ */ new Map(),
+		loadedAll: null
+	};
 }
 //#endregion
 //#region src/plugins/content/validate.ts