@openc3/vue-common 7.0.1 → 7.1.0

package/dist/TsdbTab-Cv8GjpoJ.js

@@ -0,0 +1,1164 @@
+import { B as A } from "./format-D2pYLAIF.js";
+import { resolveComponent as d, openBlock as u, createBlock as V, withCtx as n, createVNode as a, createTextVNode as h, toDisplayString as c, createCommentVNode as b, createElementBlock as p, Fragment as M, createElementVNode as o, renderList as z, normalizeClass as Q, mergeProps as K } from "vue";
+import { _ as B } from "./CustomIcon-DTR361si.js";
+const q = {
+  downloading: "Downloading files…",
+  enabling_dedup: "Enabling DEDUP…",
+  ingesting: "Ingesting packets…",
+  dedup_cooldown: "Waiting for DEDUP cooldown…",
+  disabling_dedup: "Disabling DEDUP…"
+}, F = {
+  props: {
+    modelValue: {
+      type: Boolean,
+      default: !1
+    },
+    context: {
+      type: Object,
+      required: !0
+    }
+  },
+  emits: ["update:modelValue", "complete"],
+  data() {
+    return {
+      loadingCandidates: !1,
+      candidates: [],
+      selectedKeys: [],
+      targetVersion: "as_logged",
+      bucketEnv: null,
+      path: null,
+      candidateHeaders: [
+        { title: "File", key: "filename" },
+        { title: "Key", key: "key" }
+      ],
+      jobId: null,
+      jobStatus: null,
+      pollHandle: null,
+      errorMessage: null,
+      confirmCloseOpen: !1
+    };
+  },
+  computed: {
+    isRunning() {
+      return this.jobStatus ? ["Queued", "Running"].includes(this.jobStatus.state) : !1;
+    },
+    phaseLabel() {
+      const s = this.jobStatus?.progress_phase;
+      if (!s) return this.jobStatus?.state || "";
+      if (s === "dedup_cooldown") {
+        const e = this.cooldownRemaining;
+        if (e != null)
+          return `Waiting for DEDUP cooldown (${e}s)…`;
+      }
+      return q[s] || s;
+    },
+    cooldownRemaining() {
+      const s = this.jobStatus?.dedup_enabled_at, e = this.jobStatus?.dedup_cooldown_seconds;
+      if (!s || !e) return null;
+      const i = Date.now() / 1e3, l = new Date(s).getTime() / 1e3, t = Math.round(l + e - i);
+      return Math.max(t, 0);
+    },
+    progressPercent() {
+      const s = this.jobStatus;
+      return s ? s.state === "Complete" ? 100 : !s.progress_total || s.progress_total === 0 ? 0 : Math.round(s.progress_current / s.progress_total * 100) : 0;
+    }
+  },
+  watch: {
+    modelValue(s) {
+      s && this.fetchCandidates();
+    }
+  },
+  mounted() {
+    this.modelValue && this.fetchCandidates();
+  },
+  beforeUnmount() {
+    this.stopPolling();
+  },
+  methods: {
+    close() {
+      this.stopPolling();
+      const s = this.jobStatus?.state === "Complete";
+      this.resetState(), this.$emit("update:modelValue", !1), s && this.$emit("complete");
+    },
+    attemptClose() {
+      this.isRunning ? this.confirmCloseOpen = !0 : this.close();
+    },
+    confirmClose() {
+      this.confirmCloseOpen = !1, this.close();
+    },
+    resetState() {
+      this.candidates = [], this.selectedKeys = [], this.targetVersion = "as_logged", this.bucketEnv = null, this.path = null, this.jobId = null, this.jobStatus = null, this.errorMessage = null, this.loadingCandidates = !1, this.confirmCloseOpen = !1;
+    },
+    async fetchCandidates() {
+      this.resetState(), this.loadingCandidates = !0;
+      try {
+        const s = await A.get(
+          "/openc3-api/storage/repair_candidates",
+          {
+            params: {
+              scope: this.context.scope,
+              target: this.context.target,
+              packet: this.context.packet,
+              cmd_or_tlm: this.context.cmdOrTlm,
+              start_time: this.context.gap.startIso,
+              end_time: this.context.gap.endIso
+            }
+          }
+        );
+        this.candidates = s.data.files || [], this.bucketEnv = s.data.bucket, this.path = s.data.path, this.selectedKeys = this.candidates.map((e) => e.key);
+      } catch (s) {
+        this.errorMessage = s.response?.data?.message || s.message;
+      } finally {
+        this.loadingCandidates = !1;
+      }
+    },
+    async startReingest() {
+      this.errorMessage = null;
+      const s = this.selectedKeys.map((e) => this.path && e.startsWith(this.path) ? e.slice(this.path.length) : e.split("/").pop());
+      try {
+        const e = await A.post("/openc3-api/storage/reingest", {
+          data: {
+            scope: this.context.scope,
+            bucket: this.bucketEnv,
+            path: this.path,
+            files: s,
+            target_version: this.targetVersion
+          }
+        });
+        this.jobId = e.data.job_id, this.jobStatus = { state: e.data.state }, this.startPolling();
+      } catch (e) {
+        this.errorMessage = e.response?.data?.message || e.message;
+      }
+    },
+    startPolling() {
+      this.stopPolling(), this.pollHandle = setInterval(this.pollStatus, 2e3), this.pollStatus();
+    },
+    stopPolling() {
+      this.pollHandle && (clearInterval(this.pollHandle), this.pollHandle = null);
+    },
+    async pollStatus() {
+      if (this.jobId)
+        try {
+          const s = await A.get(
+            `/openc3-api/storage/reingest/${this.jobId}`,
+            { params: { scope: this.context.scope } }
+          );
+          this.jobStatus = s.data, this.isRunning || this.stopPolling();
+        } catch (s) {
+          this.errorMessage = s.response?.data?.message || s.message, this.stopPolling();
+        }
+    }
+  }
+}, W = {
+  key: 0,
+  class: "text-red monospace mb-4"
+}, Y = {
+  key: 0,
+  class: "d-flex align-center mb-4"
+}, Z = {
+  key: 0,
+  class: "text-medium-emphasis"
+}, J = { class: "mb-2" }, X = { class: "mt-4" }, $ = { key: 0 }, ee = { key: 1 }, te = { key: 2 }, se = { class: "text-red" }, ae = { key: 3 }, oe = { class: "text-orange" };
+function ne(s, e, i, l, t, r) {
+  const f = d("v-card-title"), k = d("v-card-subtitle"), S = d("v-progress-circular"), E = d("v-data-table"), x = d("v-radio"), L = d("v-radio-group"), v = d("v-table"), T = d("v-progress-linear"), D = d("v-card-text"), g = d("v-spacer"), _ = d("v-btn"), y = d("v-card-actions"), C = d("v-card"), I = d("v-dialog");
+  return u(), V(I, {
+    "model-value": i.modelValue,
+    "max-width": "900",
+    persistent: ""
+  }, {
+    default: n(() => [
+      a(C, null, {
+        default: n(() => [
+          a(f, { class: "d-flex align-center" }, {
+            default: n(() => [
+              h(" Repair Gap: " + c(i.context.target) + " " + c(i.context.packet), 1)
+            ]),
+            _: 1
+          }),
+          i.context.gap ? (u(), V(k, { key: 0 }, {
+            default: n(() => [
+              h(c(i.context.gap.start) + " — " + c(i.context.gap.end) + " (" + c(i.context.gap.duration) + ") ", 1)
+            ]),
+            _: 1
+          })) : b("", !0),
+          a(D, { style: { "max-height": "75vh", "overflow-y": "auto" } }, {
+            default: n(() => [
+              t.errorMessage ? (u(), p("div", W, " Error: " + c(t.errorMessage), 1)) : b("", !0),
+              t.jobId ? t.jobStatus ? (u(), p(M, { key: 2 }, [
+                a(v, {
+                  density: "compact",
+                  class: "monospace mb-4"
+                }, {
+                  default: n(() => [
+                    o("tbody", null, [
+                      o("tr", null, [
+                        e[8] || (e[8] = o("td", { class: "font-weight-bold" }, "Job", -1)),
+                        o("td", null, c(t.jobId), 1)
+                      ]),
+                      o("tr", null, [
+                        e[9] || (e[9] = o("td", { class: "font-weight-bold" }, "State", -1)),
+                        o("td", null, c(t.jobStatus.state), 1)
+                      ]),
+                      o("tr", null, [
+                        e[10] || (e[10] = o("td", { class: "font-weight-bold" }, "Phase", -1)),
+                        o("td", null, c(r.phaseLabel), 1)
+                      ]),
+                      t.jobStatus.target_version ? (u(), p("tr", $, [
+                        e[11] || (e[11] = o("td", { class: "font-weight-bold" }, "Target Version", -1)),
+                        o("td", null, c(t.jobStatus.target_version), 1)
+                      ])) : b("", !0),
+                      t.jobStatus.packets_written !== void 0 ? (u(), p("tr", ee, [
+                        e[12] || (e[12] = o("td", { class: "font-weight-bold" }, "Packets Written", -1)),
+                        o("td", null, c(t.jobStatus.packets_written.toLocaleString()), 1)
+                      ])) : b("", !0),
+                      t.jobStatus.error ? (u(), p("tr", te, [
+                        e[13] || (e[13] = o("td", { class: "font-weight-bold text-red" }, "Error", -1)),
+                        o("td", se, c(t.jobStatus.error), 1)
+                      ])) : b("", !0),
+                      t.jobStatus.warnings && t.jobStatus.warnings.length ? (u(), p("tr", ae, [
+                        e[14] || (e[14] = o("td", { class: "font-weight-bold text-orange" }, "Warnings", -1)),
+                        o("td", oe, [
+                          (u(!0), p(M, null, z(t.jobStatus.warnings, (R, O) => (u(), p("div", { key: O }, c(R), 1))), 128))
+                        ])
+                      ])) : b("", !0)
+                    ])
+                  ]),
+                  _: 1
+                }),
+                a(T, {
+                  "model-value": r.progressPercent,
+                  indeterminate: r.progressPercent === 0 && r.isRunning,
+                  class: "mb-2"
+                }, null, 8, ["model-value", "indeterminate"])
+              ], 64)) : b("", !0) : (u(), p(M, { key: 1 }, [
+                t.loadingCandidates ? (u(), p("div", Y, [
+                  a(S, {
+                    indeterminate: "",
+                    size: "24",
+                    class: "mr-3"
+                  }),
+                  e[4] || (e[4] = h(" Searching bucket for raw log files that cover this gap… ", -1))
+                ])) : (u(), p(M, { key: 1 }, [
+                  t.candidates.length === 0 ? (u(), p("div", Z, " No raw log files cover this gap window. Reingest is not available — the data may have been written from a source that skipped raw logging, or the logs have been deleted. ")) : (u(), p(M, { key: 1 }, [
+                    o("div", J, c(t.candidates.length) + " raw log file(s) overlap this window. Select which to reingest: ", 1),
+                    a(E, {
+                      modelValue: t.selectedKeys,
+                      "onUpdate:modelValue": e[0] || (e[0] = (R) => t.selectedKeys = R),
+                      headers: t.candidateHeaders,
+                      items: t.candidates,
+                      "item-value": "key",
+                      "show-select": "",
+                      class: "monospace",
+                      "items-per-page": 20,
+                      density: "compact",
+                      "data-test": "repair-candidates"
+                    }, null, 8, ["modelValue", "headers", "items"]),
+                    o("div", X, [
+                      e[7] || (e[7] = o("div", { class: "text-subtitle-2 font-weight-bold mb-1" }, " Target Definition Version ", -1)),
+                      a(L, {
+                        modelValue: t.targetVersion,
+                        "onUpdate:modelValue": e[1] || (e[1] = (R) => t.targetVersion = R),
+                        "hide-details": "",
+                        density: "compact",
+                        "data-test": "repair-version"
+                      }, {
+                        default: n(() => [
+                          a(x, {
+                            value: "as_logged",
+                            "data-test": "repair-version-as-logged"
+                          }, {
+                            label: n(() => [...e[5] || (e[5] = [
+                              o("div", { style: { "padding-left": "10px" } }, [
+                                o("div", null, "As logged (default)"),
+                                o("div", { class: "text-caption text-medium-emphasis" }, " Decode each file with the cmd/tlm definition that was in effect when the data was originally logged. Safest for historical fidelity — preserves packet layouts as they existed at that time. "),
+                                o("div", { class: "text-caption text-medium-emphasis mt-1" }, " If an item's type has changed since the log was written (e.g. STRING → FLOAT), QuestDB column types are kept as-is; historical values are cast to fit the current column, and any values that can't cast are stored as NULL. ")
+                              ], -1)
+                            ])]),
+                            _: 1
+                          }),
+                          a(x, {
+                            value: "current",
+                            "data-test": "repair-version-current"
+                          }, {
+                            label: n(() => [...e[6] || (e[6] = [
+                              o("div", { style: { "padding-left": "10px" } }, [
+                                o("div", null, "Current"),
+                                o("div", { class: "text-caption text-medium-emphasis" }, " Decode all files with the latest cmd/tlm definition. Choose this when the historical definition had a bug that you've since fixed, and you want the reingested data decoded with the corrected layout. ")
+                              ], -1)
+                            ])]),
+                            _: 1
+                          })
+                        ]),
+                        _: 1
+                      }, 8, ["modelValue"])
+                    ])
+                  ], 64))
+                ], 64))
+              ], 64))
+            ]),
+            _: 1
+          }),
+          a(y, { class: "px-4 pb-4" }, {
+            default: n(() => [
+              a(g),
+              t.jobId ? b("", !0) : (u(), V(_, {
+                key: 0,
+                color: "warning",
+                variant: "elevated",
+                disabled: t.loadingCandidates || t.candidates.length === 0 || t.selectedKeys.length === 0,
+                "data-test": "repair-reingest",
+                onClick: r.startReingest
+              }, {
+                default: n(() => [
+                  h(" Reingest " + c(t.selectedKeys.length), 1)
+                ]),
+                _: 1
+              }, 8, ["disabled", "onClick"])),
+              a(_, {
+                variant: "text",
+                "data-test": "repair-close",
+                onClick: r.attemptClose
+              }, {
+                default: n(() => [...e[15] || (e[15] = [
+                  h(" Close ", -1)
+                ])]),
+                _: 1
+              }, 8, ["onClick"])
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }),
+      a(I, {
+        modelValue: t.confirmCloseOpen,
+        "onUpdate:modelValue": e[3] || (e[3] = (R) => t.confirmCloseOpen = R),
+        "max-width": "500",
+        persistent: ""
+      }, {
+        default: n(() => [
+          a(C, null, {
+            default: n(() => [
+              a(f, null, {
+                default: n(() => [...e[16] || (e[16] = [
+                  h("Reingest Still Running", -1)
+                ])]),
+                _: 1
+              }),
+              a(D, null, {
+                default: n(() => [...e[17] || (e[17] = [
+                  h(" The reingest job is still in progress. Closing this dialog will not stop the job, but you will lose visibility into its status. Are you sure you want to close? ", -1)
+                ])]),
+                _: 1
+              }),
+              a(y, { class: "px-4 pb-4" }, {
+                default: n(() => [
+                  a(g),
+                  a(_, {
+                    variant: "text",
+                    "data-test": "repair-close-cancel",
+                    onClick: e[2] || (e[2] = (R) => t.confirmCloseOpen = !1)
+                  }, {
+                    default: n(() => [...e[18] || (e[18] = [
+                      h(" Keep Watching ", -1)
+                    ])]),
+                    _: 1
+                  }),
+                  a(_, {
+                    color: "warning",
+                    variant: "elevated",
+                    "data-test": "repair-close-confirm",
+                    onClick: r.confirmClose
+                  }, {
+                    default: n(() => [...e[19] || (e[19] = [
+                      h(" Close Anyway ", -1)
+                    ])]),
+                    _: 1
+                  }, 8, ["onClick"])
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["modelValue"])
+    ]),
+    _: 1
+  }, 8, ["model-value"]);
+}
+const le = /* @__PURE__ */ B(F, [["render", ne], ["__scopeId", "data-v-2ab87eb9"]]);
+async function j(s, e, i = 3) {
+  for (let l = 1; l <= i; l++)
+    try {
+      let t = "/openc3-api/tsdb/exec";
+      return e && e !== "0" && (t += `?db_shard=${e}`), await A.post(t, {
+        data: s,
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "text/plain"
+        }
+      });
+    } catch (t) {
+      const r = t.response?.data?.message || t.message || "";
+      if ((r.includes("PQconsumeInput") || r.includes("server closed the connection")) && l < i) {
+        await new Promise((k) => setTimeout(k, 1e3 * l));
+        continue;
+      }
+      throw t;
+    }
+}
+const ie = {
+  components: {
+    RepairGapDialog: le
+  },
+  data() {
+    return {
+      metricsRows: [],
+      metricsError: null,
+      metricsLoading: !1,
+      metricsGroupBy: [{ key: "target", order: "asc" }],
+      metricsHeaders: [
+        { title: "Packet", key: "packet" },
+        { title: "Table Name", key: "tableName" },
+        { title: "Partition Count", key: "partitionCount" },
+        { title: "Row Count", key: "rowCount" },
+        { title: "Disk Size", key: "diskSize" },
+        { title: "Actions", key: "actions", sortable: !1 }
+      ],
+      gapDialog: !1,
+      gapDialogTitle: "",
+      gapLoading: !1,
+      gapProgress: 0,
+      gapError: null,
+      gapSummary: null,
+      gapGroupResults: null,
+      gapHeaders: [
+        { title: "Gap Start", key: "start" },
+        { title: "Gap End", key: "end" },
+        { title: "Duration", key: "duration" },
+        { title: "Actions", key: "actions", sortable: !1, width: 80 }
+      ],
+      repairDialog: !1,
+      repairContext: null,
+      gapSampleInterval: "1m",
+      db_shard: "0"
+    };
+  },
+  computed: {
+    sections() {
+      return [
+        {
+          title: "Telemetry",
+          items: this.metricsRows.filter((s) => s.type === "TLM")
+        },
+        {
+          title: "Commands",
+          items: this.metricsRows.filter((s) => s.type === "CMD")
+        }
+      ];
+    }
+  },
+  mounted() {
+    this.fetchMetrics();
+  },
+  methods: {
+    groupRowCount(s) {
+      return s.reduce(
+        (e, i) => e + Number((i.raw || i).rowCount || 0),
+        0
+      );
+    },
+    groupDiskSize(s) {
+      return s.reduce(
+        (e, i) => e + Number((i.raw || i).diskSize || 0),
+        0
+      );
+    },
+    formatBytes(s) {
+      if (s === 0) return "0 B";
+      const e = ["B", "KB", "MB", "GB", "TB"], i = 1024, l = Math.floor(Math.log(s) / Math.log(i));
+      return `${(s / Math.pow(i, l)).toFixed(l === 0 ? 0 : 1)} ${e[l]}`;
+    },
+    fetchMetrics() {
+      this.metricsError = null, this.metricsRows = [], this.metricsLoading = !0, j(
+        "SELECT tableName, partitionCount, rowCount, diskSize FROM table_storage;",
+        this.db_shard
+      ).then((s) => {
+        const e = s.data.columns;
+        this.metricsRows = s.data.rows.map((i) => {
+          const l = {};
+          e.forEach((r, f) => {
+            l[r] = i[f];
+          });
+          const t = (l.tableName || "").split("__");
+          return l.type = t[1] || "", l.target = t[2] || "", l.packet = t[3] || "", l;
+        });
+      }).catch((s) => {
+        s.response && s.response.data ? this.metricsError = s.response.data.message : this.metricsError = s.message;
+      }).finally(() => {
+        this.metricsLoading = !1;
+      });
+    },
+    dropTable(s) {
+      return j(`DROP TABLE '${s}';`, this.db_shard);
+    },
+    deleteTable(s) {
+      let e = s.split("__")[2] || s, i = s.split("__")[3] || s;
+      this.$dialog.confirm(
+        `Are you sure you want to drop table: ${s}? This removes ALL decommutated data for ${e} ${i}!`,
+        {
+          okText: "Delete",
+          cancelText: "Cancel"
+        }
+      ).then(() => {
+        this.dropTable(s).then(() => {
+          this.metricsRows = this.metricsRows.filter(
+            (l) => l.tableName !== s
+          );
+        }).catch((l) => {
+          l.response && l.response.data ? this.metricsError = l.response.data.message : this.metricsError = l.message;
+        });
+      });
+    },
+    deleteGroup(s) {
+      const e = s.map((l) => (l.raw || l).tableName);
+      let i = e[0].split("__")[2];
+      this.$dialog.confirm(
+        `Are you sure you want to drop ${e.length} tables? This removes ALL decommutated data for ${i}!
+
+${e.join(`
+`)}`,
+        {
+          okText: "Delete",
+          cancelText: "Cancel"
+        }
+      ).then(() => {
+        const l = new Set(e);
+        Promise.all(e.map((t) => this.dropTable(t))).then(() => {
+          this.metricsRows = this.metricsRows.filter(
+            (t) => !l.has(t.tableName)
+          );
+        }).catch((t) => {
+          t.response && t.response.data ? this.metricsError = t.response.data.message : this.metricsError = t.message;
+        });
+      });
+    },
+    formatDuration(s) {
+      const e = Math.floor(s / 1e3), i = Math.floor(e / 86400), l = Math.floor(e % 86400 / 3600), t = Math.floor(e % 3600 / 60), r = [];
+      return i && r.push(`${i}d`), l && r.push(`${l}h`), t && r.push(`${t}m`), r.length || r.push(`${e}s`), r.join(" ");
+    },
+    formatTimestamp(s) {
+      return new Date(s).toISOString().replace("T", " ").replace(".000Z", "Z");
+    },
+    // Parse a QuestDB SAMPLE BY duration like "1m", "30s", "2h" into ms.
+    // Returns null if malformed.
+    parseSampleIntervalMs(s) {
+      const e = String(s || "").trim().match(/^(\d+)\s*([smhd])$/i);
+      return e ? Number.parseInt(e[1], 10) * { s: 1e3, m: 6e4, h: 36e5, d: 864e5 }[e[2].toLowerCase()] : null;
+    },
+    async fetchTableGaps(s) {
+      const e = (this.gapSampleInterval || "1m").trim(), i = this.parseSampleIntervalMs(e);
+      if (!i)
+        throw new Error(
+          `Invalid sample interval '${e}'. Use a number followed by s, m, h, or d (e.g. 5s, 1m, 2h).`
+        );
+      const l = await j(
+        `SELECT first(PACKET_TIMESECONDS) as first_ts, last(PACKET_TIMESECONDS) as last_ts FROM '${s}';`,
+        this.db_shard
+      ), t = l.data.columns, r = l.data.rows[0], f = {};
+      t.forEach((g, _) => {
+        f[g] = r[_];
+      });
+      const k = f.first_ts, S = f.last_ts, E = new Date(S) - new Date(k), x = await j(
+        `(SELECT PACKET_TIMESECONDS, count() as cnt FROM '${s}' SAMPLE BY ${e} FILL(NULL)) WHERE cnt IS NULL`,
+        this.db_shard
+      ), L = x.data.columns, v = x.data.rows.map((g) => {
+        const _ = {};
+        return L.forEach((y, C) => {
+          _[y] = g[C];
+        }), _;
+      }), T = [], D = (g, _) => {
+        const y = new Date(g).getTime(), C = new Date(_).getTime() + i;
+        return {
+          start: this.formatTimestamp(g),
+          end: this.formatTimestamp(new Date(C)),
+          duration: this.formatDuration(C - y),
+          // ISO strings avoid the JS precision cliff on nsec integers.
+          startIso: new Date(y).toISOString(),
+          endIso: new Date(C).toISOString()
+        };
+      };
+      if (v.length > 0) {
+        let g = v[0].PACKET_TIMESECONDS, _ = g;
+        for (let y = 1; y < v.length; y++) {
+          const C = new Date(_);
+          new Date(v[y].PACKET_TIMESECONDS) - C > i && (T.push(D(g, _)), g = v[y].PACKET_TIMESECONDS), _ = v[y].PACKET_TIMESECONDS;
+        }
+        T.push(D(g, _));
+      }
+      return {
+        firstTs: this.formatTimestamp(k),
+        lastTs: this.formatTimestamp(S),
+        timeSpan: this.formatDuration(E),
+        gaps: T
+      };
+    },
+    async analyzeDataGap(s) {
+      this.gapDialogTitle = s, this.gapDialog = !0, this.gapLoading = !0, this.gapProgress = 0, this.gapError = null, this.gapSummary = null, this.gapGroupResults = null;
+      try {
+        this.gapSummary = await this.fetchTableGaps(s);
+      } catch (e) {
+        this.gapError = e.response?.data?.message || e.message;
+      } finally {
+        this.gapLoading = !1;
+      }
+    },
+    async analyzeGroupDataGap(s) {
+      const e = s.map((l) => (l.raw || l).tableName), i = (s[0].raw || s[0]).target;
+      this.gapDialogTitle = `${i} (${e.length} tables)`, this.gapDialog = !0, this.gapLoading = !0, this.gapProgress = 0, this.gapError = null, this.gapSummary = null, this.gapGroupResults = null;
+      try {
+        const l = [];
+        for (let t = 0; t < e.length; t++) {
+          this.gapProgress = Math.round((t + 1) / e.length * 100);
+          try {
+            const r = await this.fetchTableGaps(e[t]);
+            if (r.gaps.length > 0) {
+              const f = e[t].split("__");
+              l.push({
+                tableName: e[t],
+                packet: f[3] || e[t],
+                ...r
+              });
+            }
+          } catch {
+          }
+        }
+        this.gapGroupResults = {
+          totalTables: e.length,
+          withGaps: l
+        };
+      } catch (l) {
+        this.gapError = l.response?.data?.message || l.message;
+      } finally {
+        this.gapLoading = !1;
+      }
+    },
+    // scope__TLM|CMD__TARGET__PACKET → { scope, cmdOrTlm, target, packet }
+    parseTableName(s) {
+      const e = s.split("__");
+      return e.length < 4 ? null : {
+        scope: e[0],
+        cmdOrTlm: e[1],
+        target: e[2],
+        packet: e[3]
+      };
+    },
+    isTlmTable(s) {
+      return this.parseTableName(s)?.cmdOrTlm === "TLM";
+    },
+    openRepair(s, e) {
+      const i = this.parseTableName(e);
+      i && (this.repairContext = {
+        tableName: e,
+        ...i,
+        gap: s
+      }, this.repairDialog = !0);
+    },
+    onRepairComplete() {
+      this.gapGroupResults || this.gapDialogTitle && this.analyzeDataGap(this.gapDialogTitle);
+    }
+  }
+}, re = {
+  key: 0,
+  class: "mt-2 text-red monospace"
+}, de = { key: 0 }, ce = ["colspan"], ue = { class: "font-weight-bold" }, pe = { class: "ml-4 text-medium-emphasis" }, me = {
+  key: 1,
+  class: "text-red monospace mb-4"
+}, ge = { key: 0 }, he = {
+  key: 1,
+  class: "text-medium-emphasis"
+}, _e = {
+  key: 0,
+  class: "text-medium-emphasis"
+}, fe = { key: 1 }, be = { class: "mb-4 text-medium-emphasis" }, ve = { class: "text-subtitle-1 font-weight-bold mb-1" }, ye = { class: "text-medium-emphasis monospace mb-2" };
+function we(s, e, i, l, t, r) {
+  const f = d("v-card-title"), k = d("v-card-text"), S = d("v-btn"), E = d("v-text-field"), x = d("v-spacer"), L = d("v-card-actions"), v = d("v-icon"), T = d("v-list-item"), D = d("v-list"), g = d("v-menu"), _ = d("v-data-table"), y = d("v-card"), C = d("v-progress-linear"), I = d("v-table"), R = d("v-dialog"), O = d("repair-gap-dialog");
+  return u(), p("div", null, [
+    a(y, null, {
+      default: n(() => [
+        a(f, null, {
+          default: n(() => [...e[5] || (e[5] = [
+            h(" QuestDB Table Storage Metrics ", -1)
+          ])]),
+          _: 1
+        }),
+        a(k, null, {
+          default: n(() => [
+            t.metricsError ? (u(), p("div", re, " Error: " + c(t.metricsError), 1)) : b("", !0)
+          ]),
+          _: 1
+        }),
+        a(L, { class: "px-2" }, {
+          default: n(() => [
+            a(S, {
+              loading: t.metricsLoading,
+              color: "success",
+              variant: "text",
+              "data-test": "tsdb-metrics-refresh",
+              onClick: r.fetchMetrics
+            }, {
+              default: n(() => [...e[6] || (e[6] = [
+                h(" Refresh ", -1)
+              ])]),
+              _: 1
+            }, 8, ["loading", "onClick"]),
+            a(E, {
+              modelValue: t.db_shard,
+              "onUpdate:modelValue": e[0] || (e[0] = (m) => t.db_shard = m),
+              type: "number",
+              min: "0",
+              label: "DB Shard",
+              hint: "DB Shard is N/A in Core",
+              "hide-details": "",
+              density: "compact",
+              style: { "max-width": "100px" },
+              class: "ml-4"
+            }, null, 8, ["modelValue"]),
+            a(x),
+            a(E, {
+              modelValue: t.gapSampleInterval,
+              "onUpdate:modelValue": e[1] || (e[1] = (m) => t.gapSampleInterval = m),
+              label: "Data Gap Sample Interval",
+              hint: "QuestDB SAMPLE BY duration (e.g. 5s, 1m, 10m, 1h)",
+              "persistent-hint": "",
+              density: "compact",
+              "hide-details": "auto",
+              style: { "max-width": "260px" },
+              "data-test": "gap-sample-interval"
+            }, null, 8, ["modelValue"])
+          ]),
+          _: 1
+        }),
+        t.metricsRows.length ? (u(), p("div", de, [
+          (u(!0), p(M, null, z(r.sections, (m, P) => (u(), p(M, {
+            key: m.title
+          }, [
+            o("h3", {
+              class: Q(["text-h6 ml-2", P === 0 ? "mt-4" : "mt-6"])
+            }, c(m.title), 3),
+            a(_, {
+              headers: t.metricsHeaders,
+              items: m.items,
+              "group-by": t.metricsGroupBy,
+              class: "monospace",
+              "items-per-page": 50,
+              density: "compact"
+            }, {
+              "group-header": n(({ item: w, columns: G, toggleGroup: U, isGroupOpen: H }) => [
+                o("tr", null, [
+                  o("td", {
+                    colspan: G.length - 1
+                  }, [
+                    a(S, {
+                      icon: H(w) ? "$expand" : "$next",
+                      size: "small",
+                      variant: "text",
+                      onClick: (N) => U(w)
+                    }, null, 8, ["icon", "onClick"]),
+                    o("span", ue, c(w.value), 1),
+                    o("span", pe, " Packets: " + c(w.items.length) + " — Rows: " + c(r.groupRowCount(w.items).toLocaleString()) + " — Disk: " + c(r.formatBytes(r.groupDiskSize(w.items))), 1)
+                  ], 8, ce),
+                  o("td", null, [
+                    a(g, null, {
+                      activator: n(({ props: N }) => [
+                        a(v, K({ ref_for: !0 }, N, {
+                          icon: "mdi-dots-horizontal",
+                          "data-test": "group-actions"
+                        }), null, 16)
+                      ]),
+                      default: n(() => [
+                        a(D, null, {
+                          default: n(() => [
+                            a(T, {
+                              title: "Analyze Data Gaps",
+                              "prepend-icon": "mdi-chart-timeline-variant-shimmer",
+                              "data-test": "group-analyze-gap",
+                              onClick: (N) => r.analyzeGroupDataGap(w.items)
+                            }, null, 8, ["onClick"]),
+                            a(T, {
+                              title: "Delete All",
+                              "prepend-icon": "mdi-delete",
+                              "data-test": "group-delete",
+                              onClick: (N) => r.deleteGroup(w.items)
+                            }, null, 8, ["onClick"])
+                          ]),
+                          _: 2
+                        }, 1024)
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ])
+                ])
+              ]),
+              "item.diskSize": n(({ item: w }) => [
+                h(c(r.formatBytes(w.diskSize)), 1)
+              ]),
+              "item.rowCount": n(({ item: w }) => [
+                h(c(Number(w.rowCount).toLocaleString()), 1)
+              ]),
+              "item.actions": n(({ item: w }) => [
+                a(g, null, {
+                  activator: n(({ props: G }) => [
+                    a(v, K({ ref_for: !0 }, G, {
+                      icon: "mdi-dots-horizontal",
+                      "data-test": "row-actions"
+                    }), null, 16)
+                  ]),
+                  default: n(() => [
+                    a(D, null, {
+                      default: n(() => [
+                        a(T, {
+                          title: "Analyze Data Gap",
+                          "prepend-icon": "mdi-chart-timeline-variant-shimmer",
+                          "data-test": "row-analyze-gap",
+                          onClick: (G) => r.analyzeDataGap(w.tableName)
+                        }, null, 8, ["onClick"]),
+                        a(T, {
+                          title: "Delete",
+                          "prepend-icon": "mdi-delete",
+                          "data-test": "row-delete",
+                          onClick: (G) => r.deleteTable(w.tableName)
+                        }, null, 8, ["onClick"])
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ]),
+                  _: 2
+                }, 1024)
+              ]),
+              _: 1
+            }, 8, ["headers", "items", "group-by"])
+          ], 64))), 128))
+        ])) : b("", !0)
+      ]),
+      _: 1
+    }),
+    a(R, {
+      modelValue: t.gapDialog,
+      "onUpdate:modelValue": e[3] || (e[3] = (m) => t.gapDialog = m),
+      "max-width": "900"
+    }, {
+      default: n(() => [
+        a(y, null, {
+          default: n(() => [
+            a(f, { class: "d-flex align-center" }, {
+              default: n(() => [
+                h(" Data Gap Analysis: " + c(t.gapDialogTitle) + " ", 1),
+                a(x),
+                a(S, {
+                  icon: "mdi-close",
+                  variant: "text",
+                  onClick: e[2] || (e[2] = (m) => t.gapDialog = !1)
+                })
+              ]),
+              _: 1
+            }),
+            a(k, { style: { "max-height": "80vh", "overflow-y": "auto" } }, {
+              default: n(() => [
+                t.gapLoading ? (u(), V(C, {
+                  key: 0,
+                  "model-value": t.gapProgress,
+                  indeterminate: t.gapProgress === 0,
+                  class: "mb-4"
+                }, null, 8, ["model-value", "indeterminate"])) : b("", !0),
+                t.gapError ? (u(), p("div", me, " Error: " + c(t.gapError), 1)) : b("", !0),
+                !t.gapLoading && !t.gapError && t.gapSummary ? (u(), p(M, { key: 2 }, [
+                  a(I, {
+                    density: "compact",
+                    class: "monospace mb-4"
+                  }, {
+                    default: n(() => [
+                      o("tbody", null, [
+                        o("tr", null, [
+                          e[7] || (e[7] = o("td", { class: "font-weight-bold" }, "First Record", -1)),
+                          o("td", null, c(t.gapSummary.firstTs), 1)
+                        ]),
+                        o("tr", null, [
+                          e[8] || (e[8] = o("td", { class: "font-weight-bold" }, "Last Record", -1)),
+                          o("td", null, c(t.gapSummary.lastTs), 1)
+                        ]),
+                        o("tr", null, [
+                          e[9] || (e[9] = o("td", { class: "font-weight-bold" }, "Total Time Span", -1)),
+                          o("td", null, c(t.gapSummary.timeSpan), 1)
+                        ]),
+                        o("tr", null, [
+                          e[10] || (e[10] = o("td", { class: "font-weight-bold" }, "Gaps Found", -1)),
+                          o("td", null, c(t.gapSummary.gaps.length), 1)
+                        ])
+                      ])
+                    ]),
+                    _: 1
+                  }),
+                  t.gapSummary.gaps.length ? (u(), p("div", ge, [
+                    e[11] || (e[11] = o("h4", { class: "text-subtitle-1 font-weight-bold mb-2" }, " Data Gaps (periods with no data) ", -1)),
+                    a(_, {
+                      headers: t.gapHeaders,
+                      items: t.gapSummary.gaps,
+                      class: "monospace",
+                      "items-per-page": 20,
+                      density: "compact"
+                    }, {
+                      "item.actions": n(({ item: m }) => [
+                        r.isTlmTable(t.gapDialogTitle) ? (u(), V(S, {
+                          key: 0,
+                          icon: "mdi-wrench",
+                          size: "small",
+                          variant: "text",
+                          "data-test": "gap-repair",
+                          title: "Repair (reingest raw logs)",
+                          onClick: (P) => r.openRepair(m, t.gapDialogTitle)
+                        }, null, 8, ["onClick"])) : b("", !0)
+                      ]),
+                      _: 1
+                    }, 8, ["headers", "items"])
+                  ])) : (u(), p("div", he, " No data gaps detected (sampled at " + c(t.gapSampleInterval) + " intervals). ", 1))
+                ], 64)) : b("", !0),
+                !t.gapLoading && !t.gapError && t.gapGroupResults ? (u(), p(M, { key: 3 }, [
+                  t.gapGroupResults.withGaps.length === 0 ? (u(), p("div", _e, " No data gaps detected across " + c(t.gapGroupResults.totalTables) + " tables (sampled at " + c(t.gapSampleInterval) + " intervals). ", 1)) : (u(), p("div", fe, [
+                    o("div", be, c(t.gapGroupResults.withGaps.length) + " of " + c(t.gapGroupResults.totalTables) + " tables have data gaps. ", 1),
+                    (u(!0), p(M, null, z(t.gapGroupResults.withGaps, (m) => (u(), p("div", {
+                      key: m.tableName,
+                      class: "mb-6"
+                    }, [
+                      o("h4", ve, c(m.packet), 1),
+                      o("div", ye, c(m.firstTs) + " to " + c(m.lastTs) + " (" + c(m.timeSpan) + ") — " + c(m.gaps.length) + " gap(s) ", 1),
+                      a(_, {
+                        headers: t.gapHeaders,
+                        items: m.gaps,
+                        class: "monospace",
+                        "items-per-page": 10,
+                        density: "compact"
+                      }, {
+                        "item.actions": n(({ item: P }) => [
+                          r.isTlmTable(m.tableName) ? (u(), V(S, {
+                            key: 0,
+                            icon: "mdi-wrench",
+                            size: "small",
+                            variant: "text",
+                            "data-test": "gap-repair",
+                            title: "Repair (reingest raw logs)",
+                            onClick: (w) => r.openRepair(P, m.tableName)
+                          }, null, 8, ["onClick"])) : b("", !0)
+                        ]),
+                        _: 2
+                      }, 1032, ["headers", "items"])
+                    ]))), 128))
+                  ]))
+                ], 64)) : b("", !0)
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }, 8, ["modelValue"]),
+    t.repairContext ? (u(), V(O, {
+      key: 0,
+      modelValue: t.repairDialog,
+      "onUpdate:modelValue": e[4] || (e[4] = (m) => t.repairDialog = m),
+      context: t.repairContext,
+      onComplete: r.onRepairComplete
+    }, null, 8, ["modelValue", "context", "onComplete"])) : b("", !0)
+  ]);
+}
+const Se = /* @__PURE__ */ B(ie, [["render", we], ["__scopeId", "data-v-25188e19"]]), ke = {
+  data() {
+    return {
+      sqlText: "",
+      db_shard: "0",
+      columns: [],
+      rows: [],
+      errorMessage: null,
+      loading: !1
+    };
+  },
+  computed: {
+    tableHeaders() {
+      return this.columns.map((s) => ({
+        title: s,
+        key: s
+      }));
+    }
+  },
+  methods: {
+    commandKeydown(s) {
+      (s.metaKey || s.ctrlKey) && s.key === "Enter" && this.executeQuery();
+    },
+    executeQuery() {
+      this.errorMessage = null, this.columns = [], this.rows = [], this.loading = !0, j(this.sqlText, this.db_shard).then((s) => {
+        this.columns = s.data.columns, this.rows = s.data.rows.map((e) => {
+          const i = {};
+          return this.columns.forEach((l, t) => {
+            i[l] = e[t];
+          }), i;
+        });
+      }).catch((s) => {
+        s.response && s.response.data ? this.errorMessage = s.response.data.message : this.errorMessage = s.message;
+      }).finally(() => {
+        this.loading = !1;
+      });
+    }
+  }
+}, xe = {
+  key: 0,
+  class: "mt-2 text-red monospace"
+};
+function Te(s, e, i, l, t, r) {
+  const f = d("v-card-title"), k = d("v-card-subtitle"), S = d("v-textarea"), E = d("v-card-text"), x = d("v-btn"), L = d("v-text-field"), v = d("v-card-actions"), T = d("v-data-table"), D = d("v-card");
+  return u(), V(D, null, {
+    default: n(() => [
+      a(f, null, {
+        default: n(() => [...e[2] || (e[2] = [
+          h(" Send SQL Queries to QuestDB ", -1)
+        ])]),
+        _: 1
+      }),
+      a(k, null, {
+        default: n(() => [...e[3] || (e[3] = [
+          h(" THIS IS DANGEROUS! This allows you to interact directly with the underlying QuestDB time series database, making it easy to modify or delete data. ", -1),
+          o("br", null, null, -1),
+          o("br", null, null, -1),
+          h(" Enter SQL queries like: ", -1),
+          o("code", null, " SELECT * FROM DEFAULT__TLM__INST__HEALTH_STATUS LIMIT 10 ", -1),
+          h(" or ", -1),
+          o("code", null, "SHOW TABLES", -1)
+        ])]),
+        _: 1
+      }),
+      a(E, { class: "pb-0 ml-2" }, {
+        default: n(() => [
+          a(S, {
+            modelValue: t.sqlText,
+            "onUpdate:modelValue": e[0] || (e[0] = (g) => t.sqlText = g),
+            "hide-details": "",
+            label: "SQL query",
+            class: "monospace",
+            rows: "3",
+            onKeydown: r.commandKeydown
+          }, null, 8, ["modelValue", "onKeydown"]),
+          t.errorMessage ? (u(), p("div", xe, " Error: " + c(t.errorMessage), 1)) : b("", !0)
+        ]),
+        _: 1
+      }),
+      a(v, { class: "px-2" }, {
+        default: n(() => [
+          a(x, {
+            disabled: !t.sqlText.length,
+            loading: t.loading,
+            color: "success",
+            variant: "text",
+            "data-test": "tsdb-execute",
+            onClick: r.executeQuery
+          }, {
+            default: n(() => [...e[4] || (e[4] = [
+              h(" Execute ", -1)
+            ])]),
+            _: 1
+          }, 8, ["disabled", "loading", "onClick"]),
+          a(L, {
+            modelValue: t.db_shard,
+            "onUpdate:modelValue": e[1] || (e[1] = (g) => t.db_shard = g),
+            type: "number",
+            min: "0",
+            label: "DB Shard",
+            "hide-details": "",
+            density: "compact",
+            style: { "max-width": "100px" },
+            class: "ml-4"
+          }, null, 8, ["modelValue"])
+        ]),
+        _: 1
+      }),
+      t.columns.length ? (u(), V(T, {
+        key: 0,
+        headers: r.tableHeaders,
+        items: t.rows,
+        class: "monospace",
+        "items-per-page": 50,
+        density: "compact"
+      }, null, 8, ["headers", "items"])) : b("", !0)
+    ]),
+    _: 1
+  });
+}
+const Ce = /* @__PURE__ */ B(ke, [["render", Te], ["__scopeId", "data-v-4c0d0a5c"]]), Ee = {
+  components: {
+    TsdbMetrics: Se,
+    TsdbQueries: Ce
+  },
+  data() {
+    return {
+      activeTab: "metrics"
+    };
+  }
+};
+function De(s, e, i, l, t, r) {
+  const f = d("v-tab"), k = d("v-tabs"), S = d("tsdb-metrics"), E = d("v-window-item"), x = d("tsdb-queries"), L = d("v-window");
+  return u(), p("div", null, [
+    a(k, {
+      modelValue: t.activeTab,
+      "onUpdate:modelValue": e[0] || (e[0] = (v) => t.activeTab = v)
+    }, {
+      default: n(() => [
+        a(f, {
+          value: "metrics",
+          "data-test": "tsdb-metrics-tab"
+        }, {
+          default: n(() => [...e[2] || (e[2] = [
+            h("Metrics", -1)
+          ])]),
+          _: 1
+        }),
+        a(f, {
+          value: "queries",
+          "data-test": "tsdb-queries-tab"
+        }, {
+          default: n(() => [...e[3] || (e[3] = [
+            h("Queries", -1)
+          ])]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }, 8, ["modelValue"]),
+    a(L, {
+      modelValue: t.activeTab,
+      "onUpdate:modelValue": e[1] || (e[1] = (v) => t.activeTab = v)
+    }, {
+      default: n(() => [
+        a(E, { value: "metrics" }, {
+          default: n(() => [
+            a(S)
+          ]),
+          _: 1
+        }),
+        a(E, { value: "queries" }, {
+          default: n(() => [
+            a(x)
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }, 8, ["modelValue"])
+  ]);
+}
+const Ve = /* @__PURE__ */ B(Ee, [["render", De]]);
+export {
+  Ve as default
+};
+//# sourceMappingURL=TsdbTab-Cv8GjpoJ.js.map