@xplortech/insights-elements 0.0.1-draft.7729525

package/dist/components/insights-wrapper.js

@@ -0,0 +1,1123 @@
+import { p as proxyCustomElement, H, h as h$1 } from './p-DFvs3VMW.js';
+import { g as getConfiguration } from './p-CSTD3N9t.js';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var browserPonyfill = {exports: {}};
+
+var hasRequiredBrowserPonyfill;
+
+function requireBrowserPonyfill () {
+	if (hasRequiredBrowserPonyfill) return browserPonyfill.exports;
+	hasRequiredBrowserPonyfill = 1;
+	(function (module, exports) {
+		// Save global object in a variable
+		var __global__ =
+		(typeof globalThis !== 'undefined' && globalThis) ||
+		(typeof self !== 'undefined' && self) ||
+		(typeof commonjsGlobal !== 'undefined' && commonjsGlobal);
+		// Create an object that extends from __global__ without the fetch function
+		var __globalThis__ = (function () {
+		function F() {
+		this.fetch = false;
+		this.DOMException = __global__.DOMException;
+		}
+		F.prototype = __global__; // Needed for feature detection on whatwg-fetch's code
+		return new F();
+		})();
+		// Wraps whatwg-fetch with a function scope to hijack the global object
+		// "globalThis" that's going to be patched
+		(function(globalThis) {
+
+		((function (exports) {
+
+		  /* eslint-disable no-prototype-builtins */
+		  var g =
+		    (typeof globalThis !== 'undefined' && globalThis) ||
+		    (typeof self !== 'undefined' && self) ||
+		    // eslint-disable-next-line no-undef
+		    (typeof commonjsGlobal !== 'undefined' && commonjsGlobal) ||
+		    {};
+
+		  var support = {
+		    searchParams: 'URLSearchParams' in g,
+		    iterable: 'Symbol' in g && 'iterator' in Symbol,
+		    blob:
+		      'FileReader' in g &&
+		      'Blob' in g &&
+		      (function() {
+		        try {
+		          new Blob();
+		          return true
+		        } catch (e) {
+		          return false
+		        }
+		      })(),
+		    formData: 'FormData' in g,
+		    arrayBuffer: 'ArrayBuffer' in g
+		  };
+
+		  function isDataView(obj) {
+		    return obj && DataView.prototype.isPrototypeOf(obj)
+		  }
+
+		  if (support.arrayBuffer) {
+		    var viewClasses = [
+		      '[object Int8Array]',
+		      '[object Uint8Array]',
+		      '[object Uint8ClampedArray]',
+		      '[object Int16Array]',
+		      '[object Uint16Array]',
+		      '[object Int32Array]',
+		      '[object Uint32Array]',
+		      '[object Float32Array]',
+		      '[object Float64Array]'
+		    ];
+
+		    var isArrayBufferView =
+		      ArrayBuffer.isView ||
+		      function(obj) {
+		        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+		      };
+		  }
+
+		  function normalizeName(name) {
+		    if (typeof name !== 'string') {
+		      name = String(name);
+		    }
+		    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+		      throw new TypeError('Invalid character in header field name: "' + name + '"')
+		    }
+		    return name.toLowerCase()
+		  }
+
+		  function normalizeValue(value) {
+		    if (typeof value !== 'string') {
+		      value = String(value);
+		    }
+		    return value
+		  }
+
+		  // Build a destructive iterator for the value list
+		  function iteratorFor(items) {
+		    var iterator = {
+		      next: function() {
+		        var value = items.shift();
+		        return {done: value === undefined, value: value}
+		      }
+		    };
+
+		    if (support.iterable) {
+		      iterator[Symbol.iterator] = function() {
+		        return iterator
+		      };
+		    }
+
+		    return iterator
+		  }
+
+		  function Headers(headers) {
+		    this.map = {};
+
+		    if (headers instanceof Headers) {
+		      headers.forEach(function(value, name) {
+		        this.append(name, value);
+		      }, this);
+		    } else if (Array.isArray(headers)) {
+		      headers.forEach(function(header) {
+		        if (header.length != 2) {
+		          throw new TypeError('Headers constructor: expected name/value pair to be length 2, found' + header.length)
+		        }
+		        this.append(header[0], header[1]);
+		      }, this);
+		    } else if (headers) {
+		      Object.getOwnPropertyNames(headers).forEach(function(name) {
+		        this.append(name, headers[name]);
+		      }, this);
+		    }
+		  }
+
+		  Headers.prototype.append = function(name, value) {
+		    name = normalizeName(name);
+		    value = normalizeValue(value);
+		    var oldValue = this.map[name];
+		    this.map[name] = oldValue ? oldValue + ', ' + value : value;
+		  };
+
+		  Headers.prototype['delete'] = function(name) {
+		    delete this.map[normalizeName(name)];
+		  };
+
+		  Headers.prototype.get = function(name) {
+		    name = normalizeName(name);
+		    return this.has(name) ? this.map[name] : null
+		  };
+
+		  Headers.prototype.has = function(name) {
+		    return this.map.hasOwnProperty(normalizeName(name))
+		  };
+
+		  Headers.prototype.set = function(name, value) {
+		    this.map[normalizeName(name)] = normalizeValue(value);
+		  };
+
+		  Headers.prototype.forEach = function(callback, thisArg) {
+		    for (var name in this.map) {
+		      if (this.map.hasOwnProperty(name)) {
+		        callback.call(thisArg, this.map[name], name, this);
+		      }
+		    }
+		  };
+
+		  Headers.prototype.keys = function() {
+		    var items = [];
+		    this.forEach(function(value, name) {
+		      items.push(name);
+		    });
+		    return iteratorFor(items)
+		  };
+
+		  Headers.prototype.values = function() {
+		    var items = [];
+		    this.forEach(function(value) {
+		      items.push(value);
+		    });
+		    return iteratorFor(items)
+		  };
+
+		  Headers.prototype.entries = function() {
+		    var items = [];
+		    this.forEach(function(value, name) {
+		      items.push([name, value]);
+		    });
+		    return iteratorFor(items)
+		  };
+
+		  if (support.iterable) {
+		    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+		  }
+
+		  function consumed(body) {
+		    if (body._noBody) return
+		    if (body.bodyUsed) {
+		      return Promise.reject(new TypeError('Already read'))
+		    }
+		    body.bodyUsed = true;
+		  }
+
+		  function fileReaderReady(reader) {
+		    return new Promise(function(resolve, reject) {
+		      reader.onload = function() {
+		        resolve(reader.result);
+		      };
+		      reader.onerror = function() {
+		        reject(reader.error);
+		      };
+		    })
+		  }
+
+		  function readBlobAsArrayBuffer(blob) {
+		    var reader = new FileReader();
+		    var promise = fileReaderReady(reader);
+		    reader.readAsArrayBuffer(blob);
+		    return promise
+		  }
+
+		  function readBlobAsText(blob) {
+		    var reader = new FileReader();
+		    var promise = fileReaderReady(reader);
+		    var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+		    var encoding = match ? match[1] : 'utf-8';
+		    reader.readAsText(blob, encoding);
+		    return promise
+		  }
+
+		  function readArrayBufferAsText(buf) {
+		    var view = new Uint8Array(buf);
+		    var chars = new Array(view.length);
+
+		    for (var i = 0; i < view.length; i++) {
+		      chars[i] = String.fromCharCode(view[i]);
+		    }
+		    return chars.join('')
+		  }
+
+		  function bufferClone(buf) {
+		    if (buf.slice) {
+		      return buf.slice(0)
+		    } else {
+		      var view = new Uint8Array(buf.byteLength);
+		      view.set(new Uint8Array(buf));
+		      return view.buffer
+		    }
+		  }
+
+		  function Body() {
+		    this.bodyUsed = false;
+
+		    this._initBody = function(body) {
+		      /*
+		        fetch-mock wraps the Response object in an ES6 Proxy to
+		        provide useful test harness features such as flush. However, on
+		        ES5 browsers without fetch or Proxy support pollyfills must be used;
+		        the proxy-pollyfill is unable to proxy an attribute unless it exists
+		        on the object before the Proxy is created. This change ensures
+		        Response.bodyUsed exists on the instance, while maintaining the
+		        semantic of setting Request.bodyUsed in the constructor before
+		        _initBody is called.
+		      */
+		      // eslint-disable-next-line no-self-assign
+		      this.bodyUsed = this.bodyUsed;
+		      this._bodyInit = body;
+		      if (!body) {
+		        this._noBody = true;
+		        this._bodyText = '';
+		      } else if (typeof body === 'string') {
+		        this._bodyText = body;
+		      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+		        this._bodyBlob = body;
+		      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+		        this._bodyFormData = body;
+		      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+		        this._bodyText = body.toString();
+		      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+		        this._bodyArrayBuffer = bufferClone(body.buffer);
+		        // IE 10-11 can't handle a DataView body.
+		        this._bodyInit = new Blob([this._bodyArrayBuffer]);
+		      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+		        this._bodyArrayBuffer = bufferClone(body);
+		      } else {
+		        this._bodyText = body = Object.prototype.toString.call(body);
+		      }
+
+		      if (!this.headers.get('content-type')) {
+		        if (typeof body === 'string') {
+		          this.headers.set('content-type', 'text/plain;charset=UTF-8');
+		        } else if (this._bodyBlob && this._bodyBlob.type) {
+		          this.headers.set('content-type', this._bodyBlob.type);
+		        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+		          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+		        }
+		      }
+		    };
+
+		    if (support.blob) {
+		      this.blob = function() {
+		        var rejected = consumed(this);
+		        if (rejected) {
+		          return rejected
+		        }
+
+		        if (this._bodyBlob) {
+		          return Promise.resolve(this._bodyBlob)
+		        } else if (this._bodyArrayBuffer) {
+		          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+		        } else if (this._bodyFormData) {
+		          throw new Error('could not read FormData body as blob')
+		        } else {
+		          return Promise.resolve(new Blob([this._bodyText]))
+		        }
+		      };
+		    }
+
+		    this.arrayBuffer = function() {
+		      if (this._bodyArrayBuffer) {
+		        var isConsumed = consumed(this);
+		        if (isConsumed) {
+		          return isConsumed
+		        } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+		          return Promise.resolve(
+		            this._bodyArrayBuffer.buffer.slice(
+		              this._bodyArrayBuffer.byteOffset,
+		              this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+		            )
+		          )
+		        } else {
+		          return Promise.resolve(this._bodyArrayBuffer)
+		        }
+		      } else if (support.blob) {
+		        return this.blob().then(readBlobAsArrayBuffer)
+		      } else {
+		        throw new Error('could not read as ArrayBuffer')
+		      }
+		    };
+
+		    this.text = function() {
+		      var rejected = consumed(this);
+		      if (rejected) {
+		        return rejected
+		      }
+
+		      if (this._bodyBlob) {
+		        return readBlobAsText(this._bodyBlob)
+		      } else if (this._bodyArrayBuffer) {
+		        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+		      } else if (this._bodyFormData) {
+		        throw new Error('could not read FormData body as text')
+		      } else {
+		        return Promise.resolve(this._bodyText)
+		      }
+		    };
+
+		    if (support.formData) {
+		      this.formData = function() {
+		        return this.text().then(decode)
+		      };
+		    }
+
+		    this.json = function() {
+		      return this.text().then(JSON.parse)
+		    };
+
+		    return this
+		  }
+
+		  // HTTP methods whose capitalization should be normalized
+		  var methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE'];
+
+		  function normalizeMethod(method) {
+		    var upcased = method.toUpperCase();
+		    return methods.indexOf(upcased) > -1 ? upcased : method
+		  }
+
+		  function Request(input, options) {
+		    if (!(this instanceof Request)) {
+		      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+		    }
+
+		    options = options || {};
+		    var body = options.body;
+
+		    if (input instanceof Request) {
+		      if (input.bodyUsed) {
+		        throw new TypeError('Already read')
+		      }
+		      this.url = input.url;
+		      this.credentials = input.credentials;
+		      if (!options.headers) {
+		        this.headers = new Headers(input.headers);
+		      }
+		      this.method = input.method;
+		      this.mode = input.mode;
+		      this.signal = input.signal;
+		      if (!body && input._bodyInit != null) {
+		        body = input._bodyInit;
+		        input.bodyUsed = true;
+		      }
+		    } else {
+		      this.url = String(input);
+		    }
+
+		    this.credentials = options.credentials || this.credentials || 'same-origin';
+		    if (options.headers || !this.headers) {
+		      this.headers = new Headers(options.headers);
+		    }
+		    this.method = normalizeMethod(options.method || this.method || 'GET');
+		    this.mode = options.mode || this.mode || null;
+		    this.signal = options.signal || this.signal || (function () {
+		      if ('AbortController' in g) {
+		        var ctrl = new AbortController();
+		        return ctrl.signal;
+		      }
+		    }());
+		    this.referrer = null;
+
+		    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+		      throw new TypeError('Body not allowed for GET or HEAD requests')
+		    }
+		    this._initBody(body);
+
+		    if (this.method === 'GET' || this.method === 'HEAD') {
+		      if (options.cache === 'no-store' || options.cache === 'no-cache') {
+		        // Search for a '_' parameter in the query string
+		        var reParamSearch = /([?&])_=[^&]*/;
+		        if (reParamSearch.test(this.url)) {
+		          // If it already exists then set the value with the current time
+		          this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+		        } else {
+		          // Otherwise add a new '_' parameter to the end with the current time
+		          var reQueryString = /\?/;
+		          this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+		        }
+		      }
+		    }
+		  }
+
+		  Request.prototype.clone = function() {
+		    return new Request(this, {body: this._bodyInit})
+		  };
+
+		  function decode(body) {
+		    var form = new FormData();
+		    body
+		      .trim()
+		      .split('&')
+		      .forEach(function(bytes) {
+		        if (bytes) {
+		          var split = bytes.split('=');
+		          var name = split.shift().replace(/\+/g, ' ');
+		          var value = split.join('=').replace(/\+/g, ' ');
+		          form.append(decodeURIComponent(name), decodeURIComponent(value));
+		        }
+		      });
+		    return form
+		  }
+
+		  function parseHeaders(rawHeaders) {
+		    var headers = new Headers();
+		    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+		    // https://tools.ietf.org/html/rfc7230#section-3.2
+		    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+		    // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
+		    // https://github.com/github/fetch/issues/748
+		    // https://github.com/zloirock/core-js/issues/751
+		    preProcessedHeaders
+		      .split('\r')
+		      .map(function(header) {
+		        return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
+		      })
+		      .forEach(function(line) {
+		        var parts = line.split(':');
+		        var key = parts.shift().trim();
+		        if (key) {
+		          var value = parts.join(':').trim();
+		          try {
+		            headers.append(key, value);
+		          } catch (error) {
+		            console.warn('Response ' + error.message);
+		          }
+		        }
+		      });
+		    return headers
+		  }
+
+		  Body.call(Request.prototype);
+
+		  function Response(bodyInit, options) {
+		    if (!(this instanceof Response)) {
+		      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+		    }
+		    if (!options) {
+		      options = {};
+		    }
+
+		    this.type = 'default';
+		    this.status = options.status === undefined ? 200 : options.status;
+		    if (this.status < 200 || this.status > 599) {
+		      throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].")
+		    }
+		    this.ok = this.status >= 200 && this.status < 300;
+		    this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
+		    this.headers = new Headers(options.headers);
+		    this.url = options.url || '';
+		    this._initBody(bodyInit);
+		  }
+
+		  Body.call(Response.prototype);
+
+		  Response.prototype.clone = function() {
+		    return new Response(this._bodyInit, {
+		      status: this.status,
+		      statusText: this.statusText,
+		      headers: new Headers(this.headers),
+		      url: this.url
+		    })
+		  };
+
+		  Response.error = function() {
+		    var response = new Response(null, {status: 200, statusText: ''});
+		    response.ok = false;
+		    response.status = 0;
+		    response.type = 'error';
+		    return response
+		  };
+
+		  var redirectStatuses = [301, 302, 303, 307, 308];
+
+		  Response.redirect = function(url, status) {
+		    if (redirectStatuses.indexOf(status) === -1) {
+		      throw new RangeError('Invalid status code')
+		    }
+
+		    return new Response(null, {status: status, headers: {location: url}})
+		  };
+
+		  exports.DOMException = g.DOMException;
+		  try {
+		    new exports.DOMException();
+		  } catch (err) {
+		    exports.DOMException = function(message, name) {
+		      this.message = message;
+		      this.name = name;
+		      var error = Error(message);
+		      this.stack = error.stack;
+		    };
+		    exports.DOMException.prototype = Object.create(Error.prototype);
+		    exports.DOMException.prototype.constructor = exports.DOMException;
+		  }
+
+		  function fetch(input, init) {
+		    return new Promise(function(resolve, reject) {
+		      var request = new Request(input, init);
+
+		      if (request.signal && request.signal.aborted) {
+		        return reject(new exports.DOMException('Aborted', 'AbortError'))
+		      }
+
+		      var xhr = new XMLHttpRequest();
+
+		      function abortXhr() {
+		        xhr.abort();
+		      }
+
+		      xhr.onload = function() {
+		        var options = {
+		          statusText: xhr.statusText,
+		          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+		        };
+		        // This check if specifically for when a user fetches a file locally from the file system
+		        // Only if the status is out of a normal range
+		        if (request.url.indexOf('file://') === 0 && (xhr.status < 200 || xhr.status > 599)) {
+		          options.status = 200;
+		        } else {
+		          options.status = xhr.status;
+		        }
+		        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+		        var body = 'response' in xhr ? xhr.response : xhr.responseText;
+		        setTimeout(function() {
+		          resolve(new Response(body, options));
+		        }, 0);
+		      };
+
+		      xhr.onerror = function() {
+		        setTimeout(function() {
+		          reject(new TypeError('Network request failed'));
+		        }, 0);
+		      };
+
+		      xhr.ontimeout = function() {
+		        setTimeout(function() {
+		          reject(new TypeError('Network request timed out'));
+		        }, 0);
+		      };
+
+		      xhr.onabort = function() {
+		        setTimeout(function() {
+		          reject(new exports.DOMException('Aborted', 'AbortError'));
+		        }, 0);
+		      };
+
+		      function fixUrl(url) {
+		        try {
+		          return url === '' && g.location.href ? g.location.href : url
+		        } catch (e) {
+		          return url
+		        }
+		      }
+
+		      xhr.open(request.method, fixUrl(request.url), true);
+
+		      if (request.credentials === 'include') {
+		        xhr.withCredentials = true;
+		      } else if (request.credentials === 'omit') {
+		        xhr.withCredentials = false;
+		      }
+
+		      if ('responseType' in xhr) {
+		        if (support.blob) {
+		          xhr.responseType = 'blob';
+		        } else if (
+		          support.arrayBuffer
+		        ) {
+		          xhr.responseType = 'arraybuffer';
+		        }
+		      }
+
+		      if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers || (g.Headers && init.headers instanceof g.Headers))) {
+		        var names = [];
+		        Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+		          names.push(normalizeName(name));
+		          xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+		        });
+		        request.headers.forEach(function(value, name) {
+		          if (names.indexOf(name) === -1) {
+		            xhr.setRequestHeader(name, value);
+		          }
+		        });
+		      } else {
+		        request.headers.forEach(function(value, name) {
+		          xhr.setRequestHeader(name, value);
+		        });
+		      }
+
+		      if (request.signal) {
+		        request.signal.addEventListener('abort', abortXhr);
+
+		        xhr.onreadystatechange = function() {
+		          // DONE (success or failure)
+		          if (xhr.readyState === 4) {
+		            request.signal.removeEventListener('abort', abortXhr);
+		          }
+		        };
+		      }
+
+		      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+		    })
+		  }
+
+		  fetch.polyfill = true;
+
+		  if (!g.fetch) {
+		    g.fetch = fetch;
+		    g.Headers = Headers;
+		    g.Request = Request;
+		    g.Response = Response;
+		  }
+
+		  exports.Headers = Headers;
+		  exports.Request = Request;
+		  exports.Response = Response;
+		  exports.fetch = fetch;
+
+		  return exports;
+
+		}))({});
+		})(__globalThis__);
+		// This is a ponyfill, so...
+		__globalThis__.fetch.ponyfill = true;
+		delete __globalThis__.fetch.polyfill;
+		// Choose between native implementation (__global__) or custom implementation (__globalThis__)
+		var ctx = __global__.fetch ? __global__ : __globalThis__;
+		exports = ctx.fetch; // To enable: import fetch from 'cross-fetch'
+		exports.default = ctx.fetch; // For TypeScript consumers without esModuleInterop.
+		exports.fetch = ctx.fetch; // To enable: import {fetch} from 'cross-fetch'
+		exports.Headers = ctx.Headers;
+		exports.Request = ctx.Request;
+		exports.Response = ctx.Response;
+		module.exports = exports; 
+	} (browserPonyfill, browserPonyfill.exports));
+	return browserPonyfill.exports;
+}
+
+var browserPonyfillExports = requireBrowserPonyfill();
+var h = /*@__PURE__*/getDefaultExportFromCjs(browserPonyfillExports);
+
+class c {
+  /**
+   * Create a ResultSet
+   * @param {object} data - Raw data from API response
+   */
+  constructor(e) {
+    this.rawData = e;
+  }
+  /**
+   * Get all data rows as an array
+   * @returns {Array<object>} Array of data rows
+   */
+  getData() {
+    return this.rawData.data || [];
+  }
+  /**
+   * Get total count of records
+   * @returns {number} Total number of records matching the query
+   */
+  getCount() {
+    return this.rawData.meta?.count || 0;
+  }
+  /**
+   * Get calculated totals
+   * @returns {object|null} Totals object
+   */
+  getTotals() {
+    return this.rawData.totals || null;
+  }
+  /**
+   * Get pagination information
+   * @returns {object} Object containing limit and offset
+   */
+  getPagination() {
+    return {
+      limit: this.rawData.meta?.limit || 0,
+      offset: this.rawData.meta?.offset || 0
+    };
+  }
+  /**
+   * Get raw response data
+   * @returns {object} Raw API response
+   */
+  getRawData() {
+    return this.rawData;
+  }
+  /**
+   * Get raw sql query if available
+   * @returns {(string|undefined)} Raw SQL query if available
+   */
+  getRawSQL() {
+    return this.rawData.meta?.sql;
+  }
+  /**
+   * Convert data to a tabular format with specified columns
+   * @param {Array<string>} columns - Array of column names to include
+   * @returns {Array<object>} Array of rows with only specified columns
+   */
+  tablePivot(e) {
+    const t = this.getData();
+    return !e || e.length === 0 ? t : t.map((r) => {
+      const a = {};
+      return e.forEach((n) => {
+        a[n] = r[n];
+      }), a;
+    });
+  }
+  /**
+   * Convert data to series format for charting libraries
+   * @param {string} xAxis - Column to use for x-axis
+   * @param {Array<string>} yAxes - Columns to use for y-axes
+   * @returns {Array<object>} Array of series with x and y values
+   */
+  chartPivot(e, t) {
+    const r = this.getData();
+    return t.map((a) => ({
+      key: a,
+      title: a,
+      series: r.map((n) => ({
+        x: n[e],
+        y: n[a]
+      }))
+    }));
+  }
+}
+const p = "0.1.6";
+class l {
+  constructor(e, t) {
+    this.apiToken = e, this.apiUrl = t.apiUrl.endsWith("/") ? t.apiUrl.slice(0, -1) : t.apiUrl;
+  }
+  _getDefaultHeaders() {
+    const e = {
+      "Content-Type": "application/json",
+      "x-insights-sdk-version": p
+    };
+    return this.apiToken && (e.Authorization = `Bearer ${this.apiToken}`), e;
+  }
+  /**
+   * Get a report by name with specified query parameters
+   * @param {string} reportName - The name of the report to fetch
+   * @param {(Object|Array)} query - The query parameters
+   * @param {Object} [options] - Additional options
+   * @param {boolean} [options.sql=false] - Include generated SQL in response
+   * @returns {Promise<ResultSet>}
+   */
+  async getReport(e, t = {}, r = {}) {
+    if (!e)
+      throw new Error("Report name is required");
+    const a = new URL(`${this.apiUrl}/reports/${e}`);
+    (Array.isArray(t) ? t : [t]).forEach((u) => {
+      Object.keys(u).length > 0 && a.searchParams.append("query", JSON.stringify(u));
+    }), r.sql && a.searchParams.append("sql", "true");
+    const s = await h(a.toString(), {
+      headers: this._getDefaultHeaders()
+    });
+    if (!s.ok) {
+      const u = await s.text();
+      throw new Error(
+        `API request failed: ${s.status} ${s.statusText}. ${u}`
+      );
+    }
+    const i = await s.json();
+    return Array.isArray(i) ? i.map((u) => new c(u)) : new c(i);
+  }
+  /**
+   * Get metadata for a specific report
+   * @param {string} reportName - The name of the report
+   * @returns {Promise<object>} Report metadata
+   */
+  async getReportMeta(e) {
+    if (!e)
+      throw new Error("Report name is required");
+    const t = `${this.apiUrl}/reports/${e}/meta`, r = await h(t, {
+      headers: this._getDefaultHeaders()
+    });
+    if (!r.ok) {
+      const a = await r.text();
+      throw new Error(
+        `API request failed: ${r.status} ${r.statusText}. ${a}`
+      );
+    }
+    return r.json();
+  }
+  /**
+   * Get a list of all available reports
+   * @returns {Promise<object>} List of available reports
+   */
+  async listReports() {
+    const e = `${this.apiUrl}/reports`, t = await h(e, {
+      headers: this._getDefaultHeaders()
+    });
+    if (!t.ok) {
+      const r = await t.text();
+      throw new Error(
+        `API request failed: ${t.status} ${t.statusText}. ${r}`
+      );
+    }
+    return t.json();
+  }
+  /**
+   * Export a report in a specific format (default is CSV)
+   * @param {string} reportName - The name of the report to export
+   * @param {object} query - Optional query parameters
+   * @param {string} [type="csv"] - The export format (e.g., "csv", "json")
+   * @returns {Promise<string>} The exported report content as string
+   */
+  async exportReport(e, t = {}, r = "csv") {
+    if (!e)
+      throw new Error("Report name is required");
+    if (r !== "csv")
+      throw new Error("Only csv is supported");
+    const a = new URL(`${this.apiUrl}/reports/${e}/export`);
+    (Array.isArray(t) ? t : [t]).forEach((i) => {
+      Object.keys(i).length > 0 && a.searchParams.append("query", JSON.stringify(i));
+    });
+    const s = await h(a.toString(), {
+      headers: this._getDefaultHeaders()
+    });
+    if (!s.ok) {
+      const i = await s.text();
+      throw new Error(
+        `Export request failed: ${s.status} ${s.statusText}. ${i}`
+      );
+    }
+    return s.text();
+  }
+}
+function f(o, e) {
+  if (typeof o == "object" && o !== null) {
+    const { token: t, ...r } = o;
+    return new l(t, r);
+  }
+  return new l(o, e || { apiUrl: "" });
+}
+
+const insightsWrapperCss = ":host{display:block}.insights-wrapper{width:100%;height:100%}.loading{display:flex;align-items:center;justify-content:center;padding:20px;color:#666;font-family:-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif}";
+
+const InsightsWrapper$1 = /*@__PURE__*/ proxyCustomElement(class InsightsWrapper extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+    }
+    /**
+     * Name of the configuration to use from setupConfiguration
+     * Defaults to 'default' if not provided
+     */
+    configName;
+    /**
+     * API URL for the insights service (alternative to using configName)
+     */
+    apiUrl;
+    /**
+     * Authentication token (optional if using configName)
+     */
+    token;
+    /**
+     * Callback to refresh the token (can override configuration)
+     */
+    onRefreshTokenCallback;
+    /**
+     * Callback for error and warning events (can override configuration)
+     */
+    onEventEmittedCallback;
+    initialized = false;
+    insightsClient;
+    currentConfig;
+    componentWillLoad() {
+        this.initializeClient();
+    }
+    handlePropsChange() {
+        this.initializeClient();
+    }
+    async initializeClient() {
+        try {
+            let apiUrl;
+            let authToken;
+            let refreshTokenCallback;
+            let onEventEmittedCallback;
+            // Check if using configName or direct props
+            if (this.configName || (!this.apiUrl && !this.token)) {
+                // Using named configuration
+                const config = getConfiguration(this.configName);
+                if (!config) {
+                    const configNameToUse = this.configName || 'default';
+                    const errorMsg = `Configuration '${configNameToUse}' not found. Please call setupConfiguration() first.`;
+                    console.error(errorMsg);
+                    throw new Error(errorMsg);
+                }
+                apiUrl = config.apiUrl;
+                authToken = config.token;
+                // Props override configuration
+                refreshTokenCallback = this.onRefreshTokenCallback || config.refreshToken;
+                onEventEmittedCallback = this.onEventEmittedCallback || config.onEventEmitted;
+                // Store config for later use
+                this.currentConfig = {
+                    apiUrl: config.apiUrl,
+                    refreshToken: refreshTokenCallback,
+                    onEventEmitted: onEventEmittedCallback,
+                };
+                // Get initial token from refreshToken callback if provided
+                if (refreshTokenCallback) {
+                    authToken = typeof refreshTokenCallback === 'function' ? await refreshTokenCallback() : refreshTokenCallback;
+                }
+                // Emit warning through callback if no token
+                if (!authToken && onEventEmittedCallback) {
+                    onEventEmittedCallback({ eventType: 'warning', data: { message: 'No token provided for configuration' } });
+                }
+            }
+            else {
+                // Using direct props (backwards compatible)
+                if (!this.apiUrl) {
+                    const errorMsg = 'apiUrl is required when not using configName';
+                    console.error(errorMsg);
+                    throw new Error(errorMsg);
+                }
+                apiUrl = this.apiUrl;
+                authToken = this.token;
+                refreshTokenCallback = this.onRefreshTokenCallback;
+                onEventEmittedCallback = this.onEventEmittedCallback;
+                // Store config for later use even with direct props
+                this.currentConfig = {
+                    apiUrl: this.apiUrl,
+                    refreshToken: refreshTokenCallback,
+                    onEventEmitted: onEventEmittedCallback,
+                };
+            }
+            // Create the insights client
+            this.insightsClient = f(authToken, {
+                apiUrl: apiUrl,
+            });
+            this.initialized = true;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Failed to initialize insights client';
+            // Emit error through callback if configured
+            if (this.currentConfig?.onEventEmitted) {
+                this.currentConfig.onEventEmitted({ eventType: 'error', data: { message: errorMsg, error } });
+            }
+            console.error('Error initializing insights client:', error);
+            throw error;
+        }
+    }
+    async handleTokenExpired() {
+        // Auto-refresh token if refreshToken callback is configured
+        if (this.currentConfig?.refreshToken) {
+            try {
+                await this.initializeClient();
+            }
+            catch (error) {
+                console.error('Failed to refresh token:', error);
+                if (this.currentConfig?.onEventEmitted) {
+                    this.currentConfig.onEventEmitted({ eventType: 'error', data: { message: 'Failed to refresh token', error } });
+                }
+            }
+        }
+        else {
+            if (this.currentConfig?.onEventEmitted) {
+                this.currentConfig.onEventEmitted({ eventType: 'warning', data: { message: 'Token expired but no refreshToken callback configured' } });
+            }
+        }
+    }
+    /**
+     * Public method to fetch data for charts
+     * This can be called by child chart components
+     */
+    async fetchData(reportName, query) {
+        try {
+            const response = await this.insightsClient.getReport(reportName, query);
+            return response;
+        }
+        catch (error) {
+            // Check if error is token expiration
+            if (error.message && error.message.includes('401')) {
+                await this.handleTokenExpired();
+                // Retry fetching data after token refresh
+                const response = await this.insightsClient.getReport(reportName, query);
+                return response;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Helper method to build query from filters
+     */
+    async buildQuery(filters, getQueryByFilters) {
+        if (getQueryByFilters) {
+            return getQueryByFilters(filters);
+        }
+        // Default query builder
+        return {
+            columns: ['*'],
+            ...filters,
+        };
+    }
+    /**
+     * Manually refresh the token using the refreshToken callback from configuration
+     */
+    async manualRefreshToken() {
+        if (!this.currentConfig?.refreshToken) {
+            throw new Error('No refreshToken callback configured');
+        }
+        await this.initializeClient();
+    }
+    render() {
+        return (h$1("div", { key: '8a00c399458b7dff7dff0ac7e50a6217d7c2ad3d', class: "insights-wrapper" }, this.initialized && h$1("slot", { key: '85f26cab746e109f97ef29288b57377c449b7429' }), !this.initialized && h$1("div", { key: 'a59a48e70a8ff0258d5112aafeca6bc5a4a620ac', class: "loading" }, "Initializing Insights...")));
+    }
+    static get watchers() { return {
+        "configName": ["handlePropsChange"],
+        "apiUrl": ["handlePropsChange"],
+        "token": ["handlePropsChange"],
+        "onRefreshTokenCallback": ["handlePropsChange"],
+        "onEventEmittedCallback": ["handlePropsChange"]
+    }; }
+    static get style() { return insightsWrapperCss; }
+}, [769, "insights-wrapper", {
+        "configName": [1, "config-name"],
+        "apiUrl": [1, "api-url"],
+        "token": [1],
+        "onRefreshTokenCallback": [16],
+        "onEventEmittedCallback": [16],
+        "initialized": [32],
+        "fetchData": [64],
+        "buildQuery": [64],
+        "manualRefreshToken": [64]
+    }, undefined, {
+        "configName": ["handlePropsChange"],
+        "apiUrl": ["handlePropsChange"],
+        "token": ["handlePropsChange"],
+        "onRefreshTokenCallback": ["handlePropsChange"],
+        "onEventEmittedCallback": ["handlePropsChange"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["insights-wrapper"];
+    components.forEach(tagName => { switch (tagName) {
+        case "insights-wrapper":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, InsightsWrapper$1);
+            }
+            break;
+    } });
+}
+
+const InsightsWrapper = InsightsWrapper$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { InsightsWrapper, defineCustomElement };
+//# sourceMappingURL=insights-wrapper.js.map
+
+//# sourceMappingURL=insights-wrapper.js.map