@mhmo91/schmancy 0.8.6 → 0.9.2

package/dist/flow-CUj0fDT_.js

@@ -0,0 +1,386 @@
+var e = class {
+	constructor(e) {
+		this._map = /* @__PURE__ */ new Map(), this._roundAverageSize = !1, this.totalSize = 0, !0 === e?.roundAverageSize && (this._roundAverageSize = !0);
+	}
+	set(e, t) {
+		let n = this._map.get(e) || 0;
+		this._map.set(e, t), this.totalSize += t - n;
+	}
+	get averageSize() {
+		if (this._map.size > 0) {
+			let e = this.totalSize / this._map.size;
+			return this._roundAverageSize ? Math.round(e) : e;
+		}
+		return 0;
+	}
+	getSize(e) {
+		return this._map.get(e);
+	}
+	clear() {
+		this._map.clear(), this.totalSize = 0;
+	}
+};
+function t(e) {
+	return e === "horizontal" ? "width" : "height";
+}
+var n = class {
+	_getDefaultConfig() {
+		return { direction: "vertical" };
+	}
+	constructor(e, t) {
+		this._latestCoords = {
+			left: 0,
+			top: 0
+		}, this._direction = null, this._viewportSize = {
+			width: 0,
+			height: 0
+		}, this.totalScrollSize = {
+			width: 0,
+			height: 0
+		}, this.offsetWithinScroller = {
+			left: 0,
+			top: 0
+		}, this._pendingReflow = !1, this._pendingLayoutUpdate = !1, this._pin = null, this._firstVisible = 0, this._lastVisible = 0, this._physicalMin = 0, this._physicalMax = 0, this._first = -1, this._last = -1, this._sizeDim = "height", this._secondarySizeDim = "width", this._positionDim = "top", this._secondaryPositionDim = "left", this._scrollPosition = 0, this._scrollError = 0, this._items = [], this._scrollSize = 1, this._overhang = 1e3, this._hostSink = e, Promise.resolve().then(() => this.config = t || this._getDefaultConfig());
+	}
+	set config(e) {
+		Object.assign(this, Object.assign({}, this._getDefaultConfig(), e));
+	}
+	get config() {
+		return { direction: this.direction };
+	}
+	get items() {
+		return this._items;
+	}
+	set items(e) {
+		this._setItems(e);
+	}
+	_setItems(e) {
+		e !== this._items && (this._items = e, this._scheduleReflow());
+	}
+	get direction() {
+		return this._direction;
+	}
+	set direction(e) {
+		(e = e === "horizontal" ? e : "vertical") !== this._direction && (this._direction = e, this._sizeDim = e === "horizontal" ? "width" : "height", this._secondarySizeDim = e === "horizontal" ? "height" : "width", this._positionDim = e === "horizontal" ? "left" : "top", this._secondaryPositionDim = e === "horizontal" ? "top" : "left", this._triggerReflow());
+	}
+	get viewportSize() {
+		return this._viewportSize;
+	}
+	set viewportSize(e) {
+		let { _viewDim1: t, _viewDim2: n } = this;
+		Object.assign(this._viewportSize, e), n === this._viewDim2 ? t !== this._viewDim1 && this._checkThresholds() : this._scheduleLayoutUpdate();
+	}
+	get viewportScroll() {
+		return this._latestCoords;
+	}
+	set viewportScroll(e) {
+		Object.assign(this._latestCoords, e);
+		let t = this._scrollPosition;
+		this._scrollPosition = this._latestCoords[this._positionDim], Math.abs(t - this._scrollPosition) >= 1 && this._checkThresholds();
+	}
+	reflowIfNeeded(e = !1) {
+		(e || this._pendingReflow) && (this._pendingReflow = !1, this._reflow());
+	}
+	set pin(e) {
+		this._pin = e, this._triggerReflow();
+	}
+	get pin() {
+		if (this._pin !== null) {
+			let { index: e, block: t } = this._pin;
+			return {
+				index: Math.max(0, Math.min(e, this.items.length - 1)),
+				block: t
+			};
+		}
+		return null;
+	}
+	_clampScrollPosition(e) {
+		return Math.max(-this.offsetWithinScroller[this._positionDim], Math.min(e, this.totalScrollSize[t(this.direction)] - this._viewDim1));
+	}
+	unpin() {
+		this._pin !== null && (this._sendUnpinnedMessage(), this._pin = null);
+	}
+	_updateLayout() {}
+	get _viewDim1() {
+		return this._viewportSize[this._sizeDim];
+	}
+	get _viewDim2() {
+		return this._viewportSize[this._secondarySizeDim];
+	}
+	_scheduleReflow() {
+		this._pendingReflow = !0;
+	}
+	_scheduleLayoutUpdate() {
+		this._pendingLayoutUpdate = !0, this._scheduleReflow();
+	}
+	_triggerReflow() {
+		this._scheduleLayoutUpdate(), Promise.resolve().then(() => this.reflowIfNeeded());
+	}
+	_reflow() {
+		this._pendingLayoutUpdate &&= (this._updateLayout(), !1), this._updateScrollSize(), this._setPositionFromPin(), this._getActiveItems(), this._updateVisibleIndices(), this._sendStateChangedMessage();
+	}
+	_setPositionFromPin() {
+		if (this.pin !== null) {
+			let e = this._scrollPosition, { index: t, block: n } = this.pin;
+			this._scrollPosition = this._calculateScrollIntoViewPosition({
+				index: t,
+				block: n || "start"
+			}) - this.offsetWithinScroller[this._positionDim], this._scrollError = e - this._scrollPosition;
+		}
+	}
+	_calculateScrollIntoViewPosition(e) {
+		let { block: t } = e, n = Math.min(this.items.length, Math.max(0, e.index)), r = this._getItemPosition(n)[this._positionDim], i = r;
+		if (t !== "start") {
+			let e = this._getItemSize(n)[this._sizeDim];
+			if (t === "center") i = r - .5 * this._viewDim1 + .5 * e;
+			else {
+				let n = r - this._viewDim1 + e;
+				if (t === "end") i = n;
+				else {
+					let e = this._scrollPosition;
+					i = Math.abs(e - r) < Math.abs(e - n) ? r : n;
+				}
+			}
+		}
+		return i += this.offsetWithinScroller[this._positionDim], this._clampScrollPosition(i);
+	}
+	getScrollIntoViewCoordinates(e) {
+		return { [this._positionDim]: this._calculateScrollIntoViewPosition(e) };
+	}
+	_sendUnpinnedMessage() {
+		this._hostSink({ type: "unpinned" });
+	}
+	_sendVisibilityChangedMessage() {
+		this._hostSink({
+			type: "visibilityChanged",
+			firstVisible: this._firstVisible,
+			lastVisible: this._lastVisible
+		});
+	}
+	_sendStateChangedMessage() {
+		let e = /* @__PURE__ */ new Map();
+		if (this._first !== -1 && this._last !== -1) for (let t = this._first; t <= this._last; t++) e.set(t, this._getItemPosition(t));
+		let t = {
+			type: "stateChanged",
+			scrollSize: {
+				[this._sizeDim]: this._scrollSize,
+				[this._secondarySizeDim]: null
+			},
+			range: {
+				first: this._first,
+				last: this._last,
+				firstVisible: this._firstVisible,
+				lastVisible: this._lastVisible
+			},
+			childPositions: e
+		};
+		this._scrollError &&= (t.scrollError = {
+			[this._positionDim]: this._scrollError,
+			[this._secondaryPositionDim]: 0
+		}, 0), this._hostSink(t);
+	}
+	get _num() {
+		return this._first === -1 || this._last === -1 ? 0 : this._last - this._first + 1;
+	}
+	_checkThresholds() {
+		if (this._viewDim1 === 0 && this._num > 0 || this._pin !== null) this._scheduleReflow();
+		else {
+			let e = Math.max(0, this._scrollPosition - this._overhang), t = Math.min(this._scrollSize, this._scrollPosition + this._viewDim1 + this._overhang);
+			this._physicalMin > e || this._physicalMax < t ? this._scheduleReflow() : this._updateVisibleIndices({ emit: !0 });
+		}
+	}
+	_updateVisibleIndices(e) {
+		if (this._first === -1 || this._last === -1) return;
+		let t = this._first;
+		for (; t < this._last && Math.round(this._getItemPosition(t)[this._positionDim] + this._getItemSize(t)[this._sizeDim]) <= Math.round(this._scrollPosition);) t++;
+		let n = this._last;
+		for (; n > this._first && Math.round(this._getItemPosition(n)[this._positionDim]) >= Math.round(this._scrollPosition + this._viewDim1);) n--;
+		t === this._firstVisible && n === this._lastVisible || (this._firstVisible = t, this._lastVisible = n, e && e.emit && this._sendVisibilityChangedMessage());
+	}
+};
+function r(e) {
+	return e === "horizontal" ? "marginLeft" : "marginTop";
+}
+function i(e) {
+	return e === "horizontal" ? "marginRight" : "marginBottom";
+}
+function a(e) {
+	return e === "horizontal" ? "xOffset" : "yOffset";
+}
+function o(e, t) {
+	let n = [e, t].sort();
+	return n[1] <= 0 ? Math.min(...n) : n[0] >= 0 ? Math.max(...n) : n[0] + n[1];
+}
+var s = class {
+	constructor() {
+		this._childSizeCache = new e(), this._marginSizeCache = new e(), this._metricsCache = /* @__PURE__ */ new Map();
+	}
+	update(e, n) {
+		let a = /* @__PURE__ */ new Set();
+		Object.keys(e).forEach((r) => {
+			let i = Number(r);
+			this._metricsCache.set(i, e[i]), this._childSizeCache.set(i, e[i][t(n)]), a.add(i), a.add(i + 1);
+		});
+		for (let e of a) {
+			let t = this._metricsCache.get(e)?.[r(n)] || 0, a = this._metricsCache.get(e - 1)?.[i(n)] || 0;
+			this._marginSizeCache.set(e, o(t, a));
+		}
+	}
+	get averageChildSize() {
+		return this._childSizeCache.averageSize;
+	}
+	get totalChildSize() {
+		return this._childSizeCache.totalSize;
+	}
+	get averageMarginSize() {
+		return this._marginSizeCache.averageSize;
+	}
+	get totalMarginSize() {
+		return this._marginSizeCache.totalSize;
+	}
+	getLeadingMarginValue(e, t) {
+		return this._metricsCache.get(e)?.[r(t)] || 0;
+	}
+	getChildSize(e) {
+		return this._childSizeCache.getSize(e);
+	}
+	getMarginSize(e) {
+		return this._marginSizeCache.getSize(e);
+	}
+	clear() {
+		this._childSizeCache.clear(), this._marginSizeCache.clear(), this._metricsCache.clear();
+	}
+}, c = class extends n {
+	constructor() {
+		super(...arguments), this._itemSize = {
+			width: 100,
+			height: 100
+		}, this._physicalItems = /* @__PURE__ */ new Map(), this._newPhysicalItems = /* @__PURE__ */ new Map(), this._metricsCache = new s(), this._anchorIdx = null, this._anchorPos = null, this._stable = !0, this._measureChildren = !0, this._estimate = !0;
+	}
+	get measureChildren() {
+		return this._measureChildren;
+	}
+	updateItemSizes(e) {
+		this._metricsCache.update(e, this.direction), this._scheduleReflow();
+	}
+	_getPhysicalItem(e) {
+		return this._newPhysicalItems.get(e) ?? this._physicalItems.get(e);
+	}
+	_getSize(e) {
+		return this._getPhysicalItem(e) && this._metricsCache.getChildSize(e);
+	}
+	_getAverageSize() {
+		return this._metricsCache.averageChildSize || this._itemSize[this._sizeDim];
+	}
+	_estimatePosition(e) {
+		let t = this._metricsCache;
+		if (this._first === -1 || this._last === -1) return t.averageMarginSize + e * (t.averageMarginSize + this._getAverageSize());
+		if (e < this._first) {
+			let n = this._first - e;
+			return this._getPhysicalItem(this._first).pos - (t.getMarginSize(this._first - 1) || t.averageMarginSize) - (n * t.averageChildSize + (n - 1) * t.averageMarginSize);
+		}
+		{
+			let n = e - this._last;
+			return this._getPhysicalItem(this._last).pos + (t.getChildSize(this._last) || t.averageChildSize) + (t.getMarginSize(this._last) || t.averageMarginSize) + n * (t.averageChildSize + t.averageMarginSize);
+		}
+	}
+	_getPosition(e) {
+		let t = this._getPhysicalItem(e), { averageMarginSize: n } = this._metricsCache;
+		return e === 0 ? this._metricsCache.getMarginSize(0) ?? n : t ? t.pos : this._estimatePosition(e);
+	}
+	_calculateAnchor(e, t) {
+		return e <= 0 ? 0 : t > this._scrollSize - this._viewDim1 ? this.items.length - 1 : Math.max(0, Math.min(this.items.length - 1, Math.floor((e + t) / 2 / this._delta)));
+	}
+	_getAnchor(e, t) {
+		if (this._physicalItems.size === 0 || this._first < 0 || this._last < 0) return this._calculateAnchor(e, t);
+		let n = this._getPhysicalItem(this._first), r = this._getPhysicalItem(this._last), i = n.pos;
+		if (r.pos + this._metricsCache.getChildSize(this._last) < e || i > t) return this._calculateAnchor(e, t);
+		let a = this._firstVisible - 1, o = -Infinity;
+		for (; o < e;) o = this._getPhysicalItem(++a).pos + this._metricsCache.getChildSize(a);
+		return a;
+	}
+	_getActiveItems() {
+		this._viewDim1 === 0 || this.items.length === 0 ? this._clearItems() : this._getItems();
+	}
+	_clearItems() {
+		this._first = -1, this._last = -1, this._physicalMin = 0, this._physicalMax = 0;
+		let e = this._newPhysicalItems;
+		this._newPhysicalItems = this._physicalItems, this._newPhysicalItems.clear(), this._physicalItems = e, this._stable = !0;
+	}
+	_getItems() {
+		let e = this._newPhysicalItems, t, n;
+		if (this._stable = !0, this.pin !== null) {
+			let { index: e } = this.pin;
+			this._anchorIdx = e, this._anchorPos = this._getPosition(e);
+		}
+		if (t = this._scrollPosition - this._overhang, n = this._scrollPosition + this._viewDim1 + this._overhang, n < 0 || t > this._scrollSize) return void this._clearItems();
+		this._anchorIdx !== null && this._anchorPos !== null || (this._anchorIdx = this._getAnchor(t, n), this._anchorPos = this._getPosition(this._anchorIdx));
+		let r = this._getSize(this._anchorIdx);
+		r === void 0 && (this._stable = !1, r = this._getAverageSize());
+		let i = this._metricsCache.getMarginSize(this._anchorIdx) ?? this._metricsCache.averageMarginSize, a = this._metricsCache.getMarginSize(this._anchorIdx + 1) ?? this._metricsCache.averageMarginSize;
+		this._anchorIdx === 0 && (this._anchorPos = i), this._anchorIdx === this.items.length - 1 && (this._anchorPos = this._scrollSize - a - r);
+		let o = 0;
+		for (this._anchorPos + r + a < t && (o = t - (this._anchorPos + r + a)), this._anchorPos - i > n && (o = n - (this._anchorPos - i)), o && (this._scrollPosition -= o, t -= o, n -= o, this._scrollError += o), e.set(this._anchorIdx, {
+			pos: this._anchorPos,
+			size: r
+		}), this._first = this._last = this._anchorIdx, this._physicalMin = this._anchorPos - i, this._physicalMax = this._anchorPos + r + a; this._physicalMin > t && this._first > 0;) {
+			let t = this._getSize(--this._first);
+			t === void 0 && (this._stable = !1, t = this._getAverageSize());
+			let n = this._metricsCache.getMarginSize(this._first);
+			n === void 0 && (this._stable = !1, n = this._metricsCache.averageMarginSize), this._physicalMin -= t;
+			let r = this._physicalMin;
+			if (e.set(this._first, {
+				pos: r,
+				size: t
+			}), this._physicalMin -= n, !1 === this._stable && !1 === this._estimate) break;
+		}
+		for (; this._physicalMax < n && this._last < this.items.length - 1;) {
+			let t = this._getSize(++this._last);
+			t === void 0 && (this._stable = !1, t = this._getAverageSize());
+			let n = this._metricsCache.getMarginSize(this._last);
+			n === void 0 && (this._stable = !1, n = this._metricsCache.averageMarginSize);
+			let r = this._physicalMax;
+			if (e.set(this._last, {
+				pos: r,
+				size: t
+			}), this._physicalMax += t + n, !this._stable && !this._estimate) break;
+		}
+		let s = this._calculateError();
+		s && (this._physicalMin -= s, this._physicalMax -= s, this._anchorPos -= s, this._scrollPosition -= s, e.forEach((e) => e.pos -= s), this._scrollError += s), this._stable && (this._newPhysicalItems = this._physicalItems, this._newPhysicalItems.clear(), this._physicalItems = e);
+	}
+	_calculateError() {
+		return this._first === 0 ? this._physicalMin : this._physicalMin <= 0 ? this._physicalMin - this._first * this._delta : this._last === this.items.length - 1 ? this._physicalMax - this._scrollSize : this._physicalMax >= this._scrollSize ? this._physicalMax - this._scrollSize + (this.items.length - 1 - this._last) * this._delta : 0;
+	}
+	_reflow() {
+		let { _first: e, _last: t } = this;
+		super._reflow(), (this._first === -1 && this._last == -1 || this._first === e && this._last === t) && this._resetReflowState();
+	}
+	_resetReflowState() {
+		this._anchorIdx = null, this._anchorPos = null, this._stable = !0;
+	}
+	_updateScrollSize() {
+		let { averageMarginSize: e } = this._metricsCache;
+		this._scrollSize = Math.max(1, this.items.length * (e + this._getAverageSize()) + e);
+	}
+	get _delta() {
+		let { averageMarginSize: e } = this._metricsCache;
+		return this._getAverageSize() + e;
+	}
+	_getItemPosition(e) {
+		return {
+			[this._positionDim]: this._getPosition(e),
+			[this._secondaryPositionDim]: 0,
+			[a(this.direction)]: -(this._metricsCache.getLeadingMarginValue(e, this.direction) ?? this._metricsCache.averageMarginSize)
+		};
+	}
+	_getItemSize(e) {
+		return {
+			[this._sizeDim]: this._getSize(e) || this._getAverageSize(),
+			[this._secondarySizeDim]: this._itemSize[this._secondarySizeDim]
+		};
+	}
+	_viewDim2Changed() {
+		this._metricsCache.clear(), this._scheduleReflow();
+	}
+};
+export { c as FlowLayout };

package/dist/flow-CUj0fDT_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-CUj0fDT_.js","names":[],"sources":["../node_modules/@lit-labs/virtualizer/layouts/shared/SizeCache.js","../node_modules/@lit-labs/virtualizer/layouts/shared/BaseLayout.js","../node_modules/@lit-labs/virtualizer/layouts/flow.js"],"sourcesContent":["/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nexport class SizeCache {\n    constructor(config) {\n        this._map = new Map();\n        this._roundAverageSize = false;\n        this.totalSize = 0;\n        if (config?.roundAverageSize === true) {\n            this._roundAverageSize = true;\n        }\n    }\n    set(index, value) {\n        const prev = this._map.get(index) || 0;\n        this._map.set(index, value);\n        this.totalSize += value - prev;\n    }\n    get averageSize() {\n        if (this._map.size > 0) {\n            const average = this.totalSize / this._map.size;\n            return this._roundAverageSize ? Math.round(average) : average;\n        }\n        return 0;\n    }\n    getSize(index) {\n        return this._map.get(index);\n    }\n    clear() {\n        this._map.clear();\n        this.totalSize = 0;\n    }\n}\n//# sourceMappingURL=SizeCache.js.map","/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nexport function dim1(direction) {\n    return direction === 'horizontal' ? 'width' : 'height';\n}\nexport function dim2(direction) {\n    return direction === 'horizontal' ? 'height' : 'width';\n}\nexport function pos1(direction) {\n    return direction === 'horizontal' ? 'left' : 'top';\n}\nexport function pos2(direction) {\n    return direction === 'horizontal' ? 'top' : 'left';\n}\nexport class BaseLayout {\n    _getDefaultConfig() {\n        return {\n            direction: 'vertical',\n        };\n    }\n    constructor(hostSink, config) {\n        /**\n         * The last set viewport scroll position.\n         */\n        this._latestCoords = { left: 0, top: 0 };\n        /**\n         * Scrolling direction.\n         */\n        this._direction = null;\n        /**\n         * Dimensions of the viewport.\n         */\n        this._viewportSize = { width: 0, height: 0 };\n        this.totalScrollSize = { width: 0, height: 0 };\n        this.offsetWithinScroller = { left: 0, top: 0 };\n        /**\n         * Flag for debouncing asynchronous reflow requests.\n         */\n        this._pendingReflow = false;\n        this._pendingLayoutUpdate = false;\n        this._pin = null;\n        /**\n         * The index of the first item intersecting the viewport.\n         */\n        this._firstVisible = 0;\n        /**\n         * The index of the last item intersecting the viewport.\n         */\n        this._lastVisible = 0;\n        /**\n         * Pixel offset in the scroll direction of the first child.\n         */\n        this._physicalMin = 0;\n        /**\n         * Pixel offset in the scroll direction of the last child.\n         */\n        this._physicalMax = 0;\n        /**\n         * Index of the first child.\n         */\n        this._first = -1;\n        /**\n         * Index of the last child.\n         */\n        this._last = -1;\n        /**\n         * Length in the scrolling direction.\n         */\n        this._sizeDim = 'height';\n        /**\n         * Length in the non-scrolling direction.\n         */\n        this._secondarySizeDim = 'width';\n        /**\n         * Position in the scrolling direction.\n         */\n        this._positionDim = 'top';\n        /**\n         * Position in the non-scrolling direction.\n         */\n        this._secondaryPositionDim = 'left';\n        /**\n         * Current scroll offset in pixels.\n         */\n        this._scrollPosition = 0;\n        /**\n         * Difference between current scroll offset and scroll offset calculated due\n         * to a reflow.\n         */\n        this._scrollError = 0;\n        /**\n         * Total number of items that could possibly be displayed. Used to help\n         * calculate the scroll size.\n         */\n        this._items = [];\n        /**\n         * The total (estimated) length of all items in the scrolling direction.\n         */\n        this._scrollSize = 1;\n        /**\n         * Number of pixels beyond the viewport to still include\n         * in the active range of items.\n         */\n        // TODO (graynorton): Probably want to make this something we calculate based\n        // on viewport size, item size, other factors, possibly still with a dial of some kind\n        this._overhang = 1000;\n        this._hostSink = hostSink;\n        // Delay setting config so that subclasses do setup work first\n        Promise.resolve().then(() => (this.config = config || this._getDefaultConfig()));\n    }\n    set config(config) {\n        Object.assign(this, Object.assign({}, this._getDefaultConfig(), config));\n    }\n    get config() {\n        return {\n            direction: this.direction,\n        };\n    }\n    /**\n     * Maximum index of children + 1, to help estimate total height of the scroll\n     * space.\n     */\n    get items() {\n        return this._items;\n    }\n    set items(items) {\n        this._setItems(items);\n    }\n    _setItems(items) {\n        if (items !== this._items) {\n            this._items = items;\n            this._scheduleReflow();\n        }\n    }\n    /**\n     * Primary scrolling direction.\n     */\n    get direction() {\n        return this._direction;\n    }\n    set direction(dir) {\n        // Force it to be either horizontal or vertical.\n        dir = dir === 'horizontal' ? dir : 'vertical';\n        if (dir !== this._direction) {\n            this._direction = dir;\n            this._sizeDim = dir === 'horizontal' ? 'width' : 'height';\n            this._secondarySizeDim = dir === 'horizontal' ? 'height' : 'width';\n            this._positionDim = dir === 'horizontal' ? 'left' : 'top';\n            this._secondaryPositionDim = dir === 'horizontal' ? 'top' : 'left';\n            this._triggerReflow();\n        }\n    }\n    /**\n     * Height and width of the viewport.\n     */\n    get viewportSize() {\n        return this._viewportSize;\n    }\n    set viewportSize(dims) {\n        const { _viewDim1, _viewDim2 } = this;\n        Object.assign(this._viewportSize, dims);\n        if (_viewDim2 !== this._viewDim2) {\n            // this._viewDim2Changed();\n            this._scheduleLayoutUpdate();\n        }\n        else if (_viewDim1 !== this._viewDim1) {\n            this._checkThresholds();\n        }\n    }\n    /**\n     * Scroll offset of the viewport.\n     */\n    get viewportScroll() {\n        return this._latestCoords;\n    }\n    set viewportScroll(coords) {\n        Object.assign(this._latestCoords, coords);\n        const oldPos = this._scrollPosition;\n        this._scrollPosition = this._latestCoords[this._positionDim];\n        const change = Math.abs(oldPos - this._scrollPosition);\n        if (change >= 1) {\n            this._checkThresholds();\n        }\n    }\n    /**\n     * Perform a reflow if one has been scheduled.\n     */\n    reflowIfNeeded(force = false) {\n        if (force || this._pendingReflow) {\n            this._pendingReflow = false;\n            this._reflow();\n        }\n    }\n    set pin(options) {\n        this._pin = options;\n        this._triggerReflow();\n    }\n    get pin() {\n        if (this._pin !== null) {\n            const { index, block } = this._pin;\n            return {\n                index: Math.max(0, Math.min(index, this.items.length - 1)),\n                block,\n            };\n        }\n        return null;\n    }\n    _clampScrollPosition(val) {\n        return Math.max(-this.offsetWithinScroller[this._positionDim], Math.min(val, this.totalScrollSize[dim1(this.direction)] - this._viewDim1));\n    }\n    unpin() {\n        if (this._pin !== null) {\n            this._sendUnpinnedMessage();\n            this._pin = null;\n        }\n    }\n    _updateLayout() {\n        // Override\n    }\n    // protected _viewDim2Changed(): void {\n    //   this._scheduleLayoutUpdate();\n    // }\n    /**\n     * The height or width of the viewport, whichever corresponds to the scrolling direction.\n     */\n    get _viewDim1() {\n        return this._viewportSize[this._sizeDim];\n    }\n    /**\n     * The height or width of the viewport, whichever does NOT correspond to the scrolling direction.\n     */\n    get _viewDim2() {\n        return this._viewportSize[this._secondarySizeDim];\n    }\n    _scheduleReflow() {\n        this._pendingReflow = true;\n    }\n    _scheduleLayoutUpdate() {\n        this._pendingLayoutUpdate = true;\n        this._scheduleReflow();\n    }\n    // For triggering a reflow based on incoming changes to\n    // the layout config.\n    _triggerReflow() {\n        this._scheduleLayoutUpdate();\n        // TODO graynorton@: reflowIfNeeded() isn't really supposed\n        // to be called internally. Address in larger cleanup\n        // of virtualizer / layout interaction pattern.\n        // this.reflowIfNeeded(true);\n        Promise.resolve().then(() => this.reflowIfNeeded());\n    }\n    _reflow() {\n        if (this._pendingLayoutUpdate) {\n            this._updateLayout();\n            this._pendingLayoutUpdate = false;\n        }\n        this._updateScrollSize();\n        this._setPositionFromPin();\n        this._getActiveItems();\n        this._updateVisibleIndices();\n        this._sendStateChangedMessage();\n    }\n    /**\n     * If we are supposed to be pinned to a particular\n     * item or set of coordinates, we set `_scrollPosition`\n     * accordingly and adjust `_scrollError` as needed\n     * so that the virtualizer can keep the scroll\n     * position in the DOM in sync\n     */\n    _setPositionFromPin() {\n        if (this.pin !== null) {\n            const lastScrollPosition = this._scrollPosition;\n            const { index, block } = this.pin;\n            this._scrollPosition =\n                this._calculateScrollIntoViewPosition({\n                    index,\n                    block: block || 'start',\n                }) - this.offsetWithinScroller[this._positionDim];\n            this._scrollError = lastScrollPosition - this._scrollPosition;\n        }\n    }\n    /**\n     * Calculate the coordinates to scroll to, given\n     * a request to scroll to the element at a specific\n     * index.\n     *\n     * Supports the same positioning options (`start`,\n     * `center`, `end`, `nearest`) as the standard\n     * `Element.scrollIntoView()` method, but currently\n     * only considers the provided value in the `block`\n     * dimension, since we don't yet have any layouts\n     * that support virtualization in two dimensions.\n     */\n    _calculateScrollIntoViewPosition(options) {\n        const { block } = options;\n        const index = Math.min(this.items.length, Math.max(0, options.index));\n        const itemStartPosition = this._getItemPosition(index)[this._positionDim];\n        let scrollPosition = itemStartPosition;\n        if (block !== 'start') {\n            const itemSize = this._getItemSize(index)[this._sizeDim];\n            if (block === 'center') {\n                scrollPosition =\n                    itemStartPosition - 0.5 * this._viewDim1 + 0.5 * itemSize;\n            }\n            else {\n                const itemEndPosition = itemStartPosition - this._viewDim1 + itemSize;\n                if (block === 'end') {\n                    scrollPosition = itemEndPosition;\n                }\n                else {\n                    // block === 'nearest'\n                    const currentScrollPosition = this._scrollPosition;\n                    scrollPosition =\n                        Math.abs(currentScrollPosition - itemStartPosition) <\n                            Math.abs(currentScrollPosition - itemEndPosition)\n                            ? itemStartPosition\n                            : itemEndPosition;\n                }\n            }\n        }\n        scrollPosition += this.offsetWithinScroller[this._positionDim];\n        return this._clampScrollPosition(scrollPosition);\n    }\n    getScrollIntoViewCoordinates(options) {\n        return {\n            [this._positionDim]: this._calculateScrollIntoViewPosition(options),\n        };\n    }\n    _sendUnpinnedMessage() {\n        this._hostSink({\n            type: 'unpinned',\n        });\n    }\n    _sendVisibilityChangedMessage() {\n        this._hostSink({\n            type: 'visibilityChanged',\n            firstVisible: this._firstVisible,\n            lastVisible: this._lastVisible,\n        });\n    }\n    _sendStateChangedMessage() {\n        const childPositions = new Map();\n        if (this._first !== -1 && this._last !== -1) {\n            for (let idx = this._first; idx <= this._last; idx++) {\n                childPositions.set(idx, this._getItemPosition(idx));\n            }\n        }\n        const message = {\n            type: 'stateChanged',\n            scrollSize: {\n                [this._sizeDim]: this._scrollSize,\n                [this._secondarySizeDim]: null,\n            },\n            range: {\n                first: this._first,\n                last: this._last,\n                firstVisible: this._firstVisible,\n                lastVisible: this._lastVisible,\n            },\n            childPositions,\n        };\n        if (this._scrollError) {\n            message.scrollError = {\n                [this._positionDim]: this._scrollError,\n                [this._secondaryPositionDim]: 0,\n            };\n            this._scrollError = 0;\n        }\n        this._hostSink(message);\n    }\n    /**\n     * Number of items to display.\n     */\n    get _num() {\n        if (this._first === -1 || this._last === -1) {\n            return 0;\n        }\n        return this._last - this._first + 1;\n    }\n    _checkThresholds() {\n        if ((this._viewDim1 === 0 && this._num > 0) || this._pin !== null) {\n            this._scheduleReflow();\n        }\n        else {\n            const min = Math.max(0, this._scrollPosition - this._overhang);\n            const max = Math.min(this._scrollSize, this._scrollPosition + this._viewDim1 + this._overhang);\n            if (this._physicalMin > min || this._physicalMax < max) {\n                this._scheduleReflow();\n            }\n            else {\n                this._updateVisibleIndices({ emit: true });\n            }\n        }\n    }\n    /**\n     * Find the indices of the first and last items to intersect the viewport.\n     * Emit a visibleindiceschange event when either index changes.\n     */\n    _updateVisibleIndices(options) {\n        if (this._first === -1 || this._last === -1)\n            return;\n        let firstVisible = this._first;\n        while (firstVisible < this._last &&\n            Math.round(this._getItemPosition(firstVisible)[this._positionDim] +\n                this._getItemSize(firstVisible)[this._sizeDim]) <= Math.round(this._scrollPosition)) {\n            firstVisible++;\n        }\n        let lastVisible = this._last;\n        while (lastVisible > this._first &&\n            Math.round(this._getItemPosition(lastVisible)[this._positionDim]) >=\n                Math.round(this._scrollPosition + this._viewDim1)) {\n            lastVisible--;\n        }\n        if (firstVisible !== this._firstVisible ||\n            lastVisible !== this._lastVisible) {\n            this._firstVisible = firstVisible;\n            this._lastVisible = lastVisible;\n            if (options && options.emit) {\n                this._sendVisibilityChangedMessage();\n            }\n        }\n    }\n}\n//# sourceMappingURL=BaseLayout.js.map","/**\n * @license\n * Copyright 2021 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { SizeCache } from './shared/SizeCache.js';\nimport { BaseLayout, dim1 } from './shared/BaseLayout.js';\nexport const flow = (config) => Object.assign({\n    type: FlowLayout,\n}, config);\nfunction leadingMargin(direction) {\n    return direction === 'horizontal' ? 'marginLeft' : 'marginTop';\n}\nfunction trailingMargin(direction) {\n    return direction === 'horizontal' ? 'marginRight' : 'marginBottom';\n}\nfunction offset(direction) {\n    return direction === 'horizontal' ? 'xOffset' : 'yOffset';\n}\nfunction collapseMargins(a, b) {\n    const m = [a, b].sort();\n    return m[1] <= 0 ? Math.min(...m) : m[0] >= 0 ? Math.max(...m) : m[0] + m[1];\n}\nclass MetricsCache {\n    constructor() {\n        this._childSizeCache = new SizeCache();\n        this._marginSizeCache = new SizeCache();\n        this._metricsCache = new Map();\n    }\n    update(metrics, direction) {\n        const marginsToUpdate = new Set();\n        Object.keys(metrics).forEach((key) => {\n            const k = Number(key);\n            this._metricsCache.set(k, metrics[k]);\n            this._childSizeCache.set(k, metrics[k][dim1(direction)]);\n            marginsToUpdate.add(k);\n            marginsToUpdate.add(k + 1);\n        });\n        for (const k of marginsToUpdate) {\n            const a = this._metricsCache.get(k)?.[leadingMargin(direction)] || 0;\n            const b = this._metricsCache.get(k - 1)?.[trailingMargin(direction)] || 0;\n            this._marginSizeCache.set(k, collapseMargins(a, b));\n        }\n    }\n    get averageChildSize() {\n        return this._childSizeCache.averageSize;\n    }\n    get totalChildSize() {\n        return this._childSizeCache.totalSize;\n    }\n    get averageMarginSize() {\n        return this._marginSizeCache.averageSize;\n    }\n    get totalMarginSize() {\n        return this._marginSizeCache.totalSize;\n    }\n    getLeadingMarginValue(index, direction) {\n        return this._metricsCache.get(index)?.[leadingMargin(direction)] || 0;\n    }\n    getChildSize(index) {\n        return this._childSizeCache.getSize(index);\n    }\n    getMarginSize(index) {\n        return this._marginSizeCache.getSize(index);\n    }\n    clear() {\n        this._childSizeCache.clear();\n        this._marginSizeCache.clear();\n        this._metricsCache.clear();\n    }\n}\nexport class FlowLayout extends BaseLayout {\n    constructor() {\n        super(...arguments);\n        /**\n         * Initial estimate of item size\n         */\n        this._itemSize = { width: 100, height: 100 };\n        /**\n         * Indices of children mapped to their (position and length) in the scrolling\n         * direction. Used to keep track of children that are in range.\n         */\n        this._physicalItems = new Map();\n        /**\n         * Used in tandem with _physicalItems to track children in range across\n         * reflows.\n         */\n        this._newPhysicalItems = new Map();\n        /**\n         * Width and height of children by their index.\n         */\n        this._metricsCache = new MetricsCache();\n        /**\n         * anchorIdx is the anchor around which we reflow. It is designed to allow\n         * jumping to any point of the scroll size. We choose it once and stick with\n         * it until stable. _first and _last are deduced around it.\n         */\n        this._anchorIdx = null;\n        /**\n         * Position in the scrolling direction of the anchor child.\n         */\n        this._anchorPos = null;\n        /**\n         * Whether all children in range were in range during the previous reflow.\n         */\n        this._stable = true;\n        this._measureChildren = true;\n        this._estimate = true;\n    }\n    // protected _defaultConfig: BaseLayoutConfig = Object.assign({}, super._defaultConfig, {\n    // })\n    // constructor(config: Layout1dConfig) {\n    //   super(config);\n    // }\n    get measureChildren() {\n        return this._measureChildren;\n    }\n    /**\n     * Determine the average size of all children represented in the sizes\n     * argument.\n     */\n    updateItemSizes(sizes) {\n        this._metricsCache.update(sizes, this.direction);\n        // if (this._nMeasured) {\n        // this._updateItemSize();\n        this._scheduleReflow();\n        // }\n    }\n    /**\n     * Set the average item size based on the total length and number of children\n     * in range.\n     */\n    // _updateItemSize() {\n    //   // Keep integer values.\n    //   this._itemSize[this._sizeDim] = this._metricsCache.averageChildSize;\n    // }\n    _getPhysicalItem(idx) {\n        return this._newPhysicalItems.get(idx) ?? this._physicalItems.get(idx);\n    }\n    _getSize(idx) {\n        const item = this._getPhysicalItem(idx);\n        return item && this._metricsCache.getChildSize(idx);\n    }\n    _getAverageSize() {\n        return this._metricsCache.averageChildSize || this._itemSize[this._sizeDim];\n    }\n    _estimatePosition(idx) {\n        const c = this._metricsCache;\n        if (this._first === -1 || this._last === -1) {\n            return (c.averageMarginSize +\n                idx * (c.averageMarginSize + this._getAverageSize()));\n        }\n        else {\n            if (idx < this._first) {\n                const delta = this._first - idx;\n                const refItem = this._getPhysicalItem(this._first);\n                return (refItem.pos -\n                    (c.getMarginSize(this._first - 1) || c.averageMarginSize) -\n                    (delta * c.averageChildSize + (delta - 1) * c.averageMarginSize));\n            }\n            else {\n                const delta = idx - this._last;\n                const refItem = this._getPhysicalItem(this._last);\n                return (refItem.pos +\n                    (c.getChildSize(this._last) || c.averageChildSize) +\n                    (c.getMarginSize(this._last) || c.averageMarginSize) +\n                    delta * (c.averageChildSize + c.averageMarginSize));\n            }\n        }\n    }\n    /**\n     * Returns the position in the scrolling direction of the item at idx.\n     * Estimates it if the item at idx is not in the DOM.\n     */\n    _getPosition(idx) {\n        const item = this._getPhysicalItem(idx);\n        const { averageMarginSize } = this._metricsCache;\n        return idx === 0\n            ? this._metricsCache.getMarginSize(0) ?? averageMarginSize\n            : item\n                ? item.pos\n                : this._estimatePosition(idx);\n    }\n    _calculateAnchor(lower, upper) {\n        if (lower <= 0) {\n            return 0;\n        }\n        if (upper > this._scrollSize - this._viewDim1) {\n            return this.items.length - 1;\n        }\n        return Math.max(0, Math.min(this.items.length - 1, Math.floor((lower + upper) / 2 / this._delta)));\n    }\n    _getAnchor(lower, upper) {\n        if (this._physicalItems.size === 0) {\n            return this._calculateAnchor(lower, upper);\n        }\n        if (this._first < 0) {\n            return this._calculateAnchor(lower, upper);\n        }\n        if (this._last < 0) {\n            return this._calculateAnchor(lower, upper);\n        }\n        const firstItem = this._getPhysicalItem(this._first), lastItem = this._getPhysicalItem(this._last), firstMin = firstItem.pos, lastMin = lastItem.pos, lastMax = lastMin + this._metricsCache.getChildSize(this._last);\n        if (lastMax < lower) {\n            // Window is entirely past physical items, calculate new anchor\n            return this._calculateAnchor(lower, upper);\n        }\n        if (firstMin > upper) {\n            // Window is entirely before physical items, calculate new anchor\n            return this._calculateAnchor(lower, upper);\n        }\n        // Window contains a physical item\n        // Find one, starting with the one that was previously first visible\n        let candidateIdx = this._firstVisible - 1;\n        let cMax = -Infinity;\n        while (cMax < lower) {\n            const candidate = this._getPhysicalItem(++candidateIdx);\n            cMax = candidate.pos + this._metricsCache.getChildSize(candidateIdx);\n        }\n        return candidateIdx;\n    }\n    /**\n     * Updates _first and _last based on items that should be in the current\n     * viewed range.\n     */\n    _getActiveItems() {\n        if (this._viewDim1 === 0 || this.items.length === 0) {\n            this._clearItems();\n        }\n        else {\n            this._getItems();\n        }\n    }\n    /**\n     * Sets the range to empty.\n     */\n    _clearItems() {\n        this._first = -1;\n        this._last = -1;\n        this._physicalMin = 0;\n        this._physicalMax = 0;\n        const items = this._newPhysicalItems;\n        this._newPhysicalItems = this._physicalItems;\n        this._newPhysicalItems.clear();\n        this._physicalItems = items;\n        this._stable = true;\n    }\n    /*\n     * Updates _first and _last based on items that should be in the given range.\n     */\n    _getItems() {\n        const items = this._newPhysicalItems;\n        this._stable = true;\n        let lower, upper;\n        // The anchorIdx is the anchor around which we reflow. It is designed to\n        // allow jumping to any point of the scroll size. We choose it once and\n        // stick with it until stable. first and last are deduced around it.\n        // If we have a pinned item, we anchor on it\n        if (this.pin !== null) {\n            const { index } = this.pin;\n            this._anchorIdx = index;\n            this._anchorPos = this._getPosition(index);\n        }\n        // Determine the lower and upper bounds of the region to be\n        // rendered, relative to the viewport\n        lower = this._scrollPosition - this._overhang; //leadingOverhang;\n        upper = this._scrollPosition + this._viewDim1 + this._overhang; // trailingOverhang;\n        if (upper < 0 || lower > this._scrollSize) {\n            this._clearItems();\n            return;\n        }\n        // If we are scrolling to a specific index or if we are doing another\n        // pass to stabilize a previously started reflow, we will already\n        // have an anchor. If not, establish an anchor now.\n        if (this._anchorIdx === null || this._anchorPos === null) {\n            this._anchorIdx = this._getAnchor(lower, upper);\n            this._anchorPos = this._getPosition(this._anchorIdx);\n        }\n        let anchorSize = this._getSize(this._anchorIdx);\n        if (anchorSize === undefined) {\n            this._stable = false;\n            anchorSize = this._getAverageSize();\n        }\n        const anchorLeadingMargin = this._metricsCache.getMarginSize(this._anchorIdx) ??\n            this._metricsCache.averageMarginSize;\n        const anchorTrailingMargin = this._metricsCache.getMarginSize(this._anchorIdx + 1) ??\n            this._metricsCache.averageMarginSize;\n        if (this._anchorIdx === 0) {\n            this._anchorPos = anchorLeadingMargin;\n        }\n        if (this._anchorIdx === this.items.length - 1) {\n            this._anchorPos = this._scrollSize - anchorTrailingMargin - anchorSize;\n        }\n        // Anchor might be outside bounds, so prefer correcting the error and keep\n        // that anchorIdx.\n        let anchorErr = 0;\n        if (this._anchorPos + anchorSize + anchorTrailingMargin < lower) {\n            anchorErr = lower - (this._anchorPos + anchorSize + anchorTrailingMargin);\n        }\n        if (this._anchorPos - anchorLeadingMargin > upper) {\n            anchorErr = upper - (this._anchorPos - anchorLeadingMargin);\n        }\n        if (anchorErr) {\n            this._scrollPosition -= anchorErr;\n            lower -= anchorErr;\n            upper -= anchorErr;\n            this._scrollError += anchorErr;\n        }\n        items.set(this._anchorIdx, { pos: this._anchorPos, size: anchorSize });\n        this._first = this._last = this._anchorIdx;\n        this._physicalMin = this._anchorPos - anchorLeadingMargin;\n        this._physicalMax = this._anchorPos + anchorSize + anchorTrailingMargin;\n        while (this._physicalMin > lower && this._first > 0) {\n            let size = this._getSize(--this._first);\n            if (size === undefined) {\n                this._stable = false;\n                size = this._getAverageSize();\n            }\n            let margin = this._metricsCache.getMarginSize(this._first);\n            if (margin === undefined) {\n                this._stable = false;\n                margin = this._metricsCache.averageMarginSize;\n            }\n            this._physicalMin -= size;\n            const pos = this._physicalMin;\n            items.set(this._first, { pos, size });\n            this._physicalMin -= margin;\n            if (this._stable === false && this._estimate === false) {\n                break;\n            }\n        }\n        while (this._physicalMax < upper && this._last < this.items.length - 1) {\n            let size = this._getSize(++this._last);\n            if (size === undefined) {\n                this._stable = false;\n                size = this._getAverageSize();\n            }\n            let margin = this._metricsCache.getMarginSize(this._last);\n            if (margin === undefined) {\n                this._stable = false;\n                margin = this._metricsCache.averageMarginSize;\n            }\n            const pos = this._physicalMax;\n            items.set(this._last, { pos, size });\n            this._physicalMax += size + margin;\n            if (!this._stable && !this._estimate) {\n                break;\n            }\n        }\n        // This handles the cases where we were relying on estimated sizes.\n        const extentErr = this._calculateError();\n        if (extentErr) {\n            this._physicalMin -= extentErr;\n            this._physicalMax -= extentErr;\n            this._anchorPos -= extentErr;\n            this._scrollPosition -= extentErr;\n            items.forEach((item) => (item.pos -= extentErr));\n            this._scrollError += extentErr;\n        }\n        if (this._stable) {\n            this._newPhysicalItems = this._physicalItems;\n            this._newPhysicalItems.clear();\n            this._physicalItems = items;\n        }\n    }\n    _calculateError() {\n        if (this._first === 0) {\n            return this._physicalMin;\n        }\n        else if (this._physicalMin <= 0) {\n            return this._physicalMin - this._first * this._delta;\n        }\n        else if (this._last === this.items.length - 1) {\n            return this._physicalMax - this._scrollSize;\n        }\n        else if (this._physicalMax >= this._scrollSize) {\n            return (this._physicalMax -\n                this._scrollSize +\n                (this.items.length - 1 - this._last) * this._delta);\n        }\n        return 0;\n    }\n    _reflow() {\n        const { _first, _last } = this;\n        super._reflow();\n        if ((this._first === -1 && this._last == -1) ||\n            (this._first === _first && this._last === _last)) {\n            this._resetReflowState();\n        }\n    }\n    _resetReflowState() {\n        this._anchorIdx = null;\n        this._anchorPos = null;\n        this._stable = true;\n    }\n    _updateScrollSize() {\n        const { averageMarginSize } = this._metricsCache;\n        this._scrollSize = Math.max(1, this.items.length * (averageMarginSize + this._getAverageSize()) +\n            averageMarginSize);\n    }\n    /**\n     * Returns the average size (precise or estimated) of an item in the scrolling direction,\n     * including any surrounding space.\n     */\n    get _delta() {\n        const { averageMarginSize } = this._metricsCache;\n        return this._getAverageSize() + averageMarginSize;\n    }\n    /**\n     * Returns the top and left positioning of the item at idx.\n     */\n    _getItemPosition(idx) {\n        return {\n            [this._positionDim]: this._getPosition(idx),\n            [this._secondaryPositionDim]: 0,\n            [offset(this.direction)]: -(this._metricsCache.getLeadingMarginValue(idx, this.direction) ??\n                this._metricsCache.averageMarginSize),\n        };\n    }\n    /**\n     * Returns the height and width of the item at idx.\n     */\n    _getItemSize(idx) {\n        return {\n            [this._sizeDim]: this._getSize(idx) || this._getAverageSize(),\n            [this._secondarySizeDim]: this._itemSize[this._secondarySizeDim],\n        };\n    }\n    _viewDim2Changed() {\n        this._metricsCache.clear();\n        this._scheduleReflow();\n    }\n}\n//# sourceMappingURL=flow.js.map"],"x_google_ignoreList":[0,1,2],"mappings":"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"}