@mhmo91/schmancy 0.2.120 → 0.2.122

package/dist/table-C8Lqlb9G.js

@@ -0,0 +1,556 @@
+import { _ as g } from "./tslib.es6-ujVQHAQ4.js";
+import { css as H, html as d, noChange as D, LitElement as W } from "lit";
+import { property as f } from "lit/decorators/property.js";
+import { directive as q, PartType as U } from "lit/directive.js";
+import { AsyncDirective as G } from "lit/async-directive.js";
+import { repeat as L } from "lit/directives/repeat.js";
+import { $ as R } from "./litElement.mixin-CtugwVVz.js";
+import { property as c, customElement as M } from "lit/decorators.js";
+var J = Object.defineProperty, X = Object.getOwnPropertyDescriptor, v = (s, t, e, i) => {
+  for (var l, r = i > 1 ? void 0 : i ? X(t, e) : t, o = s.length - 1; o >= 0; o--) (l = s[o]) && (r = (i ? l(t, e, r) : l(r)) || r);
+  return i && r && J(t, e, r), r;
+};
+let m = class extends R(H`
+	:host {
+		display: block;
+		z-index: -1;
+	}
+`) {
+  constructor() {
+    super(...arguments), this.columns = [], this.cols = "1fr";
+  }
+  render() {
+    return d`
+			<schmancy-list-item
+				@click=${() => {
+      this.dispatchEvent(new CustomEvent("row-click", { detail: this.item, bubbles: !0, composed: !0 }));
+    }}
+				class="w-full"
+			>
+				<schmancy-grid .cols=${this.cols} align="center" gap="md">
+					${this.columns.map((s) => {
+      var t;
+      return d`
+							<div class="overflow-hidden text-ellipsis">
+								<schmancy-typography
+									align="${s.align || "left"}"
+									maxLines="2"
+									weight="${s.weight || "normal"}"
+								>
+									${s.render ? s.render(this.item) : s.key ? (t = this.item) == null ? void 0 : t[s.key] : ""}
+								</schmancy-typography>
+							</div>
+						`;
+    })}
+					<sch-flex
+						class="min-w-fit block"
+						flow="row-dense"
+						.hidden=${Array.isArray(this.actions) && this.actions.length === 0}
+					>
+						${L(this.actions ?? [], ({ name: s }) => s, ({ name: s, action: t }) => d`
+								<schmancy-icon-button
+									@click=${(e) => {
+      e.stopPropagation(), t(this.item);
+    }}
+								>
+									${s}
+								</schmancy-icon-button>
+							`)}
+					</sch-flex>
+					<!-- <schmancy-menu .hidden=${Array.isArray(this.actions) && this.actions.length === 0}>
+						${L(this.actions ?? [], ({ name: s }) => s, ({ name: s, action: t }) => d`
+							<schmancy-menu-item
+								class="z-[10000]"
+								@click=${(e) => {
+      e.stopPropagation(), t(this.item);
+    }}
+							>
+								${s}
+							</schmancy-menu-item>
+						`)}
+					</schmancy-menu> -->
+				</schmancy-grid>
+			</schmancy-list-item>
+		`;
+  }
+};
+v([c({ type: Array, attribute: !1 })], m.prototype, "columns", 2), v([c({ type: Object, attribute: !1 })], m.prototype, "item", 2), v([c({ type: String })], m.prototype, "cols", 2), v([c({ type: Array })], m.prototype, "actions", 2), m = v([M("schmancy-table-row")], m);
+class C extends Event {
+  constructor(t) {
+    super(C.eventName, { bubbles: !1 }), this.first = t.first, this.last = t.last;
+  }
+}
+C.eventName = "rangeChanged";
+class E extends Event {
+  constructor(t) {
+    super(E.eventName, { bubbles: !1 }), this.first = t.first, this.last = t.last;
+  }
+}
+E.eventName = "visibilityChanged";
+class S extends Event {
+  constructor() {
+    super(S.eventName, { bubbles: !1 });
+  }
+}
+S.eventName = "unpinned";
+class Y {
+  constructor(t) {
+    this._element = null;
+    const e = t ?? window;
+    this._node = e, t && (this._element = t);
+  }
+  get element() {
+    return this._element || document.scrollingElement || document.documentElement;
+  }
+  get scrollTop() {
+    return this.element.scrollTop || window.scrollY;
+  }
+  get scrollLeft() {
+    return this.element.scrollLeft || window.scrollX;
+  }
+  get scrollHeight() {
+    return this.element.scrollHeight;
+  }
+  get scrollWidth() {
+    return this.element.scrollWidth;
+  }
+  get viewportHeight() {
+    return this._element ? this._element.getBoundingClientRect().height : window.innerHeight;
+  }
+  get viewportWidth() {
+    return this._element ? this._element.getBoundingClientRect().width : window.innerWidth;
+  }
+  get maxScrollTop() {
+    return this.scrollHeight - this.viewportHeight;
+  }
+  get maxScrollLeft() {
+    return this.scrollWidth - this.viewportWidth;
+  }
+}
+class K extends Y {
+  constructor(t, e) {
+    super(e), this._clients = /* @__PURE__ */ new Set(), this._retarget = null, this._end = null, this.t = null, this.correctingScrollError = !1, this._checkForArrival = this._checkForArrival.bind(this), this._updateManagedScrollTo = this._updateManagedScrollTo.bind(this), this.scrollTo = this.scrollTo.bind(this), this.scrollBy = this.scrollBy.bind(this);
+    const i = this._node;
+    this._originalScrollTo = i.scrollTo, this._originalScrollBy = i.scrollBy, this._originalScroll = i.scroll, this._attach(t);
+  }
+  get _destination() {
+    return this.t;
+  }
+  get scrolling() {
+    return this._destination !== null;
+  }
+  scrollTo(t, e) {
+    const i = typeof t == "number" && typeof e == "number" ? { left: t, top: e } : t;
+    this._scrollTo(i);
+  }
+  scrollBy(t, e) {
+    const i = typeof t == "number" && typeof e == "number" ? { left: t, top: e } : t;
+    i.top !== void 0 && (i.top += this.scrollTop), i.left !== void 0 && (i.left += this.scrollLeft), this._scrollTo(i);
+  }
+  _nativeScrollTo(t) {
+    this._originalScrollTo.bind(this._element || window)(t);
+  }
+  _scrollTo(t, e = null, i = null) {
+    this._end !== null && this._end(), t.behavior === "smooth" ? (this._setDestination(t), this._retarget = e, this._end = i) : this._resetScrollState(), this._nativeScrollTo(t);
+  }
+  _setDestination(t) {
+    let { top: e, left: i } = t;
+    return e = e === void 0 ? void 0 : Math.max(0, Math.min(e, this.maxScrollTop)), i = i === void 0 ? void 0 : Math.max(0, Math.min(i, this.maxScrollLeft)), (this._destination === null || i !== this._destination.left || e !== this._destination.top) && (this.t = { top: e, left: i, behavior: "smooth" }, !0);
+  }
+  _resetScrollState() {
+    this.t = null, this._retarget = null, this._end = null;
+  }
+  _updateManagedScrollTo(t) {
+    this._destination && this._setDestination(t) && this._nativeScrollTo(this._destination);
+  }
+  managedScrollTo(t, e, i) {
+    return this._scrollTo(t, e, i), this._updateManagedScrollTo;
+  }
+  correctScrollError(t) {
+    this.correctingScrollError = !0, requestAnimationFrame(() => requestAnimationFrame(() => this.correctingScrollError = !1)), this._nativeScrollTo(t), this._retarget && this._setDestination(this._retarget()), this._destination && this._nativeScrollTo(this._destination);
+  }
+  _checkForArrival() {
+    if (this._destination !== null) {
+      const { scrollTop: t, scrollLeft: e } = this;
+      let { top: i, left: l } = this._destination;
+      i = Math.min(i || 0, this.maxScrollTop), l = Math.min(l || 0, this.maxScrollLeft);
+      const r = Math.abs(i - t), o = Math.abs(l - e);
+      r < 1 && o < 1 && (this._end && this._end(), this._resetScrollState());
+    }
+  }
+  detach(t) {
+    return this._clients.delete(t), this._clients.size === 0 && (this._node.scrollTo = this._originalScrollTo, this._node.scrollBy = this._originalScrollBy, this._node.scroll = this._originalScroll, this._node.removeEventListener("scroll", this._checkForArrival)), null;
+  }
+  _attach(t) {
+    this._clients.add(t), this._clients.size === 1 && (this._node.scrollTo = this.scrollTo, this._node.scrollBy = this.scrollBy, this._node.scroll = this.scrollTo, this._node.addEventListener("scroll", this._checkForArrival));
+  }
+}
+let k = typeof window < "u" ? window.ResizeObserver : void 0;
+const z = Symbol("virtualizerRef"), b = "virtualizer-sizer";
+let O;
+class Q {
+  constructor(t) {
+    if (this._benchmarkStart = null, this._layout = null, this._clippingAncestors = [], this._scrollSize = null, this._scrollError = null, this._childrenPos = null, this._childMeasurements = null, this._toBeMeasured = /* @__PURE__ */ new Map(), this._rangeChanged = !0, this._itemsChanged = !0, this._visibilityChanged = !0, this._scrollerController = null, this._isScroller = !1, this._sizer = null, this._hostElementRO = null, this._childrenRO = null, this._mutationObserver = null, this._scrollEventListeners = [], this._scrollEventListenerOptions = { passive: !0 }, this._loadListener = this._childLoaded.bind(this), this._scrollIntoViewTarget = null, this._updateScrollIntoViewCoordinates = null, this._items = [], this._first = -1, this._last = -1, this._firstVisible = -1, this._lastVisible = -1, this._scheduled = /* @__PURE__ */ new WeakSet(), this._measureCallback = null, this._measureChildOverride = null, this._layoutCompletePromise = null, this._layoutCompleteResolver = null, this._layoutCompleteRejecter = null, this._pendingLayoutComplete = null, this._layoutInitialized = null, this._connected = !1, !t) throw new Error("Virtualizer constructor requires a configuration object");
+    if (!t.hostElement) throw new Error('Virtualizer configuration requires the "hostElement" property');
+    this._init(t);
+  }
+  set items(t) {
+    Array.isArray(t) && t !== this._items && (this._itemsChanged = !0, this._items = t, this._schedule(this._updateLayout));
+  }
+  _init(t) {
+    this._isScroller = !!t.scroller, this._initHostElement(t);
+    const e = t.layout || {};
+    this._layoutInitialized = this._initLayout(e);
+  }
+  _initObservers() {
+    this._mutationObserver = new MutationObserver(this._finishDOMUpdate.bind(this)), this._hostElementRO = new k(() => this._hostElementSizeChanged()), this._childrenRO = new k(this._childrenSizeChanged.bind(this));
+  }
+  _initHostElement(t) {
+    const e = this._hostElement = t.hostElement;
+    this._applyVirtualizerStyles(), e[z] = this;
+  }
+  connected() {
+    this._initObservers();
+    const t = this._isScroller;
+    this._clippingAncestors = function(e, i = !1) {
+      let l = !1;
+      return function(r, o = !1) {
+        const a = [];
+        let h = o ? r : V(r);
+        for (; h !== null; ) a.push(h), h = V(h);
+        return a;
+      }(e, i).filter((r) => {
+        if (l) return !1;
+        const o = getComputedStyle(r);
+        return l = o.position === "fixed", o.overflow !== "visible";
+      });
+    }(this._hostElement, t), this._scrollerController = new K(this, this._clippingAncestors[0]), this._schedule(this._updateLayout), this._observeAndListen(), this._connected = !0;
+  }
+  _observeAndListen() {
+    this._mutationObserver.observe(this._hostElement, { childList: !0 }), this._hostElementRO.observe(this._hostElement), this._scrollEventListeners.push(window), window.addEventListener("scroll", this, this._scrollEventListenerOptions), this._clippingAncestors.forEach((t) => {
+      t.addEventListener("scroll", this, this._scrollEventListenerOptions), this._scrollEventListeners.push(t), this._hostElementRO.observe(t);
+    }), this._hostElementRO.observe(this._scrollerController.element), this._children.forEach((t) => this._childrenRO.observe(t)), this._scrollEventListeners.forEach((t) => t.addEventListener("scroll", this, this._scrollEventListenerOptions));
+  }
+  disconnected() {
+    var t, e, i, l;
+    this._scrollEventListeners.forEach((r) => r.removeEventListener("scroll", this, this._scrollEventListenerOptions)), this._scrollEventListeners = [], this._clippingAncestors = [], (t = this._scrollerController) == null || t.detach(this), this._scrollerController = null, (e = this._mutationObserver) == null || e.disconnect(), this._mutationObserver = null, (i = this._hostElementRO) == null || i.disconnect(), this._hostElementRO = null, (l = this._childrenRO) == null || l.disconnect(), this._childrenRO = null, this._rejectLayoutCompletePromise("disconnected"), this._connected = !1;
+  }
+  _applyVirtualizerStyles() {
+    const t = this._hostElement.style;
+    t.display = t.display || "block", t.position = t.position || "relative", t.contain = t.contain || "size layout", this._isScroller && (t.overflow = t.overflow || "auto", t.minHeight = t.minHeight || "150px");
+  }
+  _getSizer() {
+    const t = this._hostElement;
+    if (!this._sizer) {
+      let e = t.querySelector(`[${b}]`);
+      e || (e = document.createElement("div"), e.setAttribute(b, ""), t.appendChild(e)), Object.assign(e.style, { position: "absolute", margin: "-2px 0 0 0", padding: 0, visibility: "hidden", fontSize: "2px" }), e.textContent = "&nbsp;", e.setAttribute(b, ""), this._sizer = e;
+    }
+    return this._sizer;
+  }
+  async updateLayoutConfig(t) {
+    await this._layoutInitialized;
+    const e = t.type || O;
+    if (typeof e == "function" && this._layout instanceof e) {
+      const i = { ...t };
+      return delete i.type, this._layout.config = i, !0;
+    }
+    return !1;
+  }
+  async _initLayout(t) {
+    let e, i;
+    if (typeof t.type == "function") {
+      i = t.type;
+      const l = { ...t };
+      delete l.type, e = l;
+    } else e = t;
+    i === void 0 && (O = i = (await import("./flow-B1wMqea2.js")).FlowLayout), this._layout = new i((l) => this._handleLayoutMessage(l), e), this._layout.measureChildren && typeof this._layout.updateItemSizes == "function" && (typeof this._layout.measureChildren == "function" && (this._measureChildOverride = this._layout.measureChildren), this._measureCallback = this._layout.updateItemSizes.bind(this._layout)), this._layout.listenForChildLoadEvents && this._hostElement.addEventListener("load", this._loadListener, !0), this._schedule(this._updateLayout);
+  }
+  startBenchmarking() {
+    this._benchmarkStart === null && (this._benchmarkStart = window.performance.now());
+  }
+  stopBenchmarking() {
+    if (this._benchmarkStart !== null) {
+      const t = window.performance.now(), e = t - this._benchmarkStart, i = performance.getEntriesByName("uv-virtualizing", "measure").filter((l) => l.startTime >= this._benchmarkStart && l.startTime < t).reduce((l, r) => l + r.duration, 0);
+      return this._benchmarkStart = null, { timeElapsed: e, virtualizationTime: i };
+    }
+    return null;
+  }
+  _measureChildren() {
+    const t = {}, e = this._children, i = this._measureChildOverride || this._measureChild;
+    for (let l = 0; l < e.length; l++) {
+      const r = e[l], o = this._first + l;
+      (this._itemsChanged || this._toBeMeasured.has(r)) && (t[o] = i.call(this, r, this._items[o]));
+    }
+    this._childMeasurements = t, this._schedule(this._updateLayout), this._toBeMeasured.clear();
+  }
+  _measureChild(t) {
+    const { width: e, height: i } = t.getBoundingClientRect();
+    return Object.assign({ width: e, height: i }, function(l) {
+      const r = window.getComputedStyle(l);
+      return { marginTop: w(r.marginTop), marginRight: w(r.marginRight), marginBottom: w(r.marginBottom), marginLeft: w(r.marginLeft) };
+    }(t));
+  }
+  async _schedule(t) {
+    this._scheduled.has(t) || (this._scheduled.add(t), await Promise.resolve(), this._scheduled.delete(t), t.call(this));
+  }
+  async _updateDOM(t) {
+    this._scrollSize = t.scrollSize, this._adjustRange(t.range), this._childrenPos = t.childPositions, this._scrollError = t.scrollError || null;
+    const { _rangeChanged: e, _itemsChanged: i } = this;
+    this._visibilityChanged && (this._notifyVisibility(), this._visibilityChanged = !1), (e || i) && (this._notifyRange(), this._rangeChanged = !1), this._finishDOMUpdate();
+  }
+  _finishDOMUpdate() {
+    this._connected && (this._children.forEach((t) => this._childrenRO.observe(t)), this._checkScrollIntoViewTarget(this._childrenPos), this._positionChildren(this._childrenPos), this._sizeHostElement(this._scrollSize), this._correctScrollError(), this._benchmarkStart && "mark" in window.performance && window.performance.mark("uv-end"));
+  }
+  _updateLayout() {
+    this._layout && this._connected && (this._layout.items = this._items, this._updateView(), this._childMeasurements !== null && (this._measureCallback && this._measureCallback(this._childMeasurements), this._childMeasurements = null), this._layout.reflowIfNeeded(), this._benchmarkStart && "mark" in window.performance && window.performance.mark("uv-end"));
+  }
+  _handleScrollEvent() {
+    var t;
+    if (this._benchmarkStart && "mark" in window.performance) {
+      try {
+        window.performance.measure("uv-virtualizing", "uv-start", "uv-end");
+      } catch {
+      }
+      window.performance.mark("uv-start");
+    }
+    this._scrollerController.correctingScrollError === !1 && ((t = this._layout) == null || t.unpin()), this._schedule(this._updateLayout);
+  }
+  handleEvent(t) {
+    t.type === "scroll" && (t.currentTarget === window || this._clippingAncestors.includes(t.currentTarget)) && this._handleScrollEvent();
+  }
+  _handleLayoutMessage(t) {
+    t.type === "stateChanged" ? this._updateDOM(t) : t.type === "visibilityChanged" ? (this._firstVisible = t.firstVisible, this._lastVisible = t.lastVisible, this._notifyVisibility()) : t.type === "unpinned" && this._hostElement.dispatchEvent(new S());
+  }
+  get _children() {
+    const t = [];
+    let e = this._hostElement.firstElementChild;
+    for (; e; ) e.hasAttribute(b) || t.push(e), e = e.nextElementSibling;
+    return t;
+  }
+  _updateView() {
+    var l;
+    const t = this._hostElement, e = (l = this._scrollerController) == null ? void 0 : l.element, i = this._layout;
+    if (t && e && i) {
+      let r, o, a, h;
+      const n = t.getBoundingClientRect();
+      r = 0, o = 0, a = window.innerHeight, h = window.innerWidth;
+      const x = this._clippingAncestors.map((_) => _.getBoundingClientRect());
+      x.unshift(n);
+      for (const _ of x) r = Math.max(r, _.top), o = Math.max(o, _.left), a = Math.min(a, _.bottom), h = Math.min(h, _.right);
+      const T = e.getBoundingClientRect(), I = { left: n.left - T.left, top: n.top - T.top }, F = { width: e.scrollWidth, height: e.scrollHeight }, B = r - n.top + t.scrollTop, P = o - n.left + t.scrollLeft, N = Math.max(0, a - r), j = Math.max(0, h - o);
+      i.viewportSize = { width: j, height: N }, i.viewportScroll = { top: B, left: P }, i.totalScrollSize = F, i.offsetWithinScroller = I;
+    }
+  }
+  _sizeHostElement(t) {
+    const i = t && t.width !== null ? Math.min(82e5, t.width) : 0, l = t && t.height !== null ? Math.min(82e5, t.height) : 0;
+    if (this._isScroller) this._getSizer().style.transform = `translate(${i}px, ${l}px)`;
+    else {
+      const r = this._hostElement.style;
+      r.minWidth = i ? `${i}px` : "100%", r.minHeight = l ? `${l}px` : "100%";
+    }
+  }
+  _positionChildren(t) {
+    t && t.forEach(({ top: e, left: i, width: l, height: r, xOffset: o, yOffset: a }, h) => {
+      const n = this._children[h - this._first];
+      n && (n.style.position = "absolute", n.style.boxSizing = "border-box", n.style.transform = `translate(${i}px, ${e}px)`, l !== void 0 && (n.style.width = l + "px"), r !== void 0 && (n.style.height = r + "px"), n.style.left = o === void 0 ? null : o + "px", n.style.top = a === void 0 ? null : a + "px");
+    });
+  }
+  async _adjustRange(t) {
+    const { _first: e, _last: i, _firstVisible: l, _lastVisible: r } = this;
+    this._first = t.first, this._last = t.last, this._firstVisible = t.firstVisible, this._lastVisible = t.lastVisible, this._rangeChanged = this._rangeChanged || this._first !== e || this._last !== i, this._visibilityChanged = this._visibilityChanged || this._firstVisible !== l || this._lastVisible !== r;
+  }
+  _correctScrollError() {
+    if (this._scrollError) {
+      const { scrollTop: t, scrollLeft: e } = this._scrollerController, { top: i, left: l } = this._scrollError;
+      this._scrollError = null, this._scrollerController.correctScrollError({ top: t - i, left: e - l });
+    }
+  }
+  element(t) {
+    var e;
+    return t === 1 / 0 && (t = this._items.length - 1), ((e = this._items) == null ? void 0 : e[t]) === void 0 ? void 0 : { scrollIntoView: (i = {}) => this._scrollElementIntoView({ ...i, index: t }) };
+  }
+  _scrollElementIntoView(t) {
+    if (t.index >= this._first && t.index <= this._last) this._children[t.index - this._first].scrollIntoView(t);
+    else if (t.index = Math.min(t.index, this._items.length - 1), t.behavior === "smooth") {
+      const e = this._layout.getScrollIntoViewCoordinates(t), { behavior: i } = t;
+      this._updateScrollIntoViewCoordinates = this._scrollerController.managedScrollTo(Object.assign(e, { behavior: i }), () => this._layout.getScrollIntoViewCoordinates(t), () => this._scrollIntoViewTarget = null), this._scrollIntoViewTarget = t;
+    } else this._layout.pin = t;
+  }
+  _checkScrollIntoViewTarget(t) {
+    const { index: e } = this._scrollIntoViewTarget || {};
+    e && (t != null && t.has(e)) && this._updateScrollIntoViewCoordinates(this._layout.getScrollIntoViewCoordinates(this._scrollIntoViewTarget));
+  }
+  _notifyRange() {
+    this._hostElement.dispatchEvent(new C({ first: this._first, last: this._last }));
+  }
+  _notifyVisibility() {
+    this._hostElement.dispatchEvent(new E({ first: this._firstVisible, last: this._lastVisible }));
+  }
+  get layoutComplete() {
+    return this._layoutCompletePromise || (this._layoutCompletePromise = new Promise((t, e) => {
+      this._layoutCompleteResolver = t, this._layoutCompleteRejecter = e;
+    })), this._layoutCompletePromise;
+  }
+  _rejectLayoutCompletePromise(t) {
+    this._layoutCompleteRejecter !== null && this._layoutCompleteRejecter(t), this._resetLayoutCompleteState();
+  }
+  _scheduleLayoutComplete() {
+    this._layoutCompletePromise && this._pendingLayoutComplete === null && (this._pendingLayoutComplete = requestAnimationFrame(() => requestAnimationFrame(() => this._resolveLayoutCompletePromise())));
+  }
+  _resolveLayoutCompletePromise() {
+    this._layoutCompleteResolver !== null && this._layoutCompleteResolver(), this._resetLayoutCompleteState();
+  }
+  _resetLayoutCompleteState() {
+    this._layoutCompletePromise = null, this._layoutCompleteResolver = null, this._layoutCompleteRejecter = null, this._pendingLayoutComplete = null;
+  }
+  _hostElementSizeChanged() {
+    this._schedule(this._updateLayout);
+  }
+  _childLoaded() {
+  }
+  _childrenSizeChanged(t) {
+    var e;
+    if ((e = this._layout) != null && e.measureChildren) {
+      for (const i of t) this._toBeMeasured.set(i.target, i.contentRect);
+      this._measureChildren();
+    }
+    this._scheduleLayoutComplete(), this._itemsChanged = !1, this._rangeChanged = !1;
+  }
+}
+function w(s) {
+  const t = s ? parseFloat(s) : NaN;
+  return Number.isNaN(t) ? 0 : t;
+}
+function V(s) {
+  if (s.assignedSlot !== null) return s.assignedSlot;
+  if (s.parentElement !== null) return s.parentElement;
+  const t = s.parentNode;
+  return t && t.nodeType === Node.DOCUMENT_FRAGMENT_NODE && t.host || null;
+}
+const $ = (s) => s, A = (s, t) => d`${t}: ${JSON.stringify(s, null, 2)}`, Z = q(class extends G {
+  constructor(s) {
+    if (super(s), this._virtualizer = null, this._first = 0, this._last = -1, this._renderItem = (t, e) => A(t, e + this._first), this._keyFunction = (t, e) => $(t, this._first), this._items = [], s.type !== U.CHILD) throw new Error("The virtualize directive can only be used in child expressions");
+  }
+  render(s) {
+    s && this._setFunctions(s);
+    const t = [];
+    if (this._first >= 0 && this._last >= this._first) for (let e = this._first; e <= this._last; e++) t.push(this._items[e]);
+    return L(t, this._keyFunction, this._renderItem);
+  }
+  update(s, [t]) {
+    this._setFunctions(t);
+    const e = this._items !== t.items;
+    return this._items = t.items || [], this._virtualizer ? this._updateVirtualizerConfig(s, t) : this._initialize(s, t), e ? D : this.render();
+  }
+  async _updateVirtualizerConfig(s, t) {
+    if (!await this._virtualizer.updateLayoutConfig(t.layout || {})) {
+      const e = s.parentNode;
+      this._makeVirtualizer(e, t);
+    }
+    this._virtualizer.items = this._items;
+  }
+  _setFunctions(s) {
+    const { renderItem: t, keyFunction: e } = s;
+    t && (this._renderItem = (i, l) => t(i, l + this._first)), e && (this._keyFunction = (i, l) => e(i, l + this._first));
+  }
+  _makeVirtualizer(s, t) {
+    this._virtualizer && this._virtualizer.disconnected();
+    const { layout: e, scroller: i, items: l } = t;
+    this._virtualizer = new Q({ hostElement: s, layout: e, scroller: i }), this._virtualizer.items = l, this._virtualizer.connected();
+  }
+  _initialize(s, t) {
+    const e = s.parentNode;
+    e && e.nodeType === 1 && (e.addEventListener("rangeChanged", (i) => {
+      this._first = i.first, this._last = i.last, this.setValue(this.render());
+    }), this._makeVirtualizer(e, t));
+  }
+  disconnected() {
+    var s;
+    (s = this._virtualizer) == null || s.disconnected();
+  }
+  reconnected() {
+    var s;
+    (s = this._virtualizer) == null || s.connected();
+  }
+});
+class p extends W {
+  constructor() {
+    super(...arguments), this.items = [], this.renderItem = A, this.keyFunction = $, this.layout = {}, this.scroller = !1;
+  }
+  createRenderRoot() {
+    return this;
+  }
+  render() {
+    const { items: t, renderItem: e, keyFunction: i, layout: l, scroller: r } = this;
+    return d`${Z({ items: t, renderItem: e, keyFunction: i, layout: l, scroller: r })}`;
+  }
+  element(t) {
+    var e;
+    return (e = this[z]) == null ? void 0 : e.element(t);
+  }
+  get layoutComplete() {
+    var t;
+    return (t = this[z]) == null ? void 0 : t.layoutComplete;
+  }
+  scrollToIndex(t, e = "start") {
+    var i;
+    (i = this.element(t)) == null || i.scrollIntoView({ block: e });
+  }
+}
+g([f({ attribute: !1 })], p.prototype, "items", void 0), g([f()], p.prototype, "renderItem", void 0), g([f()], p.prototype, "keyFunction", void 0), g([f({ attribute: !1 })], p.prototype, "layout", void 0), g([f({ reflect: !0, type: Boolean })], p.prototype, "scroller", void 0), customElements.define("lit-virtualizer", p);
+var tt = Object.defineProperty, et = Object.getOwnPropertyDescriptor, y = (s, t, e, i) => {
+  for (var l, r = i > 1 ? void 0 : i ? et(t, e) : t, o = s.length - 1; o >= 0; o--) (l = s[o]) && (r = (i ? l(t, e, r) : l(r)) || r);
+  return i && r && tt(t, e, r), r;
+};
+let u = class extends R() {
+  constructor() {
+    super(...arguments), this.columns = [], this.data = [], this.keyField = "id", this.cols = "1fr", this.actions = [];
+  }
+  handleRowEvent(s, t) {
+    this.dispatchEvent(new CustomEvent(s, { detail: t.detail, bubbles: !0, composed: !0 }));
+  }
+  render() {
+    return d`
+			<schmancy-surface fill="all" type="container" rounded="all" elevation="2">
+				<schmancy-grid class="h-full w-full" cols="1fr" rows="auto 1fr">
+					<schmancy-surface rounded="top" elevation="1" type="containerHighest" class="sticky top-0 z-10">
+						<schmancy-grid align="center" class="px-4 py-3" .cols=${this.cols} gap="md" rows="1fr">
+							${this.columns.map((s) => d`
+									<schmancy-typography align=${s.align ?? "left"} weight=${s.weight ?? "bold"}>
+										${s.name}
+									</schmancy-typography>
+								`)}
+						</schmancy-grid>
+					</schmancy-surface>
+
+					<lit-virtualizer
+						scroller
+						class="w-full h-full relative overflow-auto"
+						.items=${this.data}
+						.renderItem=${(s, t) => d`
+								<schmancy-table-row
+									.actions=${this.actions}
+									class="w-full border-b-1 border-solid border-outlineVariant"
+									.columns=${this.columns}
+									.item=${s}
+									cols=${this.cols}
+									@edit=${(e) => {
+      e.detail.item = s, e.detail.index = t, this.handleRowEvent("edit", e);
+    }}
+									@delete=${(e) => {
+      e.detail.item = s, e.detail.index = t, this.handleRowEvent("delete", e);
+    }}
+								></schmancy-table-row>
+							`}
+					></lit-virtualizer>
+				</schmancy-grid>
+			</schmancy-surface>
+		`;
+  }
+};
+y([c({ type: Array, attribute: !1 })], u.prototype, "columns", 2), y([c({ type: Array, attribute: !1 })], u.prototype, "data", 2), y([c({ type: String })], u.prototype, "keyField", 2), y([c({ type: String })], u.prototype, "cols", 2), y([c({ type: Array })], u.prototype, "actions", 2), u = y([M("schmancy-table-v2")], u);
+export {
+  m as S,
+  u as a
+};
+//# sourceMappingURL=table-C8Lqlb9G.js.map