argus-table 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joessst-Dev and Argus Table contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# argus-table
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`<argus-table>` is a data table web component built with Lit and TanStack. It works in any framework, or none.
+
+- **Virtualized rows:** 100,000 rows scroll smoothly, and the DOM stays the same size.
+- **Pinned columns** at the start or end, which mirror in right-to-left layouts.
+- **Sorting and resizing:** by mouse or keyboard, controlled or uncontrolled.
+- **Accessible:** the WAI-ARIA grid pattern, with one tab stop and arrow-key navigation.
+- **Plain CSS styling:** `--argus-*` tokens and `::part()` names. Cell content is light DOM, so your own CSS and components work inside cells.
+
+**[Docs and live examples](https://joessst-dev.github.io/argus-table/)** · [GitHub](https://github.com/Joessst-Dev/argus-table)
+
+## Install
+
+```bash
+npm i argus-table @argus-table/themes
+```
+
+## A first table
+
+```html
+<argus-table id="orders" aria-label="Orders" style="height: 400px"></argus-table>
+
+<script type="module">
+  import 'argus-table';
+  import '@argus-table/themes/default.css';
+
+  const table = document.querySelector('#orders');
+  table.columns = [
+    { id: 'id', header: 'Order', accessor: 'id', width: 90, pin: 'start' },
+    {
+      id: 'customer',
+      header: 'Customer',
+      accessor: 'customer.name',
+      width: { flex: 1 },
+      sortable: true,
+    },
+    { id: 'total', header: 'Total', accessor: 'total', width: 110, align: 'end', sortable: true },
+  ];
+  table.data = await (await fetch('/api/orders')).json();
+  table.getRowId = (order) => order.id;
+  table.addEventListener('argus-row-click', (e) => console.log(e.detail.row));
+</script>
+```
+
+- **Height:** the table virtualizes its rows, so it needs a bounded height. Its default is 400 px.
+- **Label:** give it a name with `aria-label` or `aria-labelledby`.
+- **Columns and data** are JavaScript properties, because they hold objects and functions.
+- **Cells:** a column's `cell` function can return a string, a number, a DOM node or a Lit template.
+
+## Without a bundler
+
+The CDN build has every dependency bundled:
+
+```html
+<script
+  type="module"
+  src="https://cdn.jsdelivr.net/npm/argus-table/dist/cdn/argus-table.js"
+></script>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@argus-table/themes/dist/default.css" />
+```
+
+## Status
+
+This is v0.1, an early release. Names can still change before 1.0. Infinite loading, pinned rows, auto column widths, column reordering and framework wrappers come in v0.2. See the [roadmap](https://github.com/Joessst-Dev/argus-table/blob/main/docs/plan/plan/12-roadmap.md).
+
+MIT licensed.

package/dist/_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/decorate.js

@@ -0,0 +1,8 @@
+// \0@oxc-project+runtime@0.156.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+export { __decorate as default };

package/dist/argus-table.js

@@ -0,0 +1,517 @@
+import { controllable } from "./core/src/state/controllable.js";
+import { PinScrollController } from "./controllers/pin-scroll-controller.js";
+import { startResizeDrag } from "./controllers/resize-drag.js";
+import { TableController } from "./controllers/table-controller.js";
+import { VirtualController } from "./controllers/virtual-controller.js";
+import { CELL_CLICK, COLUMN_RESIZE, RANGE_CHANGE, ROW_CLICK, SORT_CHANGE, fire } from "./events.js";
+import { renderBody } from "./render/body.js";
+import { renderLightDom } from "./render/cells.js";
+import { renderHeader } from "./render/header.js";
+import { baseStyles } from "./styles/base.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/decorate.js";
+import { LitElement, html, nothing } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { styleMap } from "lit/directives/style-map.js";
+// src/argus-table.ts
+/**
+* The host carries the grid role, so rows rendered in the shadow root become
+* its children in the accessibility tree. ElementInternals sets the default;
+* `connectedCallback` also adds a `role` attribute, because tools such as
+* axe-core can't see the ElementInternals role. A `role` the page sets wins.
+*/
+function attachGridInternals(host) {
+	const internals = host.attachInternals();
+	internals.role = "grid";
+	return internals;
+}
+/**
+* The sortable column a header click came from, if any. Works for slotted content
+* too. Clicks on a resize handle never sort, so a click that ends a drag doesn't.
+*/
+function sortColumnOf(event) {
+	for (const target of event.composedPath()) {
+		if (!(target instanceof HTMLElement)) continue;
+		if (target.dataset.resizeCol !== void 0) return void 0;
+		if (target.dataset.sortCol !== void 0) return target.dataset.sortCol;
+		if (target.getAttribute("part") === "header-row") return void 0;
+	}
+}
+var RESIZE_STEP = 10;
+/** The grid cell or column header an element is, if any. */
+function gridCell(target) {
+	if (!(target instanceof HTMLElement) || target.dataset.col === void 0) return void 0;
+	const role = target.getAttribute("role");
+	return role === "gridcell" || role === "columnheader" ? target : void 0;
+}
+/** Row index of a rendered row element (`aria-rowindex` minus the header); `-1` for the header. */
+function rowIndexOf(row) {
+	return Number(row?.getAttribute("aria-rowindex") ?? 1) - 2;
+}
+/**
+* The pinned edge's shadow, drawn once per side over the scroller rather than
+* per row: a shadow on every pinned cell repaints on every scroll frame. It
+* covers the pinned columns and casts `--argus-pinned-shadow` onto the rest;
+* PinScrollController sizes it to the visible area.
+*/
+function pinShadow(side, width, rows, rowPx) {
+	if (width === 0) return nothing;
+	return html`<div
+    class="pin-shadow"
+    data-side=${side}
+    aria-hidden="true"
+    style=${styleMap({
+		inlineSize: `${String(width)}px`,
+		"--_content-h": `${String((rows + 1) * rowPx)}px`
+	})}
+  ></div>`;
+}
+/** CSS grid track for a column: fixed px, or a flex share with the min width as floor. */
+function track(column) {
+	return column.flex === void 0 ? `${String(column.width)}px` : `minmax(${String(column.minWidth)}px, ${String(column.flex)}fr)`;
+}
+var ArgusTable = class ArgusTable extends LitElement {
+	constructor(..._args) {
+		super(..._args);
+		this.columns = [];
+		this.data = [];
+		this.density = "comfortable";
+		this.overscan = 6;
+		this.#sorting = controllable([]);
+		this.#sizing = controllable({});
+		this.#internals = attachGridInternals(this);
+		this.#table = new TableController();
+		this.#virtual = new VirtualController(this, () => this.renderRoot.querySelector("[part~=\"table\"]"));
+		this.#pinScroll = new PinScrollController(this, () => this.renderRoot.querySelector("[part~=\"table\"]"));
+		this.#rowPx = 40;
+		this.#window = {
+			rows: [],
+			totalSize: 0,
+			range: null
+		};
+		this.#focusPending = false;
+		this.#lastRange = "";
+		this.#headerHandlers = {
+			click: (event) => {
+				const id = sortColumnOf(event);
+				if (id !== void 0) this.#requestSort(id);
+			},
+			pointerdown: (event) => {
+				if (event.button !== 0) return;
+				const handle = event.composedPath()[0];
+				if (!(handle instanceof HTMLElement)) return;
+				const id = handle.dataset.resizeCol;
+				const cell = handle.parentElement;
+				if (id === void 0 || !cell) return;
+				startResizeDrag(handle, event, cell.getBoundingClientRect().width, this.#direction(), (w) => {
+					this.#requestResize(id, w);
+				});
+			}
+		};
+		this.#onKeydown = (event) => {
+			const cell = gridCell(event.composedPath()[0] ?? event.target ?? this);
+			const id = cell?.dataset.col;
+			if (!cell || id === void 0) return;
+			if (event.key === "Tab" && event.shiftKey) {
+				const scroller = event.currentTarget;
+				scroller.tabIndex = -1;
+				cell.addEventListener("focusout", () => {
+					scroller.removeAttribute("tabindex");
+				}, { once: true });
+				return;
+			}
+			const inHeader = cell.getAttribute("role") === "columnheader";
+			const { key } = event;
+			if (inHeader && event.altKey && (key === "ArrowLeft" || key === "ArrowRight")) {
+				event.preventDefault();
+				const towardEnd = key === "ArrowRight" === (this.#direction() === 1);
+				this.#requestResize(id, this.#currentWidth(id, cell) + (towardEnd ? RESIZE_STEP : -10));
+				return;
+			}
+			if (inHeader && (key === "Enter" || key === " ") && cell.dataset.sortCol !== void 0) {
+				event.preventDefault();
+				this.#requestSort(id);
+				return;
+			}
+			if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) return;
+			if (!inHeader && key === "Enter") {
+				event.preventDefault();
+				this.#activate(event.composedPath());
+				return;
+			}
+			const model = this.#table.model;
+			const columns = model.columns;
+			let row = inHeader ? -1 : rowIndexOf(cell.parentElement);
+			let col = columns.findIndex((c) => c.id === id);
+			switch (key) {
+				case "ArrowDown":
+					row = Math.min(row + 1, model.rowCount - 1);
+					break;
+				case "ArrowUp":
+					row = Math.max(row - 1, -1);
+					break;
+				case "ArrowRight":
+					col += this.#direction();
+					break;
+				case "ArrowLeft":
+					col -= this.#direction();
+					break;
+				case "Home":
+					col = 0;
+					break;
+				case "End":
+					col = columns.length - 1;
+					break;
+				default: return;
+			}
+			event.preventDefault();
+			const target = columns[Math.min(Math.max(col, 0), columns.length - 1)];
+			if (target) this.#moveTo(row, target.id, model);
+		};
+		this.#onFocusin = (event) => {
+			const scroller = event.currentTarget;
+			if (event.composedPath()[0] === scroller) {
+				const from = event.relatedTarget;
+				if (!(from instanceof Node && scroller.contains(from))) {
+					this.#focusPending = true;
+					this.requestUpdate();
+				}
+				return;
+			}
+			for (const target of event.composedPath()) {
+				const cell = gridCell(target);
+				if (cell?.dataset.col !== void 0) {
+					const index = cell.getAttribute("role") === "columnheader" ? -1 : rowIndexOf(cell.parentElement);
+					const { col } = cell.dataset;
+					if (index !== this.#active?.index || col !== this.#active.col) {
+						this.#active = {
+							index,
+							rowId: this.#table.model.rowAt(index)?.id,
+							col
+						};
+						this.requestUpdate();
+					}
+					return;
+				}
+				if (target === event.currentTarget) return;
+			}
+		};
+		this.#onClick = (event) => {
+			this.#activate(event.composedPath());
+		};
+	}
+	static {
+		this.styles = baseStyles;
+	}
+	/**
+	* The sort order, e.g. `[{ id: 'total', desc: true }]`; `[]` when unsorted. Unset,
+	* the table keeps it itself and header clicks change it. Once set, it is
+	* controlled: a click only fires `argus-sort-change` with the proposed order,
+	* and nothing changes until you set the property. Set `undefined` to hand it back.
+	*/
+	get sorting() {
+		return this.#sorting.value;
+	}
+	set sorting(value) {
+		this.#sorting.set(value);
+	}
+	/**
+	* Resized widths in px by column id, e.g. `{ name: 240 }`. A resized flex column
+	* becomes fixed. Uncontrolled until set, like `sorting`: once set, a resize only
+	* fires `argus-column-resize` with the proposed widths. `undefined` hands it back.
+	*/
+	get columnSizing() {
+		return this.#sizing.value;
+	}
+	set columnSizing(value) {
+		this.#sizing.set(value);
+	}
+	#sorting;
+	#sizing;
+	/** A resize the table applied itself; its event fires once the update is done. */
+	#appliedResize;
+	/** A sort the table applied itself; its event fires once the update is done. */
+	#appliedSort;
+	#internals;
+	#table;
+	#virtual;
+	#pinScroll;
+	#rowPx;
+	#probeObserver;
+	#window;
+	#active;
+	/** Move focus to the active cell after the next update (keyboard navigation). */
+	#focusPending;
+	#lastRange;
+	connectedCallback() {
+		super.connectedCallback();
+		if (!this.hasAttribute("role")) this.setAttribute("role", "grid");
+		if (this.hasUpdated) this.#observeProbe();
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback();
+		this.#probeObserver?.disconnect();
+	}
+	/** Scrolls so that the row at `index` (in the current row order) is at the top. */
+	async scrollToRow(index) {
+		await this.updateComplete;
+		this.#virtual.scrollToIndex(index);
+		await this.updateComplete;
+	}
+	willUpdate(changed) {
+		if (changed.has("columns") || changed.has("data") || changed.has("getRowId") || changed.has("sorting") || changed.has("columnSizing")) this.#table.update({
+			columns: this.columns,
+			data: this.data,
+			getRowId: this.getRowId,
+			sorting: this.#sorting.value,
+			columnSizing: this.#sizing.value
+		});
+		const model = this.#table.model;
+		this.#reconcileActive(model);
+		const active = this.#active;
+		this.#internals.ariaRowCount = String(model.rowCount + 1);
+		this.#internals.ariaColCount = String(model.columns.length);
+		this.#virtual.configure({
+			count: model.rowCount,
+			rowHeight: this.#rowPx,
+			overscan: Math.max(0, this.overscan),
+			rowIdAt: (index) => model.rowAt(index)?.id ?? String(index),
+			keep: active?.rowId === void 0 ? void 0 : {
+				id: active.rowId,
+				index: active.index
+			}
+		});
+	}
+	render() {
+		const model = this.#table.model;
+		const columns = model.columns;
+		this.#window = this.#virtual.computeWindow();
+		const pinnedWidth = (side) => columns.reduce((sum, c) => c.pin === side ? sum + c.width : sum, 0);
+		const pinned = (side) => `${String(pinnedWidth(side))}px`;
+		const style = {
+			"--_cols": columns.map(track).join(" "),
+			"--_width": `${String(model.totalWidth)}px`,
+			"--_pin-start": pinned("start"),
+			"--_pin-end": pinned("end")
+		};
+		const active = this.#active;
+		const bodyActive = active && active.index >= 0 ? {
+			index: active.index,
+			col: active.col
+		} : void 0;
+		if (this.rowHeight !== void 0 && this.rowHeight > 0) style["--_row-height"] = `${String(this.rowHeight)}px`;
+		return html`<div
+        part="table"
+        role="presentation"
+        style=${styleMap(style)}
+        @keydown=${this.#onKeydown}
+        @focusin=${this.#onFocusin}
+        @click=${this.#onClick}
+      >
+        ${renderHeader(columns, this.#headerHandlers, active?.index === -1 ? active.col : void 0)}
+        ${model.rowCount === 0 ? html`<div part="empty"><slot name="empty">No rows</slot></div>` : renderBody(this.#window.rows, columns, this.#window.totalSize, bodyActive)}
+        <div class="probe" aria-hidden="true"></div>
+      </div>
+      ${pinShadow("start", pinnedWidth("start"), model.rowCount, this.#rowPx)}
+      ${pinShadow("end", pinnedWidth("end"), model.rowCount, this.#rowPx)}`;
+	}
+	firstUpdated() {
+		this.#observeProbe();
+		this.#measureRowHeight();
+	}
+	updated(changed) {
+		renderLightDom(this, this.#table.model, this.#window.rows);
+		if (changed.has("columns") || changed.has("columnSizing")) this.#pinScroll.measure();
+		if (this.#focusPending) {
+			this.#focusPending = false;
+			this.#focusActive();
+		}
+		if (changed.has("density") || changed.has("rowHeight")) this.#measureRowHeight();
+		if (this.#appliedResize) {
+			const detail = this.#appliedResize;
+			this.#appliedResize = void 0;
+			fire(this, COLUMN_RESIZE, detail);
+		}
+		if (this.#appliedSort) {
+			const sorting = this.#appliedSort;
+			this.#appliedSort = void 0;
+			fire(this, SORT_CHANGE, { sorting });
+		}
+		const { range } = this.#window;
+		const key = range ? `${String(range.start)}:${String(range.end)}` : "";
+		if (range && key !== this.#lastRange) {
+			this.#lastRange = key;
+			fire(this, RANGE_CHANGE, {
+				start: range.start,
+				end: range.end
+			});
+		}
+	}
+	#headerHandlers;
+	/**
+	* Keys on a focused cell or header. Keys from content inside a cell (an input,
+	* a button) are left to that content.
+	*/
+	#onKeydown;
+	/** Focus that lands in a cell (a click, or content inside it) makes that cell active. */
+	#onFocusin;
+	/** `argus-cell-click`, then `argus-row-click`, for clicks in the body. */
+	#onClick;
+	/**
+	* Fires `argus-cell-click` (when a cell is on the path), then `argus-row-click`,
+	* for the body row on an event path. Clicks and Enter on a body cell use it.
+	*/
+	#activate(path) {
+		let columnId;
+		for (const target of path) {
+			if (!(target instanceof HTMLElement)) continue;
+			const role = target.getAttribute("role");
+			if (role === "gridcell") columnId = target.dataset.col;
+			if (role !== "row") continue;
+			const model = this.#table.model;
+			const index = rowIndexOf(target);
+			const row = index >= 0 ? model.rowAt(index) : void 0;
+			if (!row) return;
+			if (columnId !== void 0) fire(this, CELL_CLICK, {
+				row: row.original,
+				columnId,
+				value: model.valueAt(index, columnId)
+			});
+			fire(this, ROW_CLICK, {
+				row: row.original,
+				rowId: row.id,
+				index
+			});
+			return;
+		}
+	}
+	/** Makes a cell active and focuses it after the update. The keep-rendered rule renders its row. */
+	#moveTo(index, col, model) {
+		this.#active = {
+			index,
+			rowId: index >= 0 ? model.rowAt(index)?.id : void 0,
+			col
+		};
+		this.#focusPending = true;
+		this.requestUpdate();
+	}
+	#focusActive() {
+		const active = this.#active;
+		if (!active) return;
+		const col = CSS.escape(active.col);
+		const selector = active.index === -1 ? `[part~='header-row'] > [data-col="${col}"]` : `[part~='body'] > [aria-rowindex="${String(active.index + 2)}"] > [data-col="${col}"]`;
+		const cell = this.renderRoot.querySelector(selector);
+		if (!cell) return;
+		cell.scrollIntoView({
+			block: "nearest",
+			inline: "nearest"
+		});
+		cell.focus({ preventScroll: true });
+	}
+	/**
+	* Keeps the active cell valid after columns or rows change: on the same row id
+	* when it still exists (it may have moved), else at the same index, clamped.
+	* Defaults to the first header. If its row went away while the grid had focus,
+	* focus follows to the replacement.
+	*/
+	#reconcileActive(model) {
+		const columns = model.columns;
+		const first = columns[0];
+		if (!first) {
+			this.#active = void 0;
+			return;
+		}
+		const prev = this.#active ?? {
+			index: -1,
+			rowId: void 0,
+			col: first.id
+		};
+		const col = columns.some((c) => c.id === prev.col) ? prev.col : first.id;
+		let { index, rowId } = prev;
+		if (rowId !== void 0) {
+			const found = model.indexOf(rowId);
+			if (found === void 0) {
+				index = Math.min(index, model.rowCount - 1);
+				rowId = model.rowAt(index)?.id;
+				if (this.matches(":focus-within")) this.#focusPending = true;
+			} else index = found;
+		}
+		if (index !== prev.index || rowId !== prev.rowId || col !== prev.col || !this.#active) this.#active = {
+			index,
+			rowId,
+			col
+		};
+	}
+	/**
+	* The width a resize starts from: the latest requested width (key presses can
+	* come faster than renders), else the model's fixed width, else the rendered
+	* width of a flex column.
+	*/
+	#currentWidth(columnId, cell) {
+		const sized = this.#sizing.value[columnId];
+		if (sized !== void 0) return sized;
+		const view = this.#table.model.columns.find((c) => c.id === columnId);
+		return view && view.flex === void 0 ? view.width : cell.getBoundingClientRect().width;
+	}
+	#direction() {
+		return getComputedStyle(this).direction === "rtl" ? -1 : 1;
+	}
+	/** Sets one column's width (clamped by core), through the controlled/uncontrolled rules. */
+	#requestResize(columnId, width) {
+		const next = this.#table.model.nextSizing(columnId, width);
+		const target = next?.[columnId];
+		if (!next || target === void 0 || target === this.#sizing.value[columnId]) return;
+		const old = this.#sizing.value;
+		const { value, applied } = this.#sizing.request(next);
+		const detail = {
+			columnId,
+			width: target,
+			sizing: value
+		};
+		if (applied) {
+			this.#appliedResize = detail;
+			this.requestUpdate("columnSizing", old);
+		} else fire(this, COLUMN_RESIZE, detail);
+	}
+	/** asc → desc → unsorted, through the controlled/uncontrolled rules. */
+	#requestSort(columnId) {
+		const next = this.#table.model.nextSorting(columnId);
+		if (!next) return;
+		const old = this.#sorting.value;
+		const { value, applied } = this.#sorting.request(next);
+		if (applied) {
+			this.#appliedSort = value;
+			this.requestUpdate("sorting", old);
+		} else fire(this, SORT_CHANGE, { sorting: value });
+	}
+	#observeProbe() {
+		const probe = this.renderRoot.querySelector(".probe");
+		if (!probe) return;
+		this.#probeObserver ??= new ResizeObserver(() => {
+			this.#measureRowHeight();
+		});
+		this.#probeObserver.observe(probe);
+	}
+	/** Reads the resolved row height, so themes and density change the virtualizer too. */
+	#measureRowHeight() {
+		const px = this.renderRoot.querySelector(".probe")?.getBoundingClientRect().height ?? 0;
+		if (px > 0 && Math.abs(px - this.#rowPx) > .01) {
+			this.#rowPx = px;
+			this.requestUpdate();
+		}
+	}
+};
+__decorate([property({ attribute: false })], ArgusTable.prototype, "columns", void 0);
+__decorate([property({ attribute: false })], ArgusTable.prototype, "data", void 0);
+__decorate([property({ attribute: false })], ArgusTable.prototype, "getRowId", void 0);
+__decorate([property({
+	attribute: "row-height",
+	type: Number
+})], ArgusTable.prototype, "rowHeight", void 0);
+__decorate([property({ reflect: true })], ArgusTable.prototype, "density", void 0);
+__decorate([property({ type: Number })], ArgusTable.prototype, "overscan", void 0);
+__decorate([property({ attribute: false })], ArgusTable.prototype, "sorting", null);
+__decorate([property({ attribute: false })], ArgusTable.prototype, "columnSizing", null);
+ArgusTable = __decorate([customElement("argus-table")], ArgusTable);
+export { ArgusTable };
+
+//# sourceMappingURL=argus-table.js.map