@quicdata/analytics 0.0.2 → 0.0.4

package/widgets/table.js

@@ -0,0 +1,740 @@
+var TableWidget_1;
+import { __decorate } from "tslib";
+import { LitElement, html, css, nothing } from 'lit';
+import { customElement, property, state } from 'lit/decorators.js';
+import { buildWidgetDataUrl, fetchWidgetData, fetchWidgetDefinition, } from '../core/fetch-data.js';
+import { EVENT_DASHBOARD_FILTER_CHANGE, EVENT_DASHBOARD_REFRESH, } from '../dashboard/index.js';
+import { observeViewport } from '../core/viewport-observer.js';
+import '../filters/index.js';
+/**
+ * Table widget. Fetches data from data-url (Laravel analytics API)
+ * or uses inline data, then renders an HTML table.
+ * When dashboard is set, merges dashboard params with dataParams and listens for
+ * analytics-dashboard-filter-change and analytics-dashboard-refresh.
+ */
+let TableWidget = class TableWidget extends LitElement {
+    static { TableWidget_1 = this; }
+    static { this.styles = css `
+    :host {
+      display: flex;
+      flex-direction: column;
+      width: 100%;
+      height: 100%;
+      overflow: hidden;
+    }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: var(--table-font-size, 0.875rem);
+    }
+    th,
+    td {
+      padding: 0.5rem 0.75rem;
+      text-align: left;
+      border-bottom: 1px solid #e5e7eb;
+    }
+    th[rowspan],
+    td[rowspan] {
+      vertical-align: top;
+    }
+    th {
+      font-weight: 600;
+      color: #374151;
+      background: #f9fafb;
+    }
+    tr.totals-row td {
+      font-weight: 600;
+      background: #f3f4f6;
+      border-top: 2px solid #e5e7eb;
+    }
+    tr.totals-row.totals-row-sticky td {
+      position: sticky;
+      z-index: 1;
+      box-shadow: 0 -2px 4px rgba(0, 0, 0, 0.06);
+    }
+    tr.totals-row.totals-row-sticky-bottom td {
+      bottom: 0;
+    }
+    tr.totals-row.totals-row-sticky-top td {
+      top: 0;
+    }
+    tr:hover td:not(.rowspan-placeholder) {
+      background: #f9fafb;
+    }
+    .error {
+      color: #c00;
+      padding: 0.5rem;
+      font-size: 0.875rem;
+    }
+    .loading-body {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 80px;
+      padding: 1rem;
+    }
+    .loading-overlay {
+      position: absolute;
+      inset: 0;
+      z-index: 2;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: rgba(255, 255, 255, 0.65);
+      backdrop-filter: blur(4px);
+      -webkit-backdrop-filter: blur(4px);
+      border-radius: 4px;
+    }
+    .loading-spinner {
+      width: 2rem;
+      height: 2rem;
+      border: 2px solid #e5e7eb;
+      border-top-color: #3b82f6;
+      border-radius: 50%;
+      animation: analytics-spin 0.7s linear infinite;
+    }
+    @keyframes analytics-spin {
+      to { transform: rotate(360deg); }
+    }
+    .empty {
+      padding: 0.5rem;
+      color: #6b7280;
+    }
+    td.empty-placeholder {
+      text-align: center;
+      padding: 2rem 0.75rem;
+      color: #9ca3af;
+    }
+    .widget-with-toolbar {
+      position: relative;
+      width: 100%;
+      height: 100%;
+      display: flex;
+      flex-direction: column;
+      min-height: 0;
+    }
+    .widget-with-toolbar:hover analytics-widget-toolbar {
+      opacity: 1;
+      pointer-events: auto;
+    }
+    .widget-header {
+      flex-shrink: 0;
+      padding: 0.5rem 0.75rem 0.25rem 0.75rem;
+      min-width: 0;
+    }
+    .widget-title {
+      margin: 0;
+      font-size: 0.9375rem;
+      font-weight: 600;
+      color: #374151;
+      line-height: 1.3;
+      display: -webkit-box;
+      -webkit-box-orient: vertical;
+      -webkit-line-clamp: 1;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .widget-body {
+      flex: 1;
+      min-height: 0;
+      position: relative;
+      overflow: auto;
+      box-sizing: border-box;
+    }
+  `; }
+    /** Initial delay (ms) before entering debounce; each new resize signal cancels and restarts. */
+    static { this._RESIZE_DELAY_MS = 300; }
+    /** Debounce (ms) after delay; resize runs only when no signal for this long. */
+    static { this._RESIZE_DEBOUNCE_MS = 300; }
+    constructor() {
+        super();
+        this._loadGeneration = 0;
+        this._loadDataDebounceId = null;
+        this._loadDataInFlight = false;
+        this._ignoreNextFilterChange = false;
+        this._dashboardEl = null;
+        this._hasLoadedOnce = false;
+        this._viewportUnobserve = null;
+        this._resizeObserver = null;
+        this._resizeDelayId = null;
+        this._resizeDebounceId = null;
+        this._boundOnDashboardFilterChange = (e) => {
+            const ce = e;
+            this._dashboardParams = { ...(ce.detail?.params ?? {}) };
+            this._loadData();
+        };
+        this._boundOnDashboardRefresh = () => {
+            if (this.lazy && !this._viewportVisible)
+                return;
+            this._loadData();
+        };
+        this.title = '';
+        this.dataUrl = '';
+        this.widgetId = '';
+        this.apiUrl = '';
+        this.dataParams = {};
+        this.dashboard = null;
+        this.data = null;
+        this.meta = { columns: {} };
+        this.lazy = false;
+        this.prefetchMargin = '200px';
+        this.initialDefinition = undefined;
+        this._widgetData = null;
+        this._loading = false;
+        this._error = null;
+        this._dashboardParams = {};
+        this._widgetFilters = [];
+        this._widgetFilterParams = {};
+        this._hideFilter = false;
+        this._viewportVisible = true;
+        this._definitionTitle = '';
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this._attachDashboard();
+    }
+    disconnectedCallback() {
+        this._viewportUnobserve?.();
+        this._viewportUnobserve = null;
+        if (this._loadDataDebounceId != null) {
+            clearTimeout(this._loadDataDebounceId);
+            this._loadDataDebounceId = null;
+        }
+        if (this._resizeDelayId != null) {
+            clearTimeout(this._resizeDelayId);
+            this._resizeDelayId = null;
+        }
+        if (this._resizeDebounceId != null) {
+            clearTimeout(this._resizeDebounceId);
+            this._resizeDebounceId = null;
+        }
+        this._resizeObserver?.disconnect();
+        this._resizeObserver = null;
+        this._detachDashboard();
+        super.disconnectedCallback();
+    }
+    updated(changed) {
+        if (changed.has('dashboard')) {
+            this._detachDashboard();
+            this._attachDashboard();
+        }
+        if (changed.has('widgetId') || changed.has('apiUrl')) {
+            this._widgetFilters = [];
+            this._widgetFilterParams = {};
+            this._definitionTitle = '';
+            this._ignoreNextFilterChange = true;
+        }
+        const onlyFilterState = (changed.has('_widgetFilterParams') || changed.has('_widgetFilters')) &&
+            !changed.has('dataUrl') &&
+            !changed.has('dataParams') &&
+            !changed.has('widgetId') &&
+            !changed.has('apiUrl') &&
+            !changed.has('_dashboardParams');
+        if (onlyFilterState && this._ignoreNextFilterChange) {
+            this._ignoreNextFilterChange = false;
+        }
+        else if (changed.has('dataUrl') ||
+            changed.has('dataParams') ||
+            changed.has('widgetId') ||
+            changed.has('apiUrl') ||
+            changed.has('_dashboardParams') ||
+            changed.has('_widgetFilterParams')) {
+            this._scheduleLoadData();
+        }
+        if (changed.has('lazy')) {
+            this._viewportVisible = !this.lazy;
+        }
+    }
+    _attachDashboard() {
+        const d = this.dashboard;
+        if (!d)
+            return;
+        this._dashboardEl = d;
+        this._dashboardParams = typeof d.getDashboardParams === 'function' ? d.getDashboardParams() : {};
+        d.addEventListener(EVENT_DASHBOARD_FILTER_CHANGE, this._boundOnDashboardFilterChange);
+        d.addEventListener(EVENT_DASHBOARD_REFRESH, this._boundOnDashboardRefresh);
+    }
+    _detachDashboard() {
+        const d = this._dashboardEl;
+        if (!d)
+            return;
+        d.removeEventListener(EVENT_DASHBOARD_FILTER_CHANGE, this._boundOnDashboardFilterChange);
+        d.removeEventListener(EVENT_DASHBOARD_REFRESH, this._boundOnDashboardRefresh);
+        this._dashboardEl = null;
+        this._dashboardParams = {};
+    }
+    firstUpdated() {
+        const body = this.renderRoot.querySelector('.widget-body');
+        if (body && typeof ResizeObserver !== 'undefined') {
+            this._resizeObserver = new ResizeObserver(() => {
+                if (this._resizeDelayId != null)
+                    clearTimeout(this._resizeDelayId);
+                if (this._resizeDebounceId != null)
+                    clearTimeout(this._resizeDebounceId);
+                this._resizeDelayId = setTimeout(() => {
+                    this._resizeDelayId = null;
+                    this._resizeDebounceId = setTimeout(() => {
+                        this._resizeDebounceId = null;
+                        this.requestUpdate();
+                    }, TableWidget_1._RESIZE_DEBOUNCE_MS);
+                }, TableWidget_1._RESIZE_DELAY_MS);
+            });
+            this._resizeObserver.observe(body);
+        }
+        if (this.lazy) {
+            this._viewportVisible = false;
+            this._viewportUnobserve = observeViewport(this, {
+                rootMargin: this.prefetchMargin || '200px',
+                threshold: 0,
+            }, {
+                onEnter: () => {
+                    this._viewportVisible = true;
+                    if (!this._hasLoadedOnce) {
+                        this._hasLoadedOnce = true;
+                        this._loadData();
+                    }
+                },
+                onLeave: () => {
+                    this._viewportVisible = false;
+                },
+            });
+        }
+    }
+    /** Debounce (ms) so multiple updated() calls (e.g. dataUrl then dataParams in separate ticks) result in one fetch. */
+    static { this._LOAD_DATA_DEBOUNCE_MS = 50; }
+    /** Debounce data load so multiple updated() calls (e.g. dataUrl then dataParams) result in one fetch. */
+    _scheduleLoadData() {
+        if (this._loadDataDebounceId != null) {
+            clearTimeout(this._loadDataDebounceId);
+            this._loadDataDebounceId = null;
+        }
+        this._loadDataDebounceId = setTimeout(() => {
+            this._loadDataDebounceId = null;
+            this._loadData();
+        }, TableWidget_1._LOAD_DATA_DEBOUNCE_MS);
+    }
+    _getEffectiveDataUrl() {
+        if (this.apiUrl && this.widgetId) {
+            return buildWidgetDataUrl(this.apiUrl, this.widgetId);
+        }
+        return this.dataUrl;
+    }
+    _getEffectiveParams() {
+        const dashboardParams = this._dashboardParams;
+        const widgetParams = this.dataParams ?? {};
+        let widgetFilterParams = {};
+        if (this._hideFilter) {
+            for (const f of this._widgetFilters) {
+                if (f.default_value !== undefined && f.default_value !== null) {
+                    widgetFilterParams[f.param_name] = f.default_value;
+                }
+            }
+        }
+        else if (this._widgetFilters.length > 0) {
+            for (const f of this._widgetFilters) {
+                const setByUser = f.param_name in this._widgetFilterParams;
+                widgetFilterParams[f.param_name] = setByUser
+                    ? (this._widgetFilterParams[f.param_name] ?? '')
+                    : (f.default_value ?? '');
+            }
+        }
+        else {
+            widgetFilterParams = { ...this._widgetFilterParams };
+        }
+        const out = { ...widgetFilterParams, ...widgetParams };
+        if (Object.keys(dashboardParams).length > 0) {
+            out.dashboard_params = dashboardParams;
+        }
+        return out;
+    }
+    /** Display title: optional host `title` overrides definition title from API. */
+    get _effectiveTitle() {
+        return (this.title != null && this.title !== '') ? this.title : (this._definitionTitle ?? '');
+    }
+    /** Run a callback after the current update cycle to avoid Lit "change-in-update" warning. */
+    _defer(fn) {
+        if (typeof requestAnimationFrame !== 'undefined') {
+            requestAnimationFrame(fn);
+        }
+        else {
+            setTimeout(fn, 0);
+        }
+    }
+    async _loadData() {
+        if (this.lazy && !this._viewportVisible)
+            return;
+        // Skip fetch only when using pure inline data (no dataUrl). When we have dataUrl we must refetch when params change (e.g. report filters).
+        if (this.data != null && !this.dataUrl) {
+            this._error = null;
+            this._loading = false;
+            return;
+        }
+        const dataUrl = this._getEffectiveDataUrl();
+        if (!dataUrl) {
+            this._error = null;
+            this._loading = false;
+            return;
+        }
+        if (this._loadDataInFlight) {
+            return;
+        }
+        const gen = ++this._loadGeneration;
+        this._loadDataInFlight = true;
+        this._loading = true;
+        this._error = null;
+        try {
+            const useWidgetApi = Boolean(this.apiUrl && this.widgetId);
+            if (useWidgetApi) {
+                let params;
+                if (this._widgetFilters.length === 0) {
+                    const def = this.initialDefinition ?? (await fetchWidgetDefinition(this.apiUrl, this.widgetId));
+                    this._definitionTitle = def.title ?? '';
+                    this._widgetFilters = def.filters ?? [];
+                    this._hideFilter = def.hide_filter ?? false;
+                    const defaultParams = {};
+                    for (const f of (def.filters ?? [])) {
+                        if (f.default_value !== undefined && f.default_value !== null) {
+                            defaultParams[f.param_name] = f.default_value;
+                        }
+                    }
+                    this._widgetFilterParams = { ...defaultParams, ...this._widgetFilterParams };
+                    this._ignoreNextFilterChange = true;
+                    params = { ...defaultParams, ...(this.dataParams ?? {}) };
+                    if (Object.keys(this._dashboardParams).length > 0) {
+                        params.dashboard_params = this._dashboardParams;
+                    }
+                }
+                else {
+                    params = this._getEffectiveParams();
+                }
+                const res = await fetchWidgetData(dataUrl, params);
+                if (gen !== this._loadGeneration)
+                    return;
+                const data = res.data ?? [];
+                const meta = res.meta ?? { columns: {} };
+                const wd = res.widgetData;
+                const widgetData = wd && wd.chartType === 'Table'
+                    ? {
+                        chartType: 'Table',
+                        columns: wd.columns ?? [],
+                        columnDefs: wd.columnDefs,
+                        header_rows: wd.header_rows,
+                        rows: wd.rows ?? res.data ?? [],
+                        rowSpanRuns: wd.rowSpanRuns,
+                        font_size: wd.font_size,
+                        totals_sticky: wd.totals_sticky,
+                        totals_position: wd.totals_position,
+                    }
+                    : null;
+                const filters = res.filters;
+                const hideFilter = res.hide_filter;
+                this._defer(() => {
+                    if (gen !== this._loadGeneration)
+                        return;
+                    this._loadDataInFlight = false;
+                    this.data = data;
+                    this.meta = meta;
+                    this._widgetData = widgetData;
+                    if (filters?.length)
+                        this._widgetFilters = filters;
+                    else if (hideFilter !== true)
+                        this._widgetFilters = [];
+                    if (hideFilter !== undefined)
+                        this._hideFilter = hideFilter;
+                    this._loading = false;
+                });
+            }
+            else {
+                const params = this._getEffectiveParams();
+                const res = await fetchWidgetData(dataUrl, params);
+                if (gen !== this._loadGeneration)
+                    return;
+                const data = res.data ?? [];
+                const meta = res.meta ?? { columns: {} };
+                const wd = res.widgetData;
+                const widgetData = wd && wd.chartType === 'Table'
+                    ? {
+                        chartType: 'Table',
+                        columns: wd.columns ?? [],
+                        columnDefs: wd.columnDefs,
+                        header_rows: wd.header_rows,
+                        rows: wd.rows ?? res.data ?? [],
+                        rowSpanRuns: wd.rowSpanRuns,
+                        font_size: wd.font_size,
+                        totals_sticky: wd.totals_sticky,
+                        totals_position: wd.totals_position,
+                    }
+                    : null;
+                const filters = res.filters;
+                const hideFilter = res.hide_filter;
+                this._defer(() => {
+                    if (gen !== this._loadGeneration)
+                        return;
+                    this._loadDataInFlight = false;
+                    this.data = data;
+                    this.meta = meta;
+                    this._widgetData = widgetData;
+                    if (filters?.length)
+                        this._widgetFilters = filters;
+                    else if (hideFilter !== true)
+                        this._widgetFilters = [];
+                    if (hideFilter !== undefined)
+                        this._hideFilter = hideFilter;
+                    this._loading = false;
+                });
+            }
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            this._defer(() => {
+                if (gen !== this._loadGeneration)
+                    return;
+                this._loadDataInFlight = false;
+                this._error = errMsg;
+                this.data = [];
+                this._widgetData = null;
+                this._loading = false;
+            });
+        }
+    }
+    _onWidgetFilterChange(e) {
+        this._widgetFilterParams = { ...(e.detail?.params ?? {}) };
+    }
+    /** Column keys in display order. From widgetData when present, else derived from data/meta. */
+    _getColumns() {
+        const wd = this._widgetData;
+        if (wd?.columns?.length)
+            return wd.columns;
+        const rows = this.data ?? [];
+        const metaKeys = Object.keys(this.meta?.columns ?? {});
+        if (rows.length > 0)
+            return Object.keys(rows[0]);
+        return metaKeys.length > 0 ? metaKeys : [];
+    }
+    /** Body rows. From widgetData.rows when present, else from data. */
+    _getRows() {
+        const wd = this._widgetData;
+        if (wd?.rows?.length !== undefined && wd.rows.length >= 0)
+            return wd.rows;
+        return this.data ?? [];
+    }
+    /** Header label for column key. From widgetData.columnDefs or header_rows when present. */
+    _getColumnLabel(colKey) {
+        const wd = this._widgetData;
+        if (wd?.columnDefs?.length) {
+            const def = wd.columnDefs.find((c) => c.key === colKey);
+            if (def)
+                return def.label;
+        }
+        return colKey;
+    }
+    /** Text-align for column. From widgetData.columnDefs when present. */
+    _getColumnAlign(colKey) {
+        const wd = this._widgetData;
+        if (wd?.columnDefs?.length) {
+            const def = wd.columnDefs.find((c) => c.key === colKey);
+            if (def?.align)
+                return def.align;
+        }
+        return null;
+    }
+    /** Rowspan for this cell (column, rowIndex). 0 = merged (skip rendering cell). */
+    _getCellRowSpan(colKey, rowIndex) {
+        const wd = this._widgetData;
+        const runs = wd?.rowSpanRuns?.[colKey];
+        if (!runs || rowIndex >= runs.length)
+            return 1;
+        return runs[rowIndex] ?? 1;
+    }
+    _isTotalsRow(row) {
+        return Boolean(row['_is_totals_row']);
+    }
+    render() {
+        const hasWidgetFilters = this._widgetFilters.length > 0 && !this._hideFilter;
+        const widgetActiveCount = Object.keys(this._widgetFilterParams).filter((k) => this._widgetFilterParams[k] !== '' && this._widgetFilterParams[k] != null).length;
+        const rows = this._getRows();
+        const columns = this._getColumns();
+        const wd = this._widgetData;
+        const hasHeaderRows = Boolean(wd?.header_rows?.length);
+        const tableFontSizeStyle = wd?.font_size ? `font-size: ${wd.font_size}` : nothing;
+        const filterToolbar = hasWidgetFilters
+            ? html `
+          <analytics-widget-toolbar
+            .filters=${this._widgetFilters}
+            .values=${this._widgetFilterParams}
+            .activeCount=${widgetActiveCount}
+            @analytics-filter-change=${this._onWidgetFilterChange}
+          ></analytics-widget-toolbar>
+        `
+            : html ``;
+        const bodyContent = this._error
+            ? html `<div class="error">${this._error}</div>`
+            : columns.length === 0
+                ? html `<div class="empty">No columns</div>`
+                : rows.length === 0
+                    ? html `
+                <table style=${tableFontSizeStyle}>
+                  <thead>
+                    ${this._renderThead(columns, hasHeaderRows)}
+                  </thead>
+                  <tbody>
+                    <tr>
+                      <td colspan=${columns.length} class="empty-placeholder">No data</td>
+                    </tr>
+                  </tbody>
+                </table>
+              `
+                    : html `
+                <table style=${tableFontSizeStyle}>
+                  <thead>
+                    ${this._renderThead(columns, hasHeaderRows)}
+                  </thead>
+                  <tbody>
+                    ${rows.map((row, rowIndex) => this._renderBodyRow(row, rowIndex, columns))}
+                  </tbody>
+                </table>
+              `;
+        return html `
+      <div class="widget-with-toolbar">
+        ${this._effectiveTitle
+            ? html `<header class="widget-header"><h2 class="widget-title">${this._effectiveTitle}</h2></header>`
+            : ''}
+        <div class="widget-body">
+          ${bodyContent}
+          ${this._loading
+            ? html `<div class="loading-overlay" aria-busy="true" aria-live="polite">
+                <div class="loading-spinner" aria-hidden="true"></div>
+              </div>`
+            : nothing}
+        </div>
+        ${filterToolbar}
+      </div>
+    `;
+    }
+    _renderThead(columns, useHeaderRows) {
+        const wd = this._widgetData;
+        if (useHeaderRows && wd?.header_rows?.length) {
+            return html `${wd.header_rows.map((headerRow) => html `
+          <tr>
+            ${headerRow.map((cell) => {
+                if (cell.hide)
+                    return null;
+                return html `<th
+                colspan=${cell.colspan != null && cell.colspan > 1 ? cell.colspan : nothing}
+                rowspan=${cell.rowspan != null && cell.rowspan > 1 ? cell.rowspan : nothing}
+              >${cell.label}</th>`;
+            })}
+          </tr>
+        `)}`;
+        }
+        return html `
+      <tr>
+        ${columns.map((col) => {
+            const align = this._getColumnAlign(col);
+            const style = align ? `text-align: ${align}` : undefined;
+            return html `<th style=${style ?? nothing}>${this._getColumnLabel(col)}</th>`;
+        })}
+      </tr>
+    `;
+    }
+    _renderBodyRow(row, rowIndex, columns) {
+        const isTotals = this._isTotalsRow(row);
+        const wd = this._widgetData;
+        const sticky = Boolean(isTotals && wd?.totals_sticky);
+        const stickyClass = sticky
+            ? wd?.totals_position === 'top'
+                ? 'totals-row-sticky totals-row-sticky-top'
+                : 'totals-row-sticky totals-row-sticky-bottom'
+            : '';
+        const totalsLabel = isTotals && row['_totals_label'] != null ? String(row['_totals_label']) : null;
+        return html `
+      <tr class=${isTotals ? `totals-row ${stickyClass}` : ''}>
+        ${columns.map((col, colIndex) => {
+            const rowSpan = this._getCellRowSpan(col, rowIndex);
+            if (rowSpan === 0)
+                return null;
+            const displayValue = colIndex === 0 && totalsLabel != null ? totalsLabel : row[col];
+            const align = this._getColumnAlign(col);
+            const style = align ? `text-align: ${align}` : undefined;
+            const cellContent = this._formatCell(displayValue, col);
+            return html `<td
+            style=${style ?? nothing}
+            rowspan=${rowSpan > 1 ? rowSpan : nothing}
+            class=${rowSpan === 0 ? 'rowspan-placeholder' : ''}
+          >${cellContent}</td>`;
+        })}
+      </tr>
+    `;
+    }
+    _formatCell(value, _col) {
+        if (value == null)
+            return '';
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return value;
+    }
+};
+__decorate([
+    property({ type: String })
+], TableWidget.prototype, "title", void 0);
+__decorate([
+    property({ type: String, attribute: 'data-url' })
+], TableWidget.prototype, "dataUrl", void 0);
+__decorate([
+    property({ type: String, attribute: 'widget-id' })
+], TableWidget.prototype, "widgetId", void 0);
+__decorate([
+    property({ type: String, attribute: 'api-url' })
+], TableWidget.prototype, "apiUrl", void 0);
+__decorate([
+    property({ type: Object })
+], TableWidget.prototype, "dataParams", void 0);
+__decorate([
+    property({ type: Object })
+], TableWidget.prototype, "dashboard", void 0);
+__decorate([
+    property({ type: Object })
+], TableWidget.prototype, "data", void 0);
+__decorate([
+    property({ type: Object })
+], TableWidget.prototype, "meta", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_widgetData", void 0);
+__decorate([
+    property({ type: Boolean })
+], TableWidget.prototype, "lazy", void 0);
+__decorate([
+    property({ type: String, attribute: 'prefetch-margin' })
+], TableWidget.prototype, "prefetchMargin", void 0);
+__decorate([
+    property({ type: Object })
+], TableWidget.prototype, "initialDefinition", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_loading", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_error", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_dashboardParams", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_widgetFilters", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_widgetFilterParams", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_hideFilter", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_viewportVisible", void 0);
+__decorate([
+    state()
+], TableWidget.prototype, "_definitionTitle", void 0);
+TableWidget = TableWidget_1 = __decorate([
+    customElement('analytics-table')
+], TableWidget);
+export { TableWidget };