@blazes/data-visualization 0.0.0-stage → 1.0.0-alpha.1

package/dist/dashboard-runtime-8a-9P8Ku.js

@@ -0,0 +1,1540 @@
+var Ce = Object.defineProperty;
+var Ee = (s) => {
+  throw TypeError(s);
+};
+var Ve = (s, e, t) => e in s ? Ce(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var E = (s, e, t) => Ve(s, typeof e != "symbol" ? e + "" : e, t), Ie = (s, e, t) => e.has(s) || Ee("Cannot " + t);
+var n = (s, e, t) => (Ie(s, e, "read from private field"), t ? t.call(s) : e.get(s)), w = (s, e, t) => e.has(s) ? Ee("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), D = (s, e, t, r) => (Ie(s, e, "write to private field"), r ? r.call(s, t) : e.set(s, t), t);
+var W = (s, e, t, r) => ({
+  set _(i) {
+    D(s, e, i, t);
+  },
+  get _() {
+    return n(s, e, r);
+  }
+});
+import { e as V, r as ke, P as J, c as Me, d as Te, w as Ne } from "./csv-Dyrr2yMA.js";
+import { i as he, s as le, c as $e } from "./serializable-DOOpLZyk.js";
+import { S as Be, a as xe } from "./standard-definitions-DHtaLAf1.js";
+import { H as Le, J as Ue, c as Ke, v as We } from "./runtime-schema-BO2qLlvE.js";
+const Ae = Le(Ke, [Ue]);
+function Rt(s) {
+  if (!he(s))
+    throw new We([
+      {
+        path: "/",
+        keyword: "jsonSerializable",
+        message: "must contain only finite JSON values and must not contain cycles or class instances",
+        params: {}
+      }
+    ]);
+  return Ae.assert(s);
+}
+class Je extends Error {
+  constructor(t) {
+    super(t.map((r) => `${r.path}: ${r.message}`).join(`
+`));
+    E(this, "diagnostics");
+    this.name = "DashboardConfigValidationError", this.diagnostics = t;
+  }
+}
+function X(s) {
+  const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set();
+  return s.forEach((r) => e.has(r) ? t.add(r) : e.add(r)), Array.from(t);
+}
+function Ge(s) {
+  switch (s.type) {
+    case "metric":
+      return [s.valueField, s.compareField].filter((e) => !!e);
+    case "line":
+      return [s.xField, ...s.yFields, s.seriesField].filter(
+        (e) => !!e
+      );
+    case "bar":
+      return [s.categoryField, ...s.valueFields, s.seriesField].filter(
+        (e) => !!e
+      );
+    case "pie":
+      return [s.nameField, s.valueField];
+    case "table":
+      return s.columns;
+    case "wordCloud":
+      return [...s.labelFields, s.valueField, s.semanticField].filter(
+        (e) => !!e
+      );
+    case "pivotTableS2":
+      return [...s.rowFields, ...s.columnFields, ...s.valueFields];
+  }
+}
+function Ye(s, e, t, r, i, a) {
+  !t || a(t) || s.push({
+    level: "error",
+    code: "panel_field_semantics_invalid",
+    message: `Field ${r} must be ${i}; received ${t.role}/${t.dataType}.`,
+    path: `/panels/${e}/binding`
+  });
+}
+function He(s, e, t, r) {
+  var u, p;
+  const i = (f) => f.role === "metric" && f.dataType === "number", a = (f) => f.role === "dimension" || f.role === "time", d = (f) => f.role === "dimension", c = (f, m, b) => Ye(s, t, r.get(f), f, m, b);
+  switch (e.binding.type) {
+    case "metric":
+      c(e.binding.valueField, "a numeric metric", i), e.binding.compareField && c(e.binding.compareField, "a numeric metric", i);
+      break;
+    case "line":
+      c(e.binding.xField, "a dimension or time field", a), e.binding.yFields.forEach((m) => c(m, "a numeric metric", i)), e.binding.seriesField && (c(e.binding.seriesField, "a dimension field", d), e.binding.yFields.length !== 1 && s.push({
+        level: "error",
+        code: "panel_series_value_arity_invalid",
+        message: "Line binding with seriesField must contain exactly one yField.",
+        path: `/panels/${t}/binding/yFields`
+      })), new Set(
+        e.binding.yFields.flatMap((m) => {
+          var h, y, l;
+          const b = r.get(m);
+          if (!b) return [];
+          const o = ((l = (y = (h = e.enhancement) == null ? void 0 : h.common) == null ? void 0 : y.formatOverrides) == null ? void 0 : l[m]) ?? b.format ?? { type: "number" };
+          return [le({ format: o, unit: b.unit ?? null })];
+        })
+      ).size > 2 && s.push({
+        level: "error",
+        code: "panel_line_axis_count_invalid",
+        message: "Line binding supports at most two distinct format and unit axis groups.",
+        path: `/panels/${t}/binding/yFields`
+      });
+      break;
+    case "bar":
+      c(e.binding.categoryField, "a dimension or time field", a), e.binding.valueFields.forEach((m) => c(m, "a numeric metric", i)), e.binding.seriesField && (c(e.binding.seriesField, "a dimension field", d), e.binding.valueFields.length !== 1 && s.push({
+        level: "error",
+        code: "panel_series_value_arity_invalid",
+        message: "Bar binding with seriesField must contain exactly one valueField.",
+        path: `/panels/${t}/binding/valueFields`
+      }));
+      break;
+    case "pie":
+      c(e.binding.nameField, "a dimension or time field", a), c(e.binding.valueField, "a numeric metric", i);
+      break;
+    case "wordCloud":
+      e.binding.labelFields.forEach((m) => c(m, "a dimension field", d)), c(e.binding.valueField, "a numeric metric", i), e.binding.semanticField && c(e.binding.semanticField, "a dimension field", d);
+      break;
+    case "pivotTableS2": {
+      e.binding.rowFields.forEach((o) => c(o, "a dimension or time field", a)), e.binding.columnFields.forEach((o) => c(o, "a dimension or time field", a)), e.binding.valueFields.forEach((o) => c(o, "a numeric metric", i));
+      const m = new Set(e.binding.rowFields), b = e.binding.columnFields.find((o) => m.has(o));
+      b && s.push({
+        level: "error",
+        code: "panel_pivot_dimension_duplicate",
+        message: `Pivot table field ${b} cannot be used as both a row and column dimension.`,
+        path: `/panels/${t}/binding`
+      });
+      break;
+    }
+    case "table": {
+      const m = ((u = e.enhancement) == null ? void 0 : u.type) === "table" ? (p = e.enhancement.table) == null ? void 0 : p.columnDisplays : void 0;
+      Object.entries(m ?? {}).forEach(([b, o]) => {
+        (o.type === "progress" || o.type === "trend") && c(b, `a numeric field for ${o.type} display`, (h) => h.dataType === "number");
+      });
+      break;
+    }
+  }
+}
+function Qe(s, e, t, r) {
+  const i = e.bindingSchema.validate(t.binding);
+  if (i.success || i.issues.forEach(
+    (a) => s.push({
+      level: "error",
+      code: "panel_binding_schema_invalid",
+      message: a.message,
+      path: `/panels/${r}/binding${a.path === "/" ? "" : a.path}`
+    })
+  ), t.enhancement) {
+    const a = e.enhancementSchema.validate(t.enhancement);
+    a.success || a.issues.forEach(
+      (d) => s.push({
+        level: "error",
+        code: "panel_enhancement_schema_invalid",
+        message: d.message,
+        path: `/panels/${r}/enhancement${d.path === "/" ? "" : d.path}`
+      })
+    );
+  }
+}
+function Ze(s, e, t = {}) {
+  var m, b;
+  if (!he(s))
+    return {
+      valid: !1,
+      diagnostics: [
+        {
+          level: "error",
+          code: "config_not_serializable",
+          message: "DashboardConfig must contain only finite JSON values and must not contain cycles or class instances.",
+          path: "/"
+        }
+      ]
+    };
+  const r = Ae.validate(s);
+  if (!r.success)
+    return {
+      valid: !1,
+      diagnostics: r.issues.map((o) => ({
+        level: "error",
+        code: "config_schema_invalid",
+        message: o.message,
+        path: o.path
+      }))
+    };
+  const i = r.value, a = [], d = i.variables ?? [], c = new Set(d.map((o) => o.id)), u = new Set(i.requests.map((o) => o.id)), p = new Map(i.datasets.map((o) => [o.id, o]));
+  return [
+    ["variable_id_duplicate", "/variables", d.map((o) => o.id)],
+    ["filter_control_id_duplicate", "/filterBar/controls", (((m = i.filterBar) == null ? void 0 : m.controls) ?? []).map((o) => o.id)],
+    ["request_id_duplicate", "/requests", i.requests.map((o) => o.id)],
+    ["dataset_id_duplicate", "/datasets", i.datasets.map((o) => o.id)],
+    ["panel_id_duplicate", "/panels", i.panels.map((o) => o.id)]
+  ].forEach(
+    ([o, h, y]) => X(y).forEach(
+      (l) => a.push({ level: "error", code: o, message: `Duplicate ID: ${l}`, path: h })
+    )
+  ), X(d.flatMap((o) => o.urlKey ? [o.urlKey] : [])).forEach(
+    (o) => a.push({
+      level: "error",
+      code: "variable_url_key_duplicate",
+      message: `Duplicate variable URL key: ${o}`,
+      path: "/variables"
+    })
+  ), (((b = i.filterBar) == null ? void 0 : b.controls) ?? []).forEach((o, h) => {
+    if ((o.type === "date-range" ? [o.startVariableId, o.endVariableId] : [o.variableId]).forEach((l) => {
+      c.has(l) || a.push({
+        level: "error",
+        code: "filter_variable_not_found",
+        message: `Filter control ${o.id} references missing variable: ${l}`,
+        path: `/filterBar/controls/${h}`
+      });
+    }), o.type === "date-range")
+      X((o.presets ?? []).map((l) => l.id)).forEach(
+        (l) => a.push({
+          level: "error",
+          code: "filter_preset_id_duplicate",
+          message: `Duplicate preset ID in filter ${o.id}: ${l}`,
+          path: `/filterBar/controls/${h}/presets`
+        })
+      );
+    else {
+      const l = o.options.map((g) => le(g.value));
+      X(l).forEach(
+        (g) => a.push({
+          level: "error",
+          code: "filter_option_value_duplicate",
+          message: `Duplicate option value in filter ${o.id}: ${g}`,
+          path: `/filterBar/controls/${h}/options`
+        })
+      );
+    }
+  }), i.requests.forEach((o, h) => {
+    const y = e.providers.get(o.providerId);
+    y ? y.operations[o.operationId] || a.push({
+      level: "error",
+      code: "request_operation_not_found",
+      message: `Provider operation is not registered: ${o.providerId}/${o.operationId}`,
+      path: `/requests/${h}/operationId`
+    }) : a.push({
+      level: "error",
+      code: "request_provider_not_found",
+      message: `Provider is not registered: ${o.providerId}`,
+      path: `/requests/${h}/providerId`
+    }), Object.entries(o.input ?? {}).forEach(([l, g]) => {
+      g.source === "variable" && (c.has(g.variableId) || a.push({
+        level: "error",
+        code: "request_variable_not_found",
+        message: `Request input references missing variable: ${g.variableId}`,
+        path: `/requests/${h}/input/${l}/variableId`
+      }), g.codecId && !e.requestValueCodecs.has(g.codecId) && a.push({
+        level: "error",
+        code: "request_codec_not_found",
+        message: `Request value codec is not registered: ${g.codecId}`,
+        path: `/requests/${h}/input/${l}/codecId`
+      }));
+    });
+  }), i.datasets.forEach((o, h) => {
+    X(o.fields.map((l) => l.key)).forEach(
+      (l) => a.push({
+        level: "error",
+        code: "dataset_field_key_duplicate",
+        message: `Duplicate field key in dataset ${o.id}: ${l}`,
+        path: `/datasets/${h}/fields`
+      })
+    ), (o.input.type === "single" ? [["default", o.input]] : Object.entries(o.input.inputs)).forEach(([l, g]) => {
+      u.has(g.requestId) || a.push({
+        level: "error",
+        code: "dataset_request_not_found",
+        message: `Dataset input references missing request: ${g.requestId}`,
+        path: `/datasets/${h}/input/${l}`
+      });
+    }), o.input.type === "multiple" && !o.transformerId && a.push({
+      level: "error",
+      code: "dataset_transformer_required",
+      message: `Dataset ${o.id} has multiple inputs and requires a transformer.`,
+      path: `/datasets/${h}/transformerId`
+    }), o.transformerId && !e.transformers.has(o.transformerId) && a.push({
+      level: "error",
+      code: "dataset_transformer_not_found",
+      message: `Dataset transformer is not registered: ${o.transformerId}`,
+      path: `/datasets/${h}/transformerId`
+    }), o.fields.forEach((l, g) => {
+      const _ = l.coerce === "number-string" ? "number" : l.coerce === "boolean-string" ? "boolean" : l.coerce === "iso-date" ? "date-or-datetime" : void 0;
+      _ && (_ === "date-or-datetime" ? l.dataType !== "date" && l.dataType !== "datetime" : l.dataType !== _) && a.push({
+        level: "error",
+        code: "dataset_coercion_type_mismatch",
+        message: `Coercion ${l.coerce} is not compatible with data type ${l.dataType}.`,
+        path: `/datasets/${h}/fields/${g}/coerce`
+      });
+    });
+  }), i.panels.forEach((o, h) => {
+    var g, _, Z, B, I, M, pe, ge, be, ye, we, _e, ve, De;
+    const y = p.get(o.binding.datasetId);
+    if (!y)
+      a.push({
+        level: "error",
+        code: "panel_dataset_not_found",
+        message: `Panel references missing dataset: ${o.binding.datasetId}`,
+        path: `/panels/${h}/binding/datasetId`
+      });
+    else {
+      const v = new Map(y.fields.map((A) => [A.key, A])), T = new Set(v.keys());
+      if (Ge(o.binding).forEach((A) => {
+        T.has(A) || a.push({
+          level: "error",
+          code: "panel_field_not_found",
+          message: `Panel binding references missing field ${A} in dataset ${y.id}.`,
+          path: `/panels/${h}/binding`
+        });
+      }), Object.keys(((_ = (g = o.enhancement) == null ? void 0 : g.common) == null ? void 0 : _.formatOverrides) ?? {}).forEach((A) => {
+        T.has(A) || a.push({
+          level: "error",
+          code: "panel_format_field_not_found",
+          message: `Panel format override references missing field ${A} in dataset ${y.id}.`,
+          path: `/panels/${h}/enhancement/common/formatOverrides/${A}`
+        });
+      }), He(a, o, h, v), ((Z = o.enhancement) == null ? void 0 : Z.type) === "table" && (/* @__PURE__ */ new Set([
+        ...((B = o.enhancement.table) == null ? void 0 : B.sortableFields) ?? [],
+        ...((I = o.enhancement.table) == null ? void 0 : I.filterableFields) ?? [],
+        ...Object.keys(((M = o.enhancement.table) == null ? void 0 : M.columnWidths) ?? {}),
+        ...Object.keys(((pe = o.enhancement.table) == null ? void 0 : pe.columnDisplays) ?? {})
+      ])).forEach((se) => {
+        (!o.binding.type || o.binding.type !== "table" || !o.binding.columns.includes(se)) && a.push({
+          level: "error",
+          code: "panel_table_enhancement_field_invalid",
+          message: `Table enhancement field ${se} must be included in the table columns.`,
+          path: `/panels/${h}/enhancement/table`
+        });
+      }), ((ge = o.enhancement) == null ? void 0 : ge.type) === "wordCloud") {
+        const A = (be = o.enhancement.wordCloud) == null ? void 0 : be.minFontSize, se = (ye = o.enhancement.wordCloud) == null ? void 0 : ye.maxFontSize;
+        A !== void 0 && se !== void 0 && A > se && a.push({
+          level: "error",
+          code: "panel_word_cloud_font_range_invalid",
+          message: "Word cloud minFontSize cannot be greater than maxFontSize.",
+          path: `/panels/${h}/enhancement/wordCloud`
+        });
+      }
+    }
+    o.enhancement && o.enhancement.type !== o.binding.type && a.push({
+      level: "error",
+      code: "panel_enhancement_type_mismatch",
+      message: `Panel enhancement type ${o.enhancement.type} does not match binding type ${o.binding.type}.`,
+      path: `/panels/${h}/enhancement/type`
+    });
+    const l = e.rendererDefinitions.get(o.rendererId);
+    if (!l)
+      a.push({
+        level: "error",
+        code: "panel_renderer_not_found",
+        message: `Renderer definition is not registered: ${o.rendererId}`,
+        path: `/panels/${h}/rendererId`
+      });
+    else {
+      Qe(a, l, o, h);
+      const v = o.adapterId ?? l.defaultAdapterId;
+      e.adapters.has(v) || a.push({
+        level: "error",
+        code: "panel_adapter_not_found",
+        message: `Visualization adapter is not registered: ${v}`,
+        path: `/panels/${h}/adapterId`
+      });
+    }
+    (((_e = (we = o.enhancement) == null ? void 0 : we.common) == null ? void 0 : _e.presetIds) ?? []).forEach((v) => {
+      const T = e.presets.get(v);
+      T ? T.rendererId && T.rendererId !== o.rendererId && a.push({
+        level: "error",
+        code: "panel_preset_renderer_mismatch",
+        message: `Preset ${v} belongs to renderer ${T.rendererId}, not ${o.rendererId}.`,
+        path: `/panels/${h}/enhancement/common/presetIds`
+      }) : a.push({
+        level: "error",
+        code: "panel_preset_not_found",
+        message: `Visualization preset is not registered: ${v}`,
+        path: `/panels/${h}/enhancement/common/presetIds`
+      });
+    }), (((De = (ve = o.enhancement) == null ? void 0 : ve.common) == null ? void 0 : De.interactions) ?? []).forEach((v) => {
+      e.actions.has(v.actionId) || a.push({
+        level: "error",
+        code: "panel_action_not_found",
+        message: `Visualization action is not registered: ${v.actionId}`,
+        path: `/panels/${h}/enhancement/common/interactions`
+      });
+    }), X((o.actions ?? []).map((v) => v.id)).forEach(
+      (v) => a.push({
+        level: "error",
+        code: "panel_action_id_duplicate",
+        message: `Duplicate panel action ID: ${v}`,
+        path: `/panels/${h}/actions`
+      })
+    ), (o.actions ?? []).forEach((v, T) => {
+      e.actions.has(v.actionId) || a.push({
+        level: "error",
+        code: "panel_action_not_found",
+        message: `Visualization action is not registered: ${v.actionId}`,
+        path: `/panels/${h}/actions/${T}/actionId`
+      });
+    });
+  }), V(t.telemetry, {
+    name: "config_validated",
+    dashboardId: i.id,
+    ...a.length ? { errorCode: "config_reference_invalid" } : {}
+  }), a.length ? { valid: !1, diagnostics: Object.freeze(a) } : { valid: !0, config: i, diagnostics: [] };
+}
+function Xe(s, e, t = {}) {
+  const r = Ze(s, e, t);
+  if (!r.valid)
+    throw new Je(r.diagnostics);
+  return r.config;
+}
+const et = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function me(s, e) {
+  return e ? e.split(".").reduce((t, r) => {
+    if (!(!r || et.has(r) || t === null || typeof t != "object"))
+      return t[r];
+  }, s) : s;
+}
+class ue extends Error {
+  constructor(t, r, i, a) {
+    super(a);
+    E(this, "code");
+    E(this, "requestId");
+    E(this, "inputName");
+    this.name = "RequestInputError", this.code = t, this.requestId = r, this.inputName = i;
+  }
+}
+function tt(s) {
+  return s === null || s === "" || Array.isArray(s) && s.length === 0;
+}
+function st(s, e, t, r) {
+  const i = {};
+  for (const [a, d] of Object.entries(s.input ?? {})) {
+    if (d.source === "constant") {
+      i[a] = $e(d.value);
+      continue;
+    }
+    let c = ke(e, t, d.variableId);
+    if (c = me(c, d.select), c === void 0) {
+      if (d.omitWhenEmpty) continue;
+      throw new ue(
+        "request_input_missing",
+        s.id,
+        a,
+        `DataRequest ${s.id} input ${a} resolved to undefined.`
+      );
+    }
+    if (!he(c))
+      throw new ue(
+        "request_input_not_serializable",
+        s.id,
+        a,
+        `DataRequest ${s.id} input ${a} is not JSON serializable.`
+      );
+    if (d.omitWhenEmpty && tt(c))
+      continue;
+    const u = d.codecId ? r.require(d.codecId).encode(c, t) : c;
+    if (u === void 0) {
+      if (d.omitWhenEmpty) continue;
+      throw new ue(
+        "request_input_missing",
+        s.id,
+        a,
+        `DataRequest ${s.id} input ${a} was omitted by codec ${d.codecId}.`
+      );
+    }
+    i[a] = $e(u);
+  }
+  return Object.freeze(i);
+}
+class rt extends Error {
+  constructor(t, r, i) {
+    super(`Provider input validation failed: ${t}/${r}`);
+    E(this, "code", "provider_input_invalid");
+    E(this, "providerId");
+    E(this, "operationId");
+    E(this, "issues");
+    this.name = "ProviderInputValidationError", this.providerId = t, this.operationId = r, this.issues = i;
+  }
+}
+function Re() {
+  return new DOMException("The request was aborted.", "AbortError");
+}
+function it(s, e) {
+  return e.aborted || s instanceof DOMException && s.name === "AbortError";
+}
+function at(s, e) {
+  return `${s.providerId}:${s.operationId}:${le(e)}`;
+}
+var G, C, Y, x, de, ce;
+class nt {
+  constructor(e, t, r, i = {}) {
+    w(this, G, /* @__PURE__ */ new Map());
+    w(this, C, /* @__PURE__ */ new Map());
+    w(this, Y, /* @__PURE__ */ new Set());
+    w(this, x, /* @__PURE__ */ new Map());
+    w(this, de, 0);
+    w(this, ce, 0);
+    this.config = e, this.providers = t, this.codecs = r, this.options = i;
+  }
+  async execute(e, t, r = {}) {
+    var B;
+    const i = this.config.requests.find((I) => I.id === e);
+    if (!i)
+      throw new Error(`DataRequest not found: ${e}`);
+    const a = r.signal;
+    if (a != null && a.aborted) throw Re();
+    const d = st(i, this.config, t, this.codecs), c = at(i, d), u = r.isolated ?? !1;
+    u || this.trackCacheKey(i.id, c);
+    const p = `${i.id}:${++W(this, ce)._}`, f = u ? void 0 : n(this, G).get(c);
+    if (!r.force && f)
+      return V(this.options.telemetry, {
+        name: "request_cache_hit",
+        dashboardId: t.dashboardId,
+        requestId: p,
+        providerId: i.providerId,
+        operationId: i.operationId
+      }), { ...f, requestConfigId: e, executionId: p, cacheKey: c, input: d, fromCache: !0 };
+    let m = u ? void 0 : n(this, C).get(c);
+    if (r.force && m && (m.controller.abort(), n(this, C).delete(c), m = void 0), m) {
+      const I = () => m.controller.abort();
+      a == null || a.addEventListener("abort", I, { once: !0 }), V(this.options.telemetry, {
+        name: "request_cache_hit",
+        dashboardId: t.dashboardId,
+        requestId: p,
+        providerId: i.providerId,
+        operationId: i.operationId
+      });
+      try {
+        return { ...await m.promise, requestConfigId: e, executionId: p, cacheKey: c, input: d, fromCache: !0 };
+      } finally {
+        a == null || a.removeEventListener("abort", I);
+      }
+    }
+    const o = this.providers.require(i.providerId).operations[i.operationId];
+    if (!o)
+      throw new Error(`Provider operation not found: ${i.providerId}/${i.operationId}`);
+    const h = (B = o.inputSchema) == null ? void 0 : B.validate(d);
+    if (h && !h.success)
+      throw new rt(i.providerId, i.operationId, h.issues);
+    const y = Date.now(), l = new AbortController();
+    u && n(this, Y).add(l);
+    const g = () => l.abort();
+    a == null || a.addEventListener("abort", g, { once: !0 }), V(this.options.telemetry, {
+      name: "request_started",
+      dashboardId: t.dashboardId,
+      requestId: p,
+      providerId: i.providerId,
+      operationId: i.operationId
+    });
+    const _ = Promise.resolve().then(
+      () => o.execute(d, {
+        signal: l.signal,
+        requestId: p,
+        timezone: t.timezone,
+        locale: t.locale,
+        emit: (I) => V(this.options.telemetry, I)
+      })
+    ).then((I) => {
+      if (l.signal.aborted) throw Re();
+      const M = {
+        response: I,
+        version: ++W(this, de)._,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return u || n(this, G).set(c, M), V(this.options.telemetry, {
+        name: "request_succeeded",
+        dashboardId: t.dashboardId,
+        requestId: p,
+        providerId: i.providerId,
+        operationId: i.operationId,
+        durationMs: Date.now() - y
+      }), M;
+    }).catch((I) => {
+      const M = it(I, l.signal);
+      throw V(this.options.telemetry, {
+        name: M ? "request_cancelled" : "request_failed",
+        dashboardId: t.dashboardId,
+        requestId: p,
+        providerId: i.providerId,
+        operationId: i.operationId,
+        durationMs: Date.now() - y,
+        errorCode: M ? "request_cancelled" : "request_failed"
+      }), I;
+    }).finally(() => {
+      var I;
+      a == null || a.removeEventListener("abort", g), u ? n(this, Y).delete(l) : ((I = n(this, C).get(c)) == null ? void 0 : I.promise) === _ && n(this, C).delete(c);
+    });
+    return u || n(this, C).set(c, { controller: l, promise: _ }), { ...await _, requestConfigId: e, executionId: p, cacheKey: c, input: d, fromCache: !1 };
+  }
+  invalidateRequest(e) {
+    var t;
+    for (const r of n(this, x).get(e) ?? [])
+      n(this, G).delete(r), (t = n(this, C).get(r)) == null || t.controller.abort(), n(this, C).delete(r);
+    n(this, x).delete(e);
+  }
+  clear() {
+    n(this, C).forEach(({ controller: e }) => e.abort()), n(this, Y).forEach((e) => e.abort()), n(this, C).clear(), n(this, Y).clear(), n(this, G).clear(), n(this, x).clear();
+  }
+  trackCacheKey(e, t) {
+    const r = n(this, x).get(e) ?? /* @__PURE__ */ new Set();
+    r.add(t), n(this, x).set(e, r);
+  }
+}
+G = new WeakMap(), C = new WeakMap(), Y = new WeakMap(), x = new WeakMap(), de = new WeakMap(), ce = new WeakMap();
+function ot() {
+  return {
+    providers: new J("DataProvider"),
+    transformers: new J("DatasetTransformer"),
+    adapters: new J("VisualizationAdapter"),
+    rendererDefinitions: new J("VisualizationRendererDefinition"),
+    presets: new J("VisualizationPreset"),
+    actions: new J("VisualizationAction"),
+    requestValueCodecs: lt()
+  };
+}
+function dt(s) {
+  return s.adapters.registerMany(Be), s.rendererDefinitions.registerMany(xe), s;
+}
+function qt() {
+  return dt(ot());
+}
+class k extends Error {
+  constructor(t, r) {
+    super(r);
+    E(this, "code", "request_value_codec_failed");
+    E(this, "codecId");
+    this.name = "RequestValueCodecError", this.codecId = t;
+  }
+}
+function qe(s, e) {
+  const t = typeof s == "number" ? s : typeof s == "string" && s.trim() !== "" ? Number(s) : Number.NaN;
+  if (!Number.isFinite(t))
+    throw new k(e, `Value cannot be encoded as a finite number by ${e}.`);
+  return t;
+}
+function ct(s) {
+  const e = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!e) return !1;
+  const t = Number(e[1]), r = Number(e[2]), i = Number(e[3]), a = new Date(Date.UTC(t, r - 1, i));
+  return a.getUTCFullYear() === t && a.getUTCMonth() === r - 1 && a.getUTCDate() === i;
+}
+const ht = Object.freeze([
+  {
+    id: "string",
+    encode(s) {
+      if (typeof s == "string") return s;
+      if (typeof s == "number" || typeof s == "boolean") return String(s);
+      throw new k("string", "Value cannot be encoded as a string.");
+    }
+  },
+  {
+    id: "number",
+    encode(s) {
+      return qe(s, "number");
+    }
+  },
+  {
+    id: "boolean",
+    encode(s) {
+      if (typeof s == "boolean") return s;
+      if (s === "true") return !0;
+      if (s === "false") return !1;
+      throw new k("boolean", "Value cannot be encoded as a boolean.");
+    }
+  },
+  {
+    id: "string-array",
+    encode(s) {
+      if (!Array.isArray(s))
+        throw new k("string-array", "Value must be an array.");
+      return s.map((e) => {
+        if (typeof e == "string" || typeof e == "number" || typeof e == "boolean")
+          return String(e);
+        throw new k("string-array", "Array entries must be primitive values.");
+      });
+    }
+  },
+  {
+    id: "number-array",
+    encode(s) {
+      if (!Array.isArray(s))
+        throw new k("number-array", "Value must be an array.");
+      return s.map((e) => qe(e, "number-array"));
+    }
+  },
+  {
+    id: "iso-date",
+    encode(s) {
+      var r;
+      if (typeof s != "string")
+        throw new k("iso-date", "ISO date input must be a string.");
+      const e = (r = /^(\d{4}-\d{2}-\d{2})/.exec(s)) == null ? void 0 : r[1];
+      if (e) {
+        if (ct(e)) return e;
+        throw new k("iso-date", "Value contains an invalid calendar date.");
+      }
+      const t = new Date(s);
+      if (Number.isNaN(t.getTime()))
+        throw new k("iso-date", "Value cannot be encoded as an ISO date.");
+      return t.toISOString().slice(0, 10);
+    }
+  },
+  {
+    id: "json",
+    encode(s) {
+      if (!he(s))
+        throw new k("json", "Value is not JSON serializable.");
+      return s;
+    }
+  }
+]);
+function lt() {
+  return new J("RequestValueCodec").registerMany(ht);
+}
+function ut(s) {
+  const e = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!e) return !1;
+  const t = Number(e[1]), r = Number(e[2]), i = Number(e[3]), a = new Date(Date.UTC(t, r - 1, i));
+  return a.getUTCFullYear() === t && a.getUTCMonth() === r - 1 && a.getUTCDate() === i;
+}
+function Se(s, e) {
+  if (typeof s != "string") return;
+  if (e === "date" && ut(s)) return s;
+  const t = new Date(s);
+  if (!Number.isNaN(t.getTime()))
+    return e === "date" ? t.toISOString().slice(0, 10) : t.toISOString();
+}
+function ft(s, e) {
+  if (!(s == null || s === "")) {
+    switch (e.coerce) {
+      case "number-string": {
+        if (typeof s == "number" && Number.isFinite(s)) return s;
+        if (typeof s != "string") return;
+        const t = Number(s);
+        return Number.isFinite(t) ? t : void 0;
+      }
+      case "boolean-string":
+        return typeof s == "boolean" ? s : s === "true" ? !0 : s === "false" ? !1 : void 0;
+      case "iso-date":
+        return e.dataType === "date" || e.dataType === "datetime" ? Se(s, e.dataType) : void 0;
+    }
+    switch (e.dataType) {
+      case "string":
+        return typeof s == "string" ? s : void 0;
+      case "number":
+        return typeof s == "number" && Number.isFinite(s) ? s : void 0;
+      case "boolean":
+        return typeof s == "boolean" ? s : void 0;
+      case "date":
+      case "datetime":
+        return Se(s, e.dataType);
+    }
+  }
+}
+function mt(s, e, t = []) {
+  const r = [...t], i = s.map((a, d) => {
+    const c = a !== null && typeof a == "object" && !Array.isArray(a) ? a : void 0, u = {};
+    for (const p of e.fields) {
+      const f = c ? me(c, p.sourcePath ?? p.key) : void 0, m = ft(f, p);
+      m === void 0 ? (r.push({
+        level: p.required ? "error" : "warning",
+        code: p.required ? "dataset_required_field_invalid" : "dataset_optional_field_invalid",
+        message: `Dataset ${e.id} row ${d + 1} has an invalid value for ${p.key}.`,
+        field: p.key,
+        rowIndex: d
+      }), u[p.key] = null) : u[p.key] = m;
+    }
+    return Object.freeze(u);
+  });
+  return {
+    rows: Object.freeze(i),
+    diagnostics: Object.freeze(r)
+  };
+}
+class N extends Error {
+  constructor(t, r, i, a = []) {
+    super(i);
+    E(this, "code");
+    E(this, "datasetId");
+    E(this, "diagnostics");
+    this.name = "DatasetExecutionError", this.datasetId = t, this.code = r, this.diagnostics = a;
+  }
+}
+function Pe(s) {
+  return s.input.type === "single" ? [["default", s.input]] : Object.entries(s.input.inputs);
+}
+function pt(s, e) {
+  if (s == null) return [];
+  if (Array.isArray(s)) return s;
+  if (typeof s == "object") return [s];
+  throw new N(
+    e,
+    "dataset_input_invalid",
+    `Dataset ${e} input must resolve to an object or an array of objects.`
+  );
+}
+function gt(s) {
+  const e = s.map((t) => Date.parse(t.execution.updatedAt)).filter(Number.isFinite);
+  return e.length ? new Date(Math.max(...e)).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+}
+var H, L;
+class bt {
+  constructor(e, t, r, i = {}) {
+    w(this, H, /* @__PURE__ */ new Map());
+    w(this, L, /* @__PURE__ */ new Map());
+    this.config = e, this.requestExecutor = t, this.transformers = r, this.options = i;
+  }
+  async run(e, t, r = {}) {
+    var c;
+    if (t.dashboardId !== this.config.id)
+      throw new N(
+        e,
+        "dashboard_context_mismatch",
+        `DashboardContext ${t.dashboardId} cannot be used with dashboard ${this.config.id}.`
+      );
+    const i = this.config.datasets.find((u) => u.id === e);
+    if (!i)
+      throw new N(e, "dataset_not_found", `Dataset not found: ${e}`);
+    const a = Date.now(), d = r.isolated ?? !1;
+    try {
+      const u = await Promise.all(
+        Pe(i).map(async ([g, _]) => {
+          const Z = await this.requestExecutor.execute(_.requestId, t, r), B = me(Z.response, _.responsePath);
+          if (_.responsePath && B === void 0)
+            throw new N(
+              i.id,
+              "dataset_input_path_missing",
+              `Dataset ${i.id} input ${g} path was not found: ${_.responsePath}`,
+              [
+                {
+                  level: "error",
+                  code: "dataset_input_path_missing",
+                  message: `Response path was not found: ${_.responsePath}`,
+                  inputName: g
+                }
+              ]
+            );
+          return {
+            name: g,
+            requestId: _.requestId,
+            ..._.responsePath ? { responsePath: _.responsePath } : {},
+            execution: Z,
+            value: B
+          };
+        })
+      ), p = Object.freeze(
+        Object.fromEntries(u.map((g) => [g.requestId, g.execution.version]))
+      ), f = le({
+        datasetId: i.id,
+        requestVersions: p,
+        transformerId: i.transformerId ?? null
+      });
+      d || this.trackCacheKey(i.id, f);
+      const m = d ? void 0 : n(this, H).get(f);
+      if (!r.force && m)
+        return V(this.options.telemetry, {
+          name: "dataset_cache_hit",
+          dashboardId: t.dashboardId,
+          datasetId: i.id
+        }), m;
+      const b = Object.freeze(Object.fromEntries(u.map((g) => [g.name, g.value])));
+      let o, h = [];
+      if (i.transformerId) {
+        const g = this.transformers.require(i.transformerId).transform(b, {
+          datasetId: i.id,
+          timezone: t.timezone,
+          locale: t.locale
+        });
+        if (!Array.isArray(g.rows))
+          throw new N(
+            i.id,
+            "dataset_transform_invalid",
+            `Dataset transformer ${i.transformerId} did not return a rows array.`
+          );
+        o = g.rows, h = g.diagnostics ?? [];
+      } else {
+        if (i.input.type === "multiple")
+          throw new N(
+            i.id,
+            "dataset_transformer_required",
+            `Dataset ${i.id} has multiple inputs and requires a transformer.`
+          );
+        o = pt((c = u[0]) == null ? void 0 : c.value, i.id);
+      }
+      const y = mt(o, i, h);
+      if (y.diagnostics.some((g) => g.level === "error"))
+        throw new N(
+          i.id,
+          "dataset_validation_failed",
+          `Dataset ${i.id} failed field validation.`,
+          y.diagnostics
+        );
+      const l = Object.freeze({
+        datasetId: i.id,
+        fields: Object.freeze([...i.fields]),
+        rows: y.rows,
+        updatedAt: gt(u),
+        requestVersions: p,
+        diagnostics: y.diagnostics
+      });
+      return d || n(this, H).set(f, l), V(this.options.telemetry, {
+        name: "dataset_succeeded",
+        dashboardId: t.dashboardId,
+        datasetId: i.id,
+        durationMs: Date.now() - a
+      }), l;
+    } catch (u) {
+      throw V(this.options.telemetry, {
+        name: "dataset_failed",
+        dashboardId: t.dashboardId,
+        datasetId: e,
+        durationMs: Date.now() - a,
+        errorCode: u instanceof N ? u.code : "dataset_failed"
+      }), u;
+    }
+  }
+  async refresh(e, t, r) {
+    const i = this.config.datasets.find((a) => a.id === e);
+    if (!i)
+      throw new N(e, "dataset_not_found", `Dataset not found: ${e}`);
+    this.invalidateDataset(e);
+    for (const [, a] of Pe(i))
+      this.requestExecutor.invalidateRequest(a.requestId);
+    return this.run(e, t, { ...r ? { signal: r } : {}, force: !0 });
+  }
+  invalidateDataset(e) {
+    for (const t of n(this, L).get(e) ?? [])
+      n(this, H).delete(t);
+    n(this, L).delete(e);
+  }
+  clear() {
+    n(this, H).clear(), n(this, L).clear(), this.requestExecutor.clear();
+  }
+  trackCacheKey(e, t) {
+    const r = n(this, L).get(e) ?? /* @__PURE__ */ new Set();
+    r.add(t), n(this, L).set(e, r);
+  }
+}
+H = new WeakMap(), L = new WeakMap();
+var ae, te, ne;
+class je {
+  constructor(e) {
+    E(this, "config");
+    E(this, "datasetRunner");
+    w(this, ae);
+    w(this, te);
+    w(this, ne);
+    try {
+      new Intl.DateTimeFormat(e.locale, { timeZone: e.timezone }).format(0);
+    } catch {
+      throw new TypeError(`Invalid locale or timezone: ${e.locale}/${e.timezone}`);
+    }
+    D(this, ae, e.registries), D(this, ne, e.telemetry);
+    const t = e.telemetry ? { telemetry: e.telemetry } : {};
+    this.config = Xe(e.config, e.registries, t), D(this, te, { timezone: e.timezone, locale: e.locale });
+    const r = new nt(
+      this.config,
+      e.registries.providers,
+      e.registries.requestValueCodecs,
+      t
+    );
+    this.datasetRunner = new bt(
+      this.config,
+      r,
+      e.registries.transformers,
+      t
+    );
+  }
+  createContext(e) {
+    return Me(this.config, {
+      ...n(this, te),
+      ...e ? { variables: e } : {}
+    });
+  }
+  restoreContext(e, t) {
+    return Te(
+      this.config,
+      e,
+      { ...n(this, te), ...t ? { variables: t } : {} },
+      n(this, ne)
+    );
+  }
+  runDataset(e, t, r) {
+    return this.datasetRunner.run(e, t, r);
+  }
+  refreshDataset(e, t, r) {
+    return this.datasetRunner.refresh(e, t, r);
+  }
+  clear() {
+    this.datasetRunner.clear();
+  }
+  get registries() {
+    return n(this, ae);
+  }
+}
+ae = new WeakMap(), te = new WeakMap(), ne = new WeakMap();
+function St(s) {
+  return new je(s);
+}
+function yt(s) {
+  return s.input.type === "single" ? [s.input.requestId] : Object.values(s.input.inputs).map((e) => e.requestId);
+}
+function Fe(s, e, t) {
+  const r = s.get(e) ?? /* @__PURE__ */ new Set();
+  r.add(t), s.set(e, r);
+}
+function wt(s) {
+  const e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  return s.datasets.forEach((a) => {
+    const d = new Set(yt(a));
+    e.set(a.id, d), d.forEach((c) => Fe(t, c, a.id));
+  }), s.panels.forEach((a) => {
+    i.set(a.id, a.binding.datasetId), Fe(r, a.binding.datasetId, a.id);
+  }), Object.freeze({
+    requestIdsByDatasetId: e,
+    datasetIdsByRequestId: t,
+    panelIdsByDatasetId: r,
+    datasetIdByPanelId: i
+  });
+}
+function ze(s, e) {
+  const t = /* @__PURE__ */ new Set();
+  return e.forEach(
+    (r) => {
+      var i;
+      return (i = s.datasetIdsByRequestId.get(r)) == null ? void 0 : i.forEach((a) => t.add(a));
+    }
+  ), t;
+}
+function Oe(s, e) {
+  const t = /* @__PURE__ */ new Set();
+  return e.forEach(
+    (r) => {
+      var i;
+      return (i = s.panelIdsByDatasetId.get(r)) == null ? void 0 : i.forEach((a) => t.add(a));
+    }
+  ), t;
+}
+function ee() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function re(s, e) {
+  const t = s;
+  return Object.freeze({
+    code: typeof (t == null ? void 0 : t.code) == "string" ? t.code : e,
+    message: typeof (t == null ? void 0 : t.message) == "string" ? t.message : String(s),
+    cause: s
+  });
+}
+function ie(s) {
+  return s instanceof DOMException && s.name === "AbortError";
+}
+function fe(s) {
+  return Object.freeze(Object.fromEntries(s));
+}
+var Q, z, $, R, q, S, P, j, oe, O, U, K, F;
+class _t {
+  constructor(e) {
+    E(this, "dataRuntime");
+    E(this, "graph");
+    w(this, Q, /* @__PURE__ */ new Set());
+    w(this, z, /* @__PURE__ */ new Map());
+    w(this, $, /* @__PURE__ */ new Map());
+    w(this, R, /* @__PURE__ */ new Map());
+    w(this, q, /* @__PURE__ */ new Map());
+    w(this, S, /* @__PURE__ */ new Map());
+    w(this, P);
+    w(this, j, 0);
+    w(this, oe, 0);
+    w(this, O);
+    w(this, U, /* @__PURE__ */ new Set());
+    w(this, K, !1);
+    w(this, F, !1);
+    this.options = e, this.dataRuntime = new je(e), this.graph = wt(this.dataRuntime.config), D(this, P, this.dataRuntime.createContext(e.variables)), this.dataRuntime.config.requests.forEach(
+      (t) => n(this, z).set(t.id, { id: t.id, status: "idle", generation: 0 })
+    ), this.dataRuntime.config.datasets.forEach(
+      (t) => n(this, $).set(t.id, { id: t.id, status: "idle", generation: 0 })
+    ), this.dataRuntime.config.panels.forEach(
+      (t) => n(this, R).set(t.id, { id: t.id, status: "idle", generation: 0, isRefreshing: !1 })
+    );
+  }
+  get config() {
+    return this.dataRuntime.config;
+  }
+  get context() {
+    return n(this, P);
+  }
+  get snapshot() {
+    return Object.freeze({
+      generation: n(this, j),
+      isGlobalLoading: !!(n(this, O) && n(this, K)),
+      context: n(this, P),
+      requestStates: fe(n(this, z)),
+      datasetStates: fe(n(this, $)),
+      panelStates: fe(n(this, R))
+    });
+  }
+  subscribe(e) {
+    return n(this, Q).add(e), () => n(this, Q).delete(e);
+  }
+  load() {
+    return this.schedule(new Set(this.config.datasets.map((e) => e.id)), !1);
+  }
+  refreshAll() {
+    return this.schedule(new Set(this.config.datasets.map((e) => e.id)), !0);
+  }
+  refreshDataset(e) {
+    const t = this.graph.requestIdsByDatasetId.get(e);
+    if (!t) throw new Error(`Dataset not found: ${e}`);
+    return this.schedule(ze(this.graph, t), !0);
+  }
+  loadPanels(e) {
+    return this.loadPanelDatasets(this.datasetIdsForPanels(e));
+  }
+  refreshPanels(e, t = {}) {
+    const r = this.datasetIdsForPanels(e);
+    if (!r.size && !t.deferUnselected) return Promise.resolve(this.snapshot);
+    n(this, U).forEach((c) => r.add(c));
+    const i = t.deferUnselected ? this.deferUnselectedDatasets(r, n(this, j) + 1) : /* @__PURE__ */ new Set();
+    if (!r.size)
+      return i.size && (D(this, j, n(this, j) + 1), this.notify()), Promise.resolve(this.snapshot);
+    const a = this.requestIdsForDatasets(r), d = ze(this.graph, a);
+    return r.forEach((c) => d.delete(c)), this.resetDatasets(d), this.schedule(r, !0);
+  }
+  refreshPanel(e) {
+    const t = this.requirePanel(e);
+    return n(this, O) || n(this, S).has(t.binding.datasetId) ? Promise.resolve(this.snapshot) : this.schedulePanel(t);
+  }
+  retryPanel(e) {
+    return this.refreshPanel(e);
+  }
+  setVariables(e, t) {
+    var c;
+    let r = n(this, P);
+    if (Object.entries(e).forEach(([u, p]) => {
+      r = Ne(this.config, r, u, p);
+    }), D(this, P, r), t === void 0) return this.refreshAll();
+    const i = this.datasetIdsForPanels(t);
+    this.cancelPanelRefreshes(new Set(n(this, q).keys())), this.cancelPanelLoads(new Set(n(this, S).keys())), (c = n(this, O)) == null || c.abort(), D(this, O, void 0), n(this, U).clear(), D(this, K, !1);
+    const a = ++W(this, j)._;
+    n(this, z).forEach((u, p) => {
+      n(this, z).set(p, Object.freeze({ id: u.id, status: "idle", generation: a }));
+    });
+    const d = new Set(this.config.datasets.map((u) => u.id));
+    return i.forEach((u) => d.delete(u)), this.resetDatasets(d, a), i.size ? this.schedule(i, !0) : (this.notify(), Promise.resolve(this.snapshot));
+  }
+  restoreContext(e, t) {
+    return this.cancelPanelRefreshes(new Set(n(this, q).keys()), !0), this.resetDatasets(new Set(n(this, S).keys())), D(this, P, this.dataRuntime.restoreContext(e, t).context), this.notify(), this.snapshot;
+  }
+  async dispatchEvent(e) {
+    var i, a, d;
+    const r = ((d = (a = (i = this.requirePanel(e.panelId).enhancement) == null ? void 0 : i.common) == null ? void 0 : a.interactions) == null ? void 0 : d.filter((c) => c.event === e.type)) ?? [];
+    await Promise.all(
+      r.map((c) => this.dataRuntime.registries.actions.require(c.actionId).execute(e, n(this, P)))
+    );
+  }
+  async executePanelAction(e, t) {
+    var a;
+    const r = this.requirePanel(e), i = (a = r.actions) == null ? void 0 : a.find((d) => d.id === t);
+    if (!i) throw new Error(`Panel action not found: ${e}/${t}`);
+    await this.dataRuntime.registries.actions.require(i.actionId).execute(
+      {
+        type: "dataPointClick",
+        panelId: e,
+        datasetId: r.binding.datasetId,
+        fields: Object.freeze({})
+      },
+      n(this, P)
+    );
+  }
+  destroy() {
+    var e;
+    D(this, F, !0), (e = n(this, O)) == null || e.abort(), D(this, O, void 0), n(this, U).clear(), D(this, K, !1), this.cancelPanelLoads(new Set(n(this, S).keys())), this.cancelPanelRefreshes(new Set(n(this, q).keys())), n(this, Q).clear(), this.dataRuntime.clear();
+  }
+  requirePanel(e) {
+    const t = this.config.panels.find((r) => r.id === e);
+    if (!t) throw new Error(`Panel not found: ${e}`);
+    return t;
+  }
+  notify() {
+    if (n(this, F)) return;
+    const e = this.snapshot;
+    n(this, Q).forEach((t) => t(e));
+  }
+  requestIdsForDatasets(e) {
+    const t = /* @__PURE__ */ new Set();
+    return e.forEach(
+      (r) => {
+        var i;
+        return (i = this.graph.requestIdsByDatasetId.get(r)) == null ? void 0 : i.forEach((a) => t.add(a));
+      }
+    ), t;
+  }
+  datasetIdsForPanels(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const r of e) {
+      this.requirePanel(r);
+      const i = this.graph.datasetIdByPanelId.get(r);
+      i && t.add(i);
+    }
+    return t;
+  }
+  resetDatasets(e, t = n(this, j)) {
+    const r = Oe(this.graph, e);
+    this.cancelPanelRefreshes(r), this.cancelPanelLoads(e), e.forEach((i) => {
+      n(this, $).set(i, Object.freeze({ id: i, status: "idle", generation: t }));
+    }), r.forEach((i) => {
+      n(this, R).set(i, Object.freeze({ id: i, status: "idle", generation: t, isRefreshing: !1 }));
+    });
+  }
+  deferUnselectedDatasets(e, t) {
+    const r = new Set(this.config.datasets.map((d) => d.id));
+    if (e.forEach((d) => r.delete(d)), !r.size) return r;
+    const i = this.requestIdsForDatasets(e);
+    return this.requestIdsForDatasets(r).forEach((d) => {
+      this.dataRuntime.datasetRunner.requestExecutor.invalidateRequest(d), i.has(d) || n(this, z).set(d, Object.freeze({ id: d, status: "idle", generation: t }));
+    }), r.forEach((d) => {
+      this.dataRuntime.datasetRunner.invalidateDataset(d);
+    }), this.resetDatasets(r, t), r;
+  }
+  loadPanelDatasets(e) {
+    if (n(this, F)) return Promise.reject(new Error("DashboardRuntime has been destroyed."));
+    const t = [];
+    return e.forEach((r) => {
+      var d;
+      const i = n(this, S).get(r);
+      if (i) {
+        t.push(i.promise);
+        return;
+      }
+      const a = (d = n(this, $).get(r)) == null ? void 0 : d.status;
+      a !== "idle" && a !== "cancelled" || t.push(this.schedulePanelLoad(r));
+    }), t.length ? Promise.all(t).then(() => this.snapshot) : Promise.resolve(this.snapshot);
+  }
+  schedulePanelLoad(e) {
+    const t = new AbortController(), r = ++W(this, oe)._, i = n(this, P), a = ee(), d = {
+      controller: t,
+      context: i,
+      generation: r,
+      startedAt: a,
+      promise: Promise.resolve()
+    };
+    n(this, S).set(e, d);
+    const c = this.graph.requestIdsByDatasetId.get(e) ?? /* @__PURE__ */ new Set(), u = this.graph.panelIdsByDatasetId.get(e) ?? /* @__PURE__ */ new Set();
+    c.forEach((b) => {
+      n(this, z).set(b, Object.freeze({ id: b, status: "loading", generation: r, startedAt: a }));
+    });
+    const p = n(this, $).get(e), { error: f, ...m } = p;
+    return n(this, $).set(e, Object.freeze({ ...m, status: "loading", generation: r })), u.forEach((b) => {
+      const o = n(this, R).get(b), { error: h, ...y } = o;
+      n(this, R).set(
+        b,
+        Object.freeze({
+          ...y,
+          status: o.viewModel ? o.status : "loading",
+          generation: r,
+          isRefreshing: !!o.viewModel
+        })
+      );
+    }), this.notify(), d.promise = this.executePanelLoad(e, d, c, u), d.promise;
+  }
+  async executePanelLoad(e, t, r, i) {
+    try {
+      const a = await this.dataRuntime.runDataset(e, t.context, {
+        signal: t.controller.signal
+      });
+      if (n(this, S).get(e) !== t || n(this, F)) return;
+      n(this, $).set(
+        e,
+        Object.freeze({
+          id: e,
+          status: a.rows.length ? "success" : "empty",
+          generation: t.generation,
+          result: a,
+          lastSuccessfulAt: a.updatedAt
+        })
+      ), r.forEach((d) => {
+        n(this, z).set(
+          d,
+          Object.freeze({
+            id: d,
+            status: "success",
+            generation: t.generation,
+            startedAt: t.startedAt,
+            completedAt: ee()
+          })
+        );
+      }), this.config.panels.filter((d) => d.binding.datasetId === e && i.has(d.id)).forEach((d) => this.adaptPanel(d, a, t.generation, t.context));
+    } catch (a) {
+      if (n(this, S).get(e) !== t || n(this, F) || t.controller.signal.aborted)
+        return;
+      const d = ie(a) ? "cancelled" : "error", c = n(this, $).get(e);
+      n(this, $).set(
+        e,
+        Object.freeze({
+          ...c,
+          status: c.result && !ie(a) ? "stale" : d,
+          generation: t.generation,
+          error: re(a, "dataset_failed")
+        })
+      ), r.forEach((u) => {
+        n(this, z).set(
+          u,
+          Object.freeze({
+            id: u,
+            status: d,
+            generation: t.generation,
+            startedAt: t.startedAt,
+            completedAt: ee(),
+            error: re(a, "request_failed")
+          })
+        );
+      }), i.forEach((u) => this.failPanel(u, t.generation, a, "dataset_failed"));
+    } finally {
+      n(this, S).get(e) === t && (n(this, S).delete(e), this.notify());
+    }
+  }
+  cancelPanelLoads(e) {
+    e.forEach((t) => {
+      const r = n(this, S).get(t);
+      r && (n(this, S).delete(t), r.controller.abort());
+    });
+  }
+  applyPresets(e) {
+    var r, i, a;
+    let t = e.enhancement;
+    return (a = (i = (r = e.enhancement) == null ? void 0 : r.common) == null ? void 0 : i.presetIds) == null || a.forEach((d) => {
+      t = this.dataRuntime.registries.presets.require(d).apply(t);
+    }), t;
+  }
+  adaptPanel(e, t, r, i = n(this, P)) {
+    try {
+      const a = this.dataRuntime.registries.rendererDefinitions.require(e.rendererId), d = this.dataRuntime.registries.adapters.require(
+        e.adapterId ?? a.defaultAdapterId
+      ), c = this.applyPresets(e), u = d.adapt({
+        dataset: t,
+        binding: e.binding,
+        ...c ? { enhancement: c } : {},
+        context: i
+      }), p = u.empty ? "empty" : "success";
+      n(this, R).set(
+        e.id,
+        Object.freeze({
+          id: e.id,
+          status: p,
+          generation: r,
+          isRefreshing: !1,
+          viewModel: u,
+          dataset: t,
+          lastSuccessfulAt: t.updatedAt
+        })
+      );
+    } catch (a) {
+      V(this.options.telemetry, {
+        name: "adapter_failed",
+        dashboardId: this.config.id,
+        panelId: e.id,
+        datasetId: e.binding.datasetId,
+        errorCode: "adapter_failed"
+      }), this.failPanel(e.id, r, a, "adapter_failed");
+    }
+  }
+  failPanel(e, t, r, i) {
+    const a = n(this, R).get(e);
+    n(this, R).set(
+      e,
+      Object.freeze({
+        ...a,
+        status: a.viewModel ? "stale" : ie(r) ? "cancelled" : "error",
+        generation: t,
+        isRefreshing: !1,
+        error: re(r, i)
+      })
+    );
+  }
+  cancelPanelRefreshes(e, t = !1) {
+    e.forEach((r) => {
+      var a;
+      const i = n(this, q).get(r);
+      i && (n(this, q).delete(r), i.controller.abort(), t && ((a = n(this, R).get(r)) == null ? void 0 : a.generation) === i.generation && n(this, R).set(r, i.previousState));
+    });
+  }
+  async schedulePanel(e) {
+    if (n(this, F)) throw new Error("DashboardRuntime has been destroyed.");
+    const t = e.binding.datasetId, r = n(this, q).get(e.id), i = (r == null ? void 0 : r.previousState) ?? n(this, R).get(e.id);
+    r && (n(this, q).delete(e.id), r.controller.abort());
+    const a = new AbortController(), d = ++W(this, oe)._, c = n(this, P), u = { controller: a, generation: d, previousState: i };
+    n(this, q).set(e.id, u);
+    const { error: p, viewModel: f, dataset: m, ...b } = i, o = !!(f && !f.empty);
+    n(this, R).set(
+      e.id,
+      Object.freeze({
+        ...b,
+        ...o && f ? { viewModel: f } : {},
+        ...o && m ? { dataset: m } : {},
+        status: o ? i.status === "stale" ? "success" : i.status : "loading",
+        generation: d,
+        isRefreshing: o
+      })
+    ), this.notify();
+    try {
+      const h = await this.dataRuntime.runDataset(t, c, {
+        signal: a.signal,
+        force: !0,
+        isolated: !0
+      });
+      if (n(this, q).get(e.id) !== u || n(this, F)) return this.snapshot;
+      this.adaptPanel(e, h, d, c);
+    } catch (h) {
+      if (n(this, q).get(e.id) !== u || n(this, F) || a.signal.aborted)
+        return this.snapshot;
+      this.failPanel(e.id, d, h, "dataset_failed");
+    } finally {
+      n(this, q).get(e.id) === u && (n(this, q).delete(e.id), this.notify());
+    }
+    return this.snapshot;
+  }
+  async schedule(e, t, r = !0) {
+    var p;
+    if (n(this, F)) throw new Error("DashboardRuntime has been destroyed.");
+    const i = this.requestIdsForDatasets(e), a = Oe(this.graph, e);
+    this.cancelPanelRefreshes(a), this.cancelPanelLoads(e), (p = n(this, O)) == null || p.abort();
+    const d = new AbortController();
+    D(this, O, d), D(this, U, new Set(e)), D(this, K, r);
+    const c = ++W(this, j)._, u = ee();
+    return t && (i.forEach((f) => this.dataRuntime.datasetRunner.requestExecutor.invalidateRequest(f)), e.forEach((f) => this.dataRuntime.datasetRunner.invalidateDataset(f))), i.forEach((f) => {
+      n(this, z).set(f, Object.freeze({ id: f, status: "loading", generation: c, startedAt: u }));
+    }), e.forEach((f) => {
+      const m = n(this, $).get(f), { error: b, ...o } = m;
+      n(this, $).set(
+        f,
+        Object.freeze({
+          ...o,
+          status: "loading",
+          generation: c
+        })
+      );
+    }), a.forEach((f) => {
+      const m = n(this, R).get(f), { error: b, viewModel: o, dataset: h, ...y } = m, l = !!(o && !o.empty);
+      n(this, R).set(
+        f,
+        Object.freeze({
+          ...y,
+          ...l && o ? { viewModel: o } : {},
+          ...l && h ? { dataset: h } : {},
+          status: l ? m.status : "loading",
+          generation: c,
+          isRefreshing: l
+        })
+      );
+    }), this.notify(), await Promise.all(
+      Array.from(e, async (f) => {
+        var m, b;
+        try {
+          const o = await this.dataRuntime.runDataset(f, n(this, P), { signal: d.signal });
+          if (c !== n(this, j) || n(this, F)) return;
+          n(this, $).set(
+            f,
+            Object.freeze({
+              id: f,
+              status: o.rows.length ? "success" : "empty",
+              generation: c,
+              result: o,
+              lastSuccessfulAt: o.updatedAt
+            })
+          ), (m = this.graph.requestIdsByDatasetId.get(f)) == null || m.forEach((h) => {
+            n(this, z).set(
+              h,
+              Object.freeze({
+                id: h,
+                status: "success",
+                generation: c,
+                startedAt: u,
+                completedAt: ee()
+              })
+            );
+          }), this.config.panels.filter((h) => h.binding.datasetId === f && a.has(h.id)).forEach((h) => this.adaptPanel(h, o, c));
+        } catch (o) {
+          if (c !== n(this, j) || n(this, F)) return;
+          const h = ie(o) ? "cancelled" : "error", y = n(this, $).get(f);
+          n(this, $).set(
+            f,
+            Object.freeze({
+              ...y,
+              status: y.result && !ie(o) ? "stale" : h,
+              generation: c,
+              error: re(o, "dataset_failed")
+            })
+          ), (b = this.graph.requestIdsByDatasetId.get(f)) == null || b.forEach((l) => {
+            n(this, z).set(
+              l,
+              Object.freeze({
+                id: l,
+                status: h,
+                generation: c,
+                startedAt: u,
+                completedAt: ee(),
+                error: re(o, "request_failed")
+              })
+            );
+          }), this.config.panels.filter((l) => l.binding.datasetId === f && a.has(l.id)).forEach((l) => this.failPanel(l.id, c, o, "dataset_failed"));
+        } finally {
+          c === n(this, j) && n(this, O) === d && !n(this, F) && this.notify();
+        }
+      })
+    ), c === n(this, j) && n(this, O) === d && (D(this, O, void 0), n(this, U).clear(), D(this, K, !1), this.notify()), this.snapshot;
+  }
+}
+Q = new WeakMap(), z = new WeakMap(), $ = new WeakMap(), R = new WeakMap(), q = new WeakMap(), S = new WeakMap(), P = new WeakMap(), j = new WeakMap(), oe = new WeakMap(), O = new WeakMap(), U = new WeakMap(), K = new WeakMap(), F = new WeakMap();
+function Pt(s) {
+  return new _t(s);
+}
+export {
+  ht as B,
+  Je as D,
+  rt as P,
+  nt as R,
+  je as a,
+  _t as b,
+  N as c,
+  bt as d,
+  ue as e,
+  k as f,
+  Xe as g,
+  ze as h,
+  Oe as i,
+  ot as j,
+  St as k,
+  wt as l,
+  Pt as m,
+  at as n,
+  lt as o,
+  qt as p,
+  Ae as q,
+  mt as r,
+  Rt as s,
+  me as t,
+  dt as u,
+  st as v,
+  Ze as w
+};
+//# sourceMappingURL=dashboard-runtime-8a-9P8Ku.js.map