@greypan/web-ui 11.2.0 → 12.0.0

package/dist/components/middle-ellipsis/index.js

@@ -1,170 +1,324 @@
-import e from "../../_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorate.js";
-import { normalizeNumber as t } from "../../shared/normalize/index.js";
-import { ElementWidthController as n } from "../../shared/element-width/index.js";
-import r from "./style.js";
-import { truncateMiddle as i } from "./truncate.js";
-import { LitElement as a, html as o, unsafeCSS as s } from "lit";
-import { customElement as c, property as l, query as u } from "lit/decorators.js";
-import { ifDefined as d } from "lit/directives/if-defined.js";
-//#region src/components/middle-ellipsis/index.ts
-var f = 0, p = 100, m = 50, h = .5, g = 3, _ = .5, v = /* @__PURE__ */ new WeakMap(), y, b = /* @__PURE__ */ new Set(), x;
-function S() {
-	for (let e of b) e();
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { normalizeNumber } from "../../shared/normalize/index.js";
+import { ElementWidthController } from "../../shared/element-width/index.js";
+import style_default from "./style.js";
+import { truncateMiddle } from "./truncate.js";
+import { LitElement, html, unsafeCSS } from "lit";
+import { customElement, property, query } from "lit/decorators.js";
+import { ifDefined } from "lit/directives/if-defined.js";
+// src/components/middle-ellipsis/index.ts
+const MIN_POSITION = 0;
+const MAX_POSITION = 100;
+const DEFAULT_POSITION = 50;
+/**
+* 合串复核的容差与轮数上限。
+*
+* 分段预算看不见两个接缝处的字距，实测偏差在亚像素量级：容差取 0.5px 吸收它。
+* 轮数上限是纯防御，不是常规路径：实测四种形态（等宽 ASCII 文件名、CJK 长串、无空格长串、
+* emoji/ZWJ 混排）各挂载一次，`_apply` 每次都只被调用一次——复核自己会再调一次 `_apply`，
+* 所以调用次数就是拟合次数，一次意味着复核一轮都没触发。这条上限防的是「标记被调用方撑得比
+* 容器还宽」这类退化输入。
+*/
+const OVERFLOW_TOLERANCE = .5;
+const MAX_REFINE_ROUNDS = 3;
+/**
+* 可用宽度变化的感知阈（px）。
+*
+* `_currentWidth()` 走 `clientWidth`（整数），ResizeObserver 报的是 `contentRect.width`（分数），
+* 同一个盒子在两条路径上最多差 0.5px 的取整误差。不设阈值时，观察者的首次回调会被当成一次「变宽」
+* 而整份重算——实测挂载时两次 `_apply` 的入参都是同一个 240，也就是每次挂载白做一次二分。
+* 0.5 同时压住了「跳过略小于半个像素的真实收缩」的代价：那个量级下输出最多溢出 0.5px，
+* 与 `OVERFLOW_TOLERANCE` 视为可忽略的量级一致。
+*/
+const WIDTH_EPSILON = .5;
+const measurementTargets = /* @__PURE__ */ new WeakMap();
+let measurementObserver;
+const fontMetricSubscribers = /* @__PURE__ */ new Set();
+let observedFontSet;
+function onFontsLoaded() {
+	for (const notify of fontMetricSubscribers) notify();
 }
-function C(e) {
-	let t = document.fonts;
-	t && (x || (x = t, x.addEventListener("loadingdone", S)), b.add(e));
+function observeFontMetrics(notify) {
+	const fontSet = document.fonts;
+	if (!fontSet) return;
+	if (!observedFontSet) {
+		observedFontSet = fontSet;
+		observedFontSet.addEventListener("loadingdone", onFontsLoaded);
+	}
+	fontMetricSubscribers.add(notify);
 }
-function w(e) {
-	b.delete(e), !(b.size > 0 || !x) && (x.removeEventListener("loadingdone", S), x = void 0);
+function unobserveFontMetrics(notify) {
+	fontMetricSubscribers.delete(notify);
+	if (fontMetricSubscribers.size > 0 || !observedFontSet) return;
+	observedFontSet.removeEventListener("loadingdone", onFontsLoaded);
+	observedFontSet = void 0;
 }
-function T() {
-	return typeof ResizeObserver > "u" ? null : y || (y = new ResizeObserver((e) => {
-		for (let t of e) {
-			let e = v.get(t.target);
-			if (!e) continue;
-			let n = t.target.textContent, r = t.contentRect.width;
-			if (e.text !== n) {
-				e.text = n, e.width = r;
+/** Observe the full-text probe so font metric changes can refit without a host resize. */
+function getMeasurementObserver() {
+	if (typeof ResizeObserver === "undefined") return null;
+	if (measurementObserver) return measurementObserver;
+	measurementObserver = new ResizeObserver((entries) => {
+		for (const entry of entries) {
+			const target = measurementTargets.get(entry.target);
+			if (!target) continue;
+			const text = entry.target.textContent;
+			const width = entry.contentRect.width;
+			if (target.text !== text) {
+				target.text = text;
+				target.width = width;
 				continue;
 			}
-			if (e.width < 0) {
-				e.width = r;
+			if (target.width < 0) {
+				target.width = width;
 				continue;
 			}
-			e.width !== r && (e.width = r, e.notify());
+			if (target.width === width) continue;
+			target.width = width;
+			target.notify();
 		}
-	}), y);
+	});
+	return measurementObserver;
 }
-function E(e, t) {
-	v.set(e, {
-		notify: t,
-		text: e.textContent,
+function observeMeasurement(target, notify) {
+	measurementTargets.set(target, {
+		notify,
+		text: target.textContent,
 		width: -1
-	}), C(t);
-	let n = T();
-	n && n.observe(e, { box: "content-box" });
+	});
+	observeFontMetrics(notify);
+	const observer = getMeasurementObserver();
+	if (!observer) return;
+	observer.observe(target, { box: "content-box" });
 }
-function D(e) {
-	let t = v.get(e);
-	t && w(t.notify), v.delete(e), y?.unobserve(e);
+function unobserveMeasurement(target) {
+	const observation = measurementTargets.get(target);
+	if (observation) unobserveFontMetrics(observation.notify);
+	measurementTargets.delete(target);
+	measurementObserver?.unobserve(target);
 }
-function O(e, t) {
-	let n = v.get(e);
-	n && (n.text = t, n.width = e.getBoundingClientRect().width);
+function updateMeasurementText(target, text) {
+	const observation = measurementTargets.get(target);
+	if (!observation) return;
+	observation.text = text;
+	observation.width = target.getBoundingClientRect().width;
 }
-var k = class extends a {
-	constructor(...e) {
-		super(...e), this.text = "", this._marker = "…", this._markerPosition = m, this._display = "", this._truncated = !1, this._available = -1, this._observedWidth = -1, this._rendered = 0, this._dirty = !0, this._refineRound = 0, this._range = document.createRange(), this._width = new n(this, (e) => this._onWidth(e)), this._onMeasurementChange = () => {
-			this._refineRound = 0, this._dirty = !0, this._apply(this._observedWidth > 0 ? this._observedWidth : this._currentWidth());
-		}, this._probe = {
-			prefix: (e) => this._rangeWidth(0, e),
-			suffix: (e) => this._rangeWidth(this.text.length - e, this.text.length),
+let WebUiMiddleEllipsis = class WebUiMiddleEllipsis extends LitElement {
+	constructor(..._args) {
+		super(..._args);
+		this.text = "";
+		this._marker = "…";
+		this._markerPosition = DEFAULT_POSITION;
+		this._display = "";
+		this._truncated = false;
+		this._available = -1;
+		this._observedWidth = -1;
+		this._rendered = 0;
+		this._dirty = true;
+		this._refineRound = 0;
+		this._range = document.createRange();
+		this._width = new ElementWidthController(this, (width) => this._onWidth(width));
+		this._onMeasurementChange = () => {
+			this._refineRound = 0;
+			this._dirty = true;
+			this._apply(this._observedWidth > 0 ? this._observedWidth : this._currentWidth());
+		};
+		this._probe = {
+			prefix: (units) => this._rangeWidth(0, units),
+			suffix: (units) => this._rangeWidth(this.text.length - units, this.text.length),
 			marker: () => this._markerProbe?.getBoundingClientRect().width ?? 0
 		};
 	}
 	static {
-		this.styles = [s(r)];
+		this.styles = [unsafeCSS(style_default)];
 	}
-	set marker(e) {
-		let t = e ?? "…";
-		if (this._marker !== t) {
-			let e = this._marker;
-			this._marker = t, this.requestUpdate("marker", e);
+	/** 中间插入的标记，默认 `…`（U+2026）。空串即「只截断不给信号」，是否这样用由调用方判断。 */
+	set marker(value) {
+		const next = value ?? "…";
+		if (this._marker !== next) {
+			const old = this._marker;
+			this._marker = next;
+			this.requestUpdate("marker", old);
 		}
-		this.getAttribute("marker") !== t && this.setAttribute("marker", t);
+		if (this.getAttribute("marker") !== next) this.setAttribute("marker", next);
 	}
 	get marker() {
 		return this._marker;
 	}
-	set markerPosition(e) {
-		let n = t(e, f, p, m);
-		if (this._markerPosition !== n) {
-			let e = this._markerPosition;
-			this._markerPosition = n, this.requestUpdate("markerPosition", e);
+	/**
+	* 标记所在的横向比例，0–100，默认 `50`（居中）。
+	*
+	* 与 CSSWG css-overflow-5 的 `text-overflow: ellipsis <length-percentage>` 同向：量的是标记
+	* 结束边距行末边的距离占可用行内空间的比例。`0` 只剩头部（等价于末尾省略），`100` 只剩尾部。
+	* 文件名这类「头部是路径噪声、尾部才是扩展名」的场景用**大于** 50 的值让尾部多留一些。
+	*/
+	set markerPosition(value) {
+		const normalized = normalizeNumber(value, MIN_POSITION, MAX_POSITION, DEFAULT_POSITION);
+		if (this._markerPosition !== normalized) {
+			const old = this._markerPosition;
+			this._markerPosition = normalized;
+			this.requestUpdate("markerPosition", old);
 		}
-		this.getAttribute("marker-position") !== String(n) && this.setAttribute("marker-position", String(n));
+		if (this.getAttribute("marker-position") !== String(normalized)) this.setAttribute("marker-position", String(normalized));
 	}
 	get markerPosition() {
 		return this._markerPosition;
 	}
 	connectedCallback() {
-		super.connectedCallback(), this._available >= 0 && (this._dirty = !0, this._refineRound = 0), this._observeMeasure();
+		super.connectedCallback();
+		if (this._available >= 0) {
+			this._dirty = true;
+			this._refineRound = 0;
+		}
+		this._observeMeasure();
 	}
 	disconnectedCallback() {
-		this._observedMeasure &&= (D(this._observedMeasure), void 0), super.disconnectedCallback();
+		if (this._observedMeasure) {
+			unobserveMeasurement(this._observedMeasure);
+			this._observedMeasure = void 0;
+		}
+		super.disconnectedCallback();
 	}
-	willUpdate(e) {
-		(e.has("text") || e.has("marker") || e.has("markerPosition")) && (this._dirty = !0, this._display = this.text, this._truncated = !1);
+	willUpdate(changed) {
+		if (!changed.has("text") && !changed.has("marker") && !changed.has("markerPosition")) return;
+		this._dirty = true;
+		this._display = this.text;
+		this._truncated = false;
 	}
 	updated() {
-		let e = this._textEl;
-		if (e && this.isConnected) {
-			if (this._observeMeasure(), this._rendered = e.getBoundingClientRect().width, this._dirty) {
-				this._refineRound = 0, this._defer(() => this._apply(this._currentWidth()));
-				return;
-			}
-			if (this._truncated && this._rendered > this._available + h) {
-				if (this._refineRound < g) {
-					this._refineRound += 1;
-					let e = this._available - (this._rendered - this._available) - h;
-					this._defer(() => this._apply(e));
-				}
-				return;
-			}
+		const textEl = this._textEl;
+		if (!textEl || !this.isConnected) return;
+		this._observeMeasure();
+		this._rendered = textEl.getBoundingClientRect().width;
+		if (this._dirty) {
 			this._refineRound = 0;
+			this._defer(() => this._apply(this._currentWidth()));
+			return;
+		}
+		if (this._truncated && this._rendered > this._available + OVERFLOW_TOLERANCE) {
+			if (this._refineRound < MAX_REFINE_ROUNDS) {
+				this._refineRound += 1;
+				const tighter = this._available - (this._rendered - this._available) - OVERFLOW_TOLERANCE;
+				this._defer(() => this._apply(tighter));
+			}
+			return;
 		}
+		this._refineRound = 0;
 	}
-	_onWidth(e) {
-		this._observedWidth = e, e > 0 && (!this._dirty && (this._available >= 0 && Math.abs(e - this._available) <= _ || this._available >= 0 && e < this._available && this._rendered <= e + h) || (this._refineRound = 0, this._apply(e)));
+	/**
+	* 容器宽度变化。
+	*
+	* 收缩方向带一条收敛守卫：宿主宽度由内容决定时（flex 主轴 `auto`、或 `width: fit-content` 在内容
+	* 缩到容器以内之后），把自己截短会反过来把宿主量窄，于是排下一次尺寸回调。这个自驱动收缩**可能**
+	* 一路棘轮到只剩标记，是否发生取决于度量：
+	*
+	* - flex + 等宽 16px + 默认 50%：缩掉的量小于一个簇宽时，重新二分落回同一组切点，走一步就停。
+	* - `width: fit-content` + `marker-position: 80` + CJK：每个簇都是整宽块，切短一簇与宿主窄一簇
+	*   互相咬合，摘掉本守卫后 300px 容器里逐帧 282→266→…→10，九步塌到只剩标记（同仓 browser spec
+	*   的「fit-content 宿主 + 非居中标记」用例钉住了这一条）。
+	*
+	* 判据因此取「当前输出已经放得下」：放得下就没有必须重切的理由，自驱动收缩在第一步就停，与度量
+	* 无关；真正的容器收缩会让输出宽于新宽度，那时才重切。放长方向没有这个问题，一律重切（可能能
+	* 少截一些）。
+	*/
+	_onWidth(width) {
+		this._observedWidth = width;
+		if (!(width > 0)) return;
+		if (!this._dirty) {
+			if (this._available >= 0 && Math.abs(width - this._available) <= WIDTH_EPSILON) return;
+			if (this._available >= 0 && width < this._available && this._rendered <= width + OVERFLOW_TOLERANCE) return;
+		}
+		this._refineRound = 0;
+		this._apply(width);
 	}
-	_defer(e) {
-		queueMicrotask(e);
+	/**
+	* 把一次重切排到当前更新周期之外。
+	*
+	* 重切只能在渲染之后量到宽度才做得了，所以第二次更新是必然的；区别只在它从哪里排出去。
+	* 微任务仍排在下一帧渲染之前，画面不会先闪一版全文，而 `updated()` 返回时更新已不再是
+	* pending，Lit 的 `change-in-update` 警告不会触发。
+	*/
+	_defer(fit) {
+		queueMicrotask(fit);
 	}
+	/**
+	* 同步可读的可用行内空间。
+	*
+	* ResizeObserver 的回调在布局之后才到，属性刚改完的那一帧还没有宽度可用；用 `.root` 的
+	* 内容盒补上，免得先按全文画一帧再切。jsdom 没有布局，读到的 0 由 `_apply` 跳过。
+	*/
 	_currentWidth() {
 		return this._root?.clientWidth ?? 0;
 	}
-	_apply(e) {
-		if (!(e > 0)) return;
+	/**
+	* 按可用宽度切分并写回渲染结果。
+	*
+	* 宽度为 0（没有布局）时什么都不做，**并且保留 `_dirty`**：宿主不可见期间改 text 时这一趟
+	* 必然被跳过，若在这里就把「有未落的拟合」清掉，等它重新有布局时就没有任何东西记得要切了。
+	* 清标记因此只发生在真的切完之后。
+	*/
+	_apply(available) {
+		if (!(available > 0)) return;
 		this._syncMeasure();
-		let t = i(this.text, this._marker, this._markerPosition, e, this._probe);
-		this._available = e, this._dirty = !1, this._settle(t.truncated ? t.head + this._marker + t.tail : this.text, t.truncated);
+		const result = truncateMiddle(this.text, this._marker, this._markerPosition, available, this._probe);
+		this._available = available;
+		this._dirty = false;
+		this._settle(result.truncated ? result.head + this._marker + result.tail : this.text, result.truncated);
 	}
-	_settle(e, t) {
-		(this._display !== e || this._truncated !== t) && (this._display = e, this._truncated = t, this.requestUpdate());
+	_settle(display, truncated) {
+		if (this._display === display && this._truncated === truncated) return;
+		this._display = display;
+		this._truncated = truncated;
+		this.requestUpdate();
 	}
+	/** 把全文装进隐藏量具。它没有 Lit 绑定，改它不会触发重渲染。 */
 	_syncMeasure() {
-		let e = this._measure;
-		e && e.textContent !== this.text && (e.textContent = this.text, O(e, this.text));
+		const measure = this._measure;
+		if (measure && measure.textContent !== this.text) {
+			measure.textContent = this.text;
+			updateMeasurementText(measure, this.text);
+		}
 	}
 	_observeMeasure() {
-		let e = this._measure;
-		e && e !== this._observedMeasure && (this._observedMeasure && D(this._observedMeasure), this._observedMeasure = e, E(e, this._onMeasurementChange));
+		const measure = this._measure;
+		if (!measure || measure === this._observedMeasure) return;
+		if (this._observedMeasure) unobserveMeasurement(this._observedMeasure);
+		this._observedMeasure = measure;
+		observeMeasurement(measure, this._onMeasurementChange);
 	}
-	_rangeWidth(e, t) {
-		if (t <= e) return 0;
-		let n = this._measure?.firstChild;
-		return n instanceof Text ? (this._range.setStart(n, e), this._range.setEnd(n, t), this._range.getBoundingClientRect().width) : 0;
+	/** `[from, to)` 这段原文在量具里的渲染宽度。空区间恒为 0——Range 塌缩矩形的宽度不可靠。 */
+	_rangeWidth(from, to) {
+		if (to <= from) return 0;
+		const node = this._measure?.firstChild;
+		if (!(node instanceof Text)) return 0;
+		this._range.setStart(node, from);
+		this._range.setEnd(node, to);
+		return this._range.getBoundingClientRect().width;
 	}
 	render() {
-		return o`
+		return html`
       <div class="root">
-        <span class="text" title=${d(this._truncated ? this.text : void 0)}>${this._display}</span>
+        <span class="text" title=${ifDefined(this._truncated ? this.text : void 0)}>${this._display}</span>
         <span class="measure"></span>
         <span class="marker-probe" aria-hidden="true">${this._marker}</span>
       </div>
     `;
 	}
 };
-e([l({ type: String })], k.prototype, "text", void 0), e([l({
+__decorate([property({ type: String })], WebUiMiddleEllipsis.prototype, "text", void 0);
+__decorate([property({
 	type: String,
-	reflect: !0
-})], k.prototype, "marker", null), e([l({
+	reflect: true
+})], WebUiMiddleEllipsis.prototype, "marker", null);
+__decorate([property({
 	type: Number,
-	reflect: !0,
+	reflect: true,
 	attribute: "marker-position"
-})], k.prototype, "markerPosition", null), e([u(".root")], k.prototype, "_root", void 0), e([u(".text")], k.prototype, "_textEl", void 0), e([u(".measure")], k.prototype, "_measure", void 0), e([u(".marker-probe")], k.prototype, "_markerProbe", void 0), k = e([c("web-ui-middle-ellipsis")], k);
-//#endregion
-export { k as WebUiMiddleEllipsis };
+})], WebUiMiddleEllipsis.prototype, "markerPosition", null);
+__decorate([query(".root")], WebUiMiddleEllipsis.prototype, "_root", void 0);
+__decorate([query(".text")], WebUiMiddleEllipsis.prototype, "_textEl", void 0);
+__decorate([query(".measure")], WebUiMiddleEllipsis.prototype, "_measure", void 0);
+__decorate([query(".marker-probe")], WebUiMiddleEllipsis.prototype, "_markerProbe", void 0);
+WebUiMiddleEllipsis = __decorate([customElement("web-ui-middle-ellipsis")], WebUiMiddleEllipsis);
+export { WebUiMiddleEllipsis };
 
 //# sourceMappingURL=index.js.map

package/dist/components/middle-ellipsis/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/components/middle-ellipsis/index.ts"],"sourcesContent":["import { html, LitElement, unsafeCSS, type PropertyValues } from 'lit'\nimport { customElement, property, query } from 'lit/decorators.js'\nimport { ifDefined } from 'lit/directives/if-defined.js'\n\nimport { ElementWidthController } from '@/shared/element-width'\nimport { normalizeNumber } from '@/shared/normalize'\n\nimport style from './style.css?inline'\nimport { DEFAULT_MARKER, truncateMiddle, type WidthProbe } from './truncate'\n\nconst MIN_POSITION = 0\nconst MAX_POSITION = 100\nconst DEFAULT_POSITION = 50\n\n/**\n * 合串复核的容差与轮数上限。\n *\n * 分段预算看不见两个接缝处的字距，实测偏差在亚像素量级：容差取 0.5px 吸收它。\n * 轮数上限是纯防御，不是常规路径：实测四种形态（等宽 ASCII 文件名、CJK 长串、无空格长串、\n * emoji/ZWJ 混排）各挂载一次，`_apply` 每次都只被调用一次——复核自己会再调一次 `_apply`，\n * 所以调用次数就是拟合次数，一次意味着复核一轮都没触发。这条上限防的是「标记被调用方撑得比\n * 容器还宽」这类退化输入。\n */\nconst OVERFLOW_TOLERANCE = 0.5\nconst MAX_REFINE_ROUNDS = 3\n\n/**\n * 可用宽度变化的感知阈（px）。\n *\n * `_currentWidth()` 走 `clientWidth`（整数），ResizeObserver 报的是 `contentRect.width`（分数），\n * 同一个盒子在两条路径上最多差 0.5px 的取整误差。不设阈值时，观察者的首次回调会被当成一次「变宽」\n * 而整份重算——实测挂载时两次 `_apply` 的入参都是同一个 240，也就是每次挂载白做一次二分。\n * 0.5 同时压住了「跳过略小于半个像素的真实收缩」的代价：那个量级下输出最多溢出 0.5px，\n * 与 `OVERFLOW_TOLERANCE` 视为可忽略的量级一致。\n */\nconst WIDTH_EPSILON = 0.5\n\ninterface MeasurementTarget {\n  readonly notify: () => void\n  text: string | null\n  width: number\n}\n\nconst measurementTargets = new WeakMap<Element, MeasurementTarget>()\nlet measurementObserver: ResizeObserver | undefined\nconst fontMetricSubscribers = new Set<() => void>()\nlet observedFontSet: FontFaceSet | undefined\n\nfunction onFontsLoaded(): void {\n  for (const notify of fontMetricSubscribers) notify()\n}\n\nfunction observeFontMetrics(notify: () => void): void {\n  const fontSet = document.fonts\n  if (!fontSet) return\n\n  if (!observedFontSet) {\n    observedFontSet = fontSet\n    observedFontSet.addEventListener('loadingdone', onFontsLoaded)\n  }\n  fontMetricSubscribers.add(notify)\n}\n\nfunction unobserveFontMetrics(notify: () => void): void {\n  fontMetricSubscribers.delete(notify)\n  if (fontMetricSubscribers.size > 0 || !observedFontSet) return\n\n  observedFontSet.removeEventListener('loadingdone', onFontsLoaded)\n  observedFontSet = undefined\n}\n\n/** Observe the full-text probe so font metric changes can refit without a host resize. */\nfunction getMeasurementObserver(): ResizeObserver | null {\n  if (typeof ResizeObserver === 'undefined') return null\n  if (measurementObserver) return measurementObserver\n\n  measurementObserver = new ResizeObserver(entries => {\n    for (const entry of entries) {\n      const target = measurementTargets.get(entry.target)\n      if (!target) continue\n\n      const text = entry.target.textContent\n      const width = entry.contentRect.width\n      if (target.text !== text) {\n        target.text = text\n        target.width = width\n        continue\n      }\n\n      if (target.width < 0) {\n        target.width = width\n        continue\n      }\n\n      if (target.width === width) continue\n      target.width = width\n      target.notify()\n    }\n  })\n\n  return measurementObserver\n}\n\nfunction observeMeasurement(target: Element, notify: () => void): void {\n  measurementTargets.set(target, { notify, text: target.textContent, width: -1 })\n  observeFontMetrics(notify)\n\n  const observer = getMeasurementObserver()\n  if (!observer) return\n\n  observer.observe(target, { box: 'content-box' })\n}\n\nfunction unobserveMeasurement(target: Element): void {\n  const observation = measurementTargets.get(target)\n  if (observation) unobserveFontMetrics(observation.notify)\n  measurementTargets.delete(target)\n  measurementObserver?.unobserve(target)\n}\n\nfunction updateMeasurementText(target: Element, text: string): void {\n  const observation = measurementTargets.get(target)\n  if (!observation) return\n\n  observation.text = text\n  observation.width = target.getBoundingClientRect().width\n}\n\n/**\n * 单行中间省略：把超长文本截成 `首段…尾段`，省略号出现在中间而不是末尾。\n *\n * 适用面与 `text-overflow: ellipsis` 相同——**单行、且有确定宽度**。文本不换行，宽度由容器\n * 给出（块级盒子的包含块、flex 主轴的 `flex: 1`、grid track 都行）。宿主自撑宽度时不存在\n * 「可用空间」可言，组件按当时量到的宽度切一次就不再收缩（见 `_onWidth` 的收敛守卫）。\n *\n * 被丢掉的是中间那段，因此**选中复制拿到的是屏幕上这串**，不是原文；原文经 `title` 暴露，\n * 悬停可见。这条与 CSS 的 `text-overflow` 不同（那里文本节点没被动过、复制得到全文），是\n * JS 方案绕不开的代价，见 docs/research/web-ui-middle-ellipsis-261007.md。\n */\n@customElement('web-ui-middle-ellipsis')\nexport class WebUiMiddleEllipsis extends LitElement {\n  static override styles = [unsafeCSS(style)]\n\n  /** 要显示的完整文本。组件只读它，不回写。 */\n  @property({ type: String }) text = ''\n\n  /** 中间插入的标记，默认 `…`（U+2026）。空串即「只截断不给信号」，是否这样用由调用方判断。 */\n  @property({ type: String, reflect: true })\n  set marker(value: string) {\n    const next = value ?? DEFAULT_MARKER\n    if (this._marker !== next) {\n      const old = this._marker\n      this._marker = next\n      this.requestUpdate('marker', old)\n    }\n    if (this.getAttribute('marker') !== next) this.setAttribute('marker', next)\n  }\n\n  get marker(): string {\n    return this._marker\n  }\n\n  private _marker = DEFAULT_MARKER\n\n  /**\n   * 标记所在的横向比例，0–100，默认 `50`（居中）。\n   *\n   * 与 CSSWG css-overflow-5 的 `text-overflow: ellipsis <length-percentage>` 同向：量的是标记\n   * 结束边距行末边的距离占可用行内空间的比例。`0` 只剩头部（等价于末尾省略），`100` 只剩尾部。\n   * 文件名这类「头部是路径噪声、尾部才是扩展名」的场景用**大于** 50 的值让尾部多留一些。\n   */\n  @property({ type: Number, reflect: true, attribute: 'marker-position' })\n  set markerPosition(value: number) {\n    const normalized = normalizeNumber(value, MIN_POSITION, MAX_POSITION, DEFAULT_POSITION)\n    if (this._markerPosition !== normalized) {\n      const old = this._markerPosition\n      this._markerPosition = normalized\n      this.requestUpdate('markerPosition', old)\n    }\n    if (this.getAttribute('marker-position') !== String(normalized)) {\n      this.setAttribute('marker-position', String(normalized))\n    }\n  }\n\n  get markerPosition(): number {\n    return this._markerPosition\n  }\n\n  private _markerPosition = DEFAULT_POSITION\n\n  /*\n   * 渲染结果用普通字段承载，不用 `@state`：切分只能在渲染之后量到真实宽度才算得出来，也就是说\n   * 「改渲染结果」必然发生在更新周期里，而周期内的 `requestUpdate` 会被 Lit 记一条\n   * `change-in-update` 警告——一个实例一条，一张千行的表就是一千条。改成普通字段 + 只在周期外\n   * （ResizeObserver 回调、微任务）显式 `requestUpdate()`，渲染时机不变，警告消失。\n   */\n  private _display = ''\n  private _truncated = false\n\n  @query('.root') private _root?: HTMLElement\n  @query('.text') private _textEl?: HTMLElement\n  @query('.measure') private _measure?: HTMLElement\n  @query('.marker-probe') private _markerProbe?: HTMLElement\n\n  /** 最近一次切分依据的可用宽度（px）；-1 表示还没量到过布局。 */\n  private _available = -1\n  /** 最近一次 ResizeObserver 测得的宿主内容盒宽度；收敛守卫跳过拟合时也继续更新。 */\n  private _observedWidth = -1\n  /** 当前渲染出来的文本实际占宽（px）。收敛守卫靠它判断现有输出是否已经放得下。 */\n  private _rendered = 0\n  /** 输入或字体度量变过、还没重新拟合。 */\n  private _dirty = true\n  private _refineRound = 0\n  private _observedMeasure?: HTMLElement\n\n  private readonly _range = document.createRange()\n\n  private readonly _width = new ElementWidthController(this, width => this._onWidth(width))\n\n  private readonly _onMeasurementChange = (): void => {\n    this._refineRound = 0\n    this._dirty = true\n    // `_available` can predate a shrink; use the latest precise content-box width even when it skipped a refit.\n    this._apply(this._observedWidth > 0 ? this._observedWidth : this._currentWidth())\n  }\n\n  private readonly _probe: WidthProbe = {\n    prefix: units => this._rangeWidth(0, units),\n    suffix: units => this._rangeWidth(this.text.length - units, this.text.length),\n    marker: () => this._markerProbe?.getBoundingClientRect().width ?? 0\n  }\n\n  override connectedCallback(): void {\n    super.connectedCallback()\n    if (this._available >= 0) {\n      this._dirty = true\n      this._refineRound = 0\n    }\n    this._observeMeasure()\n  }\n\n  override disconnectedCallback(): void {\n    if (this._observedMeasure) {\n      unobserveMeasurement(this._observedMeasure)\n      this._observedMeasure = undefined\n    }\n    super.disconnectedCallback()\n  }\n\n  override willUpdate(changed: PropertyValues<this>): void {\n    if (!changed.has('text') && !changed.has('marker') && !changed.has('markerPosition')) return\n\n    /*\n     * 输入变了就先把渲染退回全文：上一版的切分是按旧文本算的，拿它渲染新文本会显示一段两个\n     * 版本都不属于的串。真正的重切由 `updated()` 排进微任务，在同一帧渲染之前完成，所以用户\n     * 看不到这个中间态。这里写普通字段，正是为了不在更新周期里再排一次更新。\n     */\n    this._dirty = true\n    this._display = this.text\n    this._truncated = false\n  }\n\n  override updated(): void {\n    const textEl = this._textEl\n    // Lit can finish an update after this host was removed. Resume fitting only after reconnect.\n    if (!textEl || !this.isConnected) return\n\n    this._observeMeasure()\n\n    this._rendered = textEl.getBoundingClientRect().width\n\n    if (this._dirty) {\n      this._refineRound = 0\n      this._defer(() => this._apply(this._currentWidth()))\n      return\n    }\n\n    /*\n     * 合串复核：分段预算只保证「首段和尾段各自没超额度」，接缝处的字距与连字能把合串推过\n     * 边界，而这件事只有渲染出来的盒子量得到。超出时按超出量回收额度重切；轮数上限兜住\n     * 「怎么切都放不下」的退化情形（例如调用方把标记撑得比容器还宽）。\n     */\n    if (this._truncated && this._rendered > this._available + OVERFLOW_TOLERANCE) {\n      if (this._refineRound < MAX_REFINE_ROUNDS) {\n        this._refineRound += 1\n        const tighter = this._available - (this._rendered - this._available) - OVERFLOW_TOLERANCE\n        this._defer(() => this._apply(tighter))\n      }\n      return\n    }\n\n    this._refineRound = 0\n  }\n\n  /**\n   * 容器宽度变化。\n   *\n   * 收缩方向带一条收敛守卫：宿主宽度由内容决定时（flex 主轴 `auto`、或 `width: fit-content` 在内容\n   * 缩到容器以内之后），把自己截短会反过来把宿主量窄，于是排下一次尺寸回调。这个自驱动收缩**可能**\n   * 一路棘轮到只剩标记，是否发生取决于度量：\n   *\n   * - flex + 等宽 16px + 默认 50%：缩掉的量小于一个簇宽时，重新二分落回同一组切点，走一步就停。\n   * - `width: fit-content` + `marker-position: 80` + CJK：每个簇都是整宽块，切短一簇与宿主窄一簇\n   *   互相咬合，摘掉本守卫后 300px 容器里逐帧 282→266→…→10，九步塌到只剩标记（同仓 browser spec\n   *   的「fit-content 宿主 + 非居中标记」用例钉住了这一条）。\n   *\n   * 判据因此取「当前输出已经放得下」：放得下就没有必须重切的理由，自驱动收缩在第一步就停，与度量\n   * 无关；真正的容器收缩会让输出宽于新宽度，那时才重切。放长方向没有这个问题，一律重切（可能能\n   * 少截一些）。\n   */\n  private _onWidth(width: number): void {\n    this._observedWidth = width\n    if (!(width > 0)) return\n\n    /*\n     * 两条短路都只在「没有未落的拟合」时才成立，它们的依据都是「当前输出就是按这个宽度切出来的」——\n     * 而 `_dirty` 为真恰恰说明它不是（输入换过了，切分还没跟上）。宿主无布局期间改 text 就是这样：\n     * `_apply` 按宽度 ≤ 0 直接返回，`_dirty` 留着，恢复显示时宽度与上次**相同**，若这里按\n     * 「宽度没变」短路，就再也没有任何回调会把它切回来——屏幕上留着一段被 `overflow: hidden`\n     * 硬裁的全文，没有标记也没有 title。\n     */\n    if (!this._dirty) {\n      // 与上次拟合用的宽度相同（含亚像素取整差）就没有可算的：当前结果正是按这个宽度切出来的。\n      // 这一档实测存在——观察者的首次回调报的就是 `_currentWidth()` 量到的同一个宽度。\n      if (this._available >= 0 && Math.abs(width - this._available) <= WIDTH_EPSILON) return\n      if (this._available >= 0 && width < this._available && this._rendered <= width + OVERFLOW_TOLERANCE) {\n        return\n      }\n    }\n\n    this._refineRound = 0\n    this._apply(width)\n  }\n\n  /**\n   * 把一次重切排到当前更新周期之外。\n   *\n   * 重切只能在渲染之后量到宽度才做得了，所以第二次更新是必然的；区别只在它从哪里排出去。\n   * 微任务仍排在下一帧渲染之前，画面不会先闪一版全文，而 `updated()` 返回时更新已不再是\n   * pending，Lit 的 `change-in-update` 警告不会触发。\n   */\n  private _defer(fit: () => void): void {\n    queueMicrotask(fit)\n  }\n\n  /**\n   * 同步可读的可用行内空间。\n   *\n   * ResizeObserver 的回调在布局之后才到，属性刚改完的那一帧还没有宽度可用；用 `.root` 的\n   * 内容盒补上，免得先按全文画一帧再切。jsdom 没有布局，读到的 0 由 `_apply` 跳过。\n   */\n  private _currentWidth(): number {\n    return this._root?.clientWidth ?? 0\n  }\n\n  /**\n   * 按可用宽度切分并写回渲染结果。\n   *\n   * 宽度为 0（没有布局）时什么都不做，**并且保留 `_dirty`**：宿主不可见期间改 text 时这一趟\n   * 必然被跳过，若在这里就把「有未落的拟合」清掉，等它重新有布局时就没有任何东西记得要切了。\n   * 清标记因此只发生在真的切完之后。\n   */\n  private _apply(available: number): void {\n    if (!(available > 0)) return\n\n    // 量具必须在切分之前装上当前文本：首次更新时量具还不存在，只靠输入变化那次同步会让第一次\n    // 切分读到空量具，`prefix(text.length)` 量出 0 而被误判成「放得下」。\n    this._syncMeasure()\n\n    const result = truncateMiddle(this.text, this._marker, this._markerPosition, available, this._probe)\n    this._available = available\n    this._dirty = false\n    this._settle(result.truncated ? result.head + this._marker + result.tail : this.text, result.truncated)\n  }\n\n  private _settle(display: string, truncated: boolean): void {\n    if (this._display === display && this._truncated === truncated) return\n\n    this._display = display\n    this._truncated = truncated\n    // 周期内的调用会被 Lit 记 change-in-update：这里的两条来路（尺寸回调、微任务）都在周期之外。\n    this.requestUpdate()\n  }\n\n  /** 把全文装进隐藏量具。它没有 Lit 绑定，改它不会触发重渲染。 */\n  private _syncMeasure(): void {\n    const measure = this._measure\n    if (measure && measure.textContent !== this.text) {\n      measure.textContent = this.text\n      updateMeasurementText(measure, this.text)\n    }\n  }\n\n  private _observeMeasure(): void {\n    const measure = this._measure\n    if (!measure || measure === this._observedMeasure) return\n\n    if (this._observedMeasure) unobserveMeasurement(this._observedMeasure)\n    this._observedMeasure = measure\n    observeMeasurement(measure, this._onMeasurementChange)\n  }\n\n  /** `[from, to)` 这段原文在量具里的渲染宽度。空区间恒为 0——Range 塌缩矩形的宽度不可靠。 */\n  private _rangeWidth(from: number, to: number): number {\n    if (to <= from) return 0\n\n    const node = this._measure?.firstChild\n    if (!(node instanceof Text)) return 0\n\n    this._range.setStart(node, from)\n    this._range.setEnd(node, to)\n    return this._range.getBoundingClientRect().width\n  }\n\n  override render() {\n    return html`\n      <div class=\"root\">\n        <span class=\"text\" title=${ifDefined(this._truncated ? this.text : undefined)}>${this._display}</span>\n        <span class=\"measure\"></span>\n        <span class=\"marker-probe\" aria-hidden=\"true\">${this._marker}</span>\n      </div>\n    `\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    'web-ui-middle-ellipsis': WebUiMiddleEllipsis\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,IAAM,IAAe,GACf,IAAe,KACf,IAAmB,IAWnB,IAAqB,IACrB,IAAoB,GAWpB,IAAgB,IAQhB,oBAAqB,IAAI,QAAoC,GAC/D,GACE,oBAAwB,IAAI,IAAgB,GAC9C;AAEJ,SAAS,IAAsB;CAC7B,KAAK,IAAM,KAAU,GAAuB,EAAO;AACrD;AAEA,SAAS,EAAmB,GAA0B;CACpD,IAAM,IAAU,SAAS;CACpB,MAEA,MACH,IAAkB,GAClB,EAAgB,iBAAiB,eAAe,CAAa,IAE/D,EAAsB,IAAI,CAAM;AAClC;AAEA,SAAS,EAAqB,GAA0B;CACtD,EAAsB,OAAO,CAAM,GAC/B,IAAsB,OAAO,KAAK,CAAC,OAEvC,EAAgB,oBAAoB,eAAe,CAAa,GAChE,IAAkB,KAAA;AACpB;AAGA,SAAS,IAAgD;CA4BvD,OA3BI,OAAO,iBAAmB,MAAoB,OAC9C,MAEJ,IAAsB,IAAI,gBAAe,MAAW;EAClD,KAAK,IAAM,KAAS,GAAS;GAC3B,IAAM,IAAS,EAAmB,IAAI,EAAM,MAAM;GAClD,IAAI,CAAC,GAAQ;GAEb,IAAM,IAAO,EAAM,OAAO,aACpB,IAAQ,EAAM,YAAY;GAChC,IAAI,EAAO,SAAS,GAAM;IAExB,AADA,EAAO,OAAO,GACd,EAAO,QAAQ;IACf;GACF;GAEA,IAAI,EAAO,QAAQ,GAAG;IACpB,EAAO,QAAQ;IACf;GACF;GAEI,EAAO,UAAU,MACrB,EAAO,QAAQ,GACf,EAAO,OAAO;EAChB;CACF,CAAC,GAEM;AACT;AAEA,SAAS,EAAmB,GAAiB,GAA0B;CAErE,AADA,EAAmB,IAAI,GAAQ;EAAE;EAAQ,MAAM,EAAO;EAAa,OAAO;CAAG,CAAC,GAC9E,EAAmB,CAAM;CAEzB,IAAM,IAAW,EAAuB;CACnC,KAEL,EAAS,QAAQ,GAAQ,EAAE,KAAK,cAAc,CAAC;AACjD;AAEA,SAAS,EAAqB,GAAuB;CACnD,IAAM,IAAc,EAAmB,IAAI,CAAM;CAGjD,AAFI,KAAa,EAAqB,EAAY,MAAM,GACxD,EAAmB,OAAO,CAAM,GAChC,GAAqB,UAAU,CAAM;AACvC;AAEA,SAAS,EAAsB,GAAiB,GAAoB;CAClE,IAAM,IAAc,EAAmB,IAAI,CAAM;CAC5C,MAEL,EAAY,OAAO,GACnB,EAAY,QAAQ,EAAO,sBAAsB,CAAC,CAAC;AACrD;AAcO,IAAM,IAAN,cAAkC,EAAW;;EAsFZ,aAlFH,KAAA,OAAA,IAkBjB,KAAA,UAAA,KA0BQ,KAAA,kBAAA,GAQP,KAAA,WAAA,IACE,KAAA,aAAA,IAQA,KAAA,aAAA,IAEI,KAAA,iBAAA,IAEL,KAAA,YAAA,GAEH,KAAA,SAAA,IACM,KAAA,eAAA,GAGG,KAAA,SAAA,SAAS,YAAY,GAErB,KAAA,SAAA,IAAI,EAAuB,OAAM,MAAS,KAAK,SAAS,CAAK,CAAC,GAEpC,KAAA,6BAAA;GAIlD,AAHA,KAAK,eAAe,GACpB,KAAK,SAAS,IAEd,KAAK,OAAO,KAAK,iBAAiB,IAAI,KAAK,iBAAiB,KAAK,cAAc,CAAC;EAClF,GAEsC,KAAA,SAAA;GACpC,SAAQ,MAAS,KAAK,YAAY,GAAG,CAAK;GAC1C,SAAQ,MAAS,KAAK,YAAY,KAAK,KAAK,SAAS,GAAO,KAAK,KAAK,MAAM;GAC5E,cAAc,KAAK,cAAc,sBAAsB,CAAC,CAAC,SAAS;EACpE;;;EAzFyB,KAAA,SAAA,CAAC,EAAU,CAAK,CAAC;;CAM1C,IACI,OAAO,GAAe;EACxB,IAAM,IAAO,KAAA;EACb,IAAI,KAAK,YAAY,GAAM;GACzB,IAAM,IAAM,KAAK;GAEjB,AADA,KAAK,UAAU,GACf,KAAK,cAAc,UAAU,CAAG;EAClC;EACA,AAAI,KAAK,aAAa,QAAQ,MAAM,KAAM,KAAK,aAAa,UAAU,CAAI;CAC5E;CAEA,IAAI,SAAiB;EACnB,OAAO,KAAK;CACd;CAWA,IACI,eAAe,GAAe;EAChC,IAAM,IAAa,EAAgB,GAAO,GAAc,GAAc,CAAgB;EACtF,IAAI,KAAK,oBAAoB,GAAY;GACvC,IAAM,IAAM,KAAK;GAEjB,AADA,KAAK,kBAAkB,GACvB,KAAK,cAAc,kBAAkB,CAAG;EAC1C;EACA,AAAI,KAAK,aAAa,iBAAiB,MAAM,OAAO,CAAU,KAC5D,KAAK,aAAa,mBAAmB,OAAO,CAAU,CAAC;CAE3D;CAEA,IAAI,iBAAyB;EAC3B,OAAO,KAAK;CACd;CA8CA,oBAAmC;EAMjC,AALA,MAAM,kBAAkB,GACpB,KAAK,cAAc,MACrB,KAAK,SAAS,IACd,KAAK,eAAe,IAEtB,KAAK,gBAAgB;CACvB;CAEA,uBAAsC;EAKpC,AAJA,AAEE,KAAK,sBADL,EAAqB,KAAK,gBAAgB,GAClB,KAAA,IAE1B,MAAM,qBAAqB;CAC7B;CAEA,WAAoB,GAAqC;EACnD,CAAC,EAAQ,IAAI,MAAM,KAAM,EAAQ,IAAI,QAAQ,KAAM,EAAQ,IAAI,gBAAgB,OAOnF,KAAK,SAAS,IACd,KAAK,WAAW,KAAK,MACrB,KAAK,aAAa;CACpB;CAEA,UAAyB;EACvB,IAAM,IAAS,KAAK;EAEhB,IAAC,KAAW,KAAK,aAMrB;OAJA,KAAK,gBAAgB,GAErB,KAAK,YAAY,EAAO,sBAAsB,CAAC,CAAC,OAE5C,KAAK,QAAQ;IAEf,AADA,KAAK,eAAe,GACpB,KAAK,aAAa,KAAK,OAAO,KAAK,cAAc,CAAC,CAAC;IACnD;GACF;GAOA,IAAI,KAAK,cAAc,KAAK,YAAY,KAAK,aAAa,GAAoB;IAC5E,IAAI,KAAK,eAAe,GAAmB;KACzC,KAAK,gBAAgB;KACrB,IAAM,IAAU,KAAK,cAAc,KAAK,YAAY,KAAK,cAAc;KACvE,KAAK,aAAa,KAAK,OAAO,CAAO,CAAC;IACxC;IACA;GACF;GAEA,KAAK,eAAe;EAhBpB;CAiBF;CAkBA,SAAiB,GAAqB;EACpC,KAAK,iBAAiB,GAChB,IAAQ,MASV,CAAC,KAAK,WAGJ,KAAK,cAAc,KAAK,KAAK,IAAI,IAAQ,KAAK,UAAU,KAAK,KAC7D,KAAK,cAAc,KAAK,IAAQ,KAAK,cAAc,KAAK,aAAa,IAAQ,OAKnF,KAAK,eAAe,GACpB,KAAK,OAAO,CAAK;CACnB;CASA,OAAe,GAAuB;EACpC,eAAe,CAAG;CACpB;CAQA,gBAAgC;EAC9B,OAAO,KAAK,OAAO,eAAe;CACpC;CASA,OAAe,GAAyB;EACtC,IAAI,EAAE,IAAY,IAAI;EAItB,KAAK,aAAa;EAElB,IAAM,IAAS,EAAe,KAAK,MAAM,KAAK,SAAS,KAAK,iBAAiB,GAAW,KAAK,MAAM;EAGnG,AAFA,KAAK,aAAa,GAClB,KAAK,SAAS,IACd,KAAK,QAAQ,EAAO,YAAY,EAAO,OAAO,KAAK,UAAU,EAAO,OAAO,KAAK,MAAM,EAAO,SAAS;CACxG;CAEA,QAAgB,GAAiB,GAA0B;EACrD,MAAK,aAAa,KAAW,KAAK,eAAe,OAErD,KAAK,WAAW,GAChB,KAAK,aAAa,GAElB,KAAK,cAAc;CACrB;CAGA,eAA6B;EAC3B,IAAM,IAAU,KAAK;EACrB,AAAI,KAAW,EAAQ,gBAAgB,KAAK,SAC1C,EAAQ,cAAc,KAAK,MAC3B,EAAsB,GAAS,KAAK,IAAI;CAE5C;CAEA,kBAAgC;EAC9B,IAAM,IAAU,KAAK;EACjB,AAAC,KAAW,MAAY,KAAK,qBAE7B,KAAK,oBAAkB,EAAqB,KAAK,gBAAgB,GACrE,KAAK,mBAAmB,GACxB,EAAmB,GAAS,KAAK,oBAAoB;CACvD;CAGA,YAAoB,GAAc,GAAoB;EACpD,IAAI,KAAM,GAAM,OAAO;EAEvB,IAAM,IAAO,KAAK,UAAU;EAK5B,OAJM,aAAgB,QAEtB,KAAK,OAAO,SAAS,GAAM,CAAI,GAC/B,KAAK,OAAO,OAAO,GAAM,CAAE,GACpB,KAAK,OAAO,sBAAsB,CAAC,CAAC,SAJP;CAKtC;CAEA,SAAkB;EAChB,OAAO,CAAI;;mCAEoB,EAAU,KAAK,aAAa,KAAK,OAAO,KAAA,CAAS,EAAE,GAAG,KAAK,SAAS;;wDAE/C,KAAK,QAAQ;;;CAGnE;AACF;AAvRG,EAAA,CAAA,EAAS,EAAE,MAAM,OAAO,CAAC,CAAA,GAAA,EAAA,WAAA,QAAA,KAAA,CAAA,GAGzB,EAAA,CAAA,EAAS;CAAE,MAAM;CAAQ,SAAS;AAAK,CAAC,CAAA,GAAA,EAAA,WAAA,UAAA,IAAA,GAwBxC,EAAA,CAAA,EAAS;CAAE,MAAM;CAAQ,SAAS;CAAM,WAAW;AAAkB,CAAC,CAAA,GAAA,EAAA,WAAA,kBAAA,IAAA,GA4BtE,EAAA,CAAA,EAAM,OAAO,CAAA,GAAA,EAAA,WAAA,SAAA,KAAA,CAAA,GACb,EAAA,CAAA,EAAM,OAAO,CAAA,GAAA,EAAA,WAAA,WAAA,KAAA,CAAA,GACb,EAAA,CAAA,EAAM,UAAU,CAAA,GAAA,EAAA,WAAA,YAAA,KAAA,CAAA,GAChB,EAAA,CAAA,EAAM,eAAe,CAAA,GAAA,EAAA,WAAA,gBAAA,KAAA,CAAA,GA/DvB,IAAA,EAAA,CAAA,EAAc,wBAAwB,CAAA,GAAA,CAAA"}
+{"version":3,"file":"index.js","names":["style"],"sources":["../../../src/components/middle-ellipsis/index.ts"],"sourcesContent":["import { html, LitElement, unsafeCSS, type PropertyValues } from 'lit'\nimport { customElement, property, query } from 'lit/decorators.js'\nimport { ifDefined } from 'lit/directives/if-defined.js'\n\nimport { ElementWidthController } from '@/shared/element-width'\nimport { normalizeNumber } from '@/shared/normalize'\n\nimport style from './style.css?inline'\nimport { DEFAULT_MARKER, truncateMiddle, type WidthProbe } from './truncate'\n\nconst MIN_POSITION = 0\nconst MAX_POSITION = 100\nconst DEFAULT_POSITION = 50\n\n/**\n * 合串复核的容差与轮数上限。\n *\n * 分段预算看不见两个接缝处的字距，实测偏差在亚像素量级：容差取 0.5px 吸收它。\n * 轮数上限是纯防御，不是常规路径：实测四种形态（等宽 ASCII 文件名、CJK 长串、无空格长串、\n * emoji/ZWJ 混排）各挂载一次，`_apply` 每次都只被调用一次——复核自己会再调一次 `_apply`，\n * 所以调用次数就是拟合次数，一次意味着复核一轮都没触发。这条上限防的是「标记被调用方撑得比\n * 容器还宽」这类退化输入。\n */\nconst OVERFLOW_TOLERANCE = 0.5\nconst MAX_REFINE_ROUNDS = 3\n\n/**\n * 可用宽度变化的感知阈（px）。\n *\n * `_currentWidth()` 走 `clientWidth`（整数），ResizeObserver 报的是 `contentRect.width`（分数），\n * 同一个盒子在两条路径上最多差 0.5px 的取整误差。不设阈值时，观察者的首次回调会被当成一次「变宽」\n * 而整份重算——实测挂载时两次 `_apply` 的入参都是同一个 240，也就是每次挂载白做一次二分。\n * 0.5 同时压住了「跳过略小于半个像素的真实收缩」的代价：那个量级下输出最多溢出 0.5px，\n * 与 `OVERFLOW_TOLERANCE` 视为可忽略的量级一致。\n */\nconst WIDTH_EPSILON = 0.5\n\ninterface MeasurementTarget {\n  readonly notify: () => void\n  text: string | null\n  width: number\n}\n\nconst measurementTargets = new WeakMap<Element, MeasurementTarget>()\nlet measurementObserver: ResizeObserver | undefined\nconst fontMetricSubscribers = new Set<() => void>()\nlet observedFontSet: FontFaceSet | undefined\n\nfunction onFontsLoaded(): void {\n  for (const notify of fontMetricSubscribers) notify()\n}\n\nfunction observeFontMetrics(notify: () => void): void {\n  const fontSet = document.fonts\n  if (!fontSet) return\n\n  if (!observedFontSet) {\n    observedFontSet = fontSet\n    observedFontSet.addEventListener('loadingdone', onFontsLoaded)\n  }\n  fontMetricSubscribers.add(notify)\n}\n\nfunction unobserveFontMetrics(notify: () => void): void {\n  fontMetricSubscribers.delete(notify)\n  if (fontMetricSubscribers.size > 0 || !observedFontSet) return\n\n  observedFontSet.removeEventListener('loadingdone', onFontsLoaded)\n  observedFontSet = undefined\n}\n\n/** Observe the full-text probe so font metric changes can refit without a host resize. */\nfunction getMeasurementObserver(): ResizeObserver | null {\n  if (typeof ResizeObserver === 'undefined') return null\n  if (measurementObserver) return measurementObserver\n\n  measurementObserver = new ResizeObserver(entries => {\n    for (const entry of entries) {\n      const target = measurementTargets.get(entry.target)\n      if (!target) continue\n\n      const text = entry.target.textContent\n      const width = entry.contentRect.width\n      if (target.text !== text) {\n        target.text = text\n        target.width = width\n        continue\n      }\n\n      if (target.width < 0) {\n        target.width = width\n        continue\n      }\n\n      if (target.width === width) continue\n      target.width = width\n      target.notify()\n    }\n  })\n\n  return measurementObserver\n}\n\nfunction observeMeasurement(target: Element, notify: () => void): void {\n  measurementTargets.set(target, { notify, text: target.textContent, width: -1 })\n  observeFontMetrics(notify)\n\n  const observer = getMeasurementObserver()\n  if (!observer) return\n\n  observer.observe(target, { box: 'content-box' })\n}\n\nfunction unobserveMeasurement(target: Element): void {\n  const observation = measurementTargets.get(target)\n  if (observation) unobserveFontMetrics(observation.notify)\n  measurementTargets.delete(target)\n  measurementObserver?.unobserve(target)\n}\n\nfunction updateMeasurementText(target: Element, text: string): void {\n  const observation = measurementTargets.get(target)\n  if (!observation) return\n\n  observation.text = text\n  observation.width = target.getBoundingClientRect().width\n}\n\n/**\n * 单行中间省略：把超长文本截成 `首段…尾段`，省略号出现在中间而不是末尾。\n *\n * 适用面与 `text-overflow: ellipsis` 相同——**单行、且有确定宽度**。文本不换行，宽度由容器\n * 给出（块级盒子的包含块、flex 主轴的 `flex: 1`、grid track 都行）。宿主自撑宽度时不存在\n * 「可用空间」可言，组件按当时量到的宽度切一次就不再收缩（见 `_onWidth` 的收敛守卫）。\n *\n * 被丢掉的是中间那段，因此**选中复制拿到的是屏幕上这串**，不是原文；原文经 `title` 暴露，\n * 悬停可见。这条与 CSS 的 `text-overflow` 不同（那里文本节点没被动过、复制得到全文），是\n * JS 方案绕不开的代价，见 docs/research/web-ui-middle-ellipsis-261007.md。\n */\n@customElement('web-ui-middle-ellipsis')\nexport class WebUiMiddleEllipsis extends LitElement {\n  static override styles = [unsafeCSS(style)]\n\n  /** 要显示的完整文本。组件只读它，不回写。 */\n  @property({ type: String }) text = ''\n\n  /** 中间插入的标记，默认 `…`（U+2026）。空串即「只截断不给信号」，是否这样用由调用方判断。 */\n  @property({ type: String, reflect: true })\n  set marker(value: string) {\n    const next = value ?? DEFAULT_MARKER\n    if (this._marker !== next) {\n      const old = this._marker\n      this._marker = next\n      this.requestUpdate('marker', old)\n    }\n    if (this.getAttribute('marker') !== next) this.setAttribute('marker', next)\n  }\n\n  get marker(): string {\n    return this._marker\n  }\n\n  private _marker = DEFAULT_MARKER\n\n  /**\n   * 标记所在的横向比例，0–100，默认 `50`（居中）。\n   *\n   * 与 CSSWG css-overflow-5 的 `text-overflow: ellipsis <length-percentage>` 同向：量的是标记\n   * 结束边距行末边的距离占可用行内空间的比例。`0` 只剩头部（等价于末尾省略），`100` 只剩尾部。\n   * 文件名这类「头部是路径噪声、尾部才是扩展名」的场景用**大于** 50 的值让尾部多留一些。\n   */\n  @property({ type: Number, reflect: true, attribute: 'marker-position' })\n  set markerPosition(value: number) {\n    const normalized = normalizeNumber(value, MIN_POSITION, MAX_POSITION, DEFAULT_POSITION)\n    if (this._markerPosition !== normalized) {\n      const old = this._markerPosition\n      this._markerPosition = normalized\n      this.requestUpdate('markerPosition', old)\n    }\n    if (this.getAttribute('marker-position') !== String(normalized)) {\n      this.setAttribute('marker-position', String(normalized))\n    }\n  }\n\n  get markerPosition(): number {\n    return this._markerPosition\n  }\n\n  private _markerPosition = DEFAULT_POSITION\n\n  /*\n   * 渲染结果用普通字段承载，不用 `@state`：切分只能在渲染之后量到真实宽度才算得出来，也就是说\n   * 「改渲染结果」必然发生在更新周期里，而周期内的 `requestUpdate` 会被 Lit 记一条\n   * `change-in-update` 警告——一个实例一条，一张千行的表就是一千条。用普通字段 + 只在周期外\n   * （ResizeObserver 回调、微任务）显式 `requestUpdate()`，渲染时机不变，警告消失。\n   */\n  private _display = ''\n  private _truncated = false\n\n  @query('.root') private _root?: HTMLElement\n  @query('.text') private _textEl?: HTMLElement\n  @query('.measure') private _measure?: HTMLElement\n  @query('.marker-probe') private _markerProbe?: HTMLElement\n\n  /** 最近一次切分依据的可用宽度（px）；-1 表示还没量到过布局。 */\n  private _available = -1\n  /** 最近一次 ResizeObserver 测得的宿主内容盒宽度；收敛守卫跳过拟合时也继续更新。 */\n  private _observedWidth = -1\n  /** 当前渲染出来的文本实际占宽（px）。收敛守卫靠它判断现有输出是否已经放得下。 */\n  private _rendered = 0\n  /** 输入或字体度量变过、还没重新拟合。 */\n  private _dirty = true\n  private _refineRound = 0\n  private _observedMeasure?: HTMLElement\n\n  private readonly _range = document.createRange()\n\n  private readonly _width = new ElementWidthController(this, width => this._onWidth(width))\n\n  private readonly _onMeasurementChange = (): void => {\n    this._refineRound = 0\n    this._dirty = true\n    // `_available` can predate a shrink; use the latest precise content-box width even when it skipped a refit.\n    this._apply(this._observedWidth > 0 ? this._observedWidth : this._currentWidth())\n  }\n\n  private readonly _probe: WidthProbe = {\n    prefix: units => this._rangeWidth(0, units),\n    suffix: units => this._rangeWidth(this.text.length - units, this.text.length),\n    marker: () => this._markerProbe?.getBoundingClientRect().width ?? 0\n  }\n\n  override connectedCallback(): void {\n    super.connectedCallback()\n    if (this._available >= 0) {\n      this._dirty = true\n      this._refineRound = 0\n    }\n    this._observeMeasure()\n  }\n\n  override disconnectedCallback(): void {\n    if (this._observedMeasure) {\n      unobserveMeasurement(this._observedMeasure)\n      this._observedMeasure = undefined\n    }\n    super.disconnectedCallback()\n  }\n\n  override willUpdate(changed: PropertyValues<this>): void {\n    if (!changed.has('text') && !changed.has('marker') && !changed.has('markerPosition')) return\n\n    /*\n     * 输入变了就先把渲染退回全文：上一版的切分是按旧文本算的，拿它渲染新文本会显示一段两个\n     * 版本都不属于的串。真正的重切由 `updated()` 排进微任务，在同一帧渲染之前完成，所以用户\n     * 看不到这个中间态。这里写普通字段，正是为了不在更新周期里再排一次更新。\n     */\n    this._dirty = true\n    this._display = this.text\n    this._truncated = false\n  }\n\n  override updated(): void {\n    const textEl = this._textEl\n    // Lit can finish an update after this host was removed. Resume fitting only after reconnect.\n    if (!textEl || !this.isConnected) return\n\n    this._observeMeasure()\n\n    this._rendered = textEl.getBoundingClientRect().width\n\n    if (this._dirty) {\n      this._refineRound = 0\n      this._defer(() => this._apply(this._currentWidth()))\n      return\n    }\n\n    /*\n     * 合串复核：分段预算只保证「首段和尾段各自没超额度」，接缝处的字距与连字能把合串推过\n     * 边界，而这件事只有渲染出来的盒子量得到。超出时按超出量回收额度重切；轮数上限兜住\n     * 「怎么切都放不下」的退化情形（例如调用方把标记撑得比容器还宽）。\n     */\n    if (this._truncated && this._rendered > this._available + OVERFLOW_TOLERANCE) {\n      if (this._refineRound < MAX_REFINE_ROUNDS) {\n        this._refineRound += 1\n        const tighter = this._available - (this._rendered - this._available) - OVERFLOW_TOLERANCE\n        this._defer(() => this._apply(tighter))\n      }\n      return\n    }\n\n    this._refineRound = 0\n  }\n\n  /**\n   * 容器宽度变化。\n   *\n   * 收缩方向带一条收敛守卫：宿主宽度由内容决定时（flex 主轴 `auto`、或 `width: fit-content` 在内容\n   * 缩到容器以内之后），把自己截短会反过来把宿主量窄，于是排下一次尺寸回调。这个自驱动收缩**可能**\n   * 一路棘轮到只剩标记，是否发生取决于度量：\n   *\n   * - flex + 等宽 16px + 默认 50%：缩掉的量小于一个簇宽时，重新二分落回同一组切点，走一步就停。\n   * - `width: fit-content` + `marker-position: 80` + CJK：每个簇都是整宽块，切短一簇与宿主窄一簇\n   *   互相咬合，摘掉本守卫后 300px 容器里逐帧 282→266→…→10，九步塌到只剩标记（同仓 browser spec\n   *   的「fit-content 宿主 + 非居中标记」用例钉住了这一条）。\n   *\n   * 判据因此取「当前输出已经放得下」：放得下就没有必须重切的理由，自驱动收缩在第一步就停，与度量\n   * 无关；真正的容器收缩会让输出宽于新宽度，那时才重切。放长方向没有这个问题，一律重切（可能能\n   * 少截一些）。\n   */\n  private _onWidth(width: number): void {\n    this._observedWidth = width\n    if (!(width > 0)) return\n\n    /*\n     * 两条短路都只在「没有未落的拟合」时才成立，它们的依据都是「当前输出就是按这个宽度切出来的」——\n     * 而 `_dirty` 为真恰恰说明它不是（输入换过了，切分还没跟上）。宿主无布局期间改 text 就是这样：\n     * `_apply` 按宽度 ≤ 0 直接返回，`_dirty` 留着，恢复显示时宽度与上次**相同**，若这里按\n     * 「宽度没变」短路，就再也没有任何回调会把它切回来——屏幕上留着一段被 `overflow: hidden`\n     * 硬裁的全文，没有标记也没有 title。\n     */\n    if (!this._dirty) {\n      // 与上次拟合用的宽度相同（含亚像素取整差）就没有可算的：当前结果正是按这个宽度切出来的。\n      // 这一档实测存在——观察者的首次回调报的就是 `_currentWidth()` 量到的同一个宽度。\n      if (this._available >= 0 && Math.abs(width - this._available) <= WIDTH_EPSILON) return\n      if (this._available >= 0 && width < this._available && this._rendered <= width + OVERFLOW_TOLERANCE) {\n        return\n      }\n    }\n\n    this._refineRound = 0\n    this._apply(width)\n  }\n\n  /**\n   * 把一次重切排到当前更新周期之外。\n   *\n   * 重切只能在渲染之后量到宽度才做得了，所以第二次更新是必然的；区别只在它从哪里排出去。\n   * 微任务仍排在下一帧渲染之前，画面不会先闪一版全文，而 `updated()` 返回时更新已不再是\n   * pending，Lit 的 `change-in-update` 警告不会触发。\n   */\n  private _defer(fit: () => void): void {\n    queueMicrotask(fit)\n  }\n\n  /**\n   * 同步可读的可用行内空间。\n   *\n   * ResizeObserver 的回调在布局之后才到，属性刚改完的那一帧还没有宽度可用；用 `.root` 的\n   * 内容盒补上，免得先按全文画一帧再切。jsdom 没有布局，读到的 0 由 `_apply` 跳过。\n   */\n  private _currentWidth(): number {\n    return this._root?.clientWidth ?? 0\n  }\n\n  /**\n   * 按可用宽度切分并写回渲染结果。\n   *\n   * 宽度为 0（没有布局）时什么都不做，**并且保留 `_dirty`**：宿主不可见期间改 text 时这一趟\n   * 必然被跳过，若在这里就把「有未落的拟合」清掉，等它重新有布局时就没有任何东西记得要切了。\n   * 清标记因此只发生在真的切完之后。\n   */\n  private _apply(available: number): void {\n    if (!(available > 0)) return\n\n    // 量具必须在切分之前装上当前文本：首次更新时量具还不存在，只靠输入变化那次同步会让第一次\n    // 切分读到空量具，`prefix(text.length)` 量出 0 而被误判成「放得下」。\n    this._syncMeasure()\n\n    const result = truncateMiddle(this.text, this._marker, this._markerPosition, available, this._probe)\n    this._available = available\n    this._dirty = false\n    this._settle(result.truncated ? result.head + this._marker + result.tail : this.text, result.truncated)\n  }\n\n  private _settle(display: string, truncated: boolean): void {\n    if (this._display === display && this._truncated === truncated) return\n\n    this._display = display\n    this._truncated = truncated\n    // 周期内的调用会被 Lit 记 change-in-update：这里的两条来路（尺寸回调、微任务）都在周期之外。\n    this.requestUpdate()\n  }\n\n  /** 把全文装进隐藏量具。它没有 Lit 绑定，改它不会触发重渲染。 */\n  private _syncMeasure(): void {\n    const measure = this._measure\n    if (measure && measure.textContent !== this.text) {\n      measure.textContent = this.text\n      updateMeasurementText(measure, this.text)\n    }\n  }\n\n  private _observeMeasure(): void {\n    const measure = this._measure\n    if (!measure || measure === this._observedMeasure) return\n\n    if (this._observedMeasure) unobserveMeasurement(this._observedMeasure)\n    this._observedMeasure = measure\n    observeMeasurement(measure, this._onMeasurementChange)\n  }\n\n  /** `[from, to)` 这段原文在量具里的渲染宽度。空区间恒为 0——Range 塌缩矩形的宽度不可靠。 */\n  private _rangeWidth(from: number, to: number): number {\n    if (to <= from) return 0\n\n    const node = this._measure?.firstChild\n    if (!(node instanceof Text)) return 0\n\n    this._range.setStart(node, from)\n    this._range.setEnd(node, to)\n    return this._range.getBoundingClientRect().width\n  }\n\n  override render() {\n    return html`\n      <div class=\"root\">\n        <span class=\"text\" title=${ifDefined(this._truncated ? this.text : undefined)}>${this._display}</span>\n        <span class=\"measure\"></span>\n        <span class=\"marker-probe\" aria-hidden=\"true\">${this._marker}</span>\n      </div>\n    `\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    'web-ui-middle-ellipsis': WebUiMiddleEllipsis\n  }\n}\n"],"mappings":"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"}

package/dist/components/middle-ellipsis/style.js

@@ -1,6 +1,5 @@
-//#region src/components/middle-ellipsis/style.css?inline
-var e = ":host{display:block;overflow:hidden}.root{white-space:nowrap;position:relative;overflow:hidden}.text{white-space:nowrap}.measure,.marker-probe{pointer-events:none;white-space:nowrap;visibility:hidden;position:absolute;top:0;left:0}";
-//#endregion
-export { e as default };
+// src/components/middle-ellipsis/style.css?inline
+var style_default = ":host{display:block;overflow:hidden}.root{white-space:nowrap;position:relative;overflow:hidden}.text{white-space:nowrap}.measure,.marker-probe{pointer-events:none;white-space:nowrap;visibility:hidden;position:absolute;top:0;left:0}\n";
+export { style_default as default };
 
 //# sourceMappingURL=style.js.map

package/dist/components/middle-ellipsis/style.js.map

@@ -1 +1 @@
-{"version":3,"file":"style.js","names":[],"sources":["../../../src/components/middle-ellipsis/style.css?inline"],"sourcesContent":[":host {\n  overflow: hidden;\n  display: block;\n}\n\n.root {\n  position: relative;\n  overflow: hidden;\n  white-space: nowrap;\n}\n\n.text {\n  white-space: nowrap;\n}\n\n/*\n * 两个隐藏量具。必须是出流盒子：留在流内的话宿主的 max-content 会被全文撑开，\n * 而截断的前提正是「宽度来自容器」。\n */\n.measure,\n.marker-probe {\n  pointer-events: none;\n\n  position: absolute;\n  top: 0;\n  left: 0;\n\n  white-space: nowrap;\n\n  visibility: hidden;\n}\n"],"mappings":""}
+{"version":3,"file":"style.js","names":[],"sources":["../../../src/components/middle-ellipsis/style.css?inline"],"sourcesContent":[":host {\n  overflow: hidden;\n  display: block;\n}\n\n.root {\n  position: relative;\n  overflow: hidden;\n  white-space: nowrap;\n}\n\n.text {\n  white-space: nowrap;\n}\n\n/*\n * 两个隐藏量具。必须是出流盒子：留在流内的话宿主的 max-content 会被全文撑开，\n * 而截断的前提正是「宽度来自容器」。\n */\n.measure,\n.marker-probe {\n  pointer-events: none;\n\n  position: absolute;\n  top: 0;\n  left: 0;\n\n  white-space: nowrap;\n\n  visibility: hidden;\n}\n"],"mappings":";AAAA,IAAA,gBAAA"}