chat-layout 1.1.1 → 1.1.2

package/README.md

@@ -108,6 +108,7 @@ Notes:
 ## Migration notes
 
 - Use `memoRenderItemBy(keyOf, renderItem)` when list items are primitives.
+- `memoRenderItemBy()` now uses a bounded LRU cache by default; pass `{ maxEntries: Infinity }` to keep the old unbounded behavior explicitly.
 - `FlexItem` exposes `grow`, `shrink`, and `alignSelf`; `basis` is no longer public.
 - `MultilineText` now uses `align` / `physicalAlign` instead of `alignment`.
 - `ListState.position` uses `undefined` for the renderer default anchor.

package/index.d.mts

@@ -518,7 +518,9 @@ declare function memoRenderItem<C extends CanvasRenderingContext2D, T extends ob
 /**
  * Memoizes `renderItem` by a caller-provided cache key.
  */
-declare function memoRenderItemBy<C extends CanvasRenderingContext2D, T, K>(keyOf: (item: T) => K, renderItem: (item: T) => Node<C>): ((item: T) => Node<C>) & {
+declare function memoRenderItemBy<C extends CanvasRenderingContext2D, T, K>(keyOf: (item: T) => K, renderItem: (item: T) => Node<C>, options?: {
+  maxEntries?: number;
+}): ((item: T) => Node<C>) & {
   reset: (item: T) => boolean;
   resetKey: (key: K) => boolean;
 };

package/index.mjs

@@ -818,17 +818,15 @@ var Place = class extends Wrapper {
 };
 const INTRINSIC_MAX_WIDTH = Number.POSITIVE_INFINITY;
 const MIN_CONTENT_WIDTH_EPSILON = .001;
-const fontShiftCache = /* @__PURE__ */ new Map();
-const ellipsisWidthCache = /* @__PURE__ */ new Map();
 let sharedGraphemeSegmenter;
-function readLruValue(cache, key) {
+function readLruValue$1(cache, key) {
 	const cached = cache.get(key);
 	if (cached == null) return;
 	cache.delete(key);
 	cache.set(key, cached);
 	return cached;
 }
-function writeLruValue(cache, key, value, capacity) {
+function writeLruValue$1(cache, key, value, capacity) {
 	if (cache.has(key)) cache.delete(key);
 	else if (cache.size >= capacity) {
 		const firstKey = cache.keys().next().value;
@@ -838,17 +836,11 @@ function writeLruValue(cache, key, value, capacity) {
 	return value;
 }
 function measureFontShift(ctx) {
-	const font = ctx.graphics.font;
-	const cached = readLruValue(fontShiftCache, font);
-	if (cached != null) return cached;
 	const { fontBoundingBoxAscent: ascent = 0, fontBoundingBoxDescent: descent = 0 } = ctx.graphics.measureText("M");
-	return writeLruValue(fontShiftCache, font, ascent - descent, 64);
+	return ascent - descent;
 }
 function measureEllipsisWidth(ctx) {
-	const font = ctx.graphics.font;
-	const cached = readLruValue(ellipsisWidthCache, font);
-	if (cached != null) return cached;
-	return writeLruValue(ellipsisWidthCache, font, ctx.graphics.measureText("…").width, 64);
+	return ctx.graphics.measureText("…").width;
 }
 function getGraphemeSegmenter() {
 	if (sharedGraphemeSegmenter !== void 0) return sharedGraphemeSegmenter;
@@ -936,15 +928,14 @@ const LINE_START_CURSOR$1 = {
 	graphemeIndex: 0
 };
 const preparedTextCache = /* @__PURE__ */ new Map();
-const preparedUnitCache = /* @__PURE__ */ new WeakMap();
 function getPreparedTextCacheKey(text, font, whiteSpace, wordBreak) {
 	return `${font}\u0000${whiteSpace}\u0000${wordBreak}\u0000${text}`;
 }
 function readPreparedText(text, font, whiteSpace, wordBreak) {
 	const key = getPreparedTextCacheKey(text, font, whiteSpace, wordBreak);
-	const cached = readLruValue(preparedTextCache, key);
+	const cached = readLruValue$1(preparedTextCache, key);
 	if (cached != null) return cached;
-	return writeLruValue(preparedTextCache, key, prepareWithSegments(text, font, {
+	return writeLruValue$1(preparedTextCache, key, prepareWithSegments(text, font, {
 		whiteSpace,
 		wordBreak
 	}), 512);
@@ -973,8 +964,6 @@ function measurePreparedMinContentWidth(prepared, overflowWrap = "break-word") {
 	return maxWidth > 0 ? maxWidth : maxAnyWidth;
 }
 function getPreparedUnits(prepared) {
-	const cached = preparedUnitCache.get(prepared);
-	if (cached != null) return cached;
 	const units = [];
 	for (let index = 0; index < prepared.segments.length; index += 1) {
 		const segment = prepared.segments[index] ?? "";
@@ -995,7 +984,6 @@ function getPreparedUnits(prepared) {
 			width: segmentWidth
 		});
 	}
-	preparedUnitCache.set(prepared, units);
 	return units;
 }
 function joinUnitText(units, start, end) {
@@ -1248,7 +1236,7 @@ function getRichPreparedCacheKey(spans, defaultFont) {
 }
 function readRichPrepared(spans, defaultFont) {
 	const key = getRichPreparedCacheKey(spans, defaultFont);
-	const cached = readLruValue(richPreparedCache, key);
+	const cached = readLruValue$1(richPreparedCache, key);
 	if (cached != null) return cached;
 	const items = spans.map((span) => ({
 		text: span.text,
@@ -1257,7 +1245,7 @@ function readRichPrepared(spans, defaultFont) {
 		extraWidth: span.extraWidth
 	}));
 	const preparedItemIndexBySourceItemIndex = buildPreparedItemIndexBySourceItemIndex(spans);
-	return writeLruValue(richPreparedCache, key, {
+	return writeLruValue$1(richPreparedCache, key, {
 		prepared: prepareRichInline(items),
 		preparedItemIndexBySourceItemIndex
 	}, RICH_PREPARED_CACHE_CAPACITY);
@@ -2155,27 +2143,56 @@ var DebugRenderer = class extends BaseRenderer {
 	}
 };
 //#endregion
+//#region src/renderer/weak-listeners.ts
+function pruneWeakListenerMap(listeners) {
+	for (const [token, listener] of listeners) if (listener.ownerRef.deref() == null) listeners.delete(token);
+}
+function emitWeakListeners(listeners, event) {
+	for (const [token, listener] of [...listeners]) {
+		const owner = listener.ownerRef.deref();
+		if (owner == null) {
+			listeners.delete(token);
+			continue;
+		}
+		listener.notify(owner, event);
+	}
+}
+//#endregion
 //#region src/renderer/list-state.ts
 const listStateListeners = /* @__PURE__ */ new WeakMap();
+const listStateListenerRegistry = typeof FinalizationRegistry === "function" ? new FinalizationRegistry(({ listRef, token }) => {
+	const list = listRef.deref();
+	if (list == null) return;
+	deleteListStateListener(list, token);
+}) : null;
+function deleteListStateListener(list, token) {
+	const listeners = listStateListeners.get(list);
+	if (listeners == null) return;
+	listeners.delete(token);
+	if (listeners.size === 0) listStateListeners.delete(list);
+}
 function emitListStateChange(list, change) {
 	const listeners = listStateListeners.get(list);
-	if (listeners == null || listeners.size === 0) return;
-	for (const listener of [...listeners]) listener(change);
+	if (listeners == null) return;
+	emitWeakListeners(listeners, change);
+	if (listeners.size === 0) listStateListeners.delete(list);
 }
-function subscribeListState(list, listener) {
+function subscribeListState(list, owner, listener) {
 	const key = list;
 	let listeners = listStateListeners.get(key);
 	if (listeners == null) {
-		listeners = /* @__PURE__ */ new Set();
+		listeners = /* @__PURE__ */ new Map();
 		listStateListeners.set(key, listeners);
-	}
-	listeners.add(listener);
-	return () => {
-		const current = listStateListeners.get(key);
-		if (current == null) return;
-		current.delete(listener);
-		if (current.size === 0) listStateListeners.delete(key);
-	};
+	} else pruneWeakListenerMap(listeners);
+	const token = Symbol();
+	listeners.set(token, {
+		ownerRef: new WeakRef(owner),
+		notify: listener
+	});
+	listStateListenerRegistry?.register(owner, {
+		listRef: new WeakRef(key),
+		token
+	});
 }
 var ListState = class {
 	#items;
@@ -2269,9 +2286,31 @@ var ListState = class {
 };
 //#endregion
 //#region src/renderer/memo.ts
+const DEFAULT_MEMO_RENDER_ITEM_BY_MAX_ENTRIES = 512;
 function isWeakMapKey(value) {
 	return typeof value === "object" && value !== null || typeof value === "function";
 }
+function normalizeMaxEntries(maxEntries) {
+	if (maxEntries === Number.POSITIVE_INFINITY) return Number.POSITIVE_INFINITY;
+	if (maxEntries == null || !Number.isFinite(maxEntries)) return DEFAULT_MEMO_RENDER_ITEM_BY_MAX_ENTRIES;
+	return Math.max(0, Math.trunc(maxEntries));
+}
+function readLruValue(cache, key) {
+	const cached = cache.get(key);
+	if (cached == null) return;
+	cache.delete(key);
+	cache.set(key, cached);
+	return cached;
+}
+function writeLruValue(cache, key, value, maxEntries) {
+	if (cache.has(key)) cache.delete(key);
+	else if (Number.isFinite(maxEntries) && cache.size >= maxEntries) {
+		const oldestKey = cache.keys().next().value;
+		if (oldestKey != null) cache.delete(oldestKey);
+	}
+	if (maxEntries > 0) cache.set(key, value);
+	return value;
+}
 /**
 * Memoizes `renderItem` by object identity.
 */
@@ -2291,15 +2330,14 @@ function memoRenderItem(renderItem) {
 /**
 * Memoizes `renderItem` by a caller-provided cache key.
 */
-function memoRenderItemBy(keyOf, renderItem) {
+function memoRenderItemBy(keyOf, renderItem, options = {}) {
 	const cache = /* @__PURE__ */ new Map();
+	const maxEntries = normalizeMaxEntries(options.maxEntries);
 	function fn(item) {
 		const key = keyOf(item);
-		const cached = cache.get(key);
+		const cached = readLruValue(cache, key);
 		if (cached != null) return cached;
-		const result = renderItem(item);
-		cache.set(key, result);
-		return result;
+		return writeLruValue(cache, key, renderItem(item), maxEntries);
 	}
 	return Object.assign(fn, {
 		reset: (item) => cache.delete(keyOf(item)),
@@ -2341,11 +2379,10 @@ var VirtualizedRenderer = class VirtualizedRenderer extends BaseRenderer {
 	#jumpAnimation;
 	#replacementAnimations = /* @__PURE__ */ new Map();
 	#nextReplacementLayerKey = 0;
-	#unsubscribeListState;
 	constructor(graphics, options) {
 		super(graphics, options);
-		this.#unsubscribeListState = subscribeListState(options.list, (change) => {
-			this.#handleListStateChange(change);
+		subscribeListState(options.list, this, (owner, change) => {
+			owner.#handleListStateChange(change);
 		});
 	}
 	/** Current anchor item index. */